@meimu/mutracer 0.0.0-stage → 0.1.0

package/lib/renderer/WebGLJNLMDenoiser.js

@@ -0,0 +1,328 @@
+import { FragmentShader, glsl, Shader } from './shader.js';
+import { constants } from './webgl.js';
+import { WebGLFullQuadPass } from './WebGLFullQuadPass.js';
+import { JNLM_DEFAULT_COLOR_SENSITIVITY, JNLM_ALBEDO_FLOOR, JNLM_ALBEDO_REGULARIZATION, JNLM_DEFAULT_SHAPE, JNLM_COVERAGE_BANDWIDTH, JNLM_MAX_ITERATIONS, jnlmPassDilation } from './jnlm.js';
+/**
+ * WebGL 2 passes of the JNLM denoiser described in `jnlm.ts`, matching
+ * WGPUJNLMDenoiser. Textures replace its storage buffers.
+ */
+/**
+ * The guide mean and the variance of that mean. The main and catcher trace
+ * passes each accumulate (sum, sum of squares, count) for their own samples.
+ */
+const guideFragment = new FragmentShader({
+    name: 'jnlmGuide',
+    outputs: ['guide'],
+    uniforms: {
+        momentsTex: Shader.uniform('sampler2D'),
+        catcherMomentsTex: Shader.uniform('sampler2D')
+    },
+    main: glsl `
+void main() {
+ivec2 p = ivec2(gl_FragCoord.xy);
+vec4 moments = load_momentsTex(p, 0) + load_catcherMomentsTex(p, 0);
+float n = moments.z;
+float mean = moments.x / max(n, 1.0);
+
+float variance = n >= 2.0
+? max(moments.y - n * mean * mean, 0.0) / (n * (n - 1.0))
+: -1.0;
+out_guide = vec4(mean, variance, 0.0, 1.0);
+}`
+});
+/**
+ * Smooths the noisy per-pixel variance over 3 x 3 pixels. Pixels with a
+ * single sample take the spatial variance of their neighborhood instead.
+ */
+const varianceFragment = new FragmentShader({
+    name: 'jnlmVariance',
+    outputs: ['guide'],
+    uniforms: {
+        rawGuideTex: Shader.uniform('sampler2D')
+    },
+    main: glsl `
+void main() {
+ivec2 p = ivec2(gl_FragCoord.xy);
+ivec2 size = rawGuideTexRegion();
+vec2 center = load_rawGuideTex(p, 0).xy;
+float lg = 0.0;
+float iX = 0.0;
+float mL = 0.0;
+float iR = 0.0;
+for (int dy = -1; dy <= 1; dy++) {
+for (int dx = -1; dx <= 1; dx++) {
+vec2 value = load_rawGuideTex(clamp(p + ivec2(dx, dy), ivec2(0), size - 1), 0).xy;
+mL += value.x;
+iR += value.x * value.x;
+if (value.y >= 0.0) {
+lg += value.y;
+iX += 1.0;
+}
+}
+}
+float variance;
+if (center.y >= 0.0) {
+variance = lg / iX;
+} else {
+float lf = mL / 9.0;
+variance = max(iR / 9.0 - lf * lf, 0.0) * 9.0 / 8.0;
+}
+out_guide = vec4(center.x, variance, 0.0, 1.0);
+}`
+});
+/**
+ * One joint NL-means pass; see createJNLMFilterWGSL. The first pass decodes
+ * the display-encoded composition to linear light, the last encodes it again.
+ */
+const filterFragment = new FragmentShader({
+    name: 'jnlmFilter',
+    outputs: ['color', 'guide'],
+    defines: {
+        SEARCH_RADIUS: JNLM_DEFAULT_SHAPE.searchRadius,
+        PATCH_RADIUS: JNLM_DEFAULT_SHAPE.patchRadius,
+        INV_ALBEDO_BANDWIDTH2: (1 / JNLM_DEFAULT_SHAPE.albedoBandwidth ** 2).toFixed(6),
+        INV_NORMAL_BANDWIDTH2: (1 / JNLM_DEFAULT_SHAPE.normalBandwidth ** 2).toFixed(6)
+    },
+    uniforms: {
+        guideTex: Shader.uniform('sampler2D'),
+        colorTex: Shader.uniform('sampler2D'),
+        albedoTex: Shader.uniform('sampler2D'),
+        normalTex: Shader.uniform('sampler2D'),
+        shadowCatcherTex: Shader.uniform('sampler2D'),
+        colorSensitivity: Shader.uniform('float', JNLM_DEFAULT_COLOR_SENSITIVITY),
+        dilation: Shader.uniform('int', 1),
+        decodeInput: Shader.uniform('bool', 0),
+        encodeOutput: Shader.uniform('bool', 0)
+    },
+    main: glsl `
+#define PATCH_SIZE ((2 * PATCH_RADIUS + 1) * (2 * PATCH_RADIUS + 1))
+
+#define VARIANCE_CANCELLATION 1.0
+
+
+#define CENTER_WEIGHT_MIN 0.01
+#define INV_COVERAGE_BANDWIDTH2 ${(1 / JNLM_COVERAGE_BANDWIDTH ** 2).toFixed(6)}
+
+ivec2 imageSize;
+
+vec2 nq(ivec2 p) {
+return load_guideTex(clamp(p, ivec2(0), imageSize - 1), 0).xy;
+}
+
+
+vec4 rv(ivec2 p) {
+vec4 c = load_colorTex(p, 0);
+if (decodeInput) c.rgb = pow(max(c.rgb, 0.0), vec3(2.2));
+return vec4(c.rgb * c.a, c.a);
+}
+
+float lk(ivec2 q, vec4 bs, vec3 gM) {
+vec4 albedo = load_albedoTex(q, 0);
+
+
+vec3 oS = max((albedo.rgb + bs.rgb) * 0.5, vec3(${JNLM_ALBEDO_FLOOR}));
+vec3 kR = (albedo.rgb - bs.rgb) / oS;
+float iO = albedo.a - bs.a;
+vec3 lb = load_normalTex(q, 0).rgb - gM;
+return max(
+dot(kR, kR) * INV_ALBEDO_BANDWIDTH2
++ iO * iO * INV_COVERAGE_BANDWIDTH2,
+dot(lb, lb) * INV_NORMAL_BANDWIDTH2
+);
+}
+
+void main() {
+imageSize = guideTexRegion();
+ivec2 p = ivec2(gl_FragCoord.xy);
+vec4 bs = load_albedoTex(p, 0);
+vec4 fw = load_normalTex(p, 0);
+vec3 gM = fw.rgb;
+
+
+if (fw.a <= 0.0 && load_shadowCatcherTex(p, 0).r <= 0.0) {
+vec4 c = rv(p);
+vec3 rgb = c.rgb / max(c.a, 1e-6);
+if (encodeOutput) rgb = pow(max(rgb, 0.0), vec3(1.0 / 2.2));
+out_color = vec4(rgb, c.a);
+out_guide = vec4(nq(p), 0.0, 1.0);
+return;
+}
+
+vec2 kT[PATCH_SIZE];
+int k = 0;
+for (int dy = -PATCH_RADIUS; dy <= PATCH_RADIUS; dy++) {
+for (int dx = -PATCH_RADIUS; dx <= PATCH_RADIUS; dx++) {
+kT[k] = nq(p + ivec2(dx, dy) * dilation);
+k++;
+}
+}
+float k2 = colorSensitivity * colorSensitivity;
+
+vec4 sum = vec4(0.0);
+vec3 gP = max(bs.rgb, vec3(${JNLM_ALBEDO_FLOOR}));
+vec3 mb = vec3(0.0);
+vec3 gs = vec3(0.0);
+vec3 hn = vec3(0.0);
+float pg = 0.0;
+float gu = 0.0;
+float nH = 0.0;
+float kA = 0.0;
+for (int sy = -SEARCH_RADIUS; sy <= SEARCH_RADIUS; sy++) {
+for (int sx = -SEARCH_RADIUS; sx <= SEARCH_RADIUS; sx++) {
+ivec2 q = p + ivec2(sx, sy) * dilation;
+if (
+(sx == 0 && sy == 0) ||
+q.x < 0 || q.y < 0 || q.x >= imageSize.x || q.y >= imageSize.y
+) continue;
+float features = lk(q, bs, gM);
+if (features > 16.0) continue;
+
+float fT = 0.0;
+k = 0;
+for (int dy = -PATCH_RADIUS; dy <= PATCH_RADIUS; dy++) {
+for (int dx = -PATCH_RADIUS; dx <= PATCH_RADIUS; dx++) {
+vec2 a = kT[k];
+vec2 b = nq(q + ivec2(dx, dy) * dilation);
+float qH = a.x - b.x;
+fT += (qH * qH
+- VARIANCE_CANCELLATION * (a.y + min(a.y, b.y)))
+/ (1e-10 + k2 * (a.y + b.y));
+k++;
+}
+}
+fT /= float(PATCH_SIZE);
+
+float weight = exp(-max(max(fT, 0.0), features));
+vec2 g = nq(q);
+
+vec3 a = (load_albedoTex(q, 0).rgb - bs.rgb) / gP;
+vec4 value = rv(q);
+sum += value * weight;
+mb += a * weight;
+gs += a * a * weight;
+hn += a * value.rgb * weight;
+pg += g.x * weight;
+gu += g.y * weight * weight;
+nH += weight;
+kA = max(kA, weight);
+}
+}
+
+
+
+vec4 center = rv(p);
+vec2 kS = nq(p);
+float dF = max(kA, CENTER_WEIGHT_MIN);
+float totalWeight = nH + dF;
+vec4 mean = (sum + center * dF) / totalWeight;
+
+
+vec3 ez = mb / totalWeight;
+vec3 ll = max(gs / totalWeight - ez * ez, vec3(0.0));
+vec3 qi = hn / totalWeight - ez * mean.rgb;
+
+
+
+vec3 qs = bs.rgb + ez * gP;
+vec3 ol = mean.rgb * gP / max(qs, vec3(${JNLM_ALBEDO_FLOOR}));
+vec3 vk = clamp(qi / (ll + vec3(${JNLM_ALBEDO_REGULARIZATION})), vec3(0.0), ol);
+vec3 rn = mean.rgb - vk * ez;
+vec4 filtered = vec4(max(rn, vec3(0.0)), max(mean.a, 0.0));
+vec3 rgb = filtered.a > 1e-6
+? filtered.rgb / max(filtered.a, 1e-6)
+: center.rgb / max(center.a, 1e-6);
+if (encodeOutput) rgb = pow(max(rgb, 0.0), vec3(1.0 / 2.2));
+out_color = vec4(rgb, filtered.a);
+out_guide = vec4(
+(pg + kS.x * dF) / totalWeight,
+(gu + kS.y * dF * dF)
+/ (totalWeight * totalWeight),
+0.0,
+1.0
+);
+}`
+});
+const floatOutput = {
+    type: constants.FLOAT,
+    minFilter: constants.NEAREST,
+    magFilter: constants.NEAREST
+};
+export class WebGLJNLMDenoisePass {
+    _renderer;
+    _guidePass;
+    _variancePass;
+    // Two instances so consecutive passes ping-pong between their outputs.
+    _filterPasses;
+    constructor(renderer) {
+        this._renderer = renderer;
+        this._guidePass = new WebGLFullQuadPass('jnlmGuide', renderer, {
+            shader: guideFragment,
+            outputParams: { guide: floatOutput }
+        });
+        this._variancePass = new WebGLFullQuadPass('jnlmVariance', renderer, {
+            shader: varianceFragment,
+            outputParams: { guide: floatOutput }
+        });
+        this._filterPasses = [0, 1].map(() => new WebGLFullQuadPass('jnlmFilter', renderer, {
+            shader: filterFragment,
+            outputParams: {
+                color: { type: constants.HALF_FLOAT },
+                guide: floatOutput
+            }
+        }));
+    }
+    /** Runs the denoiser and returns the display-encoded result. */
+    render(inputs) {
+        const { width, height, shape } = inputs;
+        const passes = [this._guidePass, this._variancePass, ...this._filterPasses];
+        passes.forEach((pass) => pass.setSize(width, height));
+        this._guidePass.createPass({
+            momentsTex: inputs.moments,
+            catcherMomentsTex: inputs.catcherMoments ?? this._renderer.emptyTexture
+        });
+        this._variancePass.createPass({ rawGuideTex: this._guidePass.getOutput('guide') });
+        const sensitivity = JNLM_DEFAULT_COLOR_SENSITIVITY * Math.max(inputs.strength, 1e-3);
+        const iterations = Math.min(JNLM_MAX_ITERATIONS, Math.max(1, Math.round(shape.iterations)));
+        let guide = this._variancePass.getOutput('guide');
+        let color = inputs.color;
+        for (let i = 0; i < iterations; i++) {
+            const pass = this._filterPasses[i % 2];
+            pass.setDefines({
+                SEARCH_RADIUS: shape.searchRadius,
+                // Numeric zero removes a define in the WebGL shader builder.
+                PATCH_RADIUS: String(shape.patchRadius),
+                INV_ALBEDO_BANDWIDTH2: (1 / shape.albedoBandwidth ** 2).toFixed(6),
+                INV_NORMAL_BANDWIDTH2: (1 / shape.normalBandwidth ** 2).toFixed(6)
+            });
+            pass.setUniforms({
+                colorSensitivity: sensitivity,
+                dilation: jnlmPassDilation(i),
+                decodeInput: i === 0,
+                encodeOutput: i === iterations - 1
+            });
+            pass.createPass({
+                guideTex: guide,
+                colorTex: color,
+                albedoTex: inputs.albedo,
+                normalTex: inputs.normal,
+                shadowCatcherTex: inputs.shadowCatcher
+            });
+            guide = pass.getOutput('guide');
+            color = pass.getOutput('color');
+        }
+        return color;
+    }
+    reserveCapacity() {
+        [this._guidePass, this._variancePass, ...this._filterPasses].forEach(pass => pass.reserveCapacity());
+    }
+    retainOutput(texture) { this._filterPasses.forEach(pass => pass.retainOutput(texture)); }
+    releaseOutput(texture) { this._filterPasses.forEach(pass => pass.releaseOutput(texture)); }
+    getMemoryBytes() {
+        return [this._guidePass, this._variancePass, ...this._filterPasses]
+            .reduce((sum, pass) => sum + pass.getMemoryBytes(), 0);
+    }
+    dispose() {
+        [this._guidePass, this._variancePass, ...this._filterPasses].forEach((pass) => pass.dispose());
+    }
+}
+//# sourceMappingURL=WebGLJNLMDenoiser.js.map

package/lib/renderer/WebGLJNLMDenoiser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebGLJNLMDenoiser.js","sourceRoot":"","sources":["../../src/renderer/WebGLJNLMDenoiser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAC3D,OAAO,EAAE,SAAS,EAA0B,MAAM,YAAY,CAAC;AAC/D,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EACL,8BAA8B,EAC9B,iBAAiB,EACjB,0BAA0B,EAC1B,kBAAkB,EAClB,uBAAuB,EACvB,mBAAmB,EACnB,gBAAgB,EAEjB,MAAM,WAAW,CAAC;AAEnB;;;GAGG;AAEH;;;GAGG;AACH,MAAM,aAAa,GAAG,IAAI,cAAc,CAAC;IACvC,IAAI,EAAE,WAAW;IACjB,OAAO,EAAE,CAAC,OAAO,CAAC;IAClB,QAAQ,EAAE;QACR,UAAU,EAAE,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC;QACvC,iBAAiB,EAAE,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC;KAC/C;IACD,IAAI,EAAE,IAAI,CAAA;;;;;;;;;;;EAWV;CACD,CAAC,CAAC;AAEH;;;GAGG;AACH,MAAM,gBAAgB,GAAG,IAAI,cAAc,CAAC;IAC1C,IAAI,EAAE,cAAc;IACpB,OAAO,EAAE,CAAC,OAAO,CAAC;IAClB,QAAQ,EAAE;QACR,WAAW,EAAE,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC;KACzC;IACD,IAAI,EAAE,IAAI,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BV;CACD,CAAC,CAAC;AAEH;;;GAGG;AACH,MAAM,cAAc,GAAG,IAAI,cAAc,CAAC;IACxC,IAAI,EAAE,YAAY;IAClB,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC;IAC3B,OAAO,EAAE;QACP,aAAa,EAAE,kBAAkB,CAAC,YAAY;QAC9C,YAAY,EAAE,kBAAkB,CAAC,WAAW;QAC5C,qBAAqB,EAAE,CAAC,CAAC,GAAG,kBAAkB,CAAC,eAAe,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC;QAC/E,qBAAqB,EAAE,CAAC,CAAC,GAAG,kBAAkB,CAAC,eAAe,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC;KAChF;IACD,QAAQ,EAAE;QACR,QAAQ,EAAE,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC;QACrC,QAAQ,EAAE,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC;QACrC,SAAS,EAAE,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC;QACtC,SAAS,EAAE,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC;QACtC,gBAAgB,EAAE,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC;QAC7C,gBAAgB,EAAE,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,8BAA8B,CAAC;QACzE,QAAQ,EAAE,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC;QAClC,WAAW,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;QACtC,YAAY,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;KACxC;IACD,IAAI,EAAE,IAAI,CAAA;;;;;;;kCAOsB,CAAC,CAAC,GAAG,uBAAuB,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;kDAmBR,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAuCrC,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yCAiEG,iBAAiB;kCAC5B,0BAA0B;;;;;;;;;;;;;;;EAepF;CACD,CAAC,CAAC;AAmBH,MAAM,WAAW,GAAG;IAClB,IAAI,EAAE,SAAS,CAAC,KAAK;IACrB,SAAS,EAAE,SAAS,CAAC,OAAO;IAC5B,SAAS,EAAE,SAAS,CAAC,OAAO;CAC7B,CAAC;AAEF,MAAM,OAAO,oBAAoB;IACvB,SAAS,CAAc;IACvB,UAAU,CAAiE;IAC3E,aAAa,CAA4C;IACjE,uEAAuE;IAC/D,aAAa,CAGjB;IAEJ,YAAY,QAAqB;QAC/B,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC;QAC1B,IAAI,CAAC,UAAU,GAAG,IAAI,iBAAiB,CAAC,WAAW,EAAE,QAAQ,EAAE;YAC7D,MAAM,EAAE,aAAa;YACrB,YAAY,EAAE,EAAE,KAAK,EAAE,WAAW,EAAE;SACrC,CAAC,CAAC;QACH,IAAI,CAAC,aAAa,GAAG,IAAI,iBAAiB,CAAC,cAAc,EAAE,QAAQ,EAAE;YACnE,MAAM,EAAE,gBAAgB;YACxB,YAAY,EAAE,EAAE,KAAK,EAAE,WAAW,EAAE;SACrC,CAAC,CAAC;QACH,IAAI,CAAC,aAAa,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,CACnC,IAAI,iBAAiB,CAAC,YAAY,EAAE,QAAQ,EAAE;YAC5C,MAAM,EAAE,cAAc;YACtB,YAAY,EAAE;gBACZ,KAAK,EAAE,EAAE,IAAI,EAAE,SAAS,CAAC,UAAU,EAAE;gBACrC,KAAK,EAAE,WAAW;aACnB;SACF,CAAC,CACH,CAAC;IACJ,CAAC;IAED,gEAAgE;IAChE,MAAM,CAAC,MAAuB;QAC5B,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,CAAC;QACxC,MAAM,MAAM,GAAG,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,aAAa,EAAE,GAAG,IAAI,CAAC,aAAa,CAAC,CAAC;QAC5E,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC;QACtD,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC;YACzB,UAAU,EAAE,MAAM,CAAC,OAAO;YAC1B,iBAAiB,EAAE,MAAM,CAAC,cAAc,IAAI,IAAI,CAAC,SAAS,CAAC,YAAY;SACxE,CAAC,CAAC;QACH,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,EAAE,WAAW,EAAE,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;QAEnF,MAAM,WAAW,GAAG,8BAA8B,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;QACrF,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,mBAAmB,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;QAC5F,IAAI,KAAK,GAAG,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;QAClD,IAAI,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;QACzB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,EAAE,CAAC,EAAE,EAAE,CAAC;YACpC,MAAM,IAAI,GAAG,IAAI,CAAC,aAAa,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;YACvC,IAAI,CAAC,UAAU,CAAC;gBACd,aAAa,EAAE,KAAK,CAAC,YAAY;gBACjC,6DAA6D;gBAC7D,YAAY,EAAE,MAAM,CAAC,KAAK,CAAC,WAAW,CAAC;gBACvC,qBAAqB,EAAE,CAAC,CAAC,GAAG,KAAK,CAAC,eAAe,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC;gBAClE,qBAAqB,EAAE,CAAC,CAAC,GAAG,KAAK,CAAC,eAAe,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC;aACnE,CAAC,CAAC;YACH,IAAI,CAAC,WAAW,CAAC;gBACf,gBAAgB,EAAE,WAAW;gBAC7B,QAAQ,EAAE,gBAAgB,CAAC,CAAC,CAAC;gBAC7B,WAAW,EAAE,CAAC,KAAK,CAAC;gBACpB,YAAY,EAAE,CAAC,KAAK,UAAU,GAAG,CAAC;aACnC,CAAC,CAAC;YACH,IAAI,CAAC,UAAU,CAAC;gBACd,QAAQ,EAAE,KAAK;gBACf,QAAQ,EAAE,KAAK;gBACf,SAAS,EAAE,MAAM,CAAC,MAAM;gBACxB,SAAS,EAAE,MAAM,CAAC,MAAM;gBACxB,gBAAgB,EAAE,MAAM,CAAC,aAAa;aACvC,CAAC,CAAC;YACH,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;YAChC,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;QAClC,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,eAAe;QACb,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,aAAa,EAAE,GAAG,IAAI,CAAC,aAAa,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,eAAe,EAAE,CAAC,CAAC;IACvG,CAAC;IAED,YAAY,CAAC,OAAkB,IAAI,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;IACpG,aAAa,CAAC,OAAkB,IAAI,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;IAEtG,cAAc;QACZ,OAAO,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,aAAa,EAAE,GAAG,IAAI,CAAC,aAAa,CAAC;aAChE,MAAM,CAAC,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE,CAAC,GAAG,GAAG,IAAI,CAAC,cAAc,EAAE,EAAE,CAAC,CAAC,CAAC;IAC3D,CAAC;IAED,OAAO;QACL,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,aAAa,EAAE,GAAG,IAAI,CAAC,aAAa,CAAC,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE,CAC5E,IAAI,CAAC,OAAO,EAAE,CACf,CAAC;IACJ,CAAC;CACF","sourcesContent":["import { FragmentShader, glsl, Shader } from './shader.js';\nimport { constants, WebGLDevice, Texture2D } from './webgl.js';\nimport { WebGLFullQuadPass } from './WebGLFullQuadPass.js';\nimport {\n  JNLM_DEFAULT_COLOR_SENSITIVITY,\n  JNLM_ALBEDO_FLOOR,\n  JNLM_ALBEDO_REGULARIZATION,\n  JNLM_DEFAULT_SHAPE,\n  JNLM_COVERAGE_BANDWIDTH,\n  JNLM_MAX_ITERATIONS,\n  jnlmPassDilation,\n  type JNLMFilterShape\n} from './jnlm.js';\n\n/**\n * WebGL 2 passes of the JNLM denoiser described in `jnlm.ts`, matching\n * WGPUJNLMDenoiser. Textures replace its storage buffers.\n */\n\n/**\n * The guide mean and the variance of that mean. The main and catcher trace\n * passes each accumulate (sum, sum of squares, count) for their own samples.\n */\nconst guideFragment = new FragmentShader({\n  name: 'jnlmGuide',\n  outputs: ['guide'],\n  uniforms: {\n    momentsTex: Shader.uniform('sampler2D'),\n    catcherMomentsTex: Shader.uniform('sampler2D')\n  },\n  main: glsl`\nvoid main() {\n  ivec2 p = ivec2(gl_FragCoord.xy);\n  vec4 moments = load_momentsTex(p, 0) + load_catcherMomentsTex(p, 0);\n  float n = moments.z;\n  float mean = moments.x / max(n, 1.0);\n  // Variance of the mean, or -1 when one sample cannot estimate it.\n  float variance = n >= 2.0\n    ? max(moments.y - n * mean * mean, 0.0) / (n * (n - 1.0))\n    : -1.0;\n  out_guide = vec4(mean, variance, 0.0, 1.0);\n}`\n});\n\n/**\n * Smooths the noisy per-pixel variance over 3 x 3 pixels. Pixels with a\n * single sample take the spatial variance of their neighborhood instead.\n */\nconst varianceFragment = new FragmentShader({\n  name: 'jnlmVariance',\n  outputs: ['guide'],\n  uniforms: {\n    rawGuideTex: Shader.uniform('sampler2D')\n  },\n  main: glsl`\nvoid main() {\n  ivec2 p = ivec2(gl_FragCoord.xy);\n  ivec2 size = rawGuideTexRegion();\n  vec2 center = load_rawGuideTex(p, 0).xy;\n  float varianceSum = 0.0;\n  float varianceCount = 0.0;\n  float meanSum = 0.0;\n  float meanSquareSum = 0.0;\n  for (int dy = -1; dy <= 1; dy++) {\n    for (int dx = -1; dx <= 1; dx++) {\n      vec2 value = load_rawGuideTex(clamp(p + ivec2(dx, dy), ivec2(0), size - 1), 0).xy;\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  float variance;\n  if (center.y >= 0.0) {\n    variance = varianceSum / varianceCount;\n  } else {\n    float spatialMean = meanSum / 9.0;\n    variance = max(meanSquareSum / 9.0 - spatialMean * spatialMean, 0.0) * 9.0 / 8.0;\n  }\n  out_guide = vec4(center.x, variance, 0.0, 1.0);\n}`\n});\n\n/**\n * One joint NL-means pass; see createJNLMFilterWGSL. The first pass decodes\n * the display-encoded composition to linear light, the last encodes it again.\n */\nconst filterFragment = new FragmentShader({\n  name: 'jnlmFilter',\n  outputs: ['color', 'guide'],\n  defines: {\n    SEARCH_RADIUS: JNLM_DEFAULT_SHAPE.searchRadius,\n    PATCH_RADIUS: JNLM_DEFAULT_SHAPE.patchRadius,\n    INV_ALBEDO_BANDWIDTH2: (1 / JNLM_DEFAULT_SHAPE.albedoBandwidth ** 2).toFixed(6),\n    INV_NORMAL_BANDWIDTH2: (1 / JNLM_DEFAULT_SHAPE.normalBandwidth ** 2).toFixed(6)\n  },\n  uniforms: {\n    guideTex: Shader.uniform('sampler2D'),\n    colorTex: Shader.uniform('sampler2D'),\n    albedoTex: Shader.uniform('sampler2D'),\n    normalTex: Shader.uniform('sampler2D'),\n    shadowCatcherTex: Shader.uniform('sampler2D'),\n    colorSensitivity: Shader.uniform('float', JNLM_DEFAULT_COLOR_SENSITIVITY),\n    dilation: Shader.uniform('int', 1),\n    decodeInput: Shader.uniform('bool', 0),\n    encodeOutput: Shader.uniform('bool', 0)\n  },\n  main: glsl`\n#define PATCH_SIZE ((2 * PATCH_RADIUS + 1) * (2 * PATCH_RADIUS + 1))\n// Variance cancellation strength alpha of the paper.\n#define VARIANCE_CANCELLATION 1.0\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.\n#define CENTER_WEIGHT_MIN 0.01\n#define INV_COVERAGE_BANDWIDTH2 ${(1 / JNLM_COVERAGE_BANDWIDTH ** 2).toFixed(6)}\n\nivec2 imageSize;\n\nvec2 loadGuide(ivec2 p) {\n  return load_guideTex(clamp(p, ivec2(0), imageSize - 1), 0).xy;\n}\n\n// Premultiplied linear color.\nvec4 loadColor(ivec2 p) {\n  vec4 c = load_colorTex(p, 0);\n  if (decodeInput) c.rgb = pow(max(c.rgb, 0.0), vec3(2.2));\n  return vec4(c.rgb * c.a, c.a);\n}\n\nfloat featureDistance(ivec2 q, vec4 centerAlbedo, vec3 centerNormal) {\n  vec4 albedo = load_albedoTex(q, 0);\n  // Match WebGPU: protect relative RGB contrast, including dark textures,\n  // while keeping coverage differences in absolute units.\n  vec3 albedoScale = max((albedo.rgb + centerAlbedo.rgb) * 0.5, vec3(${JNLM_ALBEDO_FLOOR}));\n  vec3 albedoDelta = (albedo.rgb - centerAlbedo.rgb) / albedoScale;\n  float coverageDelta = albedo.a - centerAlbedo.a;\n  vec3 normalDelta = load_normalTex(q, 0).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\nvoid main() {\n  imageSize = guideTexRegion();\n  ivec2 p = ivec2(gl_FragCoord.xy);\n  vec4 centerAlbedo = load_albedoTex(p, 0);\n  vec4 centerNormalTexel = load_normalTex(p, 0);\n  vec3 centerNormal = centerNormalTexel.rgb;\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 && load_shadowCatcherTex(p, 0).r <= 0.0) {\n    vec4 c = loadColor(p);\n    vec3 rgb = c.rgb / max(c.a, 1e-6);\n    if (encodeOutput) rgb = pow(max(rgb, 0.0), vec3(1.0 / 2.2));\n    out_color = vec4(rgb, c.a);\n    out_guide = vec4(loadGuide(p), 0.0, 1.0);\n    return;\n  }\n\n  vec2 centerPatch[PATCH_SIZE];\n  int k = 0;\n  for (int dy = -PATCH_RADIUS; dy <= PATCH_RADIUS; dy++) {\n    for (int dx = -PATCH_RADIUS; dx <= PATCH_RADIUS; dx++) {\n      centerPatch[k] = loadGuide(p + ivec2(dx, dy) * dilation);\n      k++;\n    }\n  }\n  float k2 = colorSensitivity * colorSensitivity;\n\n  vec4 sum = vec4(0.0);\n  vec3 featureScale = max(centerAlbedo.rgb, vec3(${JNLM_ALBEDO_FLOOR}));\n  vec3 featureSum = vec3(0.0);\n  vec3 featureSquareSum = vec3(0.0);\n  vec3 featureColorSum = vec3(0.0);\n  float guideSum = 0.0;\n  float guideVarianceSum = 0.0;\n  float weightSum = 0.0;\n  float maxWeight = 0.0;\n  for (int sy = -SEARCH_RADIUS; sy <= SEARCH_RADIUS; sy++) {\n    for (int sx = -SEARCH_RADIUS; sx <= SEARCH_RADIUS; sx++) {\n      ivec2 q = p + ivec2(sx, sy) * dilation;\n      if (\n        (sx == 0 && sy == 0) ||\n        q.x < 0 || q.y < 0 || q.x >= imageSize.x || q.y >= imageSize.y\n      ) continue;\n      float features = featureDistance(q, centerAlbedo, centerNormal);\n      if (features > 16.0) continue;\n\n      float colorDistance = 0.0;\n      k = 0;\n      for (int dy = -PATCH_RADIUS; dy <= PATCH_RADIUS; dy++) {\n        for (int dx = -PATCH_RADIUS; dx <= PATCH_RADIUS; dx++) {\n          vec2 a = centerPatch[k];\n          vec2 b = loadGuide(q + ivec2(dx, dy) * dilation);\n          float 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 /= float(PATCH_SIZE);\n\n      float weight = exp(-max(max(colorDistance, 0.0), features));\n      vec2 g = loadGuide(q);\n      // Filter premultiplied color so coverage and color stay consistent.\n      vec3 a = (load_albedoTex(q, 0).rgb - centerAlbedo.rgb) / featureScale;\n      vec4 value = loadColor(q);\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  vec4 center = loadColor(p);\n  vec2 centerGuide = loadGuide(p);\n  float centerWeight = max(maxWeight, CENTER_WEIGHT_MIN);\n  float totalWeight = weightSum + centerWeight;\n  vec4 mean = (sum + center * 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  vec3 meanFeature = featureSum / totalWeight;\n  vec3 featureVariance = max(featureSquareSum / totalWeight - meanFeature * meanFeature, vec3(0.0));\n  vec3 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  vec3 meanAlbedo = centerAlbedo.rgb + meanFeature * featureScale;\n  vec3 maximumSlope = mean.rgb * featureScale / max(meanAlbedo, vec3(${JNLM_ALBEDO_FLOOR}));\n  vec3 slope = clamp(covariance / (featureVariance + vec3(${JNLM_ALBEDO_REGULARIZATION})), vec3(0.0), maximumSlope);\n  vec3 corrected = mean.rgb - slope * meanFeature;\n  vec4 filtered = vec4(max(corrected, vec3(0.0)), max(mean.a, 0.0));\n  vec3 rgb = filtered.a > 1e-6\n    ? filtered.rgb / max(filtered.a, 1e-6)\n    : center.rgb / max(center.a, 1e-6);\n  if (encodeOutput) rgb = pow(max(rgb, 0.0), vec3(1.0 / 2.2));\n  out_color = vec4(rgb, filtered.a);\n  out_guide = vec4(\n    (guideSum + centerGuide.x * centerWeight) / totalWeight,\n    (guideVarianceSum + centerGuide.y * centerWeight * centerWeight)\n      / (totalWeight * totalWeight),\n    0.0,\n    1.0\n  );\n}`\n});\n\nexport interface WebGLJNLMInputs {\n  width: number;\n  height: number;\n  /** Main trace pass moments: guide sum, sum of squares and count. */\n  moments: Texture2D;\n  /** Catcher trace pass moments, when the scene has a shadow catcher. */\n  catcherMoments?: Texture2D;\n  /** Display-encoded composition to filter. */\n  color: Texture2D;\n  albedo: Texture2D;\n  normal: Texture2D;\n  /** Normalized shadow-catcher mask; red is the catcher coverage. */\n  shadowCatcher: Texture2D;\n  strength: number;\n  shape: JNLMFilterShape;\n}\n\nconst floatOutput = {\n  type: constants.FLOAT,\n  minFilter: constants.NEAREST,\n  magFilter: constants.NEAREST\n};\n\nexport class WebGLJNLMDenoisePass {\n  private _renderer: WebGLDevice;\n  private _guidePass: WebGLFullQuadPass<'momentsTex' | 'catcherMomentsTex', 'guide'>;\n  private _variancePass: WebGLFullQuadPass<'rawGuideTex', 'guide'>;\n  // Two instances so consecutive passes ping-pong between their outputs.\n  private _filterPasses: WebGLFullQuadPass<\n    'guideTex' | 'colorTex' | 'albedoTex' | 'normalTex' | 'shadowCatcherTex',\n    'color' | 'guide'\n  >[];\n\n  constructor(renderer: WebGLDevice) {\n    this._renderer = renderer;\n    this._guidePass = new WebGLFullQuadPass('jnlmGuide', renderer, {\n      shader: guideFragment,\n      outputParams: { guide: floatOutput }\n    });\n    this._variancePass = new WebGLFullQuadPass('jnlmVariance', renderer, {\n      shader: varianceFragment,\n      outputParams: { guide: floatOutput }\n    });\n    this._filterPasses = [0, 1].map(() =>\n      new WebGLFullQuadPass('jnlmFilter', renderer, {\n        shader: filterFragment,\n        outputParams: {\n          color: { type: constants.HALF_FLOAT },\n          guide: floatOutput\n        }\n      })\n    );\n  }\n\n  /** Runs the denoiser and returns the display-encoded result. */\n  render(inputs: WebGLJNLMInputs): Texture2D {\n    const { width, height, shape } = inputs;\n    const passes = [this._guidePass, this._variancePass, ...this._filterPasses];\n    passes.forEach((pass) => pass.setSize(width, height));\n    this._guidePass.createPass({\n      momentsTex: inputs.moments,\n      catcherMomentsTex: inputs.catcherMoments ?? this._renderer.emptyTexture\n    });\n    this._variancePass.createPass({ rawGuideTex: this._guidePass.getOutput('guide') });\n\n    const sensitivity = JNLM_DEFAULT_COLOR_SENSITIVITY * Math.max(inputs.strength, 1e-3);\n    const iterations = Math.min(JNLM_MAX_ITERATIONS, Math.max(1, Math.round(shape.iterations)));\n    let guide = this._variancePass.getOutput('guide');\n    let color = inputs.color;\n    for (let i = 0; i < iterations; i++) {\n      const pass = this._filterPasses[i % 2];\n      pass.setDefines({\n        SEARCH_RADIUS: shape.searchRadius,\n        // Numeric zero removes a define in the WebGL shader builder.\n        PATCH_RADIUS: String(shape.patchRadius),\n        INV_ALBEDO_BANDWIDTH2: (1 / shape.albedoBandwidth ** 2).toFixed(6),\n        INV_NORMAL_BANDWIDTH2: (1 / shape.normalBandwidth ** 2).toFixed(6)\n      });\n      pass.setUniforms({\n        colorSensitivity: sensitivity,\n        dilation: jnlmPassDilation(i),\n        decodeInput: i === 0,\n        encodeOutput: i === iterations - 1\n      });\n      pass.createPass({\n        guideTex: guide,\n        colorTex: color,\n        albedoTex: inputs.albedo,\n        normalTex: inputs.normal,\n        shadowCatcherTex: inputs.shadowCatcher\n      });\n      guide = pass.getOutput('guide');\n      color = pass.getOutput('color');\n    }\n    return color;\n  }\n\n  reserveCapacity() {\n    [this._guidePass, this._variancePass, ...this._filterPasses].forEach(pass => pass.reserveCapacity());\n  }\n\n  retainOutput(texture: Texture2D) { this._filterPasses.forEach(pass => pass.retainOutput(texture)); }\n  releaseOutput(texture: Texture2D) { this._filterPasses.forEach(pass => pass.releaseOutput(texture)); }\n\n  getMemoryBytes() {\n    return [this._guidePass, this._variancePass, ...this._filterPasses]\n      .reduce((sum, pass) => sum + pass.getMemoryBytes(), 0);\n  }\n\n  dispose() {\n    [this._guidePass, this._variancePass, ...this._filterPasses].forEach((pass) =>\n      pass.dispose()\n    );\n  }\n}\n"]}

package/lib/renderer/WebGLRayTraceOutputPass.d.ts

@@ -0,0 +1,20 @@
+import { WebGLDevice, Texture2D } from './webgl.js';
+import WebGLRayTracePass from './WebGLRayTracePass.js';
+type LayerOutput = 'foreground' | 'catcherBackground';
+type RayTraceOutput = 'color' | 'albedo' | 'normal' | 'shadowCatcher';
+/** Converts the additive ray tracing buffers into display/denoise textures. */
+export declare class WebGLRayTraceOutputPass {
+    private readonly _renderer;
+    private readonly _pass;
+    private readonly _layersPass;
+    constructor(renderer: WebGLDevice);
+    setSize(width: number, height: number): void;
+    setSampleCount(sampleCount: number): void;
+    createPass(rayTracePass: WebGLRayTracePass): void;
+    getOutput(label: RayTraceOutput | LayerOutput): Texture2D;
+    retainOutput(texture: Texture2D): void;
+    releaseOutput(texture: Texture2D): void;
+    getMemoryBytes(): number;
+    dispose(): void;
+}
+export {};

package/lib/renderer/WebGLRayTraceOutputPass.js

@@ -0,0 +1,106 @@
+import { FragmentShader, Shader, glsl } from './shader.js';
+import { constants } from './webgl.js';
+import normalizeRayTraceOutput from './glsl/normalizeRayTraceOutput.frag.js';
+import { WebGLFullQuadPass } from './WebGLFullQuadPass.js';
+/** Converts the additive ray tracing buffers into display/denoise textures. */
+export class WebGLRayTraceOutputPass {
+    _renderer;
+    _pass;
+    _layersPass;
+    constructor(renderer) {
+        this._renderer = renderer;
+        this._pass = new WebGLFullQuadPass('rayTraceOutput', renderer, {
+            shader: normalizeRayTraceOutput,
+            outputs: ['color', 'albedo', 'normal', 'shadowCatcher'],
+            outputParams: {
+                color: {
+                    type: constants.HALF_FLOAT,
+                    minFilter: constants.LINEAR,
+                    magFilter: constants.LINEAR
+                },
+                albedo: { type: constants.UNSIGNED_BYTE },
+                normal: { type: constants.UNSIGNED_BYTE },
+                shadowCatcher: { type: constants.HALF_FLOAT }
+            }
+        });
+        this._layersPass = new WebGLFullQuadPass('rayTraceLayers', renderer, {
+            shader: new FragmentShader({
+                name: 'normalizeRayTraceLayers',
+                outputs: ['foreground', 'catcherBackground'],
+                uniforms: {
+                    colorTex: Shader.uniform('sampler2D'),
+                    albedoTex: Shader.uniform('sampler2D'),
+                    normalTex: Shader.uniform('sampler2D'),
+                    shadowCatcherTex: Shader.uniform('sampler2D'),
+                    catcherBackgroundTex: Shader.uniform('sampler2D'),
+                    sampleCount: Shader.uniform('float', 1)
+                },
+                main: glsl `
+void main() {
+vec4 light = sample_colorTex(v_Texcoord);
+vec4 mask = sample_shadowCatcherTex(v_Texcoord);
+vec4 background = sample_catcherBackgroundTex(v_Texcoord);
+float hit = sample_albedoTex(v_Texcoord).a;
+
+float pW = max(sample_normalTex(v_Texcoord).a, 1.0) / sampleCount;
+float iP = max(hit - mask.b * pW, 0.0);
+out_foreground = vec4(
+(light.rgb - background.rgb * pW)
+/ (iP > 0.0 ? iP : sampleCount),
+clamp((light.a - background.a) / sampleCount, 0.0, 1.0)
+);
+out_catcherBackground = background / sampleCount;
+}`
+            }),
+            outputs: ['foreground', 'catcherBackground'],
+            outputParams: {
+                foreground: { type: constants.HALF_FLOAT },
+                catcherBackground: { type: constants.HALF_FLOAT }
+            }
+        });
+    }
+    setSize(width, height) {
+        this._pass.setSize(width, height);
+        this._layersPass.setSize(width, height);
+    }
+    setSampleCount(sampleCount) {
+        this._pass.setUniform('sampleCount', Math.max(sampleCount, 1));
+        this._layersPass.setUniform('sampleCount', Math.max(sampleCount, 1));
+    }
+    createPass(rayTracePass) {
+        this._pass.setOutputs(rayTracePass.hasShadowCatcher() ? ['color', 'albedo', 'normal', 'shadowCatcher'] : ['color', 'albedo', 'normal']);
+        this._pass.createPass({
+            colorTex: rayTracePass.getOutput('color'),
+            albedoTex: rayTracePass.getOutput('albedo'),
+            normalTex: rayTracePass.getOutput('normal'),
+            shadowCatcherTex: rayTracePass.hasShadowCatcher()
+                ? rayTracePass.getOutput('shadowCatcher')
+                : this._renderer.emptyTexture
+        }, undefined, { clear: true });
+        if (rayTracePass.hasShadowCatcher()) {
+            this._layersPass.setOutputs(['foreground', 'catcherBackground']);
+            this._layersPass.createPass({
+                colorTex: rayTracePass.getOutput('color'),
+                albedoTex: rayTracePass.getOutput('albedo'),
+                normalTex: rayTracePass.getOutput('normal'),
+                shadowCatcherTex: rayTracePass.getOutput('shadowCatcher'),
+                catcherBackgroundTex: rayTracePass.getOutput('catcherBackground')
+            }, undefined, { clear: true });
+        }
+        else {
+            this._layersPass.setOutputs([]);
+        }
+    }
+    getOutput(label) {
+        return label === 'foreground' || label === 'catcherBackground'
+            ? this._layersPass.getOutput(label) ?? this._renderer.emptyTexture : this._pass.getOutput(label) ?? this._renderer.emptyTexture;
+    }
+    retainOutput(texture) { this._pass.retainOutput(texture); this._layersPass.retainOutput(texture); }
+    releaseOutput(texture) { this._pass.releaseOutput(texture); this._layersPass.releaseOutput(texture); }
+    getMemoryBytes() { return this._pass.getMemoryBytes() + this._layersPass.getMemoryBytes(); }
+    dispose() {
+        this._pass.dispose();
+        this._layersPass.dispose();
+    }
+}
+//# sourceMappingURL=WebGLRayTraceOutputPass.js.map

package/lib/renderer/WebGLRayTraceOutputPass.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebGLRayTraceOutputPass.js","sourceRoot":"","sources":["../../src/renderer/WebGLRayTraceOutputPass.ts"],"names":[],"mappings":"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","sourcesContent":["import { FragmentShader, Shader, glsl } from './shader.js';\nimport { constants, WebGLDevice, Texture2D } from './webgl.js';\nimport normalizeRayTraceOutput from './glsl/normalizeRayTraceOutput.frag.js';\nimport { WebGLFullQuadPass } from './WebGLFullQuadPass.js';\nimport WebGLRayTracePass from './WebGLRayTracePass.js';\n\ntype RayTraceInput =\n  | 'colorTex'\n  | 'albedoTex'\n  | 'normalTex'\n  | 'shadowCatcherTex';\ntype LayerOutput = 'foreground' | 'catcherBackground';\ntype RayTraceOutput = 'color' | 'albedo' | 'normal' | 'shadowCatcher';\n\n/** Converts the additive ray tracing buffers into display/denoise textures. */\nexport class WebGLRayTraceOutputPass {\n  private readonly _renderer: WebGLDevice;\n  private readonly _pass: WebGLFullQuadPass<RayTraceInput, RayTraceOutput>;\n\n  private readonly _layersPass: WebGLFullQuadPass<\n    RayTraceInput | 'catcherBackgroundTex', LayerOutput\n  >;\n\n  constructor(renderer: WebGLDevice) {\n    this._renderer = renderer;\n    this._pass = new WebGLFullQuadPass('rayTraceOutput', renderer, {\n      shader: normalizeRayTraceOutput,\n      outputs: ['color', 'albedo', 'normal', 'shadowCatcher'],\n      outputParams: {\n        color: {\n          type: constants.HALF_FLOAT,\n          minFilter: constants.LINEAR,\n          magFilter: constants.LINEAR\n        },\n        albedo: { type: constants.UNSIGNED_BYTE },\n        normal: { type: constants.UNSIGNED_BYTE },\n        shadowCatcher: { type: constants.HALF_FLOAT }\n      }\n    });\n    this._layersPass = new WebGLFullQuadPass('rayTraceLayers', renderer, {\n      shader: new FragmentShader({\n        name: 'normalizeRayTraceLayers',\n        outputs: ['foreground', 'catcherBackground'],\n        uniforms: {\n          colorTex: Shader.uniform('sampler2D'),\n          albedoTex: Shader.uniform('sampler2D'),\n          normalTex: Shader.uniform('sampler2D'),\n          shadowCatcherTex: Shader.uniform('sampler2D'),\n          catcherBackgroundTex: Shader.uniform('sampler2D'),\n          sampleCount: Shader.uniform('float', 1)\n        },\n        main: glsl`\nvoid main() {\n  vec4 light = sample_colorTex(v_Texcoord);\n  vec4 mask = sample_shadowCatcherTex(v_Texcoord);\n  vec4 background = sample_catcherBackgroundTex(v_Texcoord);\n  float hit = sample_albedoTex(v_Texcoord).a;\n  // Full spectral beauty has three wavelength contributions per shadow sample.\n  float contributions = max(sample_normalTex(v_Texcoord).a, 1.0) / sampleCount;\n  float foregroundHit = max(hit - mask.b * contributions, 0.0);\n  out_foreground = vec4(\n    (light.rgb - background.rgb * contributions)\n      / (foregroundHit > 0.0 ? foregroundHit : sampleCount),\n    clamp((light.a - background.a) / sampleCount, 0.0, 1.0)\n  );\n  out_catcherBackground = background / sampleCount;\n}`\n      }),\n      outputs: ['foreground', 'catcherBackground'],\n      outputParams: {\n        foreground: { type: constants.HALF_FLOAT },\n        catcherBackground: { type: constants.HALF_FLOAT }\n      }\n    });\n  }\n\n  setSize(width: number, height: number) {\n    this._pass.setSize(width, height);\n    this._layersPass.setSize(width, height);\n  }\n\n  setSampleCount(sampleCount: number) {\n    this._pass.setUniform('sampleCount', Math.max(sampleCount, 1));\n    this._layersPass.setUniform('sampleCount', Math.max(sampleCount, 1));\n  }\n\n  createPass(rayTracePass: WebGLRayTracePass) {\n    this._pass.setOutputs(rayTracePass.hasShadowCatcher() ? ['color', 'albedo', 'normal', 'shadowCatcher'] : ['color', 'albedo', 'normal']);\n    this._pass.createPass(\n      {\n        colorTex: rayTracePass.getOutput('color'),\n        albedoTex: rayTracePass.getOutput('albedo'),\n        normalTex: rayTracePass.getOutput('normal'),\n        shadowCatcherTex: rayTracePass.hasShadowCatcher()\n          ? rayTracePass.getOutput('shadowCatcher')\n          : this._renderer.emptyTexture\n      },\n      undefined,\n      { clear: true }\n    );\n    if (rayTracePass.hasShadowCatcher()) {\n      this._layersPass.setOutputs(['foreground', 'catcherBackground']);\n      this._layersPass.createPass({\n        colorTex: rayTracePass.getOutput('color'),\n        albedoTex: rayTracePass.getOutput('albedo'),\n        normalTex: rayTracePass.getOutput('normal'),\n        shadowCatcherTex: rayTracePass.getOutput('shadowCatcher'),\n        catcherBackgroundTex: rayTracePass.getOutput('catcherBackground')\n      }, undefined, { clear: true });\n    } else {\n      this._layersPass.setOutputs([]);\n    }\n  }\n\n  getOutput(label: RayTraceOutput | LayerOutput): Texture2D {\n    return label === 'foreground' || label === 'catcherBackground'\n      ? this._layersPass.getOutput(label) ?? this._renderer.emptyTexture : this._pass.getOutput(label) ?? this._renderer.emptyTexture;\n  }\n\n  retainOutput(texture: Texture2D) { this._pass.retainOutput(texture); this._layersPass.retainOutput(texture); }\n  releaseOutput(texture: Texture2D) { this._pass.releaseOutput(texture); this._layersPass.releaseOutput(texture); }\n\n  getMemoryBytes() { return this._pass.getMemoryBytes() + this._layersPass.getMemoryBytes(); }\n\n  dispose() {\n    this._pass.dispose();\n    this._layersPass.dispose();\n  }\n}\n\n"]}

package/lib/renderer/WebGLRayTracePass.d.ts

@@ -0,0 +1,142 @@
+import { type SamplingPattern } from './sampling.js';
+import { type DepthSampleArea } from './depthQuery.js';
+import { WebGLDevice as WebGLRenderer, Texture2D as WebGLTexture2D } from './webgl.js';
+import Mesh from '../scene/Mesh.js';
+import OpenPBRMaterial from '../scene/OpenPBRMaterial.js';
+import { SceneBackground, SceneLight } from '../scene/Scene.js';
+import Camera from '../scene/Camera.js';
+import Geometry from '../scene/Geometry.js';
+declare class WebGLRayTracePass {
+    private readonly _renderer;
+    private _meshes;
+    private _sceneEnvironment;
+    private _rectLightTextures;
+    private _analyticLights;
+    private _analyticLightSelectionPmfs;
+    private _analyticLightSelectionCdfs;
+    private _envLightSelectionPmf;
+    private _materialData;
+    private _maxTextureArrayBytes;
+    private _preparedMeshData?;
+    private _membershipCache;
+    private _pendingMembershipData?;
+    private _materialChanges;
+    private _pendingMaterialUpdate?;
+    private _pendingGeometryUpdates;
+    private _needsUpdateMeshData;
+    private _needsUpdateMeshMembership;
+    private _needsRefitTLAS;
+    private _dirtyTransformMeshes;
+    private _dirtyColorMeshes;
+    private _tlas?;
+    private _bvhData?;
+    private _instancesData?;
+    private _materialIndexData?;
+    private _meshSnapshot;
+    private _snapshotByMesh;
+    private _needsUpdateAnalyticLightsBuffer;
+    private _debugBvhData?;
+    private _lightTex;
+    private _iesProfileTex;
+    private _iesProfileColumns;
+    private _iesProfileTexelOffsets;
+    private _openPbrEnergyLut;
+    private _envMap;
+    private _envMapDistribution;
+    private _envImageSource?;
+    private _backgroundTex;
+    private _hasEnvMap;
+    private _hasBackground;
+    private _groundedBackgroundParams;
+    private _groundedBackgroundCenter;
+    private _bounces;
+    private _bevelSamples;
+    private _clamping?;
+    private _samplingCode;
+    private _sequenceSeed;
+    private _zLogSPP;
+    private _positionBufferTex;
+    private _normalBufferTex;
+    private _colorBufferTex;
+    private _tangentBufferTex;
+    private _uvBufferTex;
+    private _uv1BufferTex;
+    private _bvhBufferTex;
+    private _instancesBufferTex;
+    private _matIndexBufferTex;
+    private _hasTransmission;
+    private _hasAlpha;
+    private _invalid;
+    private _transmissiveAlphaMin;
+    private _mainPass;
+    private _shadowCatcherPass;
+    private _viewProjInv;
+    private _apertureRadius;
+    private _focusDistance;
+    private _tracePasses;
+    private readonly _depthPass;
+    private readonly _depthAbort;
+    private _depthAspect;
+    private _hasShadowCatcher;
+    private _spectral;
+    constructor(renderer: WebGLRenderer);
+    createPass(clear: boolean, tile: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }, disableShadowCatcher?: boolean): void;
+    getOutput(label: 'color' | 'albedo' | 'normal' | 'moments' | 'shadowCatcher' | 'catcherBackground' | 'catcherMoments'): WebGLTexture2D;
+    setBounce(bounce: number): boolean;
+    setClamping(clamping?: number): boolean;
+    setBevelSamples(samples: number): boolean;
+    private _setEnvMap;
+    setBackground(background?: SceneBackground): void;
+    setTransmissiveOutputAlphaMin(transmissiveAlphaMin: number): boolean;
+    setMeshes(meshes: Mesh[], update?: {
+        transforms?: readonly Mesh[];
+        colors?: readonly Mesh[];
+        geometries?: readonly Geometry[];
+        materials?: readonly OpenPBRMaterial[];
+    }): boolean;
+    setTextureAtlasBudget(maxBytes: number): boolean;
+    getDebugBVHData(): {
+        buffer: ArrayBuffer;
+    };
+    getDiagnostics(): {
+        textureAtlas: import("./MaterialTable.js").TextureAtlasStats | undefined;
+    };
+    private _updateMeshData;
+    private _updateMaterialConstants;
+    private _updateMeshMembership;
+    private _updateGeometryData;
+    private _updateMeshColors;
+    private _refitMeshInstances;
+    private _updateMaterialData;
+    setLights(lights: SceneLight[]): void;
+    private _getViewProjInv;
+    setCamera(camera: Camera): void;
+    cameraChanged(camera: Camera): boolean;
+    setSize(width: number, height: number, targetAspect?: number): void;
+    setJitter(x: number, y: number): void;
+    releaseTarget(target: object): void;
+    getTargetMemoryBytes(target: object): number;
+    useTarget(target: object): void;
+    setQuality(options: {
+        bounces: number;
+        bevel: boolean;
+        dispersionWavelengths: 1 | 3;
+        directLightCandidates: number;
+    }): void;
+    setWavelength(wavelength: number): void;
+    setSampleCount(sampleCount: number): void;
+    isInvalid(): boolean;
+    hasShadowCatcher(): boolean;
+    hasDispersion(): boolean;
+    prepare(): void;
+    setSamplingPattern(pattern: SamplingPattern, maxSamples: number, sequenceSeed?: number): boolean;
+    setSampleSequenceOffset(_offset: number): void;
+    readDepthSamples(area: DepthSampleArea, aspect?: number): Promise<Float32Array | undefined>;
+    dispose(): void;
+}
+export default WebGLRayTracePass;