@meimu/mutracer 0.1.3 → 0.1.5

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

@@ -1,5 +1,5 @@
 export const linearToSrgbDefine = /* wgsl */ `
-fn fJ(color: vec3f) -> vec3f {
+fn fN(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,90 +8,90 @@ return select(high, low, linear <= vec3f(0.0031308));
 `;
 export const composeDefine = /* wgsl */ `
 
-fn jN(color: vec3f) -> vec3f {
+fn jU(color: vec3f) -> vec3f {
 return clamp(color, vec3f(0.0), vec3f(1.0));
 }
-fn iK(color: vec3f) -> vec3f {
+fn iP(color: vec3f) -> vec3f {
 return clamp(color / (vec3f(1.0) + color), vec3f(0.0), vec3f(1.0));
 }
-fn jE(jm: vec3f) -> vec3f {
-let color = max(vec3f(0.0), jm - 0.004);
+fn jJ(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 oA(value: vec3f) -> vec3f {
-let kF = value * (value + 0.0245786) - 0.000090537;
+fn oI(value: vec3f) -> vec3f {
+let kO = value * (value + 0.0245786) - 0.000090537;
 let ap = value * (0.983729 * value + 0.4329510) + 0.238081;
-return kF / ap;
+return kO / ap;
 }
-fn ll(jm: vec3f) -> vec3f {
-let pn = mat3x3f(
+fn lv(jr: vec3f) -> vec3f {
+let pw = mat3x3f(
 vec3f(0.59719, 0.07600, 0.02840),
 vec3f(0.35458, 0.90834, 0.13383),
 vec3f(0.04823, 0.01566, 0.83777)
 );
-let ov = mat3x3f(
+let oD = mat3x3f(
 vec3f(1.60475, -0.10208, -0.00327),
 vec3f(-0.53108, 1.10813, -0.07276),
 vec3f(-0.07367, -0.00605, 1.07602)
 );
-let color = pn * (jm / 0.6);
-return clamp(ov * oA(color), vec3f(0.0), vec3f(1.0));
-}
-fn fP(value: vec3f) -> vec3f {
-let mE = value * value;
-let qC = mE * mE;
-return 15.5 * qC * mE - 40.14 * qC * value
-+ 31.96 * qC - 6.868 * mE * value
-+ 0.4298 * mE + 0.1191 * value - 0.00232;
-}
-fn lS(jm: vec3f) -> vec3f {
-let mG = mat3x3f(
+let color = pw * (jr / 0.6);
+return clamp(oD * oI(color), vec3f(0.0), vec3f(1.0));
+}
+fn fU(value: vec3f) -> vec3f {
+let mN = value * value;
+let qK = mN * mN;
+return 15.5 * qK * mN - 40.14 * qK * value
++ 31.96 * qK - 6.868 * mN * value
++ 0.4298 * mN + 0.1191 * value - 0.00232;
+}
+fn mc(jr: vec3f) -> vec3f {
+let mQ = mat3x3f(
 vec3f(1.6605, -0.1246, -0.0182),
 vec3f(-0.5876, 1.1329, -0.1006),
 vec3f(-0.0728, -0.0083, 1.1187)
 );
-let mH = mat3x3f(
+let mR = mat3x3f(
 vec3f(0.6274, 0.0691, 0.0164),
 vec3f(0.3293, 0.9195, 0.0880),
 vec3f(0.0433, 0.0113, 0.8956)
 );
-let pp = mat3x3f(
+let pH = mat3x3f(
 vec3f(0.856627153315983, 0.137318972929847, 0.11189821299995),
 vec3f(0.0951212405381588, 0.761241990602591, 0.0767994186031903),
 vec3f(0.0482516061458583, 0.101439036467562, 0.811302368396859)
 );
-let ow = mat3x3f(
+let oE = mat3x3f(
 vec3f(1.1271005818144368, -0.1413297634984383, -0.14132976349843826),
 vec3f(-0.11060664309660323, 1.157823702216272, -0.11060664309660294),
 vec3f(-0.016493938717834573, -0.016493938717834257, 1.2519364065950405)
 );
-var color = pp * (mH * jm);
+var color = pH * (mR * jr);
 color = clamp((log2(max(color, vec3f(1e-10))) + 12.47393) / 16.5, vec3f(0.0), vec3f(1.0));
-color = ow * fP(color);
+color = oE * fU(color);
 color = pow(max(color, vec3f(0.0)), vec3f(2.2));
-return clamp(mG * color, vec3f(0.0), vec3f(1.0));
+return clamp(mQ * color, vec3f(0.0), vec3f(1.0));
 }
 fn cl(color: vec3f) -> vec3f {
 let toneMappingMode = i32(toneMappingParams.x);
-if (toneMappingMode == 1) { return ll(color); }
-if (toneMappingMode == 2) { return jE(color); }
-if (toneMappingMode == 3) { return iK(color); }
-if (toneMappingMode == 4) { return jN(color); }
-return lS(color);
+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 mc(color);
 }
 ${linearToSrgbDefine}
-fn fX(jm: vec3f) -> vec3f {
+fn gc(jr: vec3f) -> vec3f {
 let contrast = colorGradingParams.x;
 let saturation = colorGradingParams.y;
 let temperature = colorGradingParams.z;
 let tint = colorGradingParams.w;
-let tb = vec3f(
+let tj = 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(jm * tb, vec3f(0.0));
+var color = max(jr * tj, 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));
@@ -100,54 +100,54 @@ return max(mix(vec3f(luminance), color, saturation), vec3f(0.0));
 export const composeMain = /* wgsl */ `
 
 var dY = load_colorTex(uv, 0);
-var jh = vec4(0.0);
+var jl = vec4(0.0);
 if (bloomIntensity > 0.0) {
-jh = load_bloomTex(uv, 0) * bloomIntensity;
-dY = vec4f(dY.rgb + jh.rgb, dY.a);
+jl = load_bloomTex(uv, 0) * bloomIntensity;
+dY = vec4f(dY.rgb + jl.rgb, dY.a);
 }
 
-var la = fX(dY.rgb * exposure);
-let iE = smoothstep(0.2, 0.72, distance(vec2f(uv) / vec2f(colorTexRegion()), vec2f(0.5)));
-la *= 1.0 - toneMappingParams.y * iE;
-let gw = hdrOutputEnabled > 0.5;
-if (!gw) {
-la = cl(la);
+var ll = gc(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 gC = hdrOutputEnabled > 0.5;
+if (!gC) {
+ll = cl(ll);
 }
-let mb = select(
-pow(max(la, vec3f(0.0)), vec3f(1.0 / 2.2)),
-fJ(la),
-gw
+let ml = select(
+pow(max(ll, vec3f(0.0)), vec3f(1.0 / 2.2)),
+fN(ll),
+gC
 );
-var nR = mb;
+var ob = ml;
 if (flatBackgroundColor.a > 0.5) {
-let jc = clamp(
+let jg = clamp(
 load_flatBackgroundMaskTex(uv, 0).a,
 0.0,
 1.0
 );
-let oS = fJ(max(flatBackgroundColor.rgb, vec3f(0.0)));
-nR = mix(oS, mb, jc);
+let pb = fN(max(flatBackgroundColor.rgb, vec3f(0.0)));
+ob = mix(pb, ml, jg);
 if (bloomIntensity > 0.0) {
-var ik = fX(
-max(dY.rgb - jh.rgb, vec3f(0.0))
+var ir = gc(
+max(dY.rgb - jl.rgb, vec3f(0.0))
 * exposure
 );
-ik *= 1.0 - toneMappingParams.y * iE;
-if (!gw) {
-ik = cl(ik);
-}
-let ru = select(
-pow(max(ik, vec3f(0.0)), vec3f(1.0 / 2.2)),
-fJ(ik),
-gw
+ir *= 1.0 - toneMappingParams.y * iI;
+if (!gC) {
+ir = cl(ir);
+}
+let rF = select(
+pow(max(ir, vec3f(0.0)), vec3f(1.0 / 2.2)),
+fN(ir),
+gC
 );
-nR += max(mb - ru, vec3f(0.0))
-* (1.0 - jc);
+ob += max(ml - rF, vec3f(0.0))
+* (1.0 - jg);
 }
 }
-dY = vec4f(nR, dY.a);
+dY = vec4f(ob, dY.a);
 if (bloomIntensity > 0.0) {
-dY.a = max(dY.a, min(dot(jh.rgb, vec3f(0.2125, 0.7154, 0.0721)), 1.0));
+dY.a = max(dY.a, min(dot(jl.rgb, vec3f(0.2125, 0.7154, 0.0721)), 1.0));
 }
 
 if (shadowCatcherEnabled > 0.5) {
@@ -161,36 +161,36 @@ let background = load_catcherBackgroundTex(uv, 0);
 
 
 
-let kz = select(0.0, clamp(background.a - coverage, 0.0, 1.0 - coverage), flatBackgroundColor.a > 0.5);
-var bK = fX((foreground.rgb + jh.rgb) * exposure);
-var backgroundColor = fX((background.rgb / max(background.a, 0.000001) + jh.rgb) * exposure);
-bK *= 1.0 - toneMappingParams.y * iE;
-backgroundColor *= 1.0 - toneMappingParams.y * iE;
-if (!gw) {
+let kH = select(0.0, clamp(background.a - coverage, 0.0, 1.0 - coverage), flatBackgroundColor.a > 0.5);
+var bK = gc((foreground.rgb + jl.rgb) * exposure);
+var backgroundColor = gc((background.rgb / max(background.a, 0.000001) + jl.rgb) * exposure);
+bK *= 1.0 - toneMappingParams.y * iI;
+backgroundColor *= 1.0 - toneMappingParams.y * iI;
+if (!gC) {
 bK = cl(bK);
 backgroundColor = cl(backgroundColor);
 }
-bK = select(pow(max(bK, vec3f(0.0)), vec3f(1.0 / 2.2)), fJ(bK), gw);
-backgroundColor = select(pow(max(backgroundColor, vec3f(0.0)), vec3f(1.0 / 2.2)), fJ(backgroundColor), gw);
+bK = select(pow(max(bK, vec3f(0.0)), vec3f(1.0 / 2.2)), fN(bK), gC);
+backgroundColor = select(pow(max(backgroundColor, vec3f(0.0)), vec3f(1.0 / 2.2)), fN(backgroundColor), gC);
 if (flatBackgroundColor.a > 0.5) {
-var eM = fX(background.rgb / max(background.a, 0.000001) * exposure);
-eM *= 1.0 - toneMappingParams.y * iE;
-if (!gw) { eM = cl(eM); }
-let mc = select(pow(max(eM, vec3f(0.0)), vec3f(1.0 / 2.2)), fJ(eM), gw);
-let ud = select(vec3f(0.0), max(backgroundColor - mc, vec3f(0.0)), bloomIntensity > 0.0);
-backgroundColor = fJ(max(flatBackgroundColor.rgb, vec3f(0.0))) + ud;
-}
-
-
-let fO = coverage * opacity;
-let lU = clamp(dot(jh.rgb, vec3f(0.2125, 0.7154, 0.0721)), 0.0, 1.0);
-let hr = max(foreground.a, lU * (1.0 - coverage - kz));
-let iZ = max(background.a, lU * coverage);
-let kl = (iZ - kz) * (1.0 - opacity) + kz;
-let alpha = hr + kl + fO;
-let premultiplied = bK * hr
-+ backgroundColor * kl
-+ shadowCatcherColor * fO;
+var eP = gc(background.rgb / max(background.a, 0.000001) * exposure);
+eP *= 1.0 - toneMappingParams.y * iI;
+if (!gC) { eP = cl(eP); }
+let mn = select(pow(max(eP, vec3f(0.0)), vec3f(1.0 / 2.2)), fN(eP), gC);
+let uk = select(vec3f(0.0), max(backgroundColor - mn, vec3f(0.0)), bloomIntensity > 0.0);
+backgroundColor = fN(max(flatBackgroundColor.rgb, vec3f(0.0))) + uk;
+}
+
+
+let fS = coverage * opacity;
+let mf = clamp(dot(jl.rgb, vec3f(0.2125, 0.7154, 0.0721)), 0.0, 1.0);
+let hv = max(foreground.a, mf * (1.0 - coverage - kH));
+let jd = max(background.a, mf * coverage);
+let ku = (jd - kH) * (1.0 - opacity) + kH;
+let alpha = hv + ku + fS;
+let premultiplied = bK * hv
++ backgroundColor * ku
++ shadowCatcherColor * fS;
 dY = vec4f(premultiplied / max(alpha, 0.000001), alpha);
 }
 }
@@ -203,35 +203,35 @@ output.color = dY;
 // 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 sP = select(
+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)),
-gw
+gC
 );
-output.denoiseColor = vec4f(sP, dY.a);
+output.denoiseColor = vec4f(sW, dY.a);
 
 
 
 
 
 let rawAlbedo = load_flatBackgroundMaskTex(uv, 0);
-var oN = rawAlbedo.rgb;
+var oW = 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 im = fX(background.rgb / background.a * exposure);
-im *= 1.0 - toneMappingParams.y * iE;
-if (!gw) { im = cl(im); }
+var iv = gc(background.rgb / background.a * exposure);
+iv *= 1.0 - toneMappingParams.y * iI;
+if (!gC) { iv = cl(iv); }
 
 
 
-let rk = clamp(background.a, 0.0, coverage);
-oN += rk * (clamp(im, vec3f(0.0), vec3f(1.0)) - vec3f(1.0));
+let rs = clamp(background.a, 0.0, coverage);
+oW += rs * (clamp(iv, vec3f(0.0), vec3f(1.0)) - vec3f(1.0));
 }
 }
-output.denoiseAlbedo = vec4f(clamp(oN, vec3f(0.0), vec3f(1.0)), rawAlbedo.a);
+output.denoiseAlbedo = vec4f(clamp(oW, vec3f(0.0), vec3f(1.0)), rawAlbedo.a);
 `;
 export const compositeDenoiseDisplayMain = /* wgsl */ `
 let denoised = load_colorTex(uv, 0);
@@ -240,7 +240,7 @@ 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)), fJ(linear), hdrOutputEnabled > 0.5);
+let encoded = select(pow(linear, vec3f(1.0 / 2.2)), fN(linear), hdrOutputEnabled > 0.5);
 output.color = vec4f(select(vec3f(0.0), encoded, alpha > 0.0), alpha);
 `;
 //# sourceMappingURL=compose.frag.wgsl.js.map

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 mh = foreground;
-var mg = background;
+var mr = foreground;
+var mq = background;
 if (any(filtered != original)) {
-let uq = abs(original) > vec3f(0.000001);
-let ap = select(vec3f(1.0), original, uq);
-let scale = select(vec3f(1.0), filtered / ap, uq);
-let tU = select(filtered - original, vec3f(0.0), uq);
-mh = vec4f(foreground.rgb * scale + tU, foreground.a);
+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);
+mr = vec4f(foreground.rgb * scale + ub, foreground.a);
 
-mg = vec4f(background.rgb * scale + tU * background.a, background.a);
+mq = vec4f(background.rgb * scale + ub * background.a, background.a);
 }
-output.foreground = mh;
-output.background = mg;
+output.foreground = mr;
+output.background = mq;
 `;
 /** 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);\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 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";
 export default _default;

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 = hy(uv);
+var ray = hC(uv);
 let eye = cameraUniform.viewInv[3].xyz;
-let nY = -normalize(cameraUniform.viewInv[2].xyz);
+let oj = -normalize(cameraUniform.viewInv[2].xyz);
 var si: ad;
 si.triangleIndex = -1;
 
 
 
 for (var layer = 0; layer < 32; layer++) {
-cY(ray, &si, 0, false, false);
+cZ(ray, &si, 0, false, false);
 if (!si.hit) { return; }
 var material: J;
-eT(&material, si.materialIndex, si.uv, si.uv1, si.instanceIndex);
+eX(&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, nY), 0.0), 0.0, 0.0, 0.0);
+outColor[index] = vec4f(max(dot(si.position - eye, oj), 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);\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;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"]}

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

@@ -27,8 +27,8 @@ _padding: f32,
 const LUMINANCE = vec3f(0.2126, 0.7152, 0.0722);
 
 @compute @workgroup_size(64)
-fn main(@builtin(global_invocation_id) ui: vec3u) {
-let tile = ui.x;
+fn main(@builtin(global_invocation_id) uq: vec3u) {
+let tile = uq.x;
 let tileCount = params.columns * params.rows;
 if (tile >= tileCount) {
 return;
@@ -36,18 +36,18 @@ return;
 
 let tileX = tile % params.columns;
 let tileY = tile / params.columns;
-let un = tileX * params.tileSize;
-let uo = tileY * params.tileSize;
-let wd = min(un + params.tileSize, params.width);
-let wf = min(uo + params.tileSize, params.height);
-var mO = 0.0;
-var ja = 0.0;
+let ux = tileX * params.tileSize;
+let uy = tileY * params.tileSize;
+let wl = min(ux + params.tileSize, params.width);
+let wm = min(uy + params.tileSize, params.height);
+var mY = 0.0;
+var je = 0.0;
 var count = 0u;
 
-for (var y = uo; y < wf; y++) {
-for (var x = un; x < wd; x++) {
-let fM = y * params.width + x;
-let offset = fM * 4u;
+for (var y = uy; y < wm; y++) {
+for (var x = ux; x < wl; x++) {
+let fQ = y * params.width + x;
+let offset = fQ * 4u;
 let samples = pilotMoments[offset + 3u];
 if (samples <= 0.0) {
 continue;
@@ -60,28 +60,28 @@ pilotColor[offset + 2u]
 ),
 LUMINANCE
 ) / samples;
-let tD = pilotMoments[offset] / samples;
-let oZ = max(tD - mean * mean, 0.0);
-var variance = oZ;
+let tK = pilotMoments[offset] / samples;
+let pi = max(tK - mean * mean, 0.0);
+var variance = pi;
 if (samples > 1.0) {
-variance = oZ * samples / (samples - 1.0);
+variance = pi * samples / (samples - 1.0);
 }
-mO += mean;
-ja = max(ja, variance);
+mY += mean;
+je = max(je, variance);
 count += 1u;
 }
 }
 
-let mean = mO / f32(max(count, 1u));
-var oO = 0.0;
+let mean = mY / f32(max(count, 1u));
+var oX = 0.0;
 if (params.hasPrevious != 0u) {
-oO = previousVariance[tile];
+oX = previousVariance[tile];
 }
-let sa = max(ja, oO);
-let sY = params.absoluteError + params.relativeError * abs(mean);
+let sj = max(je, oX);
+let tf = params.absoluteError + params.relativeError * abs(mean);
 let required = ceil(
-params.confidence * params.confidence * sa /
-max(sY * sY, 1e-16)
+params.confidence * params.confidence * sj /
+max(tf * tf, 1e-16)
 );
 let targetSamples = u32(min(
 f32(params.maxSamples),
@@ -91,11 +91,11 @@ max(f32(params.minSamples), required)
 tileMeans[tile] = mean;
 
 
-tileVariances[tile] = ja;
+tileVariances[tile] = je;
 tileTargets[tile] = targetSamples;
 
-for (var y = uo; y < wf; y++) {
-for (var x = un; x < wd; x++) {
+for (var y = uy; y < wm; y++) {
+for (var x = ux; x < wl; x++) {
 textureStore(
 targetTexture,
 vec2i(i32(x), i32(y)),