@meimu/mutracer 0.1.4 → 0.2.0

package/lib/renderer/wgsl/compose.frag.wgsl.js

@@ -1,5 +1,5 @@
 export const linearToSrgbDefine = /* wgsl */ `
-fn fM(color: vec3f) -> vec3f {
+fn linearToSrgb(color: vec3f) -> vec3f {
 let linear = max(color, vec3f(0.0));
 let low = linear * 12.92;
 let high = 1.055 * pow(linear, vec3f(1.0 / 2.4)) - 0.055;
@@ -8,146 +8,147 @@ return select(high, low, linear <= vec3f(0.0031308));
 `;
 export const composeDefine = /* wgsl */ `
 
-fn jU(color: vec3f) -> vec3f {
+fn ky(color: vec3f) -> vec3f {
 return clamp(color, vec3f(0.0), vec3f(1.0));
 }
-fn iP(color: vec3f) -> vec3f {
+fn jf(color: vec3f) -> vec3f {
 return clamp(color / (vec3f(1.0) + color), vec3f(0.0), vec3f(1.0));
 }
-fn jJ(jr: vec3f) -> vec3f {
-let color = max(vec3f(0.0), jr - 0.004);
+fn kj(jR: vec3f) -> vec3f {
+let color = max(vec3f(0.0), jR - 0.004);
 return pow((color * (6.2 * color + 0.5)) /
 (color * (6.2 * color + 1.7) + 0.06), vec3f(2.2));
 }
-fn oJ(value: vec3f) -> vec3f {
-let kO = value * (value + 0.0245786) - 0.000090537;
-let ap = value * (0.983729 * value + 0.4329510) + 0.238081;
-return kO / ap;
+fn pH(value: vec3f) -> vec3f {
+let lv = value * (value + 0.0245786) - 0.000090537;
+let aq = value * (0.983729 * value + 0.4329510) + 0.238081;
+return lv / aq;
 }
-fn lv(jr: vec3f) -> vec3f {
-let pw = mat3x3f(
+fn mh(jR: vec3f) -> vec3f {
+let qs = mat3x3f(
 vec3f(0.59719, 0.07600, 0.02840),
 vec3f(0.35458, 0.90834, 0.13383),
 vec3f(0.04823, 0.01566, 0.83777)
 );
-let oE = mat3x3f(
+let outputMatrix = mat3x3f(
 vec3f(1.60475, -0.10208, -0.00327),
 vec3f(-0.53108, 1.10813, -0.07276),
 vec3f(-0.07367, -0.00605, 1.07602)
 );
-let color = pw * (jr / 0.6);
-return clamp(oE * oJ(color), vec3f(0.0), vec3f(1.0));
-}
-fn fT(value: vec3f) -> vec3f {
-let mO = value * value;
-let qK = mO * mO;
-return 15.5 * qK * mO - 40.14 * qK * value
-+ 31.96 * qK - 6.868 * mO * value
-+ 0.4298 * mO + 0.1191 * value - 0.00232;
-}
-fn me(jr: vec3f) -> vec3f {
-let mR = mat3x3f(
+let color = qs * (jR / 0.6);
+return clamp(outputMatrix * pH(color), vec3f(0.0), vec3f(1.0));
+}
+fn gh(value: vec3f) -> vec3f {
+let nM = value * value;
+let rR = nM * nM;
+return 15.5 * rR * nM - 40.14 * rR * value
++ 31.96 * rR - 6.868 * nM * value
++ 0.4298 * nM + 0.1191 * value - 0.00232;
+}
+fn mM(jR: vec3f) -> vec3f {
+let nP = mat3x3f(
 vec3f(1.6605, -0.1246, -0.0182),
 vec3f(-0.5876, 1.1329, -0.1006),
 vec3f(-0.0728, -0.0083, 1.1187)
 );
-let mS = mat3x3f(
+let nQ = mat3x3f(
 vec3f(0.6274, 0.0691, 0.0164),
 vec3f(0.3293, 0.9195, 0.0880),
 vec3f(0.0433, 0.0113, 0.8956)
 );
-let pH = mat3x3f(
+let qu = mat3x3f(
 vec3f(0.856627153315983, 0.137318972929847, 0.11189821299995),
 vec3f(0.0951212405381588, 0.761241990602591, 0.0767994186031903),
 vec3f(0.0482516061458583, 0.101439036467562, 0.811302368396859)
 );
-let oF = mat3x3f(
+let pt = mat3x3f(
 vec3f(1.1271005818144368, -0.1413297634984383, -0.14132976349843826),
 vec3f(-0.11060664309660323, 1.157823702216272, -0.11060664309660294),
 vec3f(-0.016493938717834573, -0.016493938717834257, 1.2519364065950405)
 );
-var color = pH * (mS * jr);
+var color = qu * (nQ * jR);
 color = clamp((log2(max(color, vec3f(1e-10))) + 12.47393) / 16.5, vec3f(0.0), vec3f(1.0));
-color = oF * fT(color);
+color = pt * gh(color);
 color = pow(max(color, vec3f(0.0)), vec3f(2.2));
-return clamp(mR * color, vec3f(0.0), vec3f(1.0));
+return clamp(nP * color, vec3f(0.0), vec3f(1.0));
 }
-fn cl(color: vec3f) -> vec3f {
+fn cp(color: vec3f) -> vec3f {
 let toneMappingMode = i32(toneMappingParams.x);
-if (toneMappingMode == 1) { return lv(color); }
-if (toneMappingMode == 2) { return jJ(color); }
-if (toneMappingMode == 3) { return iP(color); }
-if (toneMappingMode == 4) { return jU(color); }
-return me(color);
+if (toneMappingMode == 1) { return mh(color); }
+if (toneMappingMode == 2) { return kj(color); }
+if (toneMappingMode == 3) { return jf(color); }
+if (toneMappingMode == 4) { return ky(color); }
+return mM(color);
 }
 ${linearToSrgbDefine}
-fn gb(jr: vec3f) -> vec3f {
+fn gq(jR: vec3f) -> vec3f {
 let contrast = colorGradingParams.x;
 let saturation = colorGradingParams.y;
 let temperature = colorGradingParams.z;
 let tint = colorGradingParams.w;
-let tj = vec3f(
+let uH = vec3f(
 1.0 + temperature * 0.16 + tint * 0.04,
 1.0 - tint * 0.12,
 1.0 - temperature * 0.16 + tint * 0.04
 );
-var color = max(jr * tj, vec3f(0.0));
+var color = max(jR * uH, vec3f(0.0));
 color = max((color - 0.18) * contrast + 0.18, vec3f(0.0));
 let luminance = dot(color, vec3f(0.2126, 0.7152, 0.0722));
 return max(mix(vec3f(luminance), color, saturation), vec3f(0.0));
 }
 `;
-export const composeMain = /* wgsl */ `
+export function createComposeMain(sdrEncoding = 'srgb') {
+    return /* wgsl */ `
 
-var dY = load_colorTex(uv, 0);
-var jl = vec4(0.0);
+var finalColor = load_colorTex(uv, 0);
+var jI = vec4(0.0);
 if (bloomIntensity > 0.0) {
-jl = load_bloomTex(uv, 0) * bloomIntensity;
-dY = vec4f(dY.rgb + jl.rgb, dY.a);
+jI = load_bloomTex(uv, 0) * bloomIntensity;
+finalColor = vec4f(finalColor.rgb + jI.rgb, finalColor.a);
 }
 
-var ll = gb(dY.rgb * exposure);
-let iI = smoothstep(0.2, 0.72, distance(vec2f(uv) / vec2f(colorTexRegion()), vec2f(0.5)));
-ll *= 1.0 - toneMappingParams.y * iI;
-let gA = hdrOutputEnabled > 0.5;
-if (!gA) {
-ll = cl(ll);
+var gradedColor = gq(finalColor.rgb * exposure);
+let ja = smoothstep(0.2, 0.72, distance(vec2f(uv) / vec2f(colorTexRegion()), vec2f(0.5)));
+gradedColor *= 1.0 - toneMappingParams.y * ja;
+let gQ = hdrOutputEnabled > 0.5;
+if (!gQ) {
+gradedColor = cp(gradedColor);
 }
-let mn = select(
-pow(max(ll, vec3f(0.0)), vec3f(1.0 / 2.2)),
-fM(ll),
-gA
+let mZ = select(
+${sdrEncoding === 'srgb' ? 'linearToSrgb(gradedColor)' : 'pow(max(gradedColor, vec3f(0.0)), vec3f(1.0 / 2.2))'},
+linearToSrgb(gradedColor),
+gQ
 );
-var oc = mn;
+var oV = mZ;
 if (flatBackgroundColor.a > 0.5) {
-let jg = clamp(
+let jD = clamp(
 load_flatBackgroundMaskTex(uv, 0).a,
 0.0,
 1.0
 );
-let pb = fM(max(flatBackgroundColor.rgb, vec3f(0.0)));
-oc = mix(pb, mn, jg);
+let pX = linearToSrgb(max(flatBackgroundColor.rgb, vec3f(0.0)));
+oV = mix(pX, mZ, jD);
 if (bloomIntensity > 0.0) {
-var ir = gb(
-max(dY.rgb - jl.rgb, vec3f(0.0))
+var unbloomedColor = gq(
+max(finalColor.rgb - jI.rgb, vec3f(0.0))
 * exposure
 );
-ir *= 1.0 - toneMappingParams.y * iI;
-if (!gA) {
-ir = cl(ir);
-}
-let rF = select(
-pow(max(ir, vec3f(0.0)), vec3f(1.0 / 2.2)),
-fM(ir),
-gA
+unbloomedColor *= 1.0 - toneMappingParams.y * ja;
+if (!gQ) {
+unbloomedColor = cp(unbloomedColor);
+}
+let sG = select(
+${sdrEncoding === 'srgb' ? 'linearToSrgb(unbloomedColor)' : 'pow(max(unbloomedColor, vec3f(0.0)), vec3f(1.0 / 2.2))'},
+linearToSrgb(unbloomedColor),
+gQ
 );
-oc += max(mn - rF, vec3f(0.0))
-* (1.0 - jg);
+oV += max(mZ - sG, vec3f(0.0))
+* (1.0 - jD);
 }
 }
-dY = vec4f(oc, dY.a);
+finalColor = vec4f(oV, finalColor.a);
 if (bloomIntensity > 0.0) {
-dY.a = max(dY.a, min(dot(jl.rgb, vec3f(0.2125, 0.7154, 0.0721)), 1.0));
+finalColor.a = max(finalColor.a, min(dot(jI.rgb, vec3f(0.2125, 0.7154, 0.0721)), 1.0));
 }
 
 if (shadowCatcherEnabled > 0.5) {
@@ -161,86 +162,110 @@ let background = load_catcherBackgroundTex(uv, 0);
 
 
 
-let kH = select(0.0, clamp(background.a - coverage, 0.0, 1.0 - coverage), flatBackgroundColor.a > 0.5);
-var bK = gb((foreground.rgb + jl.rgb) * exposure);
-var backgroundColor = gb((background.rgb / max(background.a, 0.000001) + jl.rgb) * exposure);
-bK *= 1.0 - toneMappingParams.y * iI;
-backgroundColor *= 1.0 - toneMappingParams.y * iI;
-if (!gA) {
-bK = cl(bK);
-backgroundColor = cl(backgroundColor);
+let ln = select(0.0, clamp(background.a - coverage, 0.0, 1.0 - coverage), flatBackgroundColor.a > 0.5);
+var foregroundColor = gq((foreground.rgb + jI.rgb) * exposure);
+var backgroundColor = gq((background.rgb / max(background.a, 0.000001) + jI.rgb) * exposure);
+foregroundColor *= 1.0 - toneMappingParams.y * ja;
+backgroundColor *= 1.0 - toneMappingParams.y * ja;
+if (!gQ) {
+foregroundColor = cp(foregroundColor);
+backgroundColor = cp(backgroundColor);
 }
-bK = select(pow(max(bK, vec3f(0.0)), vec3f(1.0 / 2.2)), fM(bK), gA);
-backgroundColor = select(pow(max(backgroundColor, vec3f(0.0)), vec3f(1.0 / 2.2)), fM(backgroundColor), gA);
+foregroundColor = select(${sdrEncoding === 'srgb' ? 'linearToSrgb(foregroundColor)' : 'pow(max(foregroundColor, vec3f(0.0)), vec3f(1.0 / 2.2))'}, linearToSrgb(foregroundColor), gQ);
+backgroundColor = select(${sdrEncoding === 'srgb' ? 'linearToSrgb(backgroundColor)' : 'pow(max(backgroundColor, vec3f(0.0)), vec3f(1.0 / 2.2))'}, linearToSrgb(backgroundColor), gQ);
 if (flatBackgroundColor.a > 0.5) {
-var eP = gb(background.rgb / max(background.a, 0.000001) * exposure);
-eP *= 1.0 - toneMappingParams.y * iI;
-if (!gA) { eP = cl(eP); }
-let mo = select(pow(max(eP, vec3f(0.0)), vec3f(1.0 / 2.2)), fM(eP), gA);
-let uk = select(vec3f(0.0), max(backgroundColor - mo, vec3f(0.0)), bloomIntensity > 0.0);
-backgroundColor = fM(max(flatBackgroundColor.rgb, vec3f(0.0))) + uk;
+var unbloomedBackground = gq(background.rgb / max(background.a, 0.000001) * exposure);
+unbloomedBackground *= 1.0 - toneMappingParams.y * ja;
+if (!gQ) { unbloomedBackground = cp(unbloomedBackground); }
+let nd = select(${sdrEncoding === 'srgb' ? 'linearToSrgb(unbloomedBackground)' : 'pow(max(unbloomedBackground, vec3f(0.0)), vec3f(1.0 / 2.2))'}, linearToSrgb(unbloomedBackground), gQ);
+let vL = select(vec3f(0.0), max(backgroundColor - nd, vec3f(0.0)), bloomIntensity > 0.0);
+backgroundColor = linearToSrgb(max(flatBackgroundColor.rgb, vec3f(0.0))) + vL;
 }
 
 
-let fR = coverage * opacity;
-let mg = clamp(dot(jl.rgb, vec3f(0.2125, 0.7154, 0.0721)), 0.0, 1.0);
-let hv = max(foreground.a, mg * (1.0 - coverage - kH));
-let jd = max(background.a, mg * coverage);
-let ku = (jd - kH) * (1.0 - opacity) + kH;
-let alpha = hv + ku + fR;
-let premultiplied = bK * hv
-+ backgroundColor * ku
-+ shadowCatcherColor * fR;
-dY = vec4f(premultiplied / max(alpha, 0.000001), alpha);
+let gf = coverage * opacity;
+let mR = clamp(dot(jI.rgb, vec3f(0.2125, 0.7154, 0.0721)), 0.0, 1.0);
+let hJ = max(foreground.a, mR * (1.0 - coverage - ln));
+let jz = max(background.a, mR * coverage);
+let kX = (jz - ln) * (1.0 - opacity) + ln;
+let alpha = hJ + kX + gf;
+let premultiplied = foregroundColor * hJ
++ backgroundColor * kX
++ shadowCatcherColor * gf;
+finalColor = vec4f(premultiplied / max(alpha, 0.000001), alpha);
 }
 }
 
-output.color = dY;
+output.color = finalColor;
 
 
 `;
+}
+export const composeMain = createComposeMain();
 // Preserve the existing display composition, but give OIDN a floating-point,
 // linear-light image. Alpha is deliberately not used as a second color layer.
-export const compositeDenoiseOutputMain = /* wgsl */ `
-let encoded = max(dY.rgb, vec3f(0.0));
-let sW = select(
-pow(encoded, vec3f(2.2)),
-select(pow((encoded + 0.055) / 1.055, vec3f(2.4)), encoded / 12.92,
-encoded <= vec3f(0.04045)),
-gA
-);
-output.denoiseColor = vec4f(sW, dY.a);
-
+export function createCompositeDenoiseColorMain(output = 'output.denoiseColor', input = 'finalColor', sdrEncoding = 'srgb') {
+    const srgbDecode = 'select(pow((encoded + 0.055) / 1.055, vec3f(2.4)), encoded / 12.92, encoded <= vec3f(0.04045))';
+    return /* wgsl */ `
+let encoded = max(${input}.rgb, vec3f(0.0));
+let um = ${sdrEncoding === 'srgb' ? srgbDecode : `select(pow(encoded, vec3f(2.2)), ${srgbDecode}, gQ)`};
+${output} = vec4f(um, ${input}.a);
 
+`;
+}
+export function createCompositeDenoiseAlbedoMain(output = 'output.denoiseAlbedo') {
+    return /* wgsl */ `
 
 
 
 let rawAlbedo = load_flatBackgroundMaskTex(uv, 0);
-var oW = rawAlbedo.rgb;
+var pS = rawAlbedo.rgb;
 if (shadowCatcherEnabled > 0.5 && flatBackgroundColor.a < 0.5) {
 let coverage = clamp(load_shadowCatcherTex(uv, 0).r, 0.0, 1.0);
 let background = load_catcherBackgroundTex(uv, 0);
 if (coverage > 0.0 && background.a > 0.0) {
-var iv = gb(background.rgb / background.a * exposure);
-iv *= 1.0 - toneMappingParams.y * iI;
-if (!gA) { iv = cl(iv); }
+var iO = gq(background.rgb / background.a * exposure);
+iO *= 1.0 - toneMappingParams.y * ja;
+if (!gQ) { iO = cp(iO); }
 
 
 
-let rs = clamp(background.a, 0.0, coverage);
-oW += rs * (clamp(iv, vec3f(0.0), vec3f(1.0)) - vec3f(1.0));
+let sA = clamp(background.a, 0.0, coverage);
+pS += sA * (clamp(iO, vec3f(0.0), vec3f(1.0)) - vec3f(1.0));
 }
 }
-output.denoiseAlbedo = vec4f(clamp(oW, vec3f(0.0), vec3f(1.0)), rawAlbedo.a);
+${output} = vec4f(clamp(pS, vec3f(0.0), vec3f(1.0)), rawAlbedo.a);
 `;
-export const compositeDenoiseDisplayMain = /* wgsl */ `
+}
+export const compositeDenoiseOutputMain = createCompositeDenoiseColorMain() + createCompositeDenoiseAlbedoMain();
+export function createCompositeDenoiseDisplayMain(sdrEncoding = 'srgb') {
+    return /* wgsl */ `
 let denoised = load_colorTex(uv, 0);
 
 
 
 let alpha = select(load_composedTex(uv, 0).a, clamp(denoised.a, 0.0, 1.0), denoisedAlpha > 0.5);
 let linear = max(denoised.rgb, vec3f(0.0));
-let encoded = select(pow(linear, vec3f(1.0 / 2.2)), fM(linear), hdrOutputEnabled > 0.5);
+let encoded = ${sdrEncoding === 'srgb' ? 'linearToSrgb(linear)' : 'select(pow(linear, vec3f(1.0 / 2.2)), linearToSrgb(linear), hdrOutputEnabled > 0.5)'};
 output.color = vec4f(select(vec3f(0.0), encoded, alpha > 0.0), alpha);
 `;
+}
+export const compositeDenoiseDisplayMain = createCompositeDenoiseDisplayMain();
+// Shared hit normalization; CPU readback retains its f32 reference path.
+export const hdrResolveWGSL = /* wgsl */ `
+fn fK(color: f32, count: f32, hit: f32, ur: f32, rgb: bool) -> f32 {
+if (count <= 0.0) {
+return 0.0;
+}
+let total = max(count, ur);
+let divisor = select(total, hit, (rgb && (hit > 0.0)));
+return (color / divisor);
+}
+fn jQ(color: f32, coverage: f32, flat: bool, rgb: bool) -> f32 {
+if ((flat && rgb) && (coverage > 0.0)) {
+return (color * coverage);
+}
+return color;
+}
+`;
 //# sourceMappingURL=compose.frag.wgsl.js.map

package/lib/renderer/wgsl/compose.frag.wgsl.js.map

@@ -1 +1 @@
-{"version":3,"file":"compose.frag.wgsl.js","sourceRoot":"","sources":["../../../src/renderer/wgsl/compose.frag.wgsl.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,kBAAkB,GAAG,UAAU,CAAC;;;;;;;CAO5C,CAAC;AAEF,MAAM,CAAC,MAAM,aAAa,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0EtC,kBAAkB;;;;;;;;;;;;;;;;CAgBnB,CAAC;AAEF,MAAM,CAAC,MAAM,WAAW,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqGrC,CAAC;AAEF,6EAA6E;AAC7E,8EAA8E;AAC9E,MAAM,CAAC,MAAM,0BAA0B,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BpD,CAAC;AAEF,MAAM,CAAC,MAAM,2BAA2B,GAAG,UAAU,CAAC;;;;;;;;;CASrD,CAAC","sourcesContent":["export const linearToSrgbDefine = /* wgsl */ `\nfn linearToSrgb(color: vec3f) -> vec3f {\n  let linear = max(color, vec3f(0.0));\n  let low = linear * 12.92;\n  let high = 1.055 * pow(linear, vec3f(1.0 / 2.4)) - 0.055;\n  return select(high, low, linear <= vec3f(0.0031308));\n}\n`;\n\nexport const composeDefine = /* wgsl */ `\n\nfn linearToneMapping(color: vec3f) -> vec3f {\n  return clamp(color, vec3f(0.0), vec3f(1.0));\n}\nfn reinhardToneMapping(color: vec3f) -> vec3f {\n  return clamp(color / (vec3f(1.0) + color), vec3f(0.0), vec3f(1.0));\n}\nfn cineonToneMapping(inputColor: vec3f) -> vec3f {\n  let color = max(vec3f(0.0), inputColor - 0.004);\n  return pow((color * (6.2 * color + 0.5)) /\n    (color * (6.2 * color + 1.7) + 0.06), vec3f(2.2));\n}\nfn rrtAndOdtFit(value: vec3f) -> vec3f {\n  let numerator = value * (value + 0.0245786) - 0.000090537;\n  let denominator = value * (0.983729 * value + 0.4329510) + 0.238081;\n  return numerator / denominator;\n}\nfn acesToneMapping(inputColor: vec3f) -> vec3f {\n  let inputMatrix = mat3x3f(\n    vec3f(0.59719, 0.07600, 0.02840),\n    vec3f(0.35458, 0.90834, 0.13383),\n    vec3f(0.04823, 0.01566, 0.83777)\n  );\n  let outputMatrix = mat3x3f(\n    vec3f(1.60475, -0.10208, -0.00327),\n    vec3f(-0.53108, 1.10813, -0.07276),\n    vec3f(-0.07367, -0.00605, 1.07602)\n  );\n  let color = inputMatrix * (inputColor / 0.6);\n  return clamp(outputMatrix * rrtAndOdtFit(color), vec3f(0.0), vec3f(1.0));\n}\nfn agxDefaultContrastApprox(value: vec3f) -> vec3f {\n  let value2 = value * value;\n  let 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}\nfn agxToneMapping(inputColor: vec3f) -> vec3f {\n  let linearRec2020ToLinearSrgb = mat3x3f(\n    vec3f(1.6605, -0.1246, -0.0182),\n    vec3f(-0.5876, 1.1329, -0.1006),\n    vec3f(-0.0728, -0.0083, 1.1187)\n  );\n  let linearSrgbToLinearRec2020 = mat3x3f(\n    vec3f(0.6274, 0.0691, 0.0164),\n    vec3f(0.3293, 0.9195, 0.0880),\n    vec3f(0.0433, 0.0113, 0.8956)\n  );\n  let insetMatrix = mat3x3f(\n    vec3f(0.856627153315983, 0.137318972929847, 0.11189821299995),\n    vec3f(0.0951212405381588, 0.761241990602591, 0.0767994186031903),\n    vec3f(0.0482516061458583, 0.101439036467562, 0.811302368396859)\n  );\n  let outsetMatrix = mat3x3f(\n    vec3f(1.1271005818144368, -0.1413297634984383, -0.14132976349843826),\n    vec3f(-0.11060664309660323, 1.157823702216272, -0.11060664309660294),\n    vec3f(-0.016493938717834573, -0.016493938717834257, 1.2519364065950405)\n  );\n  var color = insetMatrix * (linearSrgbToLinearRec2020 * inputColor);\n  color = clamp((log2(max(color, vec3f(1e-10))) + 12.47393) / 16.5, vec3f(0.0), vec3f(1.0));\n  color = outsetMatrix * agxDefaultContrastApprox(color);\n  color = pow(max(color, vec3f(0.0)), vec3f(2.2));\n  return clamp(linearRec2020ToLinearSrgb * color, vec3f(0.0), vec3f(1.0));\n}\nfn applyToneMapping(color: vec3f) -> vec3f {\n  let toneMappingMode = i32(toneMappingParams.x);\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}\n${linearToSrgbDefine}\nfn gradeColor(inputColor: vec3f) -> vec3f {\n  let contrast = colorGradingParams.x;\n  let saturation = colorGradingParams.y;\n  let temperature = colorGradingParams.z;\n  let tint = colorGradingParams.w;\n  let balance = vec3f(\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  var color = max(inputColor * balance, vec3f(0.0));\n  color = max((color - 0.18) * contrast + 0.18, vec3f(0.0));\n  let luminance = dot(color, vec3f(0.2126, 0.7152, 0.0722));\n  return max(mix(vec3f(luminance), color, saturation), vec3f(0.0));\n}\n`;\n\nexport const composeMain = /* wgsl */ `\n\nvar finalColor = load_colorTex(uv, 0);\nvar bloomTexel = vec4(0.0);\nif (bloomIntensity > 0.0) {\n  bloomTexel = load_bloomTex(uv, 0) * bloomIntensity;\n  finalColor = vec4f(finalColor.rgb + bloomTexel.rgb, finalColor.a);\n}\n\nvar gradedColor = gradeColor(finalColor.rgb * exposure);\nlet vignetteEdge = smoothstep(0.2, 0.72, distance(vec2f(uv) / vec2f(colorTexRegion()), vec2f(0.5)));\ngradedColor *= 1.0 - toneMappingParams.y * vignetteEdge;\nlet hdrOutput = hdrOutputEnabled > 0.5;\nif (!hdrOutput) {\n  gradedColor = applyToneMapping(gradedColor);\n}\nlet encodedDisplay = select(\n  pow(max(gradedColor, vec3f(0.0)), vec3f(1.0 / 2.2)),\n  linearToSrgb(gradedColor),\n  hdrOutput\n);\nvar displayColor = encodedDisplay;\nif (flatBackgroundColor.a > 0.5) {\n  let surfaceCoverage = clamp(\n    load_flatBackgroundMaskTex(uv, 0).a,\n    0.0,\n    1.0\n  );\n  let flatBackgroundDisplay = linearToSrgb(max(flatBackgroundColor.rgb, vec3f(0.0)));\n  displayColor = mix(flatBackgroundDisplay, encodedDisplay, surfaceCoverage);\n  if (bloomIntensity > 0.0) {\n    var unbloomedColor = gradeColor(\n      max(finalColor.rgb - bloomTexel.rgb, vec3f(0.0))\n        * exposure\n    );\n    unbloomedColor *= 1.0 - toneMappingParams.y * vignetteEdge;\n    if (!hdrOutput) {\n      unbloomedColor = applyToneMapping(unbloomedColor);\n    }\n    let encodedUnbloomed = select(\n      pow(max(unbloomedColor, vec3f(0.0)), vec3f(1.0 / 2.2)),\n      linearToSrgb(unbloomedColor),\n      hdrOutput\n    );\n    displayColor += max(encodedDisplay - encodedUnbloomed, vec3f(0.0))\n      * (1.0 - surfaceCoverage);\n  }\n}\nfinalColor = vec4f(displayColor, finalColor.a);\nif (bloomIntensity > 0.0) {\n  finalColor.a = max(finalColor.a, min(dot(bloomTexel.rgb, vec3f(0.2125, 0.7154, 0.0721)), 1.0));\n}\n\nif (shadowCatcherEnabled > 0.5) {\n  let shadowCatcher = load_shadowCatcherTex(uv, 0);\n  let coverage = clamp(shadowCatcher.r, 0.0, 1.0);\n  let opacity = max(clamp(shadowCatcher.a / max(coverage, 0.000001), 0.0, 1.0) - (1.0 - shadowCatcherAlpha), 0.0);\n  if (coverage > 0.0 || flatBackgroundColor.a > 0.5) {\n    let foreground = load_foregroundTex(uv, 0);\n    let background = load_catcherBackgroundTex(uv, 0);\n    // An opaque flat backdrop also owns primary misses outside the receiver.\n    // Its alpha contains catcher coverage plus miss coverage; only the catcher\n    // fraction receives shadow. These weights come from the accumulation,\n    // independently of the quantized denoising/albedo guide.\n    let flatMissCoverage = select(0.0, clamp(background.a - coverage, 0.0, 1.0 - coverage), flatBackgroundColor.a > 0.5);\n    var foregroundColor = gradeColor((foreground.rgb + bloomTexel.rgb) * exposure);\n    var backgroundColor = gradeColor((background.rgb / max(background.a, 0.000001) + bloomTexel.rgb) * exposure);\n    foregroundColor *= 1.0 - toneMappingParams.y * vignetteEdge;\n    backgroundColor *= 1.0 - toneMappingParams.y * vignetteEdge;\n    if (!hdrOutput) {\n      foregroundColor = applyToneMapping(foregroundColor);\n      backgroundColor = applyToneMapping(backgroundColor);\n    }\n    foregroundColor = select(pow(max(foregroundColor, vec3f(0.0)), vec3f(1.0 / 2.2)), linearToSrgb(foregroundColor), hdrOutput);\n    backgroundColor = select(pow(max(backgroundColor, vec3f(0.0)), vec3f(1.0 / 2.2)), linearToSrgb(backgroundColor), hdrOutput);\n    if (flatBackgroundColor.a > 0.5) {\n      var unbloomedBackground = gradeColor(background.rgb / max(background.a, 0.000001) * exposure);\n      unbloomedBackground *= 1.0 - toneMappingParams.y * vignetteEdge;\n      if (!hdrOutput) { unbloomedBackground = applyToneMapping(unbloomedBackground); }\n      let encodedUnbloomedBackground = select(pow(max(unbloomedBackground, vec3f(0.0)), vec3f(1.0 / 2.2)), linearToSrgb(unbloomedBackground), hdrOutput);\n      let bloomSpill = select(vec3f(0.0), max(backgroundColor - encodedUnbloomedBackground, vec3f(0.0)), bloomIntensity > 0.0);\n      backgroundColor = linearToSrgb(max(flatBackgroundColor.rgb, vec3f(0.0))) + bloomSpill;\n    }\n    // Foreground and catcher are disjoint primary samples, not overlapping\n    // alpha layers. Shadow only the catcher background before averaging.\n    let shadowAlpha = coverage * opacity;\n    let bloomAlpha = clamp(dot(bloomTexel.rgb, vec3f(0.2125, 0.7154, 0.0721)), 0.0, 1.0);\n    let foregroundAlpha = max(foreground.a, bloomAlpha * (1.0 - coverage - flatMissCoverage));\n    let backgroundAlpha = max(background.a, bloomAlpha * coverage);\n    let visibleBackgroundAlpha = (backgroundAlpha - flatMissCoverage) * (1.0 - opacity) + flatMissCoverage;\n    let alpha = foregroundAlpha + visibleBackgroundAlpha + shadowAlpha;\n    let premultiplied = foregroundColor * foregroundAlpha\n      + backgroundColor * visibleBackgroundAlpha\n      + shadowCatcherColor * shadowAlpha;\n    finalColor = vec4f(premultiplied / max(alpha, 0.000001), alpha);\n  }\n}\n\noutput.color = finalColor;\n\n// output.color = load_bloomTex(uv, 0) * bloomIntensity;\n`;\n\n// Preserve the existing display composition, but give OIDN a floating-point,\n// linear-light image. Alpha is deliberately not used as a second color layer.\nexport const compositeDenoiseOutputMain = /* wgsl */ `\nlet encoded = max(finalColor.rgb, vec3f(0.0));\nlet displayLinear = select(\n  pow(encoded, vec3f(2.2)),\n  select(pow((encoded + 0.055) / 1.055, vec3f(2.4)), encoded / 12.92,\n    encoded <= vec3f(0.04045)),\n  hdrOutput\n);\noutput.denoiseColor = vec4f(displayLinear, finalColor.a);\n\n// The receiver is invisible: its visible texture is the displayed background,\n// not the neutral reflectance used for its lighting estimate. Match the beauty\n// reconstruction filter, including mixed foreground/receiver primary samples.\n// Exclude the stochastic shadow and bloom so neither is preserved as texture.\nlet rawAlbedo = load_flatBackgroundMaskTex(uv, 0);\nvar compositeAlbedo = rawAlbedo.rgb;\nif (shadowCatcherEnabled > 0.5 && flatBackgroundColor.a < 0.5) {\n  let coverage = clamp(load_shadowCatcherTex(uv, 0).r, 0.0, 1.0);\n  let background = load_catcherBackgroundTex(uv, 0);\n  if (coverage > 0.0 && background.a > 0.0) {\n    var backgroundAlbedo = gradeColor(background.rgb / background.a * exposure);\n    backgroundAlbedo *= 1.0 - toneMappingParams.y * vignetteEdge;\n    if (!hdrOutput) { backgroundAlbedo = applyToneMapping(backgroundAlbedo); }\n    // Background alpha already includes primary catcher coverage. Retain the\n    // neutral receiver for its transparent part, without counting coverage twice\n    // or adding the stochastic shadow opacity to the texture guide.\n    let backgroundWeight = clamp(background.a, 0.0, coverage);\n    compositeAlbedo += backgroundWeight * (clamp(backgroundAlbedo, vec3f(0.0), vec3f(1.0)) - vec3f(1.0));\n  }\n}\noutput.denoiseAlbedo = vec4f(clamp(compositeAlbedo, vec3f(0.0), vec3f(1.0)), rawAlbedo.a);\n`;\n\nexport const compositeDenoiseDisplayMain = /* wgsl */ `\nlet denoised = load_colorTex(uv, 0);\n// Keep the original primary coverage, including transparency. OIDN only\n// filters RGB; filtering coverage separately reintroduces silhouette seams.\n// The built-in filter weights color and coverage together and may replace it.\nlet alpha = select(load_composedTex(uv, 0).a, clamp(denoised.a, 0.0, 1.0), denoisedAlpha > 0.5);\nlet linear = max(denoised.rgb, vec3f(0.0));\nlet encoded = select(pow(linear, vec3f(1.0 / 2.2)), linearToSrgb(linear), hdrOutputEnabled > 0.5);\noutput.color = vec4f(select(vec3f(0.0), encoded, alpha > 0.0), alpha);\n`;\n"]}
+{"version":3,"file":"compose.frag.wgsl.js","sourceRoot":"","sources":["../../../src/renderer/wgsl/compose.frag.wgsl.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,kBAAkB,GAAG,UAAU,CAAC;;;;;;;CAO5C,CAAC;AAEF,MAAM,CAAC,MAAM,aAAa,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0EtC,kBAAkB;;;;;;;;;;;;;;;;CAgBnB,CAAC;AAEF,MAAM,UAAU,iBAAiB,CAAC,cAAkC,MAAM;IACxE,OAAO,UAAU,CAAC;;;;;;;;;;;;;;;;;EAiBhB,WAAW,KAAK,MAAM,CAAC,CAAC,CAAC,2BAA2B,CAAC,CAAC,CAAC,qDAAqD;;;;;;;;;;;;;;;;;;;;;;;EAuBxG,WAAW,KAAK,MAAM,CAAC,CAAC,CAAC,8BAA8B,CAAC,CAAC,CAAC,wDAAwD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAiC3F,WAAW,KAAK,MAAM,CAAC,CAAC,CAAC,+BAA+B,CAAC,CAAC,CAAC,yDAAyD;2BACpH,WAAW,KAAK,MAAM,CAAC,CAAC,CAAC,+BAA+B,CAAC,CAAC,CAAC,yDAAyD;;;;;kBAKnG,WAAW,KAAK,MAAM,CAAC,CAAC,CAAC,mCAAmC,CAAC,CAAC,CAAC,6DAA6D;;;;;;;;;;;;;;;;;;;;;;CAsB3K,CAAC;AACF,CAAC;AACD,MAAM,CAAC,MAAM,WAAW,GAAG,iBAAiB,EAAE,CAAC;AAE/C,6EAA6E;AAC7E,8EAA8E;AAC9E,MAAM,UAAU,+BAA+B,CAAC,MAAM,GAAG,qBAAqB,EAAE,KAAK,GAAG,YAAY,EAAE,cAAkC,MAAM;IAC5I,MAAM,UAAU,GAAG,gGAAgG,CAAC;IACpH,OAAO,UAAU,CAAC;oBACA,KAAK;WACH,WAAW,KAAK,MAAM,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,oCAAoC,UAAU,OAAc;EACtH,MAAM,gBAA2B,KAAK;;CAEvC,CAAC;AACF,CAAC;AACD,MAAM,UAAU,gCAAgC,CAAC,MAAM,GAAG,sBAAsB;IAC9E,OAAO,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;EAoBlB,MAAM;CACP,CAAC;AACF,CAAC;AACD,MAAM,CAAC,MAAM,0BAA0B,GAAG,+BAA+B,EAAE,GAAG,gCAAgC,EAAE,CAAC;AAEjH,MAAM,UAAU,iCAAiC,CAAC,cAAkC,MAAM;IACxF,OAAO,UAAU,CAAC;;;;;;;gBAOJ,WAAW,KAAK,MAAM,CAAC,CAAC,CAAC,sBAAsB,CAAC,CAAC,CAAC,qFAAqF;;CAEtJ,CAAC;AACF,CAAC;AAED,MAAM,CAAC,MAAM,2BAA2B,GAAG,iCAAiC,EAAE,CAAC;AAE/E,yEAAyE;AACzE,MAAM,CAAC,MAAM,cAAc,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;CAexC,CAAC","sourcesContent":["export const linearToSrgbDefine = /* wgsl */ `\nfn linearToSrgb(color: vec3f) -> vec3f {\n  let linear = max(color, vec3f(0.0));\n  let low = linear * 12.92;\n  let high = 1.055 * pow(linear, vec3f(1.0 / 2.4)) - 0.055;\n  return select(high, low, linear <= vec3f(0.0031308));\n}\n`;\n\nexport const composeDefine = /* wgsl */ `\n\nfn linearToneMapping(color: vec3f) -> vec3f {\n  return clamp(color, vec3f(0.0), vec3f(1.0));\n}\nfn reinhardToneMapping(color: vec3f) -> vec3f {\n  return clamp(color / (vec3f(1.0) + color), vec3f(0.0), vec3f(1.0));\n}\nfn cineonToneMapping(inputColor: vec3f) -> vec3f {\n  let color = max(vec3f(0.0), inputColor - 0.004);\n  return pow((color * (6.2 * color + 0.5)) /\n    (color * (6.2 * color + 1.7) + 0.06), vec3f(2.2));\n}\nfn rrtAndOdtFit(value: vec3f) -> vec3f {\n  let numerator = value * (value + 0.0245786) - 0.000090537;\n  let denominator = value * (0.983729 * value + 0.4329510) + 0.238081;\n  return numerator / denominator;\n}\nfn acesToneMapping(inputColor: vec3f) -> vec3f {\n  let inputMatrix = mat3x3f(\n    vec3f(0.59719, 0.07600, 0.02840),\n    vec3f(0.35458, 0.90834, 0.13383),\n    vec3f(0.04823, 0.01566, 0.83777)\n  );\n  let outputMatrix = mat3x3f(\n    vec3f(1.60475, -0.10208, -0.00327),\n    vec3f(-0.53108, 1.10813, -0.07276),\n    vec3f(-0.07367, -0.00605, 1.07602)\n  );\n  let color = inputMatrix * (inputColor / 0.6);\n  return clamp(outputMatrix * rrtAndOdtFit(color), vec3f(0.0), vec3f(1.0));\n}\nfn agxDefaultContrastApprox(value: vec3f) -> vec3f {\n  let value2 = value * value;\n  let 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}\nfn agxToneMapping(inputColor: vec3f) -> vec3f {\n  let linearRec2020ToLinearSrgb = mat3x3f(\n    vec3f(1.6605, -0.1246, -0.0182),\n    vec3f(-0.5876, 1.1329, -0.1006),\n    vec3f(-0.0728, -0.0083, 1.1187)\n  );\n  let linearSrgbToLinearRec2020 = mat3x3f(\n    vec3f(0.6274, 0.0691, 0.0164),\n    vec3f(0.3293, 0.9195, 0.0880),\n    vec3f(0.0433, 0.0113, 0.8956)\n  );\n  let insetMatrix = mat3x3f(\n    vec3f(0.856627153315983, 0.137318972929847, 0.11189821299995),\n    vec3f(0.0951212405381588, 0.761241990602591, 0.0767994186031903),\n    vec3f(0.0482516061458583, 0.101439036467562, 0.811302368396859)\n  );\n  let outsetMatrix = mat3x3f(\n    vec3f(1.1271005818144368, -0.1413297634984383, -0.14132976349843826),\n    vec3f(-0.11060664309660323, 1.157823702216272, -0.11060664309660294),\n    vec3f(-0.016493938717834573, -0.016493938717834257, 1.2519364065950405)\n  );\n  var color = insetMatrix * (linearSrgbToLinearRec2020 * inputColor);\n  color = clamp((log2(max(color, vec3f(1e-10))) + 12.47393) / 16.5, vec3f(0.0), vec3f(1.0));\n  color = outsetMatrix * agxDefaultContrastApprox(color);\n  color = pow(max(color, vec3f(0.0)), vec3f(2.2));\n  return clamp(linearRec2020ToLinearSrgb * color, vec3f(0.0), vec3f(1.0));\n}\nfn applyToneMapping(color: vec3f) -> vec3f {\n  let toneMappingMode = i32(toneMappingParams.x);\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}\n${linearToSrgbDefine}\nfn gradeColor(inputColor: vec3f) -> vec3f {\n  let contrast = colorGradingParams.x;\n  let saturation = colorGradingParams.y;\n  let temperature = colorGradingParams.z;\n  let tint = colorGradingParams.w;\n  let balance = vec3f(\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  var color = max(inputColor * balance, vec3f(0.0));\n  color = max((color - 0.18) * contrast + 0.18, vec3f(0.0));\n  let luminance = dot(color, vec3f(0.2126, 0.7152, 0.0722));\n  return max(mix(vec3f(luminance), color, saturation), vec3f(0.0));\n}\n`;\n\nexport function createComposeMain(sdrEncoding: 'gamma22' | 'srgb' = 'srgb'): string {\n  return /* wgsl */ `\n\nvar finalColor = load_colorTex(uv, 0);\nvar bloomTexel = vec4(0.0);\nif (bloomIntensity > 0.0) {\n  bloomTexel = load_bloomTex(uv, 0) * bloomIntensity;\n  finalColor = vec4f(finalColor.rgb + bloomTexel.rgb, finalColor.a);\n}\n\nvar gradedColor = gradeColor(finalColor.rgb * exposure);\nlet vignetteEdge = smoothstep(0.2, 0.72, distance(vec2f(uv) / vec2f(colorTexRegion()), vec2f(0.5)));\ngradedColor *= 1.0 - toneMappingParams.y * vignetteEdge;\nlet hdrOutput = hdrOutputEnabled > 0.5;\nif (!hdrOutput) {\n  gradedColor = applyToneMapping(gradedColor);\n}\nlet encodedDisplay = select(\n  ${sdrEncoding === 'srgb' ? 'linearToSrgb(gradedColor)' : 'pow(max(gradedColor, vec3f(0.0)), vec3f(1.0 / 2.2))'},\n  linearToSrgb(gradedColor),\n  hdrOutput\n);\nvar displayColor = encodedDisplay;\nif (flatBackgroundColor.a > 0.5) {\n  let surfaceCoverage = clamp(\n    load_flatBackgroundMaskTex(uv, 0).a,\n    0.0,\n    1.0\n  );\n  let flatBackgroundDisplay = linearToSrgb(max(flatBackgroundColor.rgb, vec3f(0.0)));\n  displayColor = mix(flatBackgroundDisplay, encodedDisplay, surfaceCoverage);\n  if (bloomIntensity > 0.0) {\n    var unbloomedColor = gradeColor(\n      max(finalColor.rgb - bloomTexel.rgb, vec3f(0.0))\n        * exposure\n    );\n    unbloomedColor *= 1.0 - toneMappingParams.y * vignetteEdge;\n    if (!hdrOutput) {\n      unbloomedColor = applyToneMapping(unbloomedColor);\n    }\n    let encodedUnbloomed = select(\n      ${sdrEncoding === 'srgb' ? 'linearToSrgb(unbloomedColor)' : 'pow(max(unbloomedColor, vec3f(0.0)), vec3f(1.0 / 2.2))'},\n      linearToSrgb(unbloomedColor),\n      hdrOutput\n    );\n    displayColor += max(encodedDisplay - encodedUnbloomed, vec3f(0.0))\n      * (1.0 - surfaceCoverage);\n  }\n}\nfinalColor = vec4f(displayColor, finalColor.a);\nif (bloomIntensity > 0.0) {\n  finalColor.a = max(finalColor.a, min(dot(bloomTexel.rgb, vec3f(0.2125, 0.7154, 0.0721)), 1.0));\n}\n\nif (shadowCatcherEnabled > 0.5) {\n  let shadowCatcher = load_shadowCatcherTex(uv, 0);\n  let coverage = clamp(shadowCatcher.r, 0.0, 1.0);\n  let opacity = max(clamp(shadowCatcher.a / max(coverage, 0.000001), 0.0, 1.0) - (1.0 - shadowCatcherAlpha), 0.0);\n  if (coverage > 0.0 || flatBackgroundColor.a > 0.5) {\n    let foreground = load_foregroundTex(uv, 0);\n    let background = load_catcherBackgroundTex(uv, 0);\n    // An opaque flat backdrop also owns primary misses outside the receiver.\n    // Its alpha contains catcher coverage plus miss coverage; only the catcher\n    // fraction receives shadow. These weights come from the accumulation,\n    // independently of the quantized denoising/albedo guide.\n    let flatMissCoverage = select(0.0, clamp(background.a - coverage, 0.0, 1.0 - coverage), flatBackgroundColor.a > 0.5);\n    var foregroundColor = gradeColor((foreground.rgb + bloomTexel.rgb) * exposure);\n    var backgroundColor = gradeColor((background.rgb / max(background.a, 0.000001) + bloomTexel.rgb) * exposure);\n    foregroundColor *= 1.0 - toneMappingParams.y * vignetteEdge;\n    backgroundColor *= 1.0 - toneMappingParams.y * vignetteEdge;\n    if (!hdrOutput) {\n      foregroundColor = applyToneMapping(foregroundColor);\n      backgroundColor = applyToneMapping(backgroundColor);\n    }\n    foregroundColor = select(${sdrEncoding === 'srgb' ? 'linearToSrgb(foregroundColor)' : 'pow(max(foregroundColor, vec3f(0.0)), vec3f(1.0 / 2.2))'}, linearToSrgb(foregroundColor), hdrOutput);\n    backgroundColor = select(${sdrEncoding === 'srgb' ? 'linearToSrgb(backgroundColor)' : 'pow(max(backgroundColor, vec3f(0.0)), vec3f(1.0 / 2.2))'}, linearToSrgb(backgroundColor), hdrOutput);\n    if (flatBackgroundColor.a > 0.5) {\n      var unbloomedBackground = gradeColor(background.rgb / max(background.a, 0.000001) * exposure);\n      unbloomedBackground *= 1.0 - toneMappingParams.y * vignetteEdge;\n      if (!hdrOutput) { unbloomedBackground = applyToneMapping(unbloomedBackground); }\n      let encodedUnbloomedBackground = select(${sdrEncoding === 'srgb' ? 'linearToSrgb(unbloomedBackground)' : 'pow(max(unbloomedBackground, vec3f(0.0)), vec3f(1.0 / 2.2))'}, linearToSrgb(unbloomedBackground), hdrOutput);\n      let bloomSpill = select(vec3f(0.0), max(backgroundColor - encodedUnbloomedBackground, vec3f(0.0)), bloomIntensity > 0.0);\n      backgroundColor = linearToSrgb(max(flatBackgroundColor.rgb, vec3f(0.0))) + bloomSpill;\n    }\n    // Foreground and catcher are disjoint primary samples, not overlapping\n    // alpha layers. Shadow only the catcher background before averaging.\n    let shadowAlpha = coverage * opacity;\n    let bloomAlpha = clamp(dot(bloomTexel.rgb, vec3f(0.2125, 0.7154, 0.0721)), 0.0, 1.0);\n    let foregroundAlpha = max(foreground.a, bloomAlpha * (1.0 - coverage - flatMissCoverage));\n    let backgroundAlpha = max(background.a, bloomAlpha * coverage);\n    let visibleBackgroundAlpha = (backgroundAlpha - flatMissCoverage) * (1.0 - opacity) + flatMissCoverage;\n    let alpha = foregroundAlpha + visibleBackgroundAlpha + shadowAlpha;\n    let premultiplied = foregroundColor * foregroundAlpha\n      + backgroundColor * visibleBackgroundAlpha\n      + shadowCatcherColor * shadowAlpha;\n    finalColor = vec4f(premultiplied / max(alpha, 0.000001), alpha);\n  }\n}\n\noutput.color = finalColor;\n\n// output.color = load_bloomTex(uv, 0) * bloomIntensity;\n`;\n}\nexport const composeMain = createComposeMain();\n\n// Preserve the existing display composition, but give OIDN a floating-point,\n// linear-light image. Alpha is deliberately not used as a second color layer.\nexport function createCompositeDenoiseColorMain(output = 'output.denoiseColor', input = 'finalColor', sdrEncoding: 'gamma22' | 'srgb' = 'srgb'): string {\n  const srgbDecode = 'select(pow((encoded + 0.055) / 1.055, vec3f(2.4)), encoded / 12.92, encoded <= vec3f(0.04045))';\n  return /* wgsl */ `\nlet encoded = max(${input}.rgb, vec3f(0.0));\nlet displayLinear = ${sdrEncoding === 'srgb' ? srgbDecode : `select(pow(encoded, vec3f(2.2)), ${srgbDecode}, hdrOutput)`};\n${output} = vec4f(displayLinear, ${input}.a);\n\n`;\n}\nexport function createCompositeDenoiseAlbedoMain(output = 'output.denoiseAlbedo'): string {\n  return /* wgsl */ `// The receiver is invisible: its visible texture is the displayed background,\n// not the neutral reflectance used for its lighting estimate. Match the beauty\n// reconstruction filter, including mixed foreground/receiver primary samples.\n// Exclude the stochastic shadow and bloom so neither is preserved as texture.\nlet rawAlbedo = load_flatBackgroundMaskTex(uv, 0);\nvar compositeAlbedo = rawAlbedo.rgb;\nif (shadowCatcherEnabled > 0.5 && flatBackgroundColor.a < 0.5) {\n  let coverage = clamp(load_shadowCatcherTex(uv, 0).r, 0.0, 1.0);\n  let background = load_catcherBackgroundTex(uv, 0);\n  if (coverage > 0.0 && background.a > 0.0) {\n    var backgroundAlbedo = gradeColor(background.rgb / background.a * exposure);\n    backgroundAlbedo *= 1.0 - toneMappingParams.y * vignetteEdge;\n    if (!hdrOutput) { backgroundAlbedo = applyToneMapping(backgroundAlbedo); }\n    // Background alpha already includes primary catcher coverage. Retain the\n    // neutral receiver for its transparent part, without counting coverage twice\n    // or adding the stochastic shadow opacity to the texture guide.\n    let backgroundWeight = clamp(background.a, 0.0, coverage);\n    compositeAlbedo += backgroundWeight * (clamp(backgroundAlbedo, vec3f(0.0), vec3f(1.0)) - vec3f(1.0));\n  }\n}\n${output} = vec4f(clamp(compositeAlbedo, vec3f(0.0), vec3f(1.0)), rawAlbedo.a);\n`;\n}\nexport const compositeDenoiseOutputMain = createCompositeDenoiseColorMain() + createCompositeDenoiseAlbedoMain();\n\nexport function createCompositeDenoiseDisplayMain(sdrEncoding: 'gamma22' | 'srgb' = 'srgb'): string {\n  return /* wgsl */ `\nlet denoised = load_colorTex(uv, 0);\n// Keep the original primary coverage, including transparency. OIDN only\n// filters RGB; filtering coverage separately reintroduces silhouette seams.\n// The built-in filter weights color and coverage together and may replace it.\nlet alpha = select(load_composedTex(uv, 0).a, clamp(denoised.a, 0.0, 1.0), denoisedAlpha > 0.5);\nlet linear = max(denoised.rgb, vec3f(0.0));\nlet encoded = ${sdrEncoding === 'srgb' ? 'linearToSrgb(linear)' : 'select(pow(linear, vec3f(1.0 / 2.2)), linearToSrgb(linear), hdrOutputEnabled > 0.5)'};\noutput.color = vec4f(select(vec3f(0.0), encoded, alpha > 0.0), alpha);\n`;\n}\n\nexport const compositeDenoiseDisplayMain = createCompositeDenoiseDisplayMain();\n\n// Shared hit normalization; CPU readback retains its f32 reference path.\nexport const hdrResolveWGSL = /* wgsl */ `\nfn hdr_resolve_component(color: f32, count: f32, hit: f32, minimum_count: f32, rgb: bool) -> f32 {\nif (count <= 0.0) {\nreturn 0.0;\n}\nlet total = max(count, minimum_count);\nlet divisor = select(total, hit, (rgb && (hit > 0.0)));\nreturn (color / divisor);\n}\nfn hdr_flat_component(color: f32, coverage: f32, flat: bool, rgb: bool) -> f32 {\nif ((flat && rgb) && (coverage > 0.0)) {\nreturn (color * coverage);\n}\nreturn color;\n}\n`;\n"]}

package/lib/renderer/wgsl/customDenoise.wgsl.js

@@ -5,19 +5,19 @@ let filtered = load_filteredTex(uv, 0).rgb;
 let foreground = load_foregroundTex(uv, 0);
 let background = load_backgroundTex(uv, 0);
 
-var mt = foreground;
-var mr = background;
+var ni = foreground;
+var nh = background;
 if (any(filtered != original)) {
-let uz = abs(original) > vec3f(0.000001);
-let ap = select(vec3f(1.0), original, uz);
-let scale = select(vec3f(1.0), filtered / ap, uz);
-let ub = select(filtered - original, vec3f(0.0), uz);
-mt = vec4f(foreground.rgb * scale + ub, foreground.a);
+let wa = abs(original) > vec3f(0.000001);
+let aq = select(vec3f(1.0), original, wa);
+let scale = select(vec3f(1.0), filtered / aq, wa);
+let vD = select(filtered - original, vec3f(0.0), wa);
+ni = vec4f(foreground.rgb * scale + vD, foreground.a);
 
-mr = vec4f(background.rgb * scale + ub * background.a, background.a);
+nh = vec4f(background.rgb * scale + vD * background.a, background.a);
 }
-output.foreground = mt;
-output.background = mr;
+output.foreground = ni;
+output.background = nh;
 `;
 /** Custom output alpha is ignored; retain the input composition's coverage. */
 export const customDenoiseCoverageMain = /* wgsl */ `

package/lib/renderer/wgsl/depthQuery.wgsl.js

@@ -10,21 +10,21 @@ let offset = vec2f(id.xy) / ${DEPTH_SAMPLE_GRID - 1}.0 * 2.0 - 1.0;
 let uv = depthArea.xy + depthArea.zw * offset * vec2f(1.0, -1.0);
 outColor[index] = vec4f(0.0);
 if (any(uv < vec2f(0.0)) || any(uv > vec2f(1.0))) { return; }
-var ray = hC(uv);
+var ray = fj(uv);
 let eye = cameraUniform.viewInv[3].xyz;
-let ol = -normalize(cameraUniform.viewInv[2].xyz);
-var si: ad;
+let forward = -normalize(cameraUniform.viewInv[2].xyz);
+var si: SurfaceInteraction;
 si.triangleIndex = -1;
 
 
 
 for (var layer = 0; layer < 32; layer++) {
-cZ(ray, &si, 0, false, false);
+intersectScene(ray, &si, 0, false, false);
 if (!si.hit) { return; }
-var material: J;
-eX(&material, si.materialIndex, si.uv, si.uv1, si.instanceIndex, si.vertexColor);
+var material: OpenPbrResolvedMaterial;
+dg(&material, si.materialIndex, si.uv, si.uv1, si.instanceIndex, si.vertexColor);
 if (material.materialType != SHADOW_CATCHER && material.alpha > 0.0) {
-outColor[index] = vec4f(max(dot(si.position - eye, ol), 0.0), 0.0, 0.0, 0.0);
+outColor[index] = vec4f(max(dot(si.position - eye, forward), 0.0), 0.0, 0.0, 0.0);
 return;
 }
 ray.o = si.position + ray.d * (EPS * 0.02);

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

@@ -0,0 +1,25 @@
+import { type JNLMFilterShape } from '../jnlm.js';
+export type JNLMGuideBindings = 'textures' | 'buffers';
+export declare function packJNLMParameters(width: number, height: number, strength: number, pass: number): ArrayBuffer;
+export declare const JNLM_WORKGROUP_SIZE = 8;
+/**
+ * Pass 1: the guide mean and the variance of that mean from the accumulated
+ * moments. Ray buffers are stored bottom-up; guides use texture rows.
+ */
+export declare const jnlmGuideWGSL: string;
+/**
+ * Pass 2: smooth the noisy per-pixel variance over 3 x 3 pixels. Pixels with
+ * a single sample take the spatial variance of their neighborhood instead.
+ */
+export declare const jnlmVarianceWGSL = "\n\nstruct JNLMParams {\n  size: vec2u,\n  colorSensitivity: f32,\n  // Pixel spacing of the search window and patches in this pass.\n  dilation: f32,\n}\n@group(0) @binding(0) var<uniform> params: JNLMParams;\n\n@group(0) @binding(1) var<storage, read> rawGuide: array<vec2f>;\n@group(0) @binding(2) var<storage, read_write> guide: array<vec2f>;\n\n@compute @workgroup_size(8, 8, 1)\nfn main(@builtin(global_invocation_id) id: vec3u) {\n  let size = params.size;\n  if (id.x >= size.x || id.y >= size.y) { return; }\n  let center = rawGuide[id.x + id.y * size.x];\n  var varianceSum = 0.0;\n  var varianceCount = 0.0;\n  var meanSum = 0.0;\n  var meanSquareSum = 0.0;\n  for (var dy = -1; dy <= 1; dy++) {\n    for (var dx = -1; dx <= 1; dx++) {\n      let q = clamp(vec2i(id.xy) + vec2i(dx, dy), vec2i(0), vec2i(size) - 1);\n      let value = rawGuide[u32(q.x) + u32(q.y) * size.x];\n      meanSum += value.x;\n      meanSquareSum += value.x * value.x;\n      if (value.y >= 0.0) {\n        varianceSum += value.y;\n        varianceCount += 1.0;\n      }\n    }\n  }\n  var variance: f32;\n  if (center.y >= 0.0) {\n    variance = varianceSum / varianceCount;\n  } else {\n    let spatialMean = meanSum / 9.0;\n    variance = max(meanSquareSum / 9.0 - spatialMean * spatialMean, 0.0) * 9.0 / 8.0;\n  }\n  guide[id.x + id.y * size.x] = vec2f(center.x, variance);\n}\n";
+/** Copies the composed image into the filter's color buffer. */
+export declare function createJNLMLoadColorWGSL(guides?: JNLMGuideBindings): string;
+export declare const jnlmLoadColorWGSL: string;
+/**
+ * Pass 3: the joint NL-means filter of the composed image. It also filters
+ * the guide with the same weights, with the variance of the weighted mean,
+ * for a following pass. The albedo regression corrects color only, keeping
+ * uncertain fitted texture responses out of the matching guide.
+ */
+export declare function createJNLMFilterWGSL({ searchRadius, patchRadius, albedoBandwidth, normalBandwidth }?: JNLMFilterShape, guides?: JNLMGuideBindings): string;
+export declare const jnlmEncodeWGSL = "\nstruct OutputParams { size: vec2u, premultiply: u32, reserved: u32 }\n@group(0) @binding(0) var<uniform> params: OutputParams;\n@group(0) @binding(1) var<storage, read> color: array<vec4f>;\n@group(0) @binding(2) var output: texture_storage_2d<rgba8unorm, write>;\n\nfn linearToSrgb(color: vec3f) -> vec3f {\n  let linear = max(color, vec3f(0.0));\n  let low = linear * 12.92;\n  let high = 1.055 * pow(linear, vec3f(1.0 / 2.4)) - 0.055;\n  return select(high, low, linear <= vec3f(0.0031308));\n}\n\n@compute @workgroup_size(8, 8, 1)\nfn main(@builtin(global_invocation_id) id: vec3u) {\n  if (any(id.xy >= params.size)) { return; }\n  let c = color[id.y * params.size.x + id.x];\n  var rgb = linearToSrgb(c.rgb);\n  if (params.premultiply != 0u) { rgb *= c.a; }\n  textureStore(output, id.xy, vec4f(rgb, c.a));\n}\n";