@meimu/mutracer 0.1.2 → 0.1.4

package/lib/renderer/wgsl/chunks/sampling.wgsl.js

@@ -4,70 +4,70 @@ export default /*wgsl*/ `
 
 
 fn aQ(view: vec3f, alpha: vec2f, samplePoint: vec2f) -> vec3f {
-let qY = vec3f(alpha, 1.0);
-let ge = normalize(qY * view);
-let tV = min(ge.z, 1.0);
-let qD = 1.0 + tV;
-let qT = (1.0 - samplePoint.y) * qD;
-let rE = samplePoint.y * qD;
-let st = qT + (1.0 - tV);
-let fi = sqrt(max(0.0, st * rE));
+let rm = vec3f(alpha, 1.0);
+let gj = normalize(rm * view);
+let uh = min(gj.z, 1.0);
+let qQ = 1.0 + uh;
+let rh = (1.0 - samplePoint.y) * qQ;
+let rR = samplePoint.y * qQ;
+let sI = rh + (1.0 - uh);
+let fl = sqrt(max(0.0, sI * rR));
 let br = TWOPI * samplePoint.x;
-let lt = vec3f(
-ge.x + fi * cos(br),
-ge.y + fi * sin(br),
-qT
+let lJ = vec3f(
+gj.x + fl * cos(br),
+gj.y + fl * sin(br),
+rh
 );
-return normalize(qY * lt);
+return normalize(rm * lJ);
 }
 
-fn gE(oa: vec3f, alpha: vec2f) -> f32 {
-let hm = vec3f(
-oa.x / alpha.x,
-oa.y / alpha.y,
-oa.z
+fn gK(oq: vec3f, alpha: vec2f) -> f32 {
+let hr = vec3f(
+oq.x / alpha.x,
+oq.y / alpha.y,
+oq.z
 );
-let ap = dot(hm, hm);
+let ap = dot(hr, hr);
 return 1.0 / (
 PI * alpha.x * alpha.y * ap * ap
 );
 }
 
 fn bk(direction: vec3f, alpha: vec2f) -> f32 {
-let eE = abs(direction.z);
-if (eE <= 1e-8) {
+let eF = abs(direction.z);
+if (eF <= 1e-8) {
 return 0.0;
 }
-let hZ = alpha * direction.xy;
-let lu = dot(hZ, hZ)
-/ (eE * eE);
-return 2.0 / (1.0 + sqrt(1.0 + lu));
+let ic = alpha * direction.xy;
+let lK = dot(ic, ic)
+/ (eF * eF);
+return 2.0 / (1.0 + sqrt(1.0 + lK));
 }
 
 fn aE(au: f32) -> f32 {
-let dg = clamp(1.0 - au, 0.0, 1.0);
-return pow(dg, 5.0);
+let di = clamp(1.0 - au, 0.0, 1.0);
+return pow(di, 5.0);
 }
 
-fn ct(L: f32, cJ: f32) -> f32 {
-let iu = clamp(abs(L), 0.0, 1.0);
-let kc = cJ * cJ
-* max(0.0, 1.0 - iu * iu);
-if (kc >= 1.0) {
+fn cu(L: f32, cJ: f32) -> f32 {
+let iA = clamp(abs(L), 0.0, 1.0);
+let kl = cJ * cJ
+* max(0.0, 1.0 - iA * iA);
+if (kl >= 1.0) {
 return 1.0;
 }
 
-let lH = sqrt(max(0.0, 1.0 - kc));
-let ba = (iu - cJ * lH)
-/ max(iu + cJ * lH, 1e-8);
-let pr = (cJ * iu - lH)
-/ max(cJ * iu + lH, 1e-8);
+let lU = sqrt(max(0.0, 1.0 - kl));
+let ba = (iA - cJ * lU)
+/ max(iA + cJ * lU, 1e-8);
+let pN = (cJ * iA - lU)
+/ max(cJ * iA + lU, 1e-8);
 return 0.5 * (
-ba * ba + pr * pr
+ba * ba + pN * pN
 );
 }
 
-fn gc(samplePoint: vec2f) -> vec2f {
+fn gh(samplePoint: vec2f) -> vec2f {
 let offset = 2.0 * samplePoint - vec2f(1.0);
 if (offset.x == 0.0 && offset.y == 0.0) {
 return vec2f(0.0);
@@ -87,39 +87,39 @@ return radius * vec2f(cos(angle), sin(angle));
 }
 
 fn bi(samplePoint: vec2f) -> vec3f {
-let kv = gc(samplePoint);
+let kF = gh(samplePoint);
 return vec3f(
-kv,
-sqrt(max(0.0, 1.0 - dot(kv, kv)))
+kF,
+sqrt(max(0.0, 1.0 - dot(kF, kF)))
 );
 }
 
-fn aF(pe: f32, nA: f32) -> f32 {
-let scale = max(pe, nA);
+fn aG(pr: f32, nO: f32) -> f32 {
+let scale = max(pr, nO);
 if (scale <= 0.0) {
 return 0.0;
 }
-let normalized = vec2f(pe, nA) / scale;
-let oD = normalized * normalized;
-return oD.x / (oD.x + oD.y);
+let normalized = vec2f(pr, nO) / scale;
+let oP = normalized * normalized;
+return oP.x / (oP.x + oP.y);
 }
 
-fn aK(
+fn aL(
 normal: vec3f,
 tangent: ptr<function, vec3f>,
 bitangent: ptr<function, vec3f>
 ) {
-let ig = select(-1.0, 1.0, normal.z >= 0.0);
-let dW = -1.0 / (ig + normal.z);
+let ik = select(-1.0, 1.0, normal.z >= 0.0);
+let dW = -1.0 / (ik + normal.z);
 let xy = normal.x * normal.y * dW;
 *tangent = vec3f(
-1.0 + ig * normal.x * normal.x * dW,
-ig * xy,
--ig * normal.x
+1.0 + ik * normal.x * normal.x * dW,
+ik * xy,
+-ik * normal.x
 );
 *bitangent = vec3f(
 xy,
-ig + normal.y * normal.y * dW,
+ik + normal.y * normal.y * dW,
 -normal.y
 );
 }
@@ -137,32 +137,32 @@ return vec3f(0.0, rgb.g, 0.0);
 return vec3f(0.0, 0.0, rgb.b);
 }
 
-fn eK(
+fn eN(
 wavelength: f32,
-ha: f32,
-hk: f32,
-qg: f32
+hg: f32,
+hp: f32,
+qs: f32
 ) -> f32 {
-if (wavelength == 0.0 || hk <= 0.0) {
-return ha;
+if (wavelength == 0.0 || hp <= 0.0) {
+return hg;
 }
 
 let FRAUNHOFER_C = 656.3;
 let FRAUNHOFER_D = 587.6;
 let FRAUNHOFER_F = 486.1;
-let jI = 1.0 / (
+let jR = 1.0 / (
 1.0 / (FRAUNHOFER_F * FRAUNHOFER_F)
 - 1.0 / (FRAUNHOFER_C * FRAUNHOFER_C)
 );
-let mQ = max(qg / hk, 1e-6);
-let qE = (ha - 1.0) * jI / mQ;
-let sY = ha
-- qE / (FRAUNHOFER_D * FRAUNHOFER_D);
-return sY + qE / (wavelength * wavelength);
+let nh = max(qs / hp, 1e-6);
+let qR = (hg - 1.0) * jR / nh;
+let tl = hg
+- qR / (FRAUNHOFER_D * FRAUNHOFER_D);
+return tl + qR / (wavelength * wavelength);
 }
 
-fn fl(
-gt: vec3f,
+fn fp(
+gy: vec3f,
 anisotropy: f32,
 samplePoint: vec2f
 ) -> vec3f {
@@ -171,21 +171,21 @@ if (abs(anisotropy) < 0.001) {
 au = 1.0 - 2.0 * samplePoint.y;
 }
 else {
-let iU = (1.0 - anisotropy * anisotropy)
+let ja = (1.0 - anisotropy * anisotropy)
 / (1.0 + anisotropy - 2.0 * anisotropy * samplePoint.y);
 au = (
-iU * iU - 1.0 - anisotropy * anisotropy
+ja * ja - 1.0 - anisotropy * anisotropy
 ) / (2.0 * anisotropy);
 }
 
-let tR = sqrt(max(0.0, 1.0 - au * au));
+let ud = sqrt(max(0.0, 1.0 - au * au));
 let br = TWOPI * samplePoint.x;
 var tangent: vec3f;
 var bitangent: vec3f;
-aK(gt, &tangent, &bitangent);
-return tangent * (tR * cos(br))
-+ bitangent * (tR * sin(br))
-+ gt * au;
+aL(gy, &tangent, &bitangent);
+return tangent * (ud * cos(br))
++ bitangent * (ud * sin(br))
++ gy * au;
 }
 
 fn bD(au: f32, anisotropy: f32) -> f32 {

package/lib/renderer/wgsl/chunks/shadowCatcherAccumulation.wgsl.d.ts

@@ -1,8 +1,8 @@
 /**
  * Per-pixel auxiliary accumulation: the shadow-catcher mask, its premultiplied
- * primary background contribution, and luminance moments for the built-in
- * denoiser's variance estimate.
+ * primary background contribution (including opaque flat primary misses), and
+ * luminance moments for the built-in denoiser's variance estimate.
  */
 export declare const SHADOW_CATCHER_ACCUMULATION_BYTES = 48;
-declare const _default: "\nstruct ShadowCatcherAccumulation {\n  // Primary catcher coverage, background alpha, background hits, shadow opacity.\n  mask: vec4f,\n  background: vec4f,\n  // Sum of the denoising guide value and of its square (x, y).\n  moments: vec4f,\n}\n";
+declare const _default: "\nstruct ShadowCatcherAccumulation {\n  // Catcher coverage, separated background alpha, catcher background hits, shadow opacity.\n  mask: vec4f,\n  background: vec4f,\n  // Sum of the denoising guide value and of its square (x, y).\n  moments: vec4f,\n}\n";
 export default _default;

package/lib/renderer/wgsl/chunks/shadowCatcherAccumulation.wgsl.js

@@ -1,7 +1,7 @@
 /**
  * Per-pixel auxiliary accumulation: the shadow-catcher mask, its premultiplied
- * primary background contribution, and luminance moments for the built-in
- * denoiser's variance estimate.
+ * primary background contribution (including opaque flat primary misses), and
+ * luminance moments for the built-in denoiser's variance estimate.
  */
 export const SHADOW_CATCHER_ACCUMULATION_BYTES = 48;
 export default /* wgsl */ `

package/lib/renderer/wgsl/chunks/shadowCatcherAccumulation.wgsl.js.map

@@ -1 +1 @@
-{"version":3,"file":"shadowCatcherAccumulation.wgsl.js","sourceRoot":"","sources":["../../../../src/renderer/wgsl/chunks/shadowCatcherAccumulation.wgsl.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,CAAC,MAAM,iCAAiC,GAAG,EAAE,CAAC;AAEpD,eAAe,UAAU,CAAC;;;;;;;;CAQzB,CAAC","sourcesContent":["/**\n * Per-pixel auxiliary accumulation: the shadow-catcher mask, its premultiplied\n * primary background contribution, and luminance moments for the built-in\n * denoiser's variance estimate.\n */\nexport const SHADOW_CATCHER_ACCUMULATION_BYTES = 48;\n\nexport default /* wgsl */ `\nstruct ShadowCatcherAccumulation {\n  // Primary catcher coverage, background alpha, background hits, shadow opacity.\n  mask: vec4f,\n  background: vec4f,\n  // Sum of the denoising guide value and of its square (x, y).\n  moments: vec4f,\n}\n`;\n"]}
+{"version":3,"file":"shadowCatcherAccumulation.wgsl.js","sourceRoot":"","sources":["../../../../src/renderer/wgsl/chunks/shadowCatcherAccumulation.wgsl.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,CAAC,MAAM,iCAAiC,GAAG,EAAE,CAAC;AAEpD,eAAe,UAAU,CAAC;;;;;;;;CAQzB,CAAC","sourcesContent":["/**\n * Per-pixel auxiliary accumulation: the shadow-catcher mask, its premultiplied\n * primary background contribution (including opaque flat primary misses), and\n * luminance moments for the built-in denoiser's variance estimate.\n */\nexport const SHADOW_CATCHER_ACCUMULATION_BYTES = 48;\n\nexport default /* wgsl */ `\nstruct ShadowCatcherAccumulation {\n  // Catcher coverage, separated background alpha, catcher background hits, shadow opacity.\n  mask: vec4f,\n  background: vec4f,\n  // Sum of the denoising guide value and of its square (x, y).\n  moments: vec4f,\n}\n`;\n"]}

package/lib/renderer/wgsl/chunks/sobol.wgsl.js

@@ -18,10 +18,10 @@ const BOUNCE_STRIDE = 64u;
 
 var<private> bc: vec2u;
 var<private> bd: u32;
-var<private> cE: u32 = 0u;
+var<private> cF: u32 = 0u;
 var<private> em: u32 = 0u;
-fn eg(ki: u32) -> u32 {
-var x = ki;
+fn eg(kt: u32) -> u32 {
+var x = kt;
 x ^= x >> 16u; x *= 0x7feb352du;
 x ^= x >> 15u; x *= 0x846ca68bu;
 return x ^ (x >> 16u);
@@ -29,28 +29,28 @@ return x ^ (x >> 16u);
 fn aq(a: u32, b: u32) -> u32 {
 return eg(a ^ eg(b + 0x9e3779b9u));
 }
-fn iA(ki: u32, ie: u32) -> u32 {
-var x = ki + ie;
+fn iE(kt: u32, ij: u32) -> u32 {
+var x = kt + ij;
 x ^= x * 0x6c50b47cu; x ^= x * 0xb82f1e52u;
 x ^= x * 0xc7afe638u; x ^= x * 0x8d22f6e6u;
 return x;
 }
-fn sv(x: u32, ie: u32) -> u32 {
-return reverseBits(iA(reverseBits(x), ie));
+fn sK(x: u32, ij: u32) -> u32 {
+return reverseBits(iE(reverseBits(x), ij));
 }
 
-fn qX(ki: u32) -> u32 {
-var r = reverseBits(ki);
+fn rl(kt: u32) -> u32 {
+var r = reverseBits(kt);
 ${sobolD1Steps.map(([shift, mask]) => `r ^= (r << ${shift}u) & 0x${mask.toString(16)}u;`).join("\n  ")}
 return r;
 }
-fn vD(index: u32, ie: u32) -> vec2f {
-let i = sv(index, aq(ie, 0u));
-let x = reverseBits(iA(i, aq(ie, 1u)));
-let y = sv(qX(i), aq(ie, 2u));
+fn vP(index: u32, ij: u32) -> vec2f {
+let i = sK(index, aq(ij, 0u));
+let x = reverseBits(iE(i, aq(ij, 1u)));
+let y = sK(rl(i), aq(ij, 2u));
 return vec2f(f32(x >> 8u), f32(y >> 8u)) * (1.0 / 16777216.0);
 }
-fn tj(p: vec2u) -> u32 {
+fn tB(p: vec2u) -> u32 {
 var v = p & vec2u(255u);
 v = (v | (v << vec2u(4u))) & vec2u(0x0f0fu);
 v = (v | (v << vec2u(2u))) & vec2u(0x3333u);
@@ -58,112 +58,112 @@ v = (v | (v << vec2u(1u))) & vec2u(0x5555u);
 return v.x | (v.y << 1u);
 }
 ${zSobolPackedPermutations.map((v, i) => `const Z_PERM_${i} = ${v}u;`).join("\n")}
-fn kk(tm: u32) -> u32 {
-let group = tm >> 2u;
+fn kw(tE: u32) -> u32 {
+let group = tE >> 2u;
 var word = Z_PERM_5;
 ${[0, 1, 2, 3, 4].map(i => `word = select(word, Z_PERM_${i}, group == ${i}u);`).join("\n  ")}
-return (word >> ((tm & 3u) * 8u)) & 255u;
+return (word >> ((tE & 3u) * 8u)) & 255u;
 }
-fn pK(kB: u32, dim: u32, logSPP: u32) -> u32 {
+fn pW(kN: u32, dim: u32, logSPP: u32) -> u32 {
 let odd = logSPP & 1u;
-let ua = 8u + ((logSPP + 1u) >> 1u);
+let um = 8u + ((logSPP + 1u) >> 1u);
 var result = 0u;
-for (var digit = i32(ua) - 1; digit >= i32(odd); digit--) {
+for (var digit = i32(um) - 1; digit >= i32(odd); digit--) {
 let shift = 2u*u32(digit) - odd;
 
-var sd = 0u;
-if (shift < 30u) { sd = kB >> (shift + 2u); }
-let tm = (eg(sd ^ (0x55555555u * dim)) >> 24u) % 24u;
-let d = (kB >> shift) & 3u;
-result |= ((kk(tm) >> (2u*d)) & 3u) << shift;
+var st = 0u;
+if (shift < 30u) { st = kN >> (shift + 2u); }
+let tE = (eg(st ^ (0x55555555u * dim)) >> 24u) % 24u;
+let d = (kN >> shift) & 3u;
+result |= ((kw(tE) >> (2u*d)) & 3u) << shift;
 }
 if (odd != 0u) {
-result |= (kB & 1u) ^ (eg((kB >> 1u) ^ (0x55555555u * dim)) & 1u);
+result |= (kN & 1u) ^ (eg((kN >> 1u) ^ (0x55555555u * dim)) & 1u);
 }
 return result;
 }
 
 
 
-fn cv(slot: u32) -> u32 {
-return CAMERA_BEVEL_BASE + u32(BEVEL_SAMPLES) + cE * BOUNCE_STRIDE + slot;
+fn cw(slot: u32) -> u32 {
+return CAMERA_BEVEL_BASE + u32(BEVEL_SAMPLES) + cF * BOUNCE_STRIDE + slot;
 }
-fn qR(candidate: u32, slot: u32) -> u32 {
+fn rd(candidate: u32, slot: u32) -> u32 {
 if (candidate == 0u) {
-if (slot == 2u) { return cv(8u); }
-return cv(slot);
+if (slot == 2u) { return cw(8u); }
+return cw(slot);
 }
-return cv(9u + (candidate - 1u) * 3u + slot);
+return cw(9u + (candidate - 1u) * 3u + slot);
 }
 
 
-var<private> hh: vec4u;
-var<private> hi: u32;
-var<private> fv: bool = false;
-var<private> df: bool = false;
-var<private> dE: u32;
-var<private> gp: u32;
-var<private> eN: vec2f;
+var<private> hl: vec4u;
+var<private> hm: u32;
+var<private> fB: bool = false;
+var<private> dg: bool = false;
+var<private> dF: u32;
+var<private> gu: u32;
+var<private> eQ: vec2f;
 fn dw(dim: u32) {
 
-let jU = bc.x + bc.y * u32(rtUniform.outputSize.x);
-let key = vec4u(dim, bd, jU, rtUniform.sequenceSeed);
-if (fv && all(hh == key) && hi == rtUniform.zSobolLogSPP) { return; }
-hh = key; hi = rtUniform.zSobolLogSPP;
-fv = true; df = false;
-var ie = aq(aq(jU, dim), rtUniform.sequenceSeed);
+let kd = bc.x + bc.y * u32(rtUniform.outputSize.x);
+let key = vec4u(dim, bd, kd, rtUniform.sequenceSeed);
+if (fB && all(hl == key) && hm == rtUniform.zSobolLogSPP) { return; }
+hl = key; hm = rtUniform.zSobolLogSPP;
+fB = true; dg = false;
+var ij = aq(aq(kd, dim), rtUniform.sequenceSeed);
 var index = bd;
 if (SAMPLING_PATTERN == 1) {
 var logSPP = rtUniform.zSobolLogSPP;
 if (index == 0u) { logSPP = 0u; }
 else { index -= 1u; }
 
-var iV = index >> logSPP;
+var jb = index >> logSPP;
 let mask = (1u << logSPP) - 1u;
-let kB = (tj(bc) << logSPP) | (index & mask);
-index = pK(kB, dim, logSPP);
+let kN = (tB(bc) << logSPP) | (index & mask);
+index = pW(kN, dim, logSPP);
 let tile = bc >> vec2u(8u);
-ie = aq(aq(dim, rtUniform.sequenceSeed), aq(tile.x, tile.y));
+ij = aq(aq(dim, rtUniform.sequenceSeed), aq(tile.x, tile.y));
 
-if (bd != 0u) { iV += 1u; }
-ie = aq(ie, iV);
+if (bd != 0u) { jb += 1u; }
+ij = aq(ij, jb);
 }
-dE = sv(index, aq(ie, 0u));
-gp = ie;
-let x = reverseBits(iA(dE, aq(ie, 1u)));
-eN.x = f32(x >> 8u) * (1.0 / 16777216.0);
+dF = sK(index, aq(ij, 0u));
+gu = ij;
+let x = reverseBits(iE(dF, aq(ij, 1u)));
+eQ.x = f32(x >> 8u) * (1.0 / 16777216.0);
 }
-fn kG(dim: u32) -> vec2f {
+fn kS(dim: u32) -> vec2f {
 dw(dim);
-if (!df) {
-let y = sv(qX(dE), aq(gp, 2u));
-eN.y = f32(y >> 8u) * (1.0 / 16777216.0);
-df = true;
+if (!dg) {
+let y = sK(rl(dF), aq(gu, 2u));
+eQ.y = f32(y >> 8u) * (1.0 / 16777216.0);
+dg = true;
 }
-return EPS + (1.0 - 2.0*EPS) * eN;
+return EPS + (1.0 - 2.0*EPS) * eQ;
 }
 fn dz(dim: u32) -> f32 {
 if (SAMPLING_PATTERN == 2) { return EPS + (1.0 - 2.0*EPS)*rand(); }
 dw(dim);
-return EPS + (1.0 - 2.0*EPS) * eN.x;
+return EPS + (1.0 - 2.0*EPS) * eQ.x;
 }
-fn fk(dim: u32) -> vec2f {
+fn fo(dim: u32) -> vec2f {
 if (SAMPLING_PATTERN == 2) {
 let x = dz(dim); let y = dz(dim);
 return vec2f(x,y);
 }
-return kG(dim);
+return kS(dim);
 }
 
 fn eo(slot: u32) -> f32 {
-let dim = aq(aq(cE, slot), em) | 0x80000000u;
+let dim = aq(aq(cF, slot), em) | 0x80000000u;
 em += 1u;
 if (SAMPLING_PATTERN == 2) { return EPS + (1.0 - 2.0*EPS)*rand(); }
 
-let jU = bc.x + bc.y * u32(rtUniform.outputSize.x);
-let ie = aq(aq(jU, dim), rtUniform.sequenceSeed);
-let i = sv(bd, aq(ie, 0u));
-let x = reverseBits(iA(i, aq(ie, 1u)));
+let kd = bc.x + bc.y * u32(rtUniform.outputSize.x);
+let ij = aq(aq(kd, dim), rtUniform.sequenceSeed);
+let i = sK(bd, aq(ij, 0u));
+let x = reverseBits(iE(i, aq(ij, 1u)));
 return EPS + (1.0 - 2.0*EPS) * (f32(x >> 8u) * (1.0 / 16777216.0));
 }
 `;

package/lib/renderer/wgsl/chunks/uvProjection.wgsl.js

@@ -7,12 +7,12 @@ let theta = atan2(n.x, n.z) / (2.0 * PI) + 0.5;
 let phi = acos(n.y) / PI;
 return vec2f(theta, 1.0 - phi);
 }
-fn iL(pos: vec3f, normal: vec3f) -> vec2f {
-let dm = abs(normal);
+fn iR(pos: vec3f, normal: vec3f) -> vec2f {
+let dn = abs(normal);
 var uv = vec2f(0.0);
-if (dm.x > dm.y && dm.x > dm.z) {
+if (dn.x > dn.y && dn.x > dn.z) {
 uv = pos.yz;
-} else if (dm.y > dm.x && dm.y > dm.z) {
+} else if (dn.y > dn.x && dn.y > dn.z) {
 uv = pos.xz;
 } else {
 uv = pos.xy;
@@ -23,18 +23,18 @@ return uv;
 
 
 
-fn hA(pos: vec3f, normal: vec3f) -> vec2f {
+fn hD(pos: vec3f, normal: vec3f) -> vec2f {
 let theta = atan2(pos.z, pos.x) / (2.0 * PI) + 0.5;
 return vec2f(theta, pos.y);
 }
 
-fn gz(fh: i32, pos: vec3f, normal: vec3f) -> vec2f {
-if (fh == ${uvProjectionConstants.triplanar}) {
-return iL(pos, normal);
-} else if (fh == ${uvProjectionConstants.spherical}) {
+fn gH(fk: i32, pos: vec3f, normal: vec3f) -> vec2f {
+if (fk == ${uvProjectionConstants.triplanar}) {
+return iR(pos, normal);
+} else if (fk == ${uvProjectionConstants.spherical}) {
 return sphericalProjection(pos);
-} else if (fh == ${uvProjectionConstants.cylindrical}) {
-return hA(pos, normal);
+} else if (fk == ${uvProjectionConstants.cylindrical}) {
+return hD(pos, normal);
 }
 return vec2f(0.0);
 }

package/lib/renderer/wgsl/compose.frag.wgsl.d.ts

@@ -1,5 +1,5 @@
 export declare const linearToSrgbDefine = "\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";
 export declare const composeDefine = "\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\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\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";
-export declare const composeMain = "\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) {\n    let foreground = load_foregroundTex(uv, 0);\n    let background = load_catcherBackgroundTex(uv, 0);\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));\n    let backgroundAlpha = max(background.a, bloomAlpha * coverage);\n    let alpha = foregroundAlpha + backgroundAlpha * (1.0 - opacity) + shadowAlpha;\n    let premultiplied = foregroundColor * foregroundAlpha\n      + backgroundColor * backgroundAlpha * (1.0 - opacity)\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";
-export declare const compositeDenoiseOutputMain = "\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";
+export declare const composeMain = "\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";
+export declare const compositeDenoiseOutputMain = "\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";
 export declare const compositeDenoiseDisplayMain = "\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";