@meimu/mutracer 0.0.0-stage → 0.1.1

package/lib/renderer/glsl/shadowCatcher.frag.js

@@ -0,0 +1,119 @@
+// Portions adapted from ray-tracing-renderer@0.10.15
+// (https://github.com/hoverinc/ray-tracing-renderer).
+// Copyright (c) 2019 HOVER, MIT license; see LICENSES/RayTracingRenderer-MIT.txt.
+import cameraRayGlsl from './chunks/cameraRay.glsl.js';
+import common from './chunks/common.glsl.js';
+import rayTraceCore from './chunks/rayTraceCore.glsl.js';
+import textureLinear from './chunks/textureLinear.glsl.js';
+import materialBufferGlsl from './chunks/materialBuffer.glsl.js';
+import intersect from './chunks/intersect.glsl.js';
+import randGlsl from './chunks/rand.glsl.js';
+import random from './chunks/random.glsl.js';
+import envMap from './chunks/envMap.glsl.js';
+import sampleShadowCatcher from './chunks/sampleShadowCatcher.glsl.js';
+import sampleLight from './chunks/sampleLight.glsl.js';
+import { FragmentShader, glsl, Shader } from '../shader.js';
+import samplingGlsl from './chunks/sampling.glsl.js';
+import uvProjectionGlsl from './chunks/uvProjection.glsl.js';
+export default new FragmentShader({
+    name: 'shadowCatcher',
+    outputs: ['shadowCatcher', 'catcherBackground', 'catcherMoments'],
+    defines: {
+        BOUNCES: 2
+    },
+    uniforms: {
+        dispersionWavelengths: Shader.uniform('int', 3),
+        wavelength: Shader.uniform('float', 0),
+        viewportSize: Shader.uniform('vec2'),
+        viewProjectionInv: Shader.uniform('mat4'),
+        viewInv: Shader.uniform('mat4'),
+        cameraApertureRadius: Shader.uniform('float', 0),
+        cameraFocusDistance: Shader.uniform('float', 10)
+    },
+    includes: [rayTraceCore, materialBufferGlsl, intersect, random, envMap],
+    main: glsl `
+${common}
+${randGlsl}
+${random.main}
+
+${textureLinear}
+
+${rayTraceCore.main}
+${uvProjectionGlsl}
+
+${materialBufferGlsl.main}
+${intersect.main}
+${envMap.main}
+
+${samplingGlsl}
+${sampleLight}
+${sampleShadowCatcher}
+${cameraRayGlsl}
+
+
+
+vec4 mj(inout Ray ray, out vec4 background) {
+background = vec4(0.0);
+Path aa;
+aa.ray = ray;
+aa.li = vec3(0);
+aa.alpha = 1.0;
+aa.beta = vec3(1.0);
+aa.fromEye = true;
+aa.scatteringPdf = 0.0;
+aa.abort = false;
+
+ad si;
+
+cY(aa.ray, si, false);
+if (!si.hit) {
+
+
+
+return vec4(0.0, 0.0, 0.0, 1.0);
+}
+
+J mat;
+eT(mat, si.materialIndex, si.uv, si.uv1, si.instanceIndex);
+if (mat.materialType != SHADOW_CATCHER) {
+
+
+return vec4(0.0, 0.0, 0.0, 1.0);
+}
+
+vec4 bg = cw(ray.o, ray.d);
+background = vec4(bg.rgb * bg.a, bg.a);
+if (!aa.abort) {
+sampleShadowCatcher(si, 0, aa);
+}
+return vec4(1.0, bg.a, bg.a >= 0.01 ? 1.0 : 0.0, aa.alpha);
+}
+
+void main() {
+se();
+jY(v_Texcoord * viewportSize, int(uint(sampleCount) ^ eg(uint(sequenceSeed))));
+
+if (dispersionWavelengths == 1 && wavelength > 0.0) { dz(CAMERA_WAVELENGTH); }
+Ray cam = nv();
+vec4 background;
+vec4 aN = mj(cam, background);
+
+if (!(aN.x < INF && aN.x > -EPS)) {
+aN = vec4(0, 0, 0, 1);
+}
+
+out_shadowCatcher = aN;
+out_catcherBackground = background;
+
+
+
+float jj = aN.a * (background.a >= 0.01
+? dot(background.rgb / background.a, vec3(0.2126, 0.7152, 0.0722))
+: 1.0);
+out_catcherMoments = aN.r > 0.0
+? vec4(jj, jj * jj, 1.0, 0.0)
+: vec4(0.0);
+
+}`
+});
+//# sourceMappingURL=shadowCatcher.frag.js.map

package/lib/renderer/glsl/shadowCatcher.frag.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadowCatcher.frag.js","sourceRoot":"","sources":["../../../src/renderer/glsl/shadowCatcher.frag.ts"],"names":[],"mappings":"AAAA,qDAAqD;AACrD,sDAAsD;AACtD,kFAAkF;AAElF,OAAO,aAAa,MAAM,4BAA4B,CAAC;AACvD,OAAO,MAAM,MAAM,yBAAyB,CAAC;AAC7C,OAAO,YAAY,MAAM,+BAA+B,CAAC;AACzD,OAAO,aAAa,MAAM,gCAAgC,CAAC;AAC3D,OAAO,kBAAkB,MAAM,iCAAiC,CAAC;AACjE,OAAO,SAAS,MAAM,4BAA4B,CAAC;AACnD,OAAO,QAAQ,MAAM,uBAAuB,CAAC;AAC7C,OAAO,MAAM,MAAM,yBAAyB,CAAC;AAC7C,OAAO,MAAM,MAAM,yBAAyB,CAAC;AAC7C,OAAO,mBAAmB,MAAM,sCAAsC,CAAC;AACvE,OAAO,WAAW,MAAM,8BAA8B,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAC5D,OAAO,YAAY,MAAM,2BAA2B,CAAC;AACrD,OAAO,gBAAgB,MAAM,+BAA+B,CAAC;AAE7D,eAAe,IAAI,cAAc,CAAC;IAChC,IAAI,EAAE,eAAe;IACrB,OAAO,EAAE,CAAC,eAAe,EAAE,mBAAmB,EAAE,gBAAgB,CAAC;IACjE,OAAO,EAAE;QACP,OAAO,EAAE,CAAC;KACX;IACD,QAAQ,EAAE;QACR,qBAAqB,EAAE,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC;QAC/C,UAAU,EAAE,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;QACtC,YAAY,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC;QACpC,iBAAiB,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC;QACzC,OAAO,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC;QAC/B,oBAAoB,EAAE,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;QAChD,mBAAmB,EAAE,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC;KACjD;IACD,QAAQ,EAAE,CAAC,YAAY,EAAE,kBAAkB,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC;IACvE,IAAI,EAAE,IAAI,CAAA;EACV,MAAM;EACN,QAAQ;EACR,MAAM,CAAC,IAAI;;EAEX,aAAa;;EAEb,YAAY,CAAC,IAAI;EACjB,gBAAgB;;EAEhB,kBAAkB,CAAC,IAAI;EACvB,SAAS,CAAC,IAAI;EACd,MAAM,CAAC,IAAI;;EAEX,YAAY;EACZ,WAAW;EACX,mBAAmB;EACnB,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkEb;CACD,CAAC,CAAC","sourcesContent":["// Portions adapted from ray-tracing-renderer@0.10.15\n// (https://github.com/hoverinc/ray-tracing-renderer).\n// Copyright (c) 2019 HOVER, MIT license; see LICENSES/RayTracingRenderer-MIT.txt.\n\nimport cameraRayGlsl from './chunks/cameraRay.glsl.js';\nimport common from './chunks/common.glsl.js';\nimport rayTraceCore from './chunks/rayTraceCore.glsl.js';\nimport textureLinear from './chunks/textureLinear.glsl.js';\nimport materialBufferGlsl from './chunks/materialBuffer.glsl.js';\nimport intersect from './chunks/intersect.glsl.js';\nimport randGlsl from './chunks/rand.glsl.js';\nimport random from './chunks/random.glsl.js';\nimport envMap from './chunks/envMap.glsl.js';\nimport sampleShadowCatcher from './chunks/sampleShadowCatcher.glsl.js';\nimport sampleLight from './chunks/sampleLight.glsl.js';\nimport { FragmentShader, glsl, Shader } from '../shader.js';\nimport samplingGlsl from './chunks/sampling.glsl.js';\nimport uvProjectionGlsl from './chunks/uvProjection.glsl.js';\n\nexport default new FragmentShader({\n  name: 'shadowCatcher',\n  outputs: ['shadowCatcher', 'catcherBackground', 'catcherMoments'],\n  defines: {\n    BOUNCES: 2\n  },\n  uniforms: {\n    dispersionWavelengths: Shader.uniform('int', 3),\n    wavelength: Shader.uniform('float', 0),\n    viewportSize: Shader.uniform('vec2'),\n    viewProjectionInv: Shader.uniform('mat4'),\n    viewInv: Shader.uniform('mat4'),\n    cameraApertureRadius: Shader.uniform('float', 0),\n    cameraFocusDistance: Shader.uniform('float', 10)\n  },\n  includes: [rayTraceCore, materialBufferGlsl, intersect, random, envMap],\n  main: glsl`\n${common}\n${randGlsl}\n${random.main}\n\n${textureLinear}\n\n${rayTraceCore.main}\n${uvProjectionGlsl}\n\n${materialBufferGlsl.main}\n${intersect.main}\n${envMap.main}\n\n${samplingGlsl}\n${sampleLight}\n${sampleShadowCatcher}\n${cameraRayGlsl}\n\n// Path tracing integrator as described in\n// http://www.pbr-book.org/3ed-2018/Light_Transport_I_Surface_Reflection/Path_Tracing.html#\nvec4 integrator(inout Ray ray, out vec4 background) {\n  background = vec4(0.0);\n  Path path;\n  path.ray = ray;\n  path.li = vec3(0);\n  path.alpha = 1.0;\n  path.beta = vec3(1.0);\n  path.fromEye = true;\n  path.scatteringPdf = 0.0;\n  path.abort = false;\n\n  SurfaceInteraction si;\n\n  intersectScene(path.ray, si, false);\n  if (!si.hit) {\n    // Red stores catcher coverage. Keep it zero for pixels where the primary\n    // ray did not hit the catcher so denoised shadows cannot bleed onto the\n    // model silhouette during composition.\n    return vec4(0.0, 0.0, 0.0, 1.0);\n  }\n\n  OpenPbrResolvedMaterial mat;\n  getMaterial(mat, si.materialIndex, si.uv, si.uv1, si.instanceIndex);\n  if (mat.materialType != SHADOW_CATCHER) {\n    // The main path tracer already renders regular geometry. Only evaluate\n    // shadow opacity when the primary ray actually hits the catcher.\n    return vec4(0.0, 0.0, 0.0, 1.0);\n  }\n\n  vec4 bg = sampleBackgroundFromRay(ray.o, ray.d);\n  background = vec4(bg.rgb * bg.a, bg.a);\n  if (!path.abort) {\n    sampleShadowCatcher(si, 0, path);\n  }\n  return vec4(1.0, bg.a, bg.a >= 0.01 ? 1.0 : 0.0, path.alpha);\n}\n\nvoid main() {\n  initRandom();\n  rng_initialize(v_Texcoord * viewportSize, int(uint(sampleCount) ^ sampleHash(uint(sequenceSeed))));\n  // Match the beauty pass's random stream in hero-wavelength previews.\n  if (dispersionWavelengths == 1 && wavelength > 0.0) { sample1D(CAMERA_WAVELENGTH); }\n  Ray cam = primaryCameraRay();\n  vec4 background;\n  vec4 liAndAlpha = integrator(cam, background);\n\n  if (!(liAndAlpha.x < INF && liAndAlpha.x > -EPS)) {\n    liAndAlpha = vec4(0, 0, 0, 1);\n  }\n\n  out_shadowCatcher = liAndAlpha;\n  out_catcherBackground = background;\n  // The composed catcher is the background darkened by the shadow (its\n  // visibility in alpha). Over a transparent background the shadow is only\n  // its opacity.\n  float guideValue = liAndAlpha.a * (background.a >= 0.01\n    ? dot(background.rgb / background.a, vec3(0.2126, 0.7152, 0.0722))\n    : 1.0);\n  out_catcherMoments = liAndAlpha.r > 0.0\n    ? vec4(guideValue, guideValue * guideValue, 1.0, 0.0)\n    : vec4(0.0);\n\n}`\n});\n"]}

package/lib/renderer/glsl/webglPipeline.frag.d.ts

@@ -0,0 +1,4 @@
+import { FragmentShader } from '../shader.js';
+export declare const brightFragment: FragmentShader<Record<string, import("../shader.js").ShaderDefineValue>, Record<string, import("../shader.js").ShaderUniform<unknown>>>;
+export declare const composeFragment: FragmentShader<Record<string, import("../shader.js").ShaderDefineValue>, Record<string, import("../shader.js").ShaderUniform<unknown>>>;
+export declare const outputFragment: FragmentShader<Record<string, import("../shader.js").ShaderDefineValue>, Record<string, import("../shader.js").ShaderUniform<unknown>>>;

package/lib/renderer/glsl/webglPipeline.frag.js

@@ -0,0 +1,208 @@
+import { FragmentShader, Shader, glsl } from '../shader.js';
+export const brightFragment = new FragmentShader({
+    name: 'bloomBright',
+    uniforms: {
+        colorTex: Shader.uniform('sampler2D'),
+        threshold: Shader.uniform('float', 1),
+        scale: Shader.uniform('float', 1)
+    },
+    main: glsl `
+const vec3 uC = vec3(0.2125, 0.7154, 0.0721);
+vec4 sm(vec4 a, vec4 b, vec4 c) {
+return a + b + c - min(min(a, b), c) - max(max(a, b), c);
+}
+void main() {
+vec2 d = 1.0 / vec2(colorTexRegion());
+vec4 iW = sample_colorTex(v_Texcoord);
+vec4 s1 = sample_colorTex(v_Texcoord - vec2(d.x, 0.0));
+vec4 s2 = sample_colorTex(v_Texcoord + vec2(d.x, 0.0));
+vec4 s3 = sample_colorTex(v_Texcoord - vec2(0.0, d.y));
+vec4 s4 = sample_colorTex(v_Texcoord + vec2(0.0, d.y));
+iW = sm(sm(iW, s1, s2), s3, s4);
+float lum = dot(iW.rgb, uC);
+out_color = lum > threshold && iW.a > 0.0
+? vec4(iW.rgb * scale, iW.a)
+: vec4(0.0, 0.0, 0.0, iW.a);
+}`
+});
+export const composeFragment = new FragmentShader({
+    name: 'compose',
+    uniforms: {
+        colorTex: Shader.uniform('sampler2D'),
+        foregroundTex: Shader.uniform('sampler2D'),
+        catcherBackgroundTex: Shader.uniform('sampler2D'),
+        shadowCatcherTex: Shader.uniform('sampler2D'),
+        bloomTex: Shader.uniform('sampler2D'),
+        exposure: Shader.uniform('float', 1),
+        shadowCatcherColor: Shader.uniform('vec3', [0, 0, 0]),
+        shadowCatcherAlpha: Shader.uniform('float', 1),
+        shadowCatcherEnabled: Shader.uniform('float', 0),
+        bloomIntensity: Shader.uniform('float', 0),
+        toneMappingMode: Shader.uniform('int', 0),
+        contrast: Shader.uniform('float', 1),
+        saturation: Shader.uniform('float', 1),
+        temperature: Shader.uniform('float', 0),
+        tint: Shader.uniform('float', 0),
+        vignette: Shader.uniform('float', 0),
+        outputMode: Shader.uniform('int', 0),
+        sRGBOutput: Shader.uniform('bool', 1)
+    },
+    main: glsl `
+vec3 jL(vec3 color) {
+return clamp(color, 0.0, 1.0);
+}
+vec3 iJ(vec3 color) {
+return clamp(color / (vec3(1.0) + color), 0.0, 1.0);
+}
+vec3 jC(vec3 color) {
+color = max(vec3(0.0), color - 0.004);
+return pow((color * (6.2 * color + 0.5)) /
+(color * (6.2 * color + 1.7) + 0.06), vec3(2.2));
+}
+vec3 ox(vec3 value) {
+vec3 kC = value * (value + 0.0245786) - 0.000090537;
+vec3 ap = value * (0.983729 * value + 0.4329510) + 0.238081;
+return kC / ap;
+}
+vec3 lh(vec3 color) {
+const mat3 pj = mat3(
+vec3(0.59719, 0.07600, 0.02840),
+vec3(0.35458, 0.90834, 0.13383),
+vec3(0.04823, 0.01566, 0.83777)
+);
+const mat3 os = mat3(
+vec3(1.60475, -0.10208, -0.00327),
+vec3(-0.53108, 1.10813, -0.07276),
+vec3(-0.07367, -0.00605, 1.07602)
+);
+color = pj * (color / 0.6);
+return clamp(os * ox(color), 0.0, 1.0);
+}
+const mat3 LINEAR_REC2020_TO_LINEAR_SRGB = mat3(
+vec3(1.6605, -0.1246, -0.0182),
+vec3(-0.5876, 1.1329, -0.1006),
+vec3(-0.0728, -0.0083, 1.1187)
+);
+const mat3 LINEAR_SRGB_TO_LINEAR_REC2020 = mat3(
+vec3(0.6274, 0.0691, 0.0164),
+vec3(0.3293, 0.9195, 0.0880),
+vec3(0.0433, 0.0113, 0.8956)
+);
+vec3 fP(vec3 value) {
+vec3 mB = value * value;
+vec3 qy = mB * mB;
+return 15.5 * qy * mB - 40.14 * qy * value
++ 31.96 * qy - 6.868 * mB * value
++ 0.4298 * mB + 0.1191 * value - 0.00232;
+}
+vec3 lP(vec3 color) {
+const mat3 pl = mat3(
+vec3(0.856627153315983, 0.137318972929847, 0.11189821299995),
+vec3(0.0951212405381588, 0.761241990602591, 0.0767994186031903),
+vec3(0.0482516061458583, 0.101439036467562, 0.811302368396859)
+);
+const mat3 ot = mat3(
+vec3(1.1271005818144368, -0.1413297634984383, -0.14132976349843826),
+vec3(-0.11060664309660323, 1.157823702216272, -0.11060664309660294),
+vec3(-0.016493938717834573, -0.016493938717834257, 1.2519364065950405)
+);
+color = pl * (LINEAR_SRGB_TO_LINEAR_REC2020 * color);
+color = clamp((log2(max(color, 1e-10)) + 12.47393) / 16.5, 0.0, 1.0);
+color = ot * fP(color);
+color = pow(max(color, 0.0), vec3(2.2));
+return clamp(LINEAR_REC2020_TO_LINEAR_SRGB * color, 0.0, 1.0);
+}
+vec3 cH(vec3 color) {
+if (toneMappingMode == 1) return lh(color);
+if (toneMappingMode == 2) return jC(color);
+if (toneMappingMode == 3) return iJ(color);
+if (toneMappingMode == 4) return jL(color);
+return lP(color);
+}
+vec3 gS(vec3 color) {
+vec3 sW = vec3(
+1.0 + temperature * 0.16 + tint * 0.04,
+1.0 - tint * 0.12,
+1.0 - temperature * 0.16 + tint * 0.04
+);
+color = max(color * sW, 0.0);
+color = max((color - 0.18) * contrast + 0.18, 0.0);
+float luminance = dot(color, vec3(0.2126, 0.7152, 0.0722));
+return max(mix(vec3(luminance), color, saturation), 0.0);
+}
+void main() {
+vec2 uv = v_Texcoord;
+vec4 shadow = sample_shadowCatcherTex(uv);
+if (outputMode == 1) {
+out_color = vec4(vec3(shadow.a), 1.0);
+return;
+}
+
+vec4 color = sample_colorTex(uv);
+vec4 bloom = sample_bloomTex(uv) * bloomIntensity;
+color.rgb += bloom.rgb;
+color.rgb = gS(color.rgb * exposure);
+if (sRGBOutput) {
+float edge = smoothstep(0.2, 0.72, distance(uv, vec2(0.5)));
+color.rgb *= 1.0 - vignette * edge;
+color.rgb = cH(color.rgb);
+color.rgb = pow(max(color.rgb, 0.0), vec3(1.0 / 2.2));
+}
+color.a = max(color.a, min(dot(bloom.rgb, vec3(0.2125, 0.7154, 0.0721)), 1.0));
+
+if (shadowCatcherEnabled > 0.5) {
+float coverage = clamp(shadow.r, 0.0, 1.0);
+
+
+float fO = clamp(
+(1.0 - shadow.a) / max(coverage, 0.000001), 0.0, 1.0
+);
+fO = max(fO - (1.0 - shadowCatcherAlpha), 0.0);
+if (coverage > 0.0) {
+vec4 foreground = sample_foregroundTex(uv);
+vec4 background = sample_catcherBackgroundTex(uv);
+vec3 bK = gS((foreground.rgb + bloom.rgb) * exposure);
+vec3 backgroundColor = gS((background.rgb / max(background.a, 0.000001) + bloom.rgb) * exposure);
+if (sRGBOutput) {
+float edge = smoothstep(0.2, 0.72, distance(uv, vec2(0.5)));
+bK *= 1.0 - vignette * edge;
+backgroundColor *= 1.0 - vignette * edge;
+bK = pow(max(cH(bK), 0.0), vec3(1.0 / 2.2));
+backgroundColor = pow(max(cH(backgroundColor), 0.0), vec3(1.0 / 2.2));
+}
+
+float opacity = fO;
+fO *= coverage;
+float lR = clamp(dot(bloom.rgb, vec3(0.2125, 0.7154, 0.0721)), 0.0, 1.0);
+float hr = max(foreground.a, lR * (1.0 - coverage));
+float hg = max(background.a, lR * coverage);
+float alpha = hr + hg * (1.0 - opacity) + fO;
+vec3 premultiplied = bK * hr
++ backgroundColor * hg * (1.0 - opacity)
++ shadowCatcherColor * fO;
+color = vec4(premultiplied / max(alpha, 0.000001), alpha);
+}
+}
+out_color = color;
+}`
+});
+export const outputFragment = new FragmentShader({
+    name: 'output',
+    uniforms: {
+        colorTex: Shader.uniform('sampler2D'),
+        colorDenoisedTex: Shader.uniform('sampler2D'),
+        denoisedPercent: Shader.uniform('float', 0)
+    },
+    main: glsl `
+void main() {
+vec2 uv = v_Texcoord;
+vec4 color = mix(
+sample_colorTex(uv),
+sample_colorDenoisedTex(uv),
+denoisedPercent
+);
+color = vec4(color.rgb * color.a, color.a);
+out_color = color;
+}`
+});
+//# sourceMappingURL=webglPipeline.frag.js.map

package/lib/renderer/glsl/webglPipeline.frag.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"webglPipeline.frag.js","sourceRoot":"","sources":["../../../src/renderer/glsl/webglPipeline.frag.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAE5D,MAAM,CAAC,MAAM,cAAc,GAAG,IAAI,cAAc,CAAC;IAC/C,IAAI,EAAE,aAAa;IACnB,QAAQ,EAAE;QACR,QAAQ,EAAE,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC;QACrC,SAAS,EAAE,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;QACrC,KAAK,EAAE,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;KAClC;IACD,IAAI,EAAE,IAAI,CAAA;;;;;;;;;;;;;;;;;EAiBV;CACD,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,eAAe,GAAG,IAAI,cAAc,CAAC;IAChD,IAAI,EAAE,SAAS;IACf,QAAQ,EAAE;QACR,QAAQ,EAAE,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC;QACrC,aAAa,EAAE,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC;QAC1C,oBAAoB,EAAE,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC;QACjD,gBAAgB,EAAE,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC;QAC7C,QAAQ,EAAE,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC;QACrC,QAAQ,EAAE,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;QACpC,kBAAkB,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;QACrD,kBAAkB,EAAE,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;QAC9C,oBAAoB,EAAE,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;QAChD,cAAc,EAAE,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;QAC1C,eAAe,EAAE,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC;QACzC,QAAQ,EAAE,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;QACpC,UAAU,EAAE,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;QACtC,WAAW,EAAE,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;QACvC,IAAI,EAAE,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;QAChC,QAAQ,EAAE,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;QACpC,UAAU,EAAE,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC;QACpC,UAAU,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;KACtC;IACD,IAAI,EAAE,IAAI,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyIV;CACD,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,cAAc,GAAG,IAAI,cAAc,CAAC;IAC/C,IAAI,EAAE,QAAQ;IACd,QAAQ,EAAE;QACR,QAAQ,EAAE,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC;QACrC,gBAAgB,EAAE,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC;QAC7C,eAAe,EAAE,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;KAC5C;IACD,IAAI,EAAE,IAAI,CAAA;;;;;;;;;;EAUV;CACD,CAAC,CAAC","sourcesContent":["import { FragmentShader, Shader, glsl } from '../shader.js';\n\nexport const brightFragment = new FragmentShader({\n  name: 'bloomBright',\n  uniforms: {\n    colorTex: Shader.uniform('sampler2D'),\n    threshold: Shader.uniform('float', 1),\n    scale: Shader.uniform('float', 1)\n  },\n  main: glsl`\nconst vec3 lumWeight = vec3(0.2125, 0.7154, 0.0721);\nvec4 median(vec4 a, vec4 b, vec4 c) {\n  return a + b + c - min(min(a, b), c) - max(max(a, b), c);\n}\nvoid main() {\n  vec2 d = 1.0 / vec2(colorTexRegion());\n  vec4 texel = sample_colorTex(v_Texcoord);\n  vec4 s1 = sample_colorTex(v_Texcoord - vec2(d.x, 0.0));\n  vec4 s2 = sample_colorTex(v_Texcoord + vec2(d.x, 0.0));\n  vec4 s3 = sample_colorTex(v_Texcoord - vec2(0.0, d.y));\n  vec4 s4 = sample_colorTex(v_Texcoord + vec2(0.0, d.y));\n  texel = median(median(texel, s1, s2), s3, s4);\n  float lum = dot(texel.rgb, lumWeight);\n  out_color = lum > threshold && texel.a > 0.0\n    ? vec4(texel.rgb * scale, texel.a)\n    : vec4(0.0, 0.0, 0.0, texel.a);\n}`\n});\n\nexport const composeFragment = new FragmentShader({\n  name: 'compose',\n  uniforms: {\n    colorTex: Shader.uniform('sampler2D'),\n    foregroundTex: Shader.uniform('sampler2D'),\n    catcherBackgroundTex: Shader.uniform('sampler2D'),\n    shadowCatcherTex: Shader.uniform('sampler2D'),\n    bloomTex: Shader.uniform('sampler2D'),\n    exposure: Shader.uniform('float', 1),\n    shadowCatcherColor: Shader.uniform('vec3', [0, 0, 0]),\n    shadowCatcherAlpha: Shader.uniform('float', 1),\n    shadowCatcherEnabled: Shader.uniform('float', 0),\n    bloomIntensity: Shader.uniform('float', 0),\n    toneMappingMode: Shader.uniform('int', 0),\n    contrast: Shader.uniform('float', 1),\n    saturation: Shader.uniform('float', 1),\n    temperature: Shader.uniform('float', 0),\n    tint: Shader.uniform('float', 0),\n    vignette: Shader.uniform('float', 0),\n    outputMode: Shader.uniform('int', 0),\n    sRGBOutput: Shader.uniform('bool', 1)\n  },\n  main: glsl`\nvec3 linearToneMapping(vec3 color) {\n  return clamp(color, 0.0, 1.0);\n}\nvec3 reinhardToneMapping(vec3 color) {\n  return clamp(color / (vec3(1.0) + color), 0.0, 1.0);\n}\nvec3 cineonToneMapping(vec3 color) {\n  color = max(vec3(0.0), color - 0.004);\n  return pow((color * (6.2 * color + 0.5)) /\n    (color * (6.2 * color + 1.7) + 0.06), vec3(2.2));\n}\nvec3 rrtAndOdtFit(vec3 value) {\n  vec3 numerator = value * (value + 0.0245786) - 0.000090537;\n  vec3 denominator = value * (0.983729 * value + 0.4329510) + 0.238081;\n  return numerator / denominator;\n}\nvec3 acesToneMapping(vec3 color) {\n  const mat3 inputMatrix = mat3(\n    vec3(0.59719, 0.07600, 0.02840),\n    vec3(0.35458, 0.90834, 0.13383),\n    vec3(0.04823, 0.01566, 0.83777)\n  );\n  const mat3 outputMatrix = mat3(\n    vec3(1.60475, -0.10208, -0.00327),\n    vec3(-0.53108, 1.10813, -0.07276),\n    vec3(-0.07367, -0.00605, 1.07602)\n  );\n  color = inputMatrix * (color / 0.6);\n  return clamp(outputMatrix * rrtAndOdtFit(color), 0.0, 1.0);\n}\nconst mat3 LINEAR_REC2020_TO_LINEAR_SRGB = mat3(\n  vec3(1.6605, -0.1246, -0.0182),\n  vec3(-0.5876, 1.1329, -0.1006),\n  vec3(-0.0728, -0.0083, 1.1187)\n);\nconst mat3 LINEAR_SRGB_TO_LINEAR_REC2020 = mat3(\n  vec3(0.6274, 0.0691, 0.0164),\n  vec3(0.3293, 0.9195, 0.0880),\n  vec3(0.0433, 0.0113, 0.8956)\n);\nvec3 agxDefaultContrastApprox(vec3 value) {\n  vec3 value2 = value * value;\n  vec3 value4 = value2 * value2;\n  return 15.5 * value4 * value2 - 40.14 * value4 * value\n    + 31.96 * value4 - 6.868 * value2 * value\n    + 0.4298 * value2 + 0.1191 * value - 0.00232;\n}\nvec3 agxToneMapping(vec3 color) {\n  const mat3 insetMatrix = mat3(\n    vec3(0.856627153315983, 0.137318972929847, 0.11189821299995),\n    vec3(0.0951212405381588, 0.761241990602591, 0.0767994186031903),\n    vec3(0.0482516061458583, 0.101439036467562, 0.811302368396859)\n  );\n  const mat3 outsetMatrix = mat3(\n    vec3(1.1271005818144368, -0.1413297634984383, -0.14132976349843826),\n    vec3(-0.11060664309660323, 1.157823702216272, -0.11060664309660294),\n    vec3(-0.016493938717834573, -0.016493938717834257, 1.2519364065950405)\n  );\n  color = insetMatrix * (LINEAR_SRGB_TO_LINEAR_REC2020 * color);\n  color = clamp((log2(max(color, 1e-10)) + 12.47393) / 16.5, 0.0, 1.0);\n  color = outsetMatrix * agxDefaultContrastApprox(color);\n  color = pow(max(color, 0.0), vec3(2.2));\n  return clamp(LINEAR_REC2020_TO_LINEAR_SRGB * color, 0.0, 1.0);\n}\nvec3 applyToneMapping(vec3 color) {\n  if (toneMappingMode == 1) return acesToneMapping(color);\n  if (toneMappingMode == 2) return cineonToneMapping(color);\n  if (toneMappingMode == 3) return reinhardToneMapping(color);\n  if (toneMappingMode == 4) return linearToneMapping(color);\n  return agxToneMapping(color);\n}\nvec3 gradeColor(vec3 color) {\n  vec3 balance = vec3(\n    1.0 + temperature * 0.16 + tint * 0.04,\n    1.0 - tint * 0.12,\n    1.0 - temperature * 0.16 + tint * 0.04\n  );\n  color = max(color * balance, 0.0);\n  color = max((color - 0.18) * contrast + 0.18, 0.0);\n  float luminance = dot(color, vec3(0.2126, 0.7152, 0.0722));\n  return max(mix(vec3(luminance), color, saturation), 0.0);\n}\nvoid main() {\n  vec2 uv = v_Texcoord;\n  vec4 shadow = sample_shadowCatcherTex(uv);\n  if (outputMode == 1) {\n    out_color = vec4(vec3(shadow.a), 1.0);\n    return;\n  }\n\n  vec4 color = sample_colorTex(uv);\n  vec4 bloom = sample_bloomTex(uv) * bloomIntensity;\n  color.rgb += bloom.rgb;\n  color.rgb = gradeColor(color.rgb * exposure);\n  if (sRGBOutput) {\n    float edge = smoothstep(0.2, 0.72, distance(uv, vec2(0.5)));\n    color.rgb *= 1.0 - vignette * edge;\n    color.rgb = applyToneMapping(color.rgb);\n    color.rgb = pow(max(color.rgb, 0.0), vec3(1.0 / 2.2));\n  }\n  color.a = max(color.a, min(dot(bloom.rgb, vec3(0.2125, 0.7154, 0.0721)), 1.0));\n\n  if (shadowCatcherEnabled > 0.5) {\n    float coverage = clamp(shadow.r, 0.0, 1.0);\n    // Non-catcher samples contribute visibility 1. Undo primary coverage\n    // before adjusting opacity, then apply the coverage exactly once.\n    float shadowAlpha = clamp(\n      (1.0 - shadow.a) / max(coverage, 0.000001), 0.0, 1.0\n    );\n    shadowAlpha = max(shadowAlpha - (1.0 - shadowCatcherAlpha), 0.0);\n    if (coverage > 0.0) {\n      vec4 foreground = sample_foregroundTex(uv);\n      vec4 background = sample_catcherBackgroundTex(uv);\n      vec3 foregroundColor = gradeColor((foreground.rgb + bloom.rgb) * exposure);\n      vec3 backgroundColor = gradeColor((background.rgb / max(background.a, 0.000001) + bloom.rgb) * exposure);\n      if (sRGBOutput) {\n        float edge = smoothstep(0.2, 0.72, distance(uv, vec2(0.5)));\n        foregroundColor *= 1.0 - vignette * edge;\n        backgroundColor *= 1.0 - vignette * edge;\n        foregroundColor = pow(max(applyToneMapping(foregroundColor), 0.0), vec3(1.0 / 2.2));\n        backgroundColor = pow(max(applyToneMapping(backgroundColor), 0.0), vec3(1.0 / 2.2));\n      }\n      // The primary samples belong to disjoint layers. Never shadow the model.\n      float opacity = shadowAlpha;\n      shadowAlpha *= coverage;\n      float bloomAlpha = clamp(dot(bloom.rgb, vec3(0.2125, 0.7154, 0.0721)), 0.0, 1.0);\n      float foregroundAlpha = max(foreground.a, bloomAlpha * (1.0 - coverage));\n      float backgroundAlpha = max(background.a, bloomAlpha * coverage);\n      float alpha = foregroundAlpha + backgroundAlpha * (1.0 - opacity) + shadowAlpha;\n      vec3 premultiplied = foregroundColor * foregroundAlpha\n        + backgroundColor * backgroundAlpha * (1.0 - opacity)\n        + shadowCatcherColor * shadowAlpha;\n      color = vec4(premultiplied / max(alpha, 0.000001), alpha);\n    }\n  }\n  out_color = color;\n}`\n});\n\nexport const outputFragment = new FragmentShader({\n  name: 'output',\n  uniforms: {\n    colorTex: Shader.uniform('sampler2D'),\n    colorDenoisedTex: Shader.uniform('sampler2D'),\n    denoisedPercent: Shader.uniform('float', 0)\n  },\n  main: glsl`\nvoid main() {\n  vec2 uv = v_Texcoord;\n  vec4 color = mix(\n    sample_colorTex(uv),\n    sample_colorDenoisedTex(uv),\n    denoisedPercent\n  );\n  color = vec4(color.rgb * color.a, color.a);\n  out_color = color;\n}`\n});\n"]}

package/lib/renderer/gpuMemory.d.ts

@@ -0,0 +1,2 @@
+/** Payload bytes of the uncompressed render-target formats used by MuTracer. */
+export declare function textureBytes(texture: GPUTexture | undefined): number;

package/lib/renderer/gpuMemory.js

@@ -0,0 +1,10 @@
+/** Payload bytes of the uncompressed render-target formats used by MuTracer. */
+export function textureBytes(texture) {
+    if (!texture)
+        return 0;
+    const bytes = texture.format === 'rgba32float' ? 16 :
+        texture.format === 'rgba16float' ? 8 :
+            texture.format === 'r32float' ? 4 : 4;
+    return texture.width * texture.height * texture.depthOrArrayLayers * bytes;
+}
+//# sourceMappingURL=gpuMemory.js.map

package/lib/renderer/gpuMemory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gpuMemory.js","sourceRoot":"","sources":["../../src/renderer/gpuMemory.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,MAAM,UAAU,YAAY,CAAC,OAA+B;IAC1D,IAAI,CAAC,OAAO;QAAE,OAAO,CAAC,CAAC;IACvB,MAAM,KAAK,GAAG,OAAO,CAAC,MAAM,KAAK,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QACnD,OAAO,CAAC,MAAM,KAAK,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YACtC,OAAO,CAAC,MAAM,KAAK,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACxC,OAAO,OAAO,CAAC,KAAK,GAAG,OAAO,CAAC,MAAM,GAAG,OAAO,CAAC,kBAAkB,GAAG,KAAK,CAAC;AAC7E,CAAC","sourcesContent":["/** Payload bytes of the uncompressed render-target formats used by MuTracer. */\nexport function textureBytes(texture: GPUTexture | undefined): number {\n  if (!texture) return 0;\n  const bytes = texture.format === 'rgba32float' ? 16 :\n    texture.format === 'rgba16float' ? 8 :\n    texture.format === 'r32float' ? 4 : 4;\n  return texture.width * texture.height * texture.depthOrArrayLayers * bytes;\n}\n"]}

package/lib/renderer/halton.d.ts

@@ -0,0 +1 @@
+export default function halton(index: number, base: number): number;

package/lib/renderer/halton.js

@@ -0,0 +1,15 @@
+// Temporal Super Sample for static Scene
+// Generate halton sequence
+// https://en.wikipedia.org/wiki/Halton_sequence
+export default function halton(index, base) {
+    var result = 0;
+    var f = 1 / base;
+    var i = index;
+    while (i > 0) {
+        result = result + f * (i % base);
+        i = Math.floor(i / base);
+        f = f / base;
+    }
+    return result;
+}
+//# sourceMappingURL=halton.js.map

package/lib/renderer/halton.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"halton.js","sourceRoot":"","sources":["../../src/renderer/halton.ts"],"names":[],"mappings":"AAAA,yCAAyC;AAEzC,2BAA2B;AAC3B,gDAAgD;AAEhD,MAAM,CAAC,OAAO,UAAU,MAAM,CAAC,KAAa,EAAE,IAAY;IACxD,IAAI,MAAM,GAAG,CAAC,CAAC;IACf,IAAI,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC;IACjB,IAAI,CAAC,GAAG,KAAK,CAAC;IACd,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;QACb,MAAM,GAAG,MAAM,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;QACjC,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;QACzB,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC;IACf,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC","sourcesContent":["// Temporal Super Sample for static Scene\n\n// Generate halton sequence\n// https://en.wikipedia.org/wiki/Halton_sequence\n\nexport default function halton(index: number, base: number) {\n  var result = 0;\n  var f = 1 / base;\n  var i = index;\n  while (i > 0) {\n    result = result + f * (i % base);\n    i = Math.floor(i / base);\n    f = f / base;\n  }\n  return result;\n}\n"]}

package/lib/renderer/jnlm.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Joint non-local means (JNLM) denoiser, after Rousselle, Manzi and Zwicker,
+ * "Robust Denoising using Feature and Color Information" (Pacific Graphics
+ * 2013). Each pixel starts with a weighted mean of its neighborhood. The
+ * weight of a neighbor is the minimum of
+ *
+ * - a color weight: the NL-means distance between the two pixels' patches,
+ *   normalized by their estimated variance, so differences explained by
+ *   noise are ignored and real structure is kept;
+ * - a feature weight: the albedo, coverage and normal differences, which keep
+ *   texture and geometric edges that the noisy color cannot resolve.
+ *
+ * A bounded, regularized local albedo regression corrects that mean to retain
+ * low-contrast texture while averaging lighting noise. Each RGB channel is
+ * fitted independently using the same JNLM weights.
+ *
+ * Weights are computed on a per-sample luminance guide whose moments are
+ * accumulated by the ray tracer, and applied to the complete composed image.
+ * The WebGPU (WGPUJNLMDenoiser) and WebGL 2 (WebGLJNLMDenoiser) passes
+ * implement the same filter with these parameters.
+ */
+/** Neighborhood radius in pixels; the search window is 11 x 11. */
+export declare const JNLM_SEARCH_RADIUS = 5;
+/** Patch radius in pixels; patches are 3 x 3 to retain small color details. */
+export declare const JNLM_PATCH_RADIUS = 1;
+/** Filter passes; the second samples every other pixel. */
+export declare const JNLM_ITERATIONS = 2;
+/** Color sensitivity k_c of the paper. Larger values filter more. */
+export declare const JNLM_DEFAULT_COLOR_SENSITIVITY = 0.6;
+/** Relative RGB albedo bandwidth. */
+export declare const JNLM_ALBEDO_BANDWIDTH = 0.4;
+/** Absolute coverage bandwidth, independent of albedo brightness. */
+export declare const JNLM_COVERAGE_BANDWIDTH = 0.1;
+/** Minimum linear albedo used to normalize contrast near black. */
+export declare const JNLM_ALBEDO_FLOOR = 0.02;
+/** Squared relative contrast ridge for the local albedo regression (1%). */
+export declare const JNLM_ALBEDO_REGULARIZATION = 0.0001;
+/** Normal bandwidth, with normals encoded as n * 0.5 + 0.5. */
+export declare const JNLM_NORMAL_BANDWIDTH = 0.05;
+/** Maximum number of filter passes supported by both backends. */
+export declare const JNLM_MAX_ITERATIONS = 4;
+/** User-configurable options for the built-in JNLM denoiser. */
+export interface JNLMOptions {
+    /** Positive filter strength multiplier; larger values smooth more. Default `1`. */
+    strength?: number;
+    /** Search radius in pixels, an integer from `1` to `16`. Default `5` (11 × 11). */
+    searchRadius?: number;
+    /** Color comparison patch radius, an integer from `0` to `3`. Default `1` (3 × 3). */
+    patchRadius?: number;
+    /** Relative RGB albedo tolerance, from `0.0001` to `10`. Larger values mix more texture. Default `0.4`. */
+    albedoBandwidth?: number;
+    /** Encoded normal tolerance, from `0.0001` to `10`. Larger values mix more geometric detail. Default `0.05`. */
+    normalBandwidth?: number;
+    /** Filter passes, an integer from `1` to `4`; each doubles the spacing. Default `2`. */
+    iterations?: number;
+}
+/** Default JNLM settings used when options are omitted. */
+export declare const DEFAULT_JNLM_OPTIONS: Readonly<Required<JNLMOptions>>;
+/** Filter shape; fixed by default, adjustable for evaluation. */
+export interface JNLMFilterShape {
+    searchRadius: number;
+    patchRadius: number;
+    /** Relative RGB contrast. */
+    albedoBandwidth: number;
+    /** Absolute difference of normals encoded as n * 0.5 + 0.5. */
+    normalBandwidth: number;
+    /**
+     * Filter passes. Each pass filters the previous result with double the
+     * sample spacing (a-trous), which removes the blotches a single NL-means
+     * pass leaves at the scale of its window.
+     */
+    iterations: number;
+}
+export declare const JNLM_DEFAULT_SHAPE: JNLMFilterShape;
+/** The built-in denoiser as attached to the pipeline. */
+export interface JNLMDenoiser {
+    readonly type: 'jnlm';
+    /** Filter strength multiplier, applied to the color sensitivity. */
+    strength: number;
+    shape: JNLMFilterShape;
+    dispose(): void;
+}
+export declare function createJNLMDenoiser(options?: JNLMOptions): JNLMDenoiser;
+/** Pixel spacing of filter pass `index` (from 0): 1, 2, 4, ... */
+export declare function jnlmPassDilation(index: number): number;

package/lib/renderer/jnlm.js

@@ -0,0 +1,87 @@
+/**
+ * Joint non-local means (JNLM) denoiser, after Rousselle, Manzi and Zwicker,
+ * "Robust Denoising using Feature and Color Information" (Pacific Graphics
+ * 2013). Each pixel starts with a weighted mean of its neighborhood. The
+ * weight of a neighbor is the minimum of
+ *
+ * - a color weight: the NL-means distance between the two pixels' patches,
+ *   normalized by their estimated variance, so differences explained by
+ *   noise are ignored and real structure is kept;
+ * - a feature weight: the albedo, coverage and normal differences, which keep
+ *   texture and geometric edges that the noisy color cannot resolve.
+ *
+ * A bounded, regularized local albedo regression corrects that mean to retain
+ * low-contrast texture while averaging lighting noise. Each RGB channel is
+ * fitted independently using the same JNLM weights.
+ *
+ * Weights are computed on a per-sample luminance guide whose moments are
+ * accumulated by the ray tracer, and applied to the complete composed image.
+ * The WebGPU (WGPUJNLMDenoiser) and WebGL 2 (WebGLJNLMDenoiser) passes
+ * implement the same filter with these parameters.
+ */
+/** Neighborhood radius in pixels; the search window is 11 x 11. */
+export const JNLM_SEARCH_RADIUS = 5;
+/** Patch radius in pixels; patches are 3 x 3 to retain small color details. */
+export const JNLM_PATCH_RADIUS = 1;
+/** Filter passes; the second samples every other pixel. */
+export const JNLM_ITERATIONS = 2;
+/** Color sensitivity k_c of the paper. Larger values filter more. */
+export const JNLM_DEFAULT_COLOR_SENSITIVITY = 0.6;
+/** Relative RGB albedo bandwidth. */
+export const JNLM_ALBEDO_BANDWIDTH = 0.4;
+/** Absolute coverage bandwidth, independent of albedo brightness. */
+export const JNLM_COVERAGE_BANDWIDTH = 0.1;
+/** Minimum linear albedo used to normalize contrast near black. */
+export const JNLM_ALBEDO_FLOOR = 0.02;
+/** Squared relative contrast ridge for the local albedo regression (1%). */
+export const JNLM_ALBEDO_REGULARIZATION = 0.0001;
+/** Normal bandwidth, with normals encoded as n * 0.5 + 0.5. */
+export const JNLM_NORMAL_BANDWIDTH = 0.05;
+/** Maximum number of filter passes supported by both backends. */
+export const JNLM_MAX_ITERATIONS = 4;
+/** Default JNLM settings used when options are omitted. */
+export const DEFAULT_JNLM_OPTIONS = Object.freeze({
+    strength: 1,
+    searchRadius: JNLM_SEARCH_RADIUS,
+    patchRadius: JNLM_PATCH_RADIUS,
+    albedoBandwidth: JNLM_ALBEDO_BANDWIDTH,
+    normalBandwidth: JNLM_NORMAL_BANDWIDTH,
+    iterations: JNLM_ITERATIONS
+});
+export const JNLM_DEFAULT_SHAPE = {
+    searchRadius: JNLM_SEARCH_RADIUS,
+    patchRadius: JNLM_PATCH_RADIUS,
+    albedoBandwidth: JNLM_ALBEDO_BANDWIDTH,
+    normalBandwidth: JNLM_NORMAL_BANDWIDTH,
+    iterations: JNLM_ITERATIONS
+};
+export function createJNLMDenoiser(options = {}) {
+    const values = { ...DEFAULT_JNLM_OPTIONS };
+    for (const key of Object.keys(values)) {
+        const value = options[key];
+        if (value !== undefined)
+            values[key] = value;
+    }
+    if (!Number.isFinite(values.strength) || values.strength <= 0) {
+        throw new Error('strength must be finite and positive');
+    }
+    for (const [key, min, max] of [
+        ['searchRadius', 1, 16], ['patchRadius', 0, 3], ['iterations', 1, JNLM_MAX_ITERATIONS]
+    ]) {
+        if (!Number.isInteger(values[key]) || values[key] < min || values[key] > max) {
+            throw new Error(`${key} must be an integer from ${min} to ${max}`);
+        }
+    }
+    for (const key of ['albedoBandwidth', 'normalBandwidth']) {
+        if (!Number.isFinite(values[key]) || values[key] < 0.0001 || values[key] > 10) {
+            throw new Error(`${key} must be finite and from 0.0001 to 10`);
+        }
+    }
+    const { strength, ...shape } = values;
+    return { type: 'jnlm', strength, shape, dispose() { } };
+}
+/** Pixel spacing of filter pass `index` (from 0): 1, 2, 4, ... */
+export function jnlmPassDilation(index) {
+    return 2 ** index;
+}
+//# sourceMappingURL=jnlm.js.map

package/lib/renderer/jnlm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jnlm.js","sourceRoot":"","sources":["../../src/renderer/jnlm.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Joint non-local means (JNLM) denoiser, after Rousselle, Manzi and Zwicker,\n * \"Robust Denoising using Feature and Color Information\" (Pacific Graphics\n * 2013). Each pixel starts with a weighted mean of its neighborhood. The\n * weight of a neighbor is the minimum of\n *\n * - a color weight: the NL-means distance between the two pixels' patches,\n *   normalized by their estimated variance, so differences explained by\n *   noise are ignored and real structure is kept;\n * - a feature weight: the albedo, coverage and normal differences, which keep\n *   texture and geometric edges that the noisy color cannot resolve.\n *\n * A bounded, regularized local albedo regression corrects that mean to retain\n * low-contrast texture while averaging lighting noise. Each RGB channel is\n * fitted independently using the same JNLM weights.\n *\n * Weights are computed on a per-sample luminance guide whose moments are\n * accumulated by the ray tracer, and applied to the complete composed image.\n * The WebGPU (WGPUJNLMDenoiser) and WebGL 2 (WebGLJNLMDenoiser) passes\n * implement the same filter with these parameters.\n */\n\n/** Neighborhood radius in pixels; the search window is 11 x 11. */\nexport const JNLM_SEARCH_RADIUS = 5;\n/** Patch radius in pixels; patches are 3 x 3 to retain small color details. */\nexport const JNLM_PATCH_RADIUS = 1;\n/** Filter passes; the second samples every other pixel. */\nexport const JNLM_ITERATIONS = 2;\n/** Color sensitivity k_c of the paper. Larger values filter more. */\nexport const JNLM_DEFAULT_COLOR_SENSITIVITY = 0.6;\n/** Relative RGB albedo bandwidth. */\nexport const JNLM_ALBEDO_BANDWIDTH = 0.4;\n/** Absolute coverage bandwidth, independent of albedo brightness. */\nexport const JNLM_COVERAGE_BANDWIDTH = 0.1;\n/** Minimum linear albedo used to normalize contrast near black. */\nexport const JNLM_ALBEDO_FLOOR = 0.02;\n/** Squared relative contrast ridge for the local albedo regression (1%). */\nexport const JNLM_ALBEDO_REGULARIZATION = 0.0001;\n/** Normal bandwidth, with normals encoded as n * 0.5 + 0.5. */\nexport const JNLM_NORMAL_BANDWIDTH = 0.05;\n/** Maximum number of filter passes supported by both backends. */\nexport const JNLM_MAX_ITERATIONS = 4;\n\n/** User-configurable options for the built-in JNLM denoiser. */\nexport interface JNLMOptions {\n  /** Positive filter strength multiplier; larger values smooth more. Default `1`. */\n  strength?: number;\n  /** Search radius in pixels, an integer from `1` to `16`. Default `5` (11 × 11). */\n  searchRadius?: number;\n  /** Color comparison patch radius, an integer from `0` to `3`. Default `1` (3 × 3). */\n  patchRadius?: number;\n  /** Relative RGB albedo tolerance, from `0.0001` to `10`. Larger values mix more texture. Default `0.4`. */\n  albedoBandwidth?: number;\n  /** Encoded normal tolerance, from `0.0001` to `10`. Larger values mix more geometric detail. Default `0.05`. */\n  normalBandwidth?: number;\n  /** Filter passes, an integer from `1` to `4`; each doubles the spacing. Default `2`. */\n  iterations?: number;\n}\n\n/** Default JNLM settings used when options are omitted. */\nexport const DEFAULT_JNLM_OPTIONS: Readonly<Required<JNLMOptions>> = Object.freeze({\n  strength: 1,\n  searchRadius: JNLM_SEARCH_RADIUS,\n  patchRadius: JNLM_PATCH_RADIUS,\n  albedoBandwidth: JNLM_ALBEDO_BANDWIDTH,\n  normalBandwidth: JNLM_NORMAL_BANDWIDTH,\n  iterations: JNLM_ITERATIONS\n});\n\n/** Filter shape; fixed by default, adjustable for evaluation. */\nexport interface JNLMFilterShape {\n  searchRadius: number;\n  patchRadius: number;\n  /** Relative RGB contrast. */\n  albedoBandwidth: number;\n  /** Absolute difference of normals encoded as n * 0.5 + 0.5. */\n  normalBandwidth: number;\n  /**\n   * Filter passes. Each pass filters the previous result with double the\n   * sample spacing (a-trous), which removes the blotches a single NL-means\n   * pass leaves at the scale of its window.\n   */\n  iterations: number;\n}\n\nexport const JNLM_DEFAULT_SHAPE: JNLMFilterShape = {\n  searchRadius: JNLM_SEARCH_RADIUS,\n  patchRadius: JNLM_PATCH_RADIUS,\n  albedoBandwidth: JNLM_ALBEDO_BANDWIDTH,\n  normalBandwidth: JNLM_NORMAL_BANDWIDTH,\n  iterations: JNLM_ITERATIONS\n};\n\n/** The built-in denoiser as attached to the pipeline. */\nexport interface JNLMDenoiser {\n  readonly type: 'jnlm';\n  /** Filter strength multiplier, applied to the color sensitivity. */\n  strength: number;\n  shape: JNLMFilterShape;\n  dispose(): void;\n}\n\nexport function createJNLMDenoiser(options: JNLMOptions = {}): JNLMDenoiser {\n  const values = { ...DEFAULT_JNLM_OPTIONS };\n  for (const key of Object.keys(values) as (keyof JNLMOptions)[]) {\n    const value = options[key];\n    if (value !== undefined) values[key] = value;\n  }\n  if (!Number.isFinite(values.strength) || values.strength <= 0) {\n    throw new Error('strength must be finite and positive');\n  }\n  for (const [key, min, max] of [\n    ['searchRadius', 1, 16], ['patchRadius', 0, 3], ['iterations', 1, JNLM_MAX_ITERATIONS]\n  ] as const) {\n    if (!Number.isInteger(values[key]) || values[key] < min || values[key] > max) {\n      throw new Error(`${key} must be an integer from ${min} to ${max}`);\n    }\n  }\n  for (const key of ['albedoBandwidth', 'normalBandwidth'] as const) {\n    if (!Number.isFinite(values[key]) || values[key] < 0.0001 || values[key] > 10) {\n      throw new Error(`${key} must be finite and from 0.0001 to 10`);\n    }\n  }\n  const { strength, ...shape } = values;\n  return { type: 'jnlm', strength, shape, dispose() {} };\n}\n\n/** Pixel spacing of filter pass `index` (from 0): 1, 2, 4, ... */\nexport function jnlmPassDilation(index: number) {\n  return 2 ** index;\n}\n"]}