@meimu/mutracer 0.2.0 → 0.3.1

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

@@ -1,3 +1,5 @@
+/** Mode indices understood by applyToneMapping. */
+export const TONE_MAPPING_MODES = { agx: 0, aces: 1, cineon: 2, reinhard: 3, linear: 4 };
 export const linearToSrgbDefine = /* wgsl */ `
 fn linearToSrgb(color: vec3f) -> vec3f {
 let linear = max(color, vec3f(0.0));
@@ -8,24 +10,24 @@ return select(high, low, linear <= vec3f(0.0031308));
 `;
 export const composeDefine = /* wgsl */ `
 
-fn ky(color: vec3f) -> vec3f {
+fn kH(color: vec3f) -> vec3f {
 return clamp(color, vec3f(0.0), vec3f(1.0));
 }
-fn jf(color: vec3f) -> vec3f {
+fn jp(color: vec3f) -> vec3f {
 return clamp(color / (vec3f(1.0) + color), vec3f(0.0), vec3f(1.0));
 }
-fn kj(jR: vec3f) -> vec3f {
-let color = max(vec3f(0.0), jR - 0.004);
+fn kw(kb: vec3f) -> vec3f {
+let color = max(vec3f(0.0), kb - 0.004);
 return pow((color * (6.2 * color + 0.5)) /
 (color * (6.2 * color + 1.7) + 0.06), vec3f(2.2));
 }
-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 qw(value: vec3f) -> vec3f {
+let je = value * (value + 0.0245786) - 0.000090537;
+let ah = value * (0.983729 * value + 0.4329510) + 0.238081;
+return je / ah;
 }
-fn mh(jR: vec3f) -> vec3f {
-let qs = mat3x3f(
+fn mH(kb: vec3f) -> vec3f {
+let rt = mat3x3f(
 vec3f(0.59719, 0.07600, 0.02840),
 vec3f(0.35458, 0.90834, 0.13383),
 vec3f(0.04823, 0.01566, 0.83777)
@@ -35,63 +37,63 @@ vec3f(1.60475, -0.10208, -0.00327),
 vec3f(-0.53108, 1.10813, -0.07276),
 vec3f(-0.07367, -0.00605, 1.07602)
 );
-let color = qs * (jR / 0.6);
-return clamp(outputMatrix * pH(color), vec3f(0.0), vec3f(1.0));
+let color = rt * (kb / 0.6);
+return clamp(outputMatrix * qw(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 gj(value: vec3f) -> vec3f {
+let ox = value * value;
+let tf = ox * ox;
+return 15.5 * tf * ox - 40.14 * tf * value
++ 31.96 * tf - 6.868 * ox * value
++ 0.4298 * ox + 0.1191 * value - 0.00232;
 }
-fn mM(jR: vec3f) -> vec3f {
-let nP = mat3x3f(
+fn nC(kb: vec3f) -> vec3f {
+let oB = mat3x3f(
 vec3f(1.6605, -0.1246, -0.0182),
 vec3f(-0.5876, 1.1329, -0.1006),
 vec3f(-0.0728, -0.0083, 1.1187)
 );
-let nQ = mat3x3f(
+let oC = mat3x3f(
 vec3f(0.6274, 0.0691, 0.0164),
 vec3f(0.3293, 0.9195, 0.0880),
 vec3f(0.0433, 0.0113, 0.8956)
 );
-let qu = mat3x3f(
+let rv = mat3x3f(
 vec3f(0.856627153315983, 0.137318972929847, 0.11189821299995),
 vec3f(0.0951212405381588, 0.761241990602591, 0.0767994186031903),
 vec3f(0.0482516061458583, 0.101439036467562, 0.811302368396859)
 );
-let pt = mat3x3f(
+let qr = mat3x3f(
 vec3f(1.1271005818144368, -0.1413297634984383, -0.14132976349843826),
 vec3f(-0.11060664309660323, 1.157823702216272, -0.11060664309660294),
 vec3f(-0.016493938717834573, -0.016493938717834257, 1.2519364065950405)
 );
-var color = qu * (nQ * jR);
+var color = rv * (oC * kb);
 color = clamp((log2(max(color, vec3f(1e-10))) + 12.47393) / 16.5, vec3f(0.0), vec3f(1.0));
-color = pt * gh(color);
+color = qr * gj(color);
 color = pow(max(color, vec3f(0.0)), vec3f(2.2));
-return clamp(nP * color, vec3f(0.0), vec3f(1.0));
+return clamp(oB * color, vec3f(0.0), vec3f(1.0));
 }
-fn cp(color: vec3f) -> vec3f {
+fn bH(color: vec3f) -> vec3f {
 let toneMappingMode = i32(toneMappingParams.x);
-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);
+if (toneMappingMode == 1) { return mH(color); }
+if (toneMappingMode == 2) { return kw(color); }
+if (toneMappingMode == 3) { return jp(color); }
+if (toneMappingMode == 4) { return kH(color); }
+return nC(color);
 }
 ${linearToSrgbDefine}
-fn gq(jR: vec3f) -> vec3f {
+fn fm(kb: vec3f) -> vec3f {
 let contrast = colorGradingParams.x;
 let saturation = colorGradingParams.y;
 let temperature = colorGradingParams.z;
 let tint = colorGradingParams.w;
-let uH = vec3f(
+let wu = 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 * uH, vec3f(0.0));
+var color = max(kb * wu, 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));
@@ -101,54 +103,54 @@ export function createComposeMain(sdrEncoding = 'srgb') {
     return /* wgsl */ `
 
 var finalColor = load_colorTex(uv, 0);
-var jI = vec4(0.0);
+var jU = vec4(0.0);
 if (bloomIntensity > 0.0) {
-jI = load_bloomTex(uv, 0) * bloomIntensity;
-finalColor = vec4f(finalColor.rgb + jI.rgb, finalColor.a);
+jU = load_bloomTex(uv, 0) * bloomIntensity;
+finalColor = vec4f(finalColor.rgb + jU.rgb, finalColor.a);
 }
 
-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);
+var gradedColor = fm(finalColor.rgb * exposure);
+let ji = smoothstep(0.2, 0.72, distance(vec2f(uv) / vec2f(colorTexRegion()), vec2f(0.5)));
+gradedColor *= 1.0 - toneMappingParams.y * ji;
+let gS = hdrOutputEnabled > 0.5;
+if (!gS) {
+gradedColor = bH(gradedColor);
 }
-let mZ = select(
+let nP = select(
 ${sdrEncoding === 'srgb' ? 'linearToSrgb(gradedColor)' : 'pow(max(gradedColor, vec3f(0.0)), vec3f(1.0 / 2.2))'},
 linearToSrgb(gradedColor),
-gQ
+gS
 );
-var oV = mZ;
+var pT = nP;
 if (flatBackgroundColor.a > 0.5) {
-let jD = clamp(
+let jN = clamp(
 load_flatBackgroundMaskTex(uv, 0).a,
 0.0,
 1.0
 );
-let pX = linearToSrgb(max(flatBackgroundColor.rgb, vec3f(0.0)));
-oV = mix(pX, mZ, jD);
+let qV = linearToSrgb(max(flatBackgroundColor.rgb, vec3f(0.0)));
+pT = mix(qV, nP, jN);
 if (bloomIntensity > 0.0) {
-var unbloomedColor = gq(
-max(finalColor.rgb - jI.rgb, vec3f(0.0))
+var unbloomedColor = fm(
+max(finalColor.rgb - jU.rgb, vec3f(0.0))
 * exposure
 );
-unbloomedColor *= 1.0 - toneMappingParams.y * ja;
-if (!gQ) {
-unbloomedColor = cp(unbloomedColor);
+unbloomedColor *= 1.0 - toneMappingParams.y * ji;
+if (!gS) {
+unbloomedColor = bH(unbloomedColor);
 }
-let sG = select(
+let ub = select(
 ${sdrEncoding === 'srgb' ? 'linearToSrgb(unbloomedColor)' : 'pow(max(unbloomedColor, vec3f(0.0)), vec3f(1.0 / 2.2))'},
 linearToSrgb(unbloomedColor),
-gQ
+gS
 );
-oV += max(mZ - sG, vec3f(0.0))
-* (1.0 - jD);
+pT += max(nP - ub, vec3f(0.0))
+* (1.0 - jN);
 }
 }
-finalColor = vec4f(oV, finalColor.a);
+finalColor = vec4f(pT, finalColor.a);
 if (bloomIntensity > 0.0) {
-finalColor.a = max(finalColor.a, min(dot(jI.rgb, vec3f(0.2125, 0.7154, 0.0721)), 1.0));
+finalColor.a = max(finalColor.a, min(dot(jU.rgb, vec3f(0.2125, 0.7154, 0.0721)), 1.0));
 }
 
 if (shadowCatcherEnabled > 0.5) {
@@ -162,36 +164,36 @@ let background = load_catcherBackgroundTex(uv, 0);
 
 
 
-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);
+let lN = select(0.0, clamp(background.a - coverage, 0.0, 1.0 - coverage), flatBackgroundColor.a > 0.5);
+var foregroundColor = fm((foreground.rgb + jU.rgb) * exposure);
+var backgroundColor = fm((background.rgb / max(background.a, 0.000001) + jU.rgb) * exposure);
+foregroundColor *= 1.0 - toneMappingParams.y * ji;
+backgroundColor *= 1.0 - toneMappingParams.y * ji;
+if (!gS) {
+foregroundColor = bH(foregroundColor);
+backgroundColor = bH(backgroundColor);
 }
-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);
+foregroundColor = select(${sdrEncoding === 'srgb' ? 'linearToSrgb(foregroundColor)' : 'pow(max(foregroundColor, vec3f(0.0)), vec3f(1.0 / 2.2))'}, linearToSrgb(foregroundColor), gS);
+backgroundColor = select(${sdrEncoding === 'srgb' ? 'linearToSrgb(backgroundColor)' : 'pow(max(backgroundColor, vec3f(0.0)), vec3f(1.0 / 2.2))'}, linearToSrgb(backgroundColor), gS);
 if (flatBackgroundColor.a > 0.5) {
-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;
+var unbloomedBackground = fm(background.rgb / max(background.a, 0.000001) * exposure);
+unbloomedBackground *= 1.0 - toneMappingParams.y * ji;
+if (!gS) { unbloomedBackground = bH(unbloomedBackground); }
+let nQ = select(${sdrEncoding === 'srgb' ? 'linearToSrgb(unbloomedBackground)' : 'pow(max(unbloomedBackground, vec3f(0.0)), vec3f(1.0 / 2.2))'}, linearToSrgb(unbloomedBackground), gS);
+let xU = select(vec3f(0.0), max(backgroundColor - nQ, vec3f(0.0)), bloomIntensity > 0.0);
+backgroundColor = linearToSrgb(max(flatBackgroundColor.rgb, vec3f(0.0))) + xU;
 }
 
 
-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;
+let gd = coverage * opacity;
+let nF = clamp(dot(jU.rgb, vec3f(0.2125, 0.7154, 0.0721)), 0.0, 1.0);
+let hK = max(foreground.a, nF * (1.0 - coverage - lN));
+let jJ = max(background.a, nF * coverage);
+let ln = (jJ - lN) * (1.0 - opacity) + lN;
+let alpha = hK + ln + gd;
+let premultiplied = foregroundColor * hK
++ backgroundColor * ln
++ shadowCatcherColor * gd;
 finalColor = vec4f(premultiplied / max(alpha, 0.000001), alpha);
 }
 }
@@ -208,8 +210,8 @@ export function createCompositeDenoiseColorMain(output = 'output.denoiseColor',
     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);
+let wa = ${sdrEncoding === 'srgb' ? srgbDecode : `select(pow(encoded, vec3f(2.2)), ${srgbDecode}, gS)`};
+${output} = vec4f(wa, ${input}.a);
 
 `;
 }
@@ -219,22 +221,22 @@ export function createCompositeDenoiseAlbedoMain(output = 'output.denoiseAlbedo'
 
 
 let rawAlbedo = load_flatBackgroundMaskTex(uv, 0);
-var pS = rawAlbedo.rgb;
+var qM = 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 iO = gq(background.rgb / background.a * exposure);
-iO *= 1.0 - toneMappingParams.y * ja;
-if (!gQ) { iO = cp(iO); }
+var iW = fm(background.rgb / background.a * exposure);
+iW *= 1.0 - toneMappingParams.y * ji;
+if (!gS) { iW = bH(iW); }
 
 
 
-let sA = clamp(background.a, 0.0, coverage);
-pS += sA * (clamp(iO, vec3f(0.0), vec3f(1.0)) - vec3f(1.0));
+let tS = clamp(background.a, 0.0, coverage);
+qM += tS * (clamp(iW, vec3f(0.0), vec3f(1.0)) - vec3f(1.0));
 }
 }
-${output} = vec4f(clamp(pS, vec3f(0.0), vec3f(1.0)), rawAlbedo.a);
+${output} = vec4f(clamp(qM, vec3f(0.0), vec3f(1.0)), rawAlbedo.a);
 `;
 }
 export const compositeDenoiseOutputMain = createCompositeDenoiseColorMain() + createCompositeDenoiseAlbedoMain();
@@ -253,15 +255,15 @@ 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 {
+fn fF(color: f32, count: f32, hit: f32, wf: f32, rgb: bool) -> f32 {
 if (count <= 0.0) {
 return 0.0;
 }
-let total = max(count, ur);
+let total = max(count, wf);
 let divisor = select(total, hit, (rgb && (hit > 0.0)));
 return (color / divisor);
 }
-fn jQ(color: f32, coverage: f32, flat: bool, rgb: bool) -> f32 {
+fn ka(color: f32, coverage: f32, flat: bool, rgb: bool) -> f32 {
 if ((flat && rgb) && (coverage > 0.0)) {
 return (color * coverage);
 }

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,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"]}
+{"version":3,"file":"compose.frag.wgsl.js","sourceRoot":"","sources":["../../../src/renderer/wgsl/compose.frag.wgsl.ts"],"names":[],"mappings":"AAAA,mDAAmD;AACnD,MAAM,CAAC,MAAM,kBAAkB,GAAqC,EAAC,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAC,CAAC;AAEzH,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":["/** Mode indices understood by applyToneMapping. */\nexport const TONE_MAPPING_MODES: Readonly<Record<string, number>> = {agx: 0, aces: 1, cineon: 2, reinhard: 3, linear: 4};\n\nexport 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 ni = foreground;
-var nh = background;
+var nU = foreground;
+var nT = background;
 if (any(filtered != original)) {
-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);
+let yr = abs(original) > vec3f(0.000001);
+let ah = select(vec3f(1.0), original, yr);
+let scale = select(vec3f(1.0), filtered / ah, yr);
+let xI = select(filtered - original, vec3f(0.0), yr);
+nU = vec4f(foreground.rgb * scale + xI, foreground.a);
 
-nh = vec4f(background.rgb * scale + vD * background.a, background.a);
+nT = vec4f(background.rgb * scale + xI * background.a, background.a);
 }
-output.foreground = ni;
-output.background = nh;
+output.foreground = nU;
+output.background = nT;
 `;
 /** Custom output alpha is ignored; retain the input composition's coverage. */
 export const customDenoiseCoverageMain = /* wgsl */ `

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

@@ -1,3 +1,3 @@
 /** Extra entry point in the ray-tracing module; reuses its scene bindings. */
-declare const _default: "\n@group(3) @binding(4) var<uniform> depthArea: vec4f;\n\n@compute @workgroup_size(7, 7)\nfn depthQuery(@builtin(global_invocation_id) id: vec3u) {\n  let index = id.x + id.y * 7u;\n  let offset = vec2f(id.xy) / 6.0 * 2.0 - 1.0;\n  let uv = depthArea.xy + depthArea.zw * offset * vec2f(1.0, -1.0);\n  outColor[index] = vec4f(0.0);\n  if (any(uv < vec2f(0.0)) || any(uv > vec2f(1.0))) { return; }\n  var ray = initCameraRay(uv);\n  let eye = cameraUniform.viewInv[3].xyz;\n  let forward = -normalize(cameraUniform.viewInv[2].xyz);\n  var si: SurfaceInteraction;\n  si.triangleIndex = -1;\n  // Ignore invisible catchers and alpha-cutout holes, without stochastic DOF\n  // or pixel jitter. A bounded continuation prevents coincident surfaces\n  // from keeping the query alive indefinitely.\n  for (var layer = 0; layer < 32; layer++) {\n    intersectScene(ray, &si, 0, false, false);\n    if (!si.hit) { return; }\n    var material: OpenPbrResolvedMaterial;\n    getMaterial(&material, si.materialIndex, si.uv, si.uv1, si.instanceIndex, si.vertexColor);\n    if (material.materialType != SHADOW_CATCHER && material.alpha > 0.0) {\n      outColor[index] = vec4f(max(dot(si.position - eye, forward), 0.0), 0.0, 0.0, 0.0);\n      return;\n    }\n    ray.o = si.position + ray.d * (EPS * 0.02);\n  }\n}\n";
+declare const _default: "\n@group(3) @binding(4) var<uniform> depthArea: vec4f;\n\n@compute @workgroup_size(7, 7)\nfn depthQuery(@builtin(global_invocation_id) id: vec3u) {\n  let index = id.x + id.y * 7u;\n  let picking = depthArea.z < 0.0;\n  if (picking && index != 0u) {return;}\n  let offset = vec2f(id.xy) / 6.0 * 2.0 - 1.0;\n  let uv = select(depthArea.xy + depthArea.zw * offset * vec2f(1.0, -1.0), depthArea.xy, picking);\n  outColor[index] = vec4f(0.0);\n  if (any(uv < vec2f(0.0)) || any(uv > vec2f(1.0))) { return; }\n  var ray = initCameraRay(uv);\n  let eye = cameraUniform.viewInv[3].xyz;\n  let forward = -normalize(cameraUniform.viewInv[2].xyz);\n  var si: SurfaceInteraction;\n  si.triangleIndex = -1;\n  // Ignore invisible catchers and alpha-cutout holes, without stochastic DOF\n  // or pixel jitter. A bounded continuation prevents coincident surfaces\n  // from keeping the query alive indefinitely.\n  for (var layer = 0; layer < 32; layer++) {\n    intersectScene(ray, &si, 0, false, false);\n    if (!si.hit) { return; }\n    var material: OpenPbrResolvedMaterial;\n    getMaterial(&material, si.materialIndex, si.uv, si.uv1, si.instanceIndex, si.vertexColor);\n    if (material.materialType != SHADOW_CATCHER && material.alpha > 0.0) {\n      if (picking) {\n        let instance = u32(si.instanceIndex) + 1u;\n        let materialIndex = u32(si.materialIndex) + 1u;\n        outColor[index] = vec4f(f32(instance & 65535u), f32(instance >> 16u),\n          f32(materialIndex & 65535u), f32(materialIndex >> 16u));\n      } else {\n        outColor[index] = vec4f(max(dot(si.position - eye, forward), 0.0), 0.0, 0.0, 0.0);\n      }\n      return;\n    }\n    ray.o = si.position + ray.d * (EPS * 0.02);\n  }\n}\n";
 export default _default;

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

@@ -6,11 +6,13 @@ export default /* wgsl */ `
 @compute @workgroup_size(${DEPTH_SAMPLE_GRID}, ${DEPTH_SAMPLE_GRID})
 fn depthQuery(@builtin(global_invocation_id) id: vec3u) {
 let index = id.x + id.y * ${DEPTH_SAMPLE_GRID}u;
+let picking = depthArea.z < 0.0;
+if (picking && index != 0u) {return;}
 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);
+let uv = select(depthArea.xy + depthArea.zw * offset * vec2f(1.0, -1.0), depthArea.xy, picking);
 outColor[index] = vec4f(0.0);
 if (any(uv < vec2f(0.0)) || any(uv > vec2f(1.0))) { return; }
-var ray = fj(uv);
+var ray = cV(uv);
 let eye = cameraUniform.viewInv[3].xyz;
 let forward = -normalize(cameraUniform.viewInv[2].xyz);
 var si: SurfaceInteraction;
@@ -22,9 +24,16 @@ for (var layer = 0; layer < 32; layer++) {
 intersectScene(ray, &si, 0, false, false);
 if (!si.hit) { return; }
 var material: OpenPbrResolvedMaterial;
-dg(&material, si.materialIndex, si.uv, si.uv1, si.instanceIndex, si.vertexColor);
+getMaterial(&material, si.materialIndex, si.uv, si.uv1, si.instanceIndex, si.vertexColor);
 if (material.materialType != SHADOW_CATCHER && material.alpha > 0.0) {
+if (picking) {
+let instance = u32(si.instanceIndex) + 1u;
+let materialIndex = u32(si.materialIndex) + 1u;
+outColor[index] = vec4f(f32(instance & 65535u), f32(instance >> 16u),
+f32(materialIndex & 65535u), f32(materialIndex >> 16u));
+} else {
 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/depthQuery.wgsl.js.map

@@ -1 +1 @@
-{"version":3,"file":"depthQuery.wgsl.js","sourceRoot":"","sources":["../../../src/renderer/wgsl/depthQuery.wgsl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAErD,8EAA8E;AAC9E,eAAe,UAAU,CAAC;;;2BAGC,iBAAiB,KAAK,iBAAiB;;4BAEpC,iBAAiB;8BACf,iBAAiB,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;CAwBpD,CAAC","sourcesContent":["import { DEPTH_SAMPLE_GRID } from '../depthQuery.js';\n\n/** Extra entry point in the ray-tracing module; reuses its scene bindings. */\nexport default /* wgsl */ `\n@group(3) @binding(4) var<uniform> depthArea: vec4f;\n\n@compute @workgroup_size(${DEPTH_SAMPLE_GRID}, ${DEPTH_SAMPLE_GRID})\nfn depthQuery(@builtin(global_invocation_id) id: vec3u) {\n  let index = id.x + id.y * ${DEPTH_SAMPLE_GRID}u;\n  let offset = vec2f(id.xy) / ${DEPTH_SAMPLE_GRID - 1}.0 * 2.0 - 1.0;\n  let uv = depthArea.xy + depthArea.zw * offset * vec2f(1.0, -1.0);\n  outColor[index] = vec4f(0.0);\n  if (any(uv < vec2f(0.0)) || any(uv > vec2f(1.0))) { return; }\n  var ray = initCameraRay(uv);\n  let eye = cameraUniform.viewInv[3].xyz;\n  let forward = -normalize(cameraUniform.viewInv[2].xyz);\n  var si: SurfaceInteraction;\n  si.triangleIndex = -1;\n  // Ignore invisible catchers and alpha-cutout holes, without stochastic DOF\n  // or pixel jitter. A bounded continuation prevents coincident surfaces\n  // from keeping the query alive indefinitely.\n  for (var layer = 0; layer < 32; layer++) {\n    intersectScene(ray, &si, 0, false, false);\n    if (!si.hit) { return; }\n    var material: OpenPbrResolvedMaterial;\n    getMaterial(&material, si.materialIndex, si.uv, si.uv1, si.instanceIndex, si.vertexColor);\n    if (material.materialType != SHADOW_CATCHER && material.alpha > 0.0) {\n      outColor[index] = vec4f(max(dot(si.position - eye, forward), 0.0), 0.0, 0.0, 0.0);\n      return;\n    }\n    ray.o = si.position + ray.d * (EPS * 0.02);\n  }\n}\n`;\n"]}
+{"version":3,"file":"depthQuery.wgsl.js","sourceRoot":"","sources":["../../../src/renderer/wgsl/depthQuery.wgsl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAErD,8EAA8E;AAC9E,eAAe,UAAU,CAAC;;;2BAGC,iBAAiB,KAAK,iBAAiB;;4BAEpC,iBAAiB;;;8BAGf,iBAAiB,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BpD,CAAC","sourcesContent":["import { DEPTH_SAMPLE_GRID } from '../depthQuery.js';\n\n/** Extra entry point in the ray-tracing module; reuses its scene bindings. */\nexport default /* wgsl */ `\n@group(3) @binding(4) var<uniform> depthArea: vec4f;\n\n@compute @workgroup_size(${DEPTH_SAMPLE_GRID}, ${DEPTH_SAMPLE_GRID})\nfn depthQuery(@builtin(global_invocation_id) id: vec3u) {\n  let index = id.x + id.y * ${DEPTH_SAMPLE_GRID}u;\n  let picking = depthArea.z < 0.0;\n  if (picking && index != 0u) {return;}\n  let offset = vec2f(id.xy) / ${DEPTH_SAMPLE_GRID - 1}.0 * 2.0 - 1.0;\n  let uv = select(depthArea.xy + depthArea.zw * offset * vec2f(1.0, -1.0), depthArea.xy, picking);\n  outColor[index] = vec4f(0.0);\n  if (any(uv < vec2f(0.0)) || any(uv > vec2f(1.0))) { return; }\n  var ray = initCameraRay(uv);\n  let eye = cameraUniform.viewInv[3].xyz;\n  let forward = -normalize(cameraUniform.viewInv[2].xyz);\n  var si: SurfaceInteraction;\n  si.triangleIndex = -1;\n  // Ignore invisible catchers and alpha-cutout holes, without stochastic DOF\n  // or pixel jitter. A bounded continuation prevents coincident surfaces\n  // from keeping the query alive indefinitely.\n  for (var layer = 0; layer < 32; layer++) {\n    intersectScene(ray, &si, 0, false, false);\n    if (!si.hit) { return; }\n    var material: OpenPbrResolvedMaterial;\n    getMaterial(&material, si.materialIndex, si.uv, si.uv1, si.instanceIndex, si.vertexColor);\n    if (material.materialType != SHADOW_CATCHER && material.alpha > 0.0) {\n      if (picking) {\n        let instance = u32(si.instanceIndex) + 1u;\n        let materialIndex = u32(si.materialIndex) + 1u;\n        outColor[index] = vec4f(f32(instance & 65535u), f32(instance >> 16u),\n          f32(materialIndex & 65535u), f32(materialIndex >> 16u));\n      } else {\n        outColor[index] = vec4f(max(dot(si.position - eye, forward), 0.0), 0.0, 0.0, 0.0);\n      }\n      return;\n    }\n    ray.o = si.position + ray.d * (EPS * 0.02);\n  }\n}\n`;\n"]}

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

@@ -0,0 +1,2 @@
+export declare const easuShader = "\n@group(0) @binding(0) var colorImage: texture_2d<f32>;\n@group(0) @binding(1) var<uniform> outputSize: vec4f;\n@vertex fn vertex(@builtin(vertex_index) index: u32) -> @builtin(position) vec4f {\n  let p = vec2f(f32((index << 1u) & 2u), f32(index & 2u));\n  return vec4f(p * 2.0 - 1.0, 0.0, 1.0);\n}\nconst offsets = array<vec2i,12>(vec2i(0,-1),vec2i(1,-1),vec2i(-1,0),vec2i(0,0),vec2i(1,0),vec2i(2,0),\n  vec2i(-1,1),vec2i(0,1),vec2i(1,1),vec2i(2,1),vec2i(0,2),vec2i(1,2));\nfn loadColor(p: vec2i) -> vec4f {return textureLoad(colorImage, clamp(p,vec2i(0),vec2i(textureDimensions(colorImage))-1),0);}\nfn gradient(a: f32,b: f32,c: f32,d: f32,e: f32,w: f32) -> vec3f {\n  let direction = vec2f(d-b,e-a);\n  let length = clamp(abs(direction)/max(vec2f(max(abs(d-c),abs(c-b)),max(abs(e-c),abs(c-a))),vec2f(1e-8)),vec2f(0),vec2f(1));\n  return vec3f(direction,dot(length,length))*w;\n}\nfn easuWeight(offset: vec2f, direction: vec2f, length: vec2f, lobe: f32) -> f32 {\n  let v = vec2f(dot(offset,direction),dot(offset,vec2f(-direction.y,direction.x)))*length;\n  let distance = min(dot(v,v),1.0/lobe);\n  let b = 0.4*distance-1.0;\n  let a = lobe*distance-1.0;\n  return (1.5625*b*b-0.5625)*a*a;\n}\n@fragment fn fragment(@builtin(position) position: vec4f) -> @location(0) vec4f {\n  let point = position.xy*vec2f(textureDimensions(colorImage))/outputSize.xy-0.5;\n  let base = vec2i(floor(point)); let phase = fract(point);\n  var colors: array<vec4f,12>;\n  var luma: array<f32,12>;\n  // FSR expects [0,1]. Normalize the neighborhood for direction estimation\n  // in extended-range output; filter the original RGB without clipping it to 1.\n  var range = 1.0;\n  for(var i=0u;i<12u;i++){colors[i]=loadColor(base+offsets[i]);range=max(range,max(max(colors[i].r,colors[i].g),colors[i].b));}\n  for(var i=0u;i<12u;i++){luma[i]=dot(colors[i].rgb/range,vec3f(0.5,1.0,0.5));}\n  let g = gradient(luma[0],luma[2],luma[3],luma[4],luma[7],(1.0-phase.x)*(1.0-phase.y))+\n    gradient(luma[1],luma[3],luma[4],luma[5],luma[8],phase.x*(1.0-phase.y))+\n    gradient(luma[3],luma[6],luma[7],luma[8],luma[10],(1.0-phase.x)*phase.y)+\n    gradient(luma[4],luma[7],luma[8],luma[9],luma[11],phase.x*phase.y);\n  var direction = vec2f(1.0,0.0);\n  if(dot(g.xy,g.xy)>=1.0/32768.0){direction=normalize(g.xy);}\n  let edge = (g.z*0.5)*(g.z*0.5);\n  let stretch = dot(direction,direction)/max(abs(direction.x),abs(direction.y));\n  let length = vec2f(1.0+(stretch-1.0)*edge,1.0-0.5*edge);\n  let lobe = 0.5+(0.21-0.5)*edge;\n  var result=vec4f(0); var total=0.0;\n  for(var i=0u;i<12u;i++){\n    let weight=easuWeight(vec2f(offsets[i])-phase,direction,length,lobe);\n    result+=colors[i]*weight;total+=weight;\n  }\n  let lower=min(min(colors[3],colors[4]),min(colors[7],colors[8]));\n  let upper=max(max(colors[3],colors[4]),max(colors[7],colors[8]));\n  return clamp(result/total,lower,upper);\n}\n";
+export declare const areaDownsampleShader = "\n@group(0) @binding(0) var colorImage: texture_2d<f32>;\n@group(0) @binding(1) var<uniform> outputSize: vec4f;\n@vertex fn vertex(@builtin(vertex_index) index: u32) -> @builtin(position) vec4f {\n  let p = vec2f(f32((index << 1u) & 2u), f32(index & 2u));\n  return vec4f(p * 2.0 - 1.0, 0.0, 1.0);\n}\n@fragment fn fragment(@builtin(position) position: vec4f) -> @location(0) vec4f {\n  let scale = vec2f(textureDimensions(colorImage))/outputSize.xy;\n  let start = floor(position.xy)*scale; let end = start+scale;\n  var sum = vec4f(0);\n  for (var y = i32(floor(start.y)); y < i32(ceil(end.y)); y++) {\n    for (var x = i32(floor(start.x)); x < i32(ceil(end.x)); x++) {\n      let overlap = max(vec2f(0), min(vec2f(vec2i(x+1,y+1)), end)-max(vec2f(vec2i(x,y)), start));\n      let color = textureLoad(colorImage, vec2i(x,y), 0);\n      sum += vec4f(color.rgb*color.a, color.a)*overlap.x*overlap.y;\n    }\n  }\n  return vec4f(sum.rgb/max(sum.a, 1e-8), sum.a/(scale.x*scale.y));\n}\n";

package/lib/renderer/wgsl/easu.wgsl.js

@@ -0,0 +1,80 @@
+// Adapted from AMD FidelityFX FSR 1, ffx_fsr1.h v1.20210629,
+// FsrEasuSetF/FsrEasuTapF/FsrEasuF (32-bit path). MIT; see LICENSES/FidelityFX-FSR.txt.
+// https://github.com/GPUOpen-Effects/FidelityFX-FSR/blob/master/ffx-fsr/ffx_fsr1.h
+// Uses exact reciprocals instead of the reference's low precision approximations.
+export const easuShader = /* wgsl */ `
+@group(0) @binding(0) var colorImage: texture_2d<f32>;
+@group(0) @binding(1) var<uniform> outputSize: vec4f;
+@vertex fn vertex(@builtin(vertex_index) index: u32) -> @builtin(position) vec4f {
+let p = vec2f(f32((index << 1u) & 2u), f32(index & 2u));
+return vec4f(p * 2.0 - 1.0, 0.0, 1.0);
+}
+const offsets = array<vec2i,12>(vec2i(0,-1),vec2i(1,-1),vec2i(-1,0),vec2i(0,0),vec2i(1,0),vec2i(2,0),
+vec2i(-1,1),vec2i(0,1),vec2i(1,1),vec2i(2,1),vec2i(0,2),vec2i(1,2));
+fn ns(p: vec2i) -> vec4f {return textureLoad(colorImage, clamp(p,vec2i(0),vec2i(textureDimensions(colorImage))-1),0);}
+fn tB(a: f32,b: f32,c: f32,d: f32,e: f32,w: f32) -> vec3f {
+let direction = vec2f(d-b,e-a);
+let length = clamp(abs(direction)/max(vec2f(max(abs(d-c),abs(c-b)),max(abs(e-c),abs(c-a))),vec2f(1e-8)),vec2f(0),vec2f(1));
+return vec3f(direction,dot(length,length))*w;
+}
+fn sJ(offset: vec2f, direction: vec2f, length: vec2f, lobe: f32) -> f32 {
+let v = vec2f(dot(offset,direction),dot(offset,vec2f(-direction.y,direction.x)))*length;
+let distance = min(dot(v,v),1.0/lobe);
+let b = 0.4*distance-1.0;
+let a = lobe*distance-1.0;
+return (1.5625*b*b-0.5625)*a*a;
+}
+@fragment fn fragment(@builtin(position) position: vec4f) -> @location(0) vec4f {
+let point = position.xy*vec2f(textureDimensions(colorImage))/outputSize.xy-0.5;
+let base = vec2i(floor(point)); let phase = fract(point);
+var colors: array<vec4f,12>;
+var lQ: array<f32,12>;
+
+
+var range = 1.0;
+for(var i=0u;i<12u;i++){colors[i]=ns(base+offsets[i]);range=max(range,max(max(colors[i].r,colors[i].g),colors[i].b));}
+for(var i=0u;i<12u;i++){lQ[i]=dot(colors[i].rgb/range,vec3f(0.5,1.0,0.5));}
+let g = tB(lQ[0],lQ[2],lQ[3],lQ[4],lQ[7],(1.0-phase.x)*(1.0-phase.y))+
+tB(lQ[1],lQ[3],lQ[4],lQ[5],lQ[8],phase.x*(1.0-phase.y))+
+tB(lQ[3],lQ[6],lQ[7],lQ[8],lQ[10],(1.0-phase.x)*phase.y)+
+tB(lQ[4],lQ[7],lQ[8],lQ[9],lQ[11],phase.x*phase.y);
+var direction = vec2f(1.0,0.0);
+if(dot(g.xy,g.xy)>=1.0/32768.0){direction=normalize(g.xy);}
+let edge = (g.z*0.5)*(g.z*0.5);
+let qD = dot(direction,direction)/max(abs(direction.x),abs(direction.y));
+let length = vec2f(1.0+(qD-1.0)*edge,1.0-0.5*edge);
+let lobe = 0.5+(0.21-0.5)*edge;
+var result=vec4f(0); var total=0.0;
+for(var i=0u;i<12u;i++){
+let weight=sJ(vec2f(offsets[i])-phase,direction,length,lobe);
+result+=colors[i]*weight;total+=weight;
+}
+let lower=min(min(colors[3],colors[4]),min(colors[7],colors[8]));
+let upper=max(max(colors[3],colors[4]),max(colors[7],colors[8]));
+return clamp(result/total,lower,upper);
+}
+`;
+// Not part of FSR: exact area average for inputs larger than the output,
+// alpha-weighted so transparent texels do not darken coverage edges.
+export const areaDownsampleShader = /* wgsl */ `
+@group(0) @binding(0) var colorImage: texture_2d<f32>;
+@group(0) @binding(1) var<uniform> outputSize: vec4f;
+@vertex fn vertex(@builtin(vertex_index) index: u32) -> @builtin(position) vec4f {
+let p = vec2f(f32((index << 1u) & 2u), f32(index & 2u));
+return vec4f(p * 2.0 - 1.0, 0.0, 1.0);
+}
+@fragment fn fragment(@builtin(position) position: vec4f) -> @location(0) vec4f {
+let scale = vec2f(textureDimensions(colorImage))/outputSize.xy;
+let start = floor(position.xy)*scale; let end = start+scale;
+var sum = vec4f(0);
+for (var y = i32(floor(start.y)); y < i32(ceil(end.y)); y++) {
+for (var x = i32(floor(start.x)); x < i32(ceil(end.x)); x++) {
+let tK = max(vec2f(0), min(vec2f(vec2i(x+1,y+1)), end)-max(vec2f(vec2i(x,y)), start));
+let color = textureLoad(colorImage, vec2i(x,y), 0);
+sum += vec4f(color.rgb*color.a, color.a)*tK.x*tK.y;
+}
+}
+return vec4f(sum.rgb/max(sum.a, 1e-8), sum.a/(scale.x*scale.y));
+}
+`;
+//# sourceMappingURL=easu.wgsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"easu.wgsl.js","sourceRoot":"","sources":["../../../src/renderer/wgsl/easu.wgsl.ts"],"names":[],"mappings":"AAAA,6DAA6D;AAC7D,wFAAwF;AACxF,mFAAmF;AACnF,kFAAkF;AAClF,MAAM,CAAC,MAAM,UAAU,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmDpC,CAAC;AAEF,yEAAyE;AACzE,qEAAqE;AACrE,MAAM,CAAC,MAAM,oBAAoB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;CAoB9C,CAAC","sourcesContent":["// Adapted from AMD FidelityFX FSR 1, ffx_fsr1.h v1.20210629,\n// FsrEasuSetF/FsrEasuTapF/FsrEasuF (32-bit path). MIT; see LICENSES/FidelityFX-FSR.txt.\n// https://github.com/GPUOpen-Effects/FidelityFX-FSR/blob/master/ffx-fsr/ffx_fsr1.h\n// Uses exact reciprocals instead of the reference's low precision approximations.\nexport const easuShader = /* wgsl */ `\n@group(0) @binding(0) var colorImage: texture_2d<f32>;\n@group(0) @binding(1) var<uniform> outputSize: vec4f;\n@vertex fn vertex(@builtin(vertex_index) index: u32) -> @builtin(position) vec4f {\n  let p = vec2f(f32((index << 1u) & 2u), f32(index & 2u));\n  return vec4f(p * 2.0 - 1.0, 0.0, 1.0);\n}\nconst offsets = array<vec2i,12>(vec2i(0,-1),vec2i(1,-1),vec2i(-1,0),vec2i(0,0),vec2i(1,0),vec2i(2,0),\n  vec2i(-1,1),vec2i(0,1),vec2i(1,1),vec2i(2,1),vec2i(0,2),vec2i(1,2));\nfn loadColor(p: vec2i) -> vec4f {return textureLoad(colorImage, clamp(p,vec2i(0),vec2i(textureDimensions(colorImage))-1),0);}\nfn gradient(a: f32,b: f32,c: f32,d: f32,e: f32,w: f32) -> vec3f {\n  let direction = vec2f(d-b,e-a);\n  let length = clamp(abs(direction)/max(vec2f(max(abs(d-c),abs(c-b)),max(abs(e-c),abs(c-a))),vec2f(1e-8)),vec2f(0),vec2f(1));\n  return vec3f(direction,dot(length,length))*w;\n}\nfn easuWeight(offset: vec2f, direction: vec2f, length: vec2f, lobe: f32) -> f32 {\n  let v = vec2f(dot(offset,direction),dot(offset,vec2f(-direction.y,direction.x)))*length;\n  let distance = min(dot(v,v),1.0/lobe);\n  let b = 0.4*distance-1.0;\n  let a = lobe*distance-1.0;\n  return (1.5625*b*b-0.5625)*a*a;\n}\n@fragment fn fragment(@builtin(position) position: vec4f) -> @location(0) vec4f {\n  let point = position.xy*vec2f(textureDimensions(colorImage))/outputSize.xy-0.5;\n  let base = vec2i(floor(point)); let phase = fract(point);\n  var colors: array<vec4f,12>;\n  var luma: array<f32,12>;\n  // FSR expects [0,1]. Normalize the neighborhood for direction estimation\n  // in extended-range output; filter the original RGB without clipping it to 1.\n  var range = 1.0;\n  for(var i=0u;i<12u;i++){colors[i]=loadColor(base+offsets[i]);range=max(range,max(max(colors[i].r,colors[i].g),colors[i].b));}\n  for(var i=0u;i<12u;i++){luma[i]=dot(colors[i].rgb/range,vec3f(0.5,1.0,0.5));}\n  let g = gradient(luma[0],luma[2],luma[3],luma[4],luma[7],(1.0-phase.x)*(1.0-phase.y))+\n    gradient(luma[1],luma[3],luma[4],luma[5],luma[8],phase.x*(1.0-phase.y))+\n    gradient(luma[3],luma[6],luma[7],luma[8],luma[10],(1.0-phase.x)*phase.y)+\n    gradient(luma[4],luma[7],luma[8],luma[9],luma[11],phase.x*phase.y);\n  var direction = vec2f(1.0,0.0);\n  if(dot(g.xy,g.xy)>=1.0/32768.0){direction=normalize(g.xy);}\n  let edge = (g.z*0.5)*(g.z*0.5);\n  let stretch = dot(direction,direction)/max(abs(direction.x),abs(direction.y));\n  let length = vec2f(1.0+(stretch-1.0)*edge,1.0-0.5*edge);\n  let lobe = 0.5+(0.21-0.5)*edge;\n  var result=vec4f(0); var total=0.0;\n  for(var i=0u;i<12u;i++){\n    let weight=easuWeight(vec2f(offsets[i])-phase,direction,length,lobe);\n    result+=colors[i]*weight;total+=weight;\n  }\n  let lower=min(min(colors[3],colors[4]),min(colors[7],colors[8]));\n  let upper=max(max(colors[3],colors[4]),max(colors[7],colors[8]));\n  return clamp(result/total,lower,upper);\n}\n`;\n\n// Not part of FSR: exact area average for inputs larger than the output,\n// alpha-weighted so transparent texels do not darken coverage edges.\nexport const areaDownsampleShader = /* wgsl */ `\n@group(0) @binding(0) var colorImage: texture_2d<f32>;\n@group(0) @binding(1) var<uniform> outputSize: vec4f;\n@vertex fn vertex(@builtin(vertex_index) index: u32) -> @builtin(position) vec4f {\n  let p = vec2f(f32((index << 1u) & 2u), f32(index & 2u));\n  return vec4f(p * 2.0 - 1.0, 0.0, 1.0);\n}\n@fragment fn fragment(@builtin(position) position: vec4f) -> @location(0) vec4f {\n  let scale = vec2f(textureDimensions(colorImage))/outputSize.xy;\n  let start = floor(position.xy)*scale; let end = start+scale;\n  var sum = vec4f(0);\n  for (var y = i32(floor(start.y)); y < i32(ceil(end.y)); y++) {\n    for (var x = i32(floor(start.x)); x < i32(ceil(end.x)); x++) {\n      let overlap = max(vec2f(0), min(vec2f(vec2i(x+1,y+1)), end)-max(vec2f(vec2i(x,y)), start));\n      let color = textureLoad(colorImage, vec2i(x,y), 0);\n      sum += vec4f(color.rgb*color.a, color.a)*overlap.x*overlap.y;\n    }\n  }\n  return vec4f(sum.rgb/max(sum.a, 1e-8), sum.a/(scale.x*scale.y));\n}\n`;\n"]}

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

@@ -0,0 +1,21 @@
+/** Scene-linear log2 range covered by the tone lookup table. */
+export declare const TONE_LUT_LOG2: readonly [-24, 24];
+export declare const TONE_LUT_SIZE = 1024;
+/** Detail compensation defaults and fixed regularizers shared by the Web and native passes. */
+export declare const EASU_DETAIL: {
+    ratioRange: readonly [0.7, 1.43];
+    depthThreshold: number;
+    coverageThreshold: number;
+    minimumAlbedo: number;
+    depthTolerance: number;
+    guidedEpsilon: number;
+};
+/**
+ * guided: scale only the albedo-correlated part of local scene-linear radiance (default);
+ * separate: lobe-share approximation; silhouettes: depth-guided edge reconstruction.
+ * The last two are retained for comparisons.
+ */
+export declare function easuDetailShader(separate?: boolean, silhouettes?: boolean, guided?: boolean): string;
+export declare const albedoDownsampleShader: (depthOutput?: boolean) => string;
+export declare const toneLutShader: string;
+export declare const guidedCoefficientShader: string;