@meimu/mutracer 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,198 @@
+export default /*wgsl*/ `
+
+
+
+
+fn aQ(view: vec3f, alpha: vec2f, samplePoint: vec2f) -> vec3f {
+let qY = vec3f(alpha, 1.0);
+let ge = normalize(qY * view);
+let tU = min(ge.z, 1.0);
+let qD = 1.0 + tU;
+let qT = (1.0 - samplePoint.y) * qD;
+let rE = samplePoint.y * qD;
+let st = qT + (1.0 - tU);
+let fi = sqrt(max(0.0, st * rE));
+let br = TWOPI * samplePoint.x;
+let lt = vec3f(
+ge.x + fi * cos(br),
+ge.y + fi * sin(br),
+qT
+);
+return normalize(qY * lt);
+}
+
+fn gE(oa: vec3f, alpha: vec2f) -> f32 {
+let hm = vec3f(
+oa.x / alpha.x,
+oa.y / alpha.y,
+oa.z
+);
+let ap = dot(hm, hm);
+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) {
+return 0.0;
+}
+let hZ = alpha * direction.xy;
+let lu = dot(hZ, hZ)
+/ (eE * eE);
+return 2.0 / (1.0 + sqrt(1.0 + lu));
+}
+
+fn aE(au: f32) -> f32 {
+let dg = clamp(1.0 - au, 0.0, 1.0);
+return pow(dg, 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) {
+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);
+return 0.5 * (
+ba * ba + pr * pr
+);
+}
+
+fn gc(samplePoint: vec2f) -> vec2f {
+let offset = 2.0 * samplePoint - vec2f(1.0);
+if (offset.x == 0.0 && offset.y == 0.0) {
+return vec2f(0.0);
+}
+
+var radius: f32;
+var angle: f32;
+if (abs(offset.x) > abs(offset.y)) {
+radius = offset.x;
+angle = 0.25 * PI * (offset.y / offset.x);
+}
+else {
+radius = offset.y;
+angle = 0.5 * PI - 0.25 * PI * (offset.x / offset.y);
+}
+return radius * vec2f(cos(angle), sin(angle));
+}
+
+fn bi(samplePoint: vec2f) -> vec3f {
+let kv = gc(samplePoint);
+return vec3f(
+kv,
+sqrt(max(0.0, 1.0 - dot(kv, kv)))
+);
+}
+
+fn aF(pe: f32, nA: f32) -> f32 {
+let scale = max(pe, nA);
+if (scale <= 0.0) {
+return 0.0;
+}
+let normalized = vec2f(pe, nA) / scale;
+let oD = normalized * normalized;
+return oD.x / (oD.x + oD.y);
+}
+
+fn aK(
+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 xy = normal.x * normal.y * dW;
+*tangent = vec3f(
+1.0 + ig * normal.x * normal.x * dW,
+ig * xy,
+-ig * normal.x
+);
+*bitangent = vec3f(
+xy,
+ig + normal.y * normal.y * dW,
+-normal.y
+);
+}
+
+fn ai(rgb: vec3f, wavelength: f32) -> vec3f {
+if (wavelength == 0.0) {
+return rgb;
+}
+if (wavelength > 600.0) {
+return vec3f(rgb.r, 0.0, 0.0);
+}
+if (wavelength > 500.0) {
+return vec3f(0.0, rgb.g, 0.0);
+}
+return vec3f(0.0, 0.0, rgb.b);
+}
+
+fn eK(
+wavelength: f32,
+ha: f32,
+hk: f32,
+qg: f32
+) -> f32 {
+if (wavelength == 0.0 || hk <= 0.0) {
+return ha;
+}
+
+let FRAUNHOFER_C = 656.3;
+let FRAUNHOFER_D = 587.6;
+let FRAUNHOFER_F = 486.1;
+let jI = 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);
+}
+
+fn fl(
+gt: vec3f,
+anisotropy: f32,
+samplePoint: vec2f
+) -> vec3f {
+var au: f32;
+if (abs(anisotropy) < 0.001) {
+au = 1.0 - 2.0 * samplePoint.y;
+}
+else {
+let iU = (1.0 - anisotropy * anisotropy)
+/ (1.0 + anisotropy - 2.0 * anisotropy * samplePoint.y);
+au = (
+iU * iU - 1.0 - anisotropy * anisotropy
+) / (2.0 * anisotropy);
+}
+
+let tR = 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;
+}
+
+fn bD(au: f32, anisotropy: f32) -> f32 {
+let ap = 1.0 + anisotropy * anisotropy
++ 2.0 * anisotropy * au;
+return INV4PI * (1.0 - anisotropy * anisotropy)
+/ (ap * sqrt(ap));
+}
+`;
+//# sourceMappingURL=sampling.wgsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sampling.wgsl.js","sourceRoot":"","sources":["../../../../src/renderer/wgsl/chunks/sampling.wgsl.ts"],"names":[],"mappings":"AAAA,eAAe,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoMvB,CAAC","sourcesContent":["export default /*wgsl*/ `\n// The GGX distribution and spherical-cap VNDF sampler are adapted from\n// adobe/openpbr-bsdf, Copyright 2026 Adobe, Apache-2.0. Other routines are\n// project implementations of their stated analytic distributions.\n\nfn sampling_ggx_visible_normal(view: vec3f, alpha: vec2f, samplePoint: vec2f) -> vec3f {\n    let stretch = vec3f(alpha, 1.0);\n    let sphericalView = normalize(stretch * view);\n    let viewZ = min(sphericalView.z, 1.0);\n    let capSpan = 1.0 + viewZ;\n    let normalZ = (1.0 - samplePoint.y) * capSpan;\n    let oneMinusZ = samplePoint.y * capSpan;\n    let onePlusZ = normalZ + (1.0 - viewZ);\n    let radial = sqrt(max(0.0, onePlusZ * oneMinusZ));\n    let azimuth = TWOPI * samplePoint.x;\n    let sphericalNormal = vec3f(\n        sphericalView.x + radial * cos(azimuth),\n        sphericalView.y + radial * sin(azimuth),\n        normalZ\n    );\n    return normalize(stretch * sphericalNormal);\n}\n\nfn sampling_ggx_ndf(halfway: vec3f, alpha: vec2f) -> f32 {\n    let ellipsoidNormal = vec3f(\n        halfway.x / alpha.x,\n        halfway.y / alpha.y,\n        halfway.z\n    );\n    let denominator = dot(ellipsoidNormal, ellipsoidNormal);\n    return 1.0 / (\n        PI * alpha.x * alpha.y * denominator * denominator\n    );\n}\n\nfn sampling_ggx_smith_g1(direction: vec3f, alpha: vec2f) -> f32 {\n    let normalComponent = abs(direction.z);\n    if (normalComponent <= 1e-8) {\n        return 0.0;\n    }\n    let roughDirection = alpha * direction.xy;\n    let tanThetaSquared = dot(roughDirection, roughDirection)\n        / (normalComponent * normalComponent);\n    return 2.0 / (1.0 + sqrt(1.0 + tanThetaSquared));\n}\n\nfn sampling_schlick_fifth_power(cosine: f32) -> f32 {\n    let complement = clamp(1.0 - cosine, 0.0, 1.0);\n    return pow(complement, 5.0);\n}\n\nfn sampling_dielectric_fresnel(incidentCosine: f32, etaIOverEtaT: f32) -> f32 {\n    let cosineI = clamp(abs(incidentCosine), 0.0, 1.0);\n    let sineTSquared = etaIOverEtaT * etaIOverEtaT\n        * max(0.0, 1.0 - cosineI * cosineI);\n    if (sineTSquared >= 1.0) {\n        return 1.0;\n    }\n\n    let cosineT = sqrt(max(0.0, 1.0 - sineTSquared));\n    let perpendicular = (cosineI - etaIOverEtaT * cosineT)\n        / max(cosineI + etaIOverEtaT * cosineT, 1e-8);\n    let parallel = (etaIOverEtaT * cosineI - cosineT)\n        / max(etaIOverEtaT * cosineI + cosineT, 1e-8);\n    return 0.5 * (\n        perpendicular * perpendicular + parallel * parallel\n    );\n}\n\nfn sampling_concentric_disk(samplePoint: vec2f) -> vec2f {\n    let offset = 2.0 * samplePoint - vec2f(1.0);\n    if (offset.x == 0.0 && offset.y == 0.0) {\n        return vec2f(0.0);\n    }\n\n    var radius: f32;\n    var angle: f32;\n    if (abs(offset.x) > abs(offset.y)) {\n        radius = offset.x;\n        angle = 0.25 * PI * (offset.y / offset.x);\n    }\n    else {\n        radius = offset.y;\n        angle = 0.5 * PI - 0.25 * PI * (offset.x / offset.y);\n    }\n    return radius * vec2f(cos(angle), sin(angle));\n}\n\nfn sampling_cosine_hemisphere(samplePoint: vec2f) -> vec3f {\n    let diskPoint = sampling_concentric_disk(samplePoint);\n    return vec3f(\n        diskPoint,\n        sqrt(max(0.0, 1.0 - dot(diskPoint, diskPoint)))\n    );\n}\n\nfn sampling_power_heuristic(firstPdf: f32, secondPdf: f32) -> f32 {\n    let scale = max(firstPdf, secondPdf);\n    if (scale <= 0.0) {\n        return 0.0;\n    }\n    let normalized = vec2f(firstPdf, secondPdf) / scale;\n    let squared = normalized * normalized;\n    return squared.x / (squared.x + squared.y);\n}\n\nfn sampling_orthonormal_basis(\n    normal: vec3f,\n    tangent: ptr<function, vec3f>,\n    bitangent: ptr<function, vec3f>\n) {\n    let signZ = select(-1.0, 1.0, normal.z >= 0.0);\n    let factor = -1.0 / (signZ + normal.z);\n    let xy = normal.x * normal.y * factor;\n    *tangent = vec3f(\n        1.0 + signZ * normal.x * normal.x * factor,\n        signZ * xy,\n        -signZ * normal.x\n    );\n    *bitangent = vec3f(\n        xy,\n        signZ + normal.y * normal.y * factor,\n        -normal.y\n    );\n}\n\nfn sampling_spectral_rgb_filter(rgb: vec3f, wavelength: f32) -> vec3f {\n    if (wavelength == 0.0) {\n        return rgb;\n    }\n    if (wavelength > 600.0) {\n        return vec3f(rgb.r, 0.0, 0.0);\n    }\n    if (wavelength > 500.0) {\n        return vec3f(0.0, rgb.g, 0.0);\n    }\n    return vec3f(0.0, 0.0, rgb.b);\n}\n\nfn sampling_cauchy_ior(\n    wavelength: f32,\n    referenceIor: f32,\n    dispersionScale: f32,\n    abbeNumber: f32\n) -> f32 {\n    if (wavelength == 0.0 || dispersionScale <= 0.0) {\n        return referenceIor;\n    }\n\n    let FRAUNHOFER_C = 656.3;\n    let FRAUNHOFER_D = 587.6;\n    let FRAUNHOFER_F = 486.1;\n    let inverseDifference = 1.0 / (\n        1.0 / (FRAUNHOFER_F * FRAUNHOFER_F)\n        - 1.0 / (FRAUNHOFER_C * FRAUNHOFER_C)\n    );\n    let effectiveAbbe = max(abbeNumber / dispersionScale, 1e-6);\n    let cauchyB = (referenceIor - 1.0) * inverseDifference / effectiveAbbe;\n    let cauchyA = referenceIor\n        - cauchyB / (FRAUNHOFER_D * FRAUNHOFER_D);\n    return cauchyA + cauchyB / (wavelength * wavelength);\n}\n\nfn sampling_henyey_greenstein(\n    forwardDirection: vec3f,\n    anisotropy: f32,\n    samplePoint: vec2f\n) -> vec3f {\n    var cosine: f32;\n    if (abs(anisotropy) < 0.001) {\n        cosine = 1.0 - 2.0 * samplePoint.y;\n    }\n    else {\n        let ratio = (1.0 - anisotropy * anisotropy)\n            / (1.0 + anisotropy - 2.0 * anisotropy * samplePoint.y);\n        cosine = (\n            ratio * ratio - 1.0 - anisotropy * anisotropy\n        ) / (2.0 * anisotropy);\n    }\n\n    let sine = sqrt(max(0.0, 1.0 - cosine * cosine));\n    let azimuth = TWOPI * samplePoint.x;\n    var tangent: vec3f;\n    var bitangent: vec3f;\n    sampling_orthonormal_basis(forwardDirection, &tangent, &bitangent);\n    return tangent * (sine * cos(azimuth))\n        + bitangent * (sine * sin(azimuth))\n        + forwardDirection * cosine;\n}\n\nfn sampling_henyey_greenstein_phase(cosine: f32, anisotropy: f32) -> f32 {\n    let denominator = 1.0 + anisotropy * anisotropy\n        + 2.0 * anisotropy * cosine;\n    return INV4PI * (1.0 - anisotropy * anisotropy)\n        / (denominator * sqrt(denominator));\n}\n`;\n"]}

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

@@ -0,0 +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.
+ */
+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";
+export default _default;

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

@@ -0,0 +1,16 @@
+/**
+ * Per-pixel auxiliary accumulation: the shadow-catcher mask, its premultiplied
+ * primary background contribution, and luminance moments for the built-in
+ * denoiser's variance estimate.
+ */
+export const SHADOW_CATCHER_ACCUMULATION_BYTES = 48;
+export default /* wgsl */ `
+struct ShadowCatcherAccumulation {
+
+mask: vec4f,
+background: vec4f,
+
+moments: vec4f,
+}
+`;
+//# sourceMappingURL=shadowCatcherAccumulation.wgsl.js.map

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

@@ -0,0 +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"]}

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

@@ -0,0 +1,2 @@
+declare const _default: string;
+export default _default;

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

@@ -0,0 +1,170 @@
+import { zSobolPackedPermutations, sobolD1Steps } from '../../sampling.js';
+export default /* wgsl */ `
+const CAMERA_PIXEL = 0u;
+const CAMERA_LENS = 1u;
+const CAMERA_WAVELENGTH = 2u;
+const CAMERA_BEVEL_BASE = 3u;
+const LIGHT_SELECT = 0u;
+const LIGHT_POSITION = 1u;
+const BSDF_LOBE = 2u;
+const BSDF_DIRECTION = 3u;
+const MEDIUM_CHANNEL = 4u;
+const MEDIUM_DISTANCE = 5u;
+const PHASE_DIRECTION = 6u;
+const RUSSIAN_ROULETTE = 7u;
+const BOUNCE_STRIDE = 64u;
+
+
+
+var<private> bc: vec2u;
+var<private> bd: u32;
+var<private> cE: u32 = 0u;
+var<private> em: u32 = 0u;
+fn eg(ki: u32) -> u32 {
+var x = ki;
+x ^= x >> 16u; x *= 0x7feb352du;
+x ^= x >> 15u; x *= 0x846ca68bu;
+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;
+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 qX(ki: u32) -> u32 {
+var r = reverseBits(ki);
+${sobolD1Steps.map(([shift, mask]) => `r ^= (r << ${shift}u) & 0x${mask.toString(16)}u;`).join("\n  ")}
+return r;
+}
+fn vC(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));
+return vec2f(f32(x >> 8u), f32(y >> 8u)) * (1.0 / 16777216.0);
+}
+fn tj(p: vec2u) -> u32 {
+var v = p & vec2u(255u);
+v = (v | (v << vec2u(4u))) & vec2u(0x0f0fu);
+v = (v | (v << vec2u(2u))) & vec2u(0x3333u);
+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;
+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;
+}
+fn pK(kB: u32, dim: u32, logSPP: u32) -> u32 {
+let odd = logSPP & 1u;
+let tZ = 8u + ((logSPP + 1u) >> 1u);
+var result = 0u;
+for (var digit = i32(tZ) - 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;
+}
+if (odd != 0u) {
+result |= (kB & 1u) ^ (eg((kB >> 1u) ^ (0x55555555u * dim)) & 1u);
+}
+return result;
+}
+
+
+
+fn cv(slot: u32) -> u32 {
+return CAMERA_BEVEL_BASE + u32(BEVEL_SAMPLES) + cE * BOUNCE_STRIDE + slot;
+}
+fn qR(candidate: u32, slot: u32) -> u32 {
+if (candidate == 0u) {
+if (slot == 2u) { return cv(8u); }
+return cv(slot);
+}
+return cv(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;
+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);
+var index = bd;
+if (SAMPLING_PATTERN == 1) {
+var logSPP = rtUniform.zSobolLogSPP;
+if (index == 0u) { logSPP = 0u; }
+else { index -= 1u; }
+
+var iV = index >> logSPP;
+let mask = (1u << logSPP) - 1u;
+let kB = (tj(bc) << logSPP) | (index & mask);
+index = pK(kB, dim, logSPP);
+let tile = bc >> vec2u(8u);
+ie = aq(aq(dim, rtUniform.sequenceSeed), aq(tile.x, tile.y));
+
+if (bd != 0u) { iV += 1u; }
+ie = aq(ie, iV);
+}
+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);
+}
+fn kG(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;
+}
+return EPS + (1.0 - 2.0*EPS) * eN;
+}
+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;
+}
+fn fk(dim: u32) -> vec2f {
+if (SAMPLING_PATTERN == 2) {
+let x = dz(dim); let y = dz(dim);
+return vec2f(x,y);
+}
+return kG(dim);
+}
+
+fn eo(slot: u32) -> f32 {
+let dim = aq(aq(cE, 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)));
+return EPS + (1.0 - 2.0*EPS) * (f32(x >> 8u) * (1.0 / 16777216.0));
+}
+`;
+//# sourceMappingURL=sobol.wgsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sobol.wgsl.js","sourceRoot":"","sources":["../../../../src/renderer/wgsl/chunks/sobol.wgsl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAC3E,eAAe,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0CtB,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,cAAc,KAAK,UAAU,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC;;;;;;;;;;;;;;;;EAgBtG,wBAAwB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAC,CAAC,EAAE,EAAE,CAAC,gBAAgB,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;;;;EAI5E,CAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,8BAA8B,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyGzF,CAAC","sourcesContent":["import { zSobolPackedPermutations, sobolD1Steps } from '../../sampling.js';\nexport default /* wgsl */ `\nconst CAMERA_PIXEL = 0u;\nconst CAMERA_LENS = 1u;\nconst CAMERA_WAVELENGTH = 2u;\nconst CAMERA_BEVEL_BASE = 3u;\nconst LIGHT_SELECT = 0u;\nconst LIGHT_POSITION = 1u;\nconst BSDF_LOBE = 2u;\nconst BSDF_DIRECTION = 3u;\nconst MEDIUM_CHANNEL = 4u;\nconst MEDIUM_DISTANCE = 5u;\nconst PHASE_DIRECTION = 6u;\nconst RUSSIAN_ROULETTE = 7u;\nconst BOUNCE_STRIDE = 64u;\n\n// Burley 2020, Practical Hash-based Owen Scrambling, JCGT 9(4).\n// ZSobol digit walk adapted from pbrt-v4 samplers.h (Apache-2.0).\nvar<private> samplingPixel: vec2u;\nvar<private> pixelSampleIndex: u32;\nvar<private> samplingBounce: u32 = 0u;\nvar<private> hashedCounter: u32 = 0u;\nfn sampleHash(valueIn: u32) -> u32 {\n  var x = valueIn;\n  x ^= x >> 16u; x *= 0x7feb352du;\n  x ^= x >> 15u; x *= 0x846ca68bu;\n  return x ^ (x >> 16u);\n}\nfn sampleSeed(a: u32, b: u32) -> u32 {\n  return sampleHash(a ^ sampleHash(b + 0x9e3779b9u));\n}\nfn lkPermute(valueIn: u32, seed: u32) -> u32 {\n  var x = valueIn + seed;\n  x ^= x * 0x6c50b47cu; x ^= x * 0xb82f1e52u;\n  x ^= x * 0xc7afe638u; x ^= x * 0x8d22f6e6u;\n  return x;\n}\nfn owen(x: u32, seed: u32) -> u32 {\n  return reverseBits(lkPermute(reverseBits(x), seed));\n}\n// Parallel XOR butterfly equals v ^= v >> 1 for all 32 direction bits.\nfn sobolD1(valueIn: u32) -> u32 {\n  var r = reverseBits(valueIn);\n  ${sobolD1Steps.map(([shift, mask]) => `r ^= (r << ${shift}u) & 0x${mask.toString(16)}u;`).join(\"\\n  \")}\n  return r;\n}\nfn sobol2D(index: u32, seed: u32) -> vec2f {\n  let i = owen(index, sampleSeed(seed, 0u));\n  let x = reverseBits(lkPermute(i, sampleSeed(seed, 1u)));\n  let y = owen(sobolD1(i), sampleSeed(seed, 2u));\n  return vec2f(f32(x >> 8u), f32(y >> 8u)) * (1.0 / 16777216.0);\n}\nfn morton2(p: vec2u) -> u32 {\n  var v = p & vec2u(255u);\n  v = (v | (v << vec2u(4u))) & vec2u(0x0f0fu);\n  v = (v | (v << vec2u(2u))) & vec2u(0x3333u);\n  v = (v | (v << vec2u(1u))) & vec2u(0x5555u);\n  return v.x | (v.y << 1u);\n}\n${zSobolPackedPermutations.map((v,i) => `const Z_PERM_${i} = ${v}u;`).join(\"\\n\")}\nfn zSobolPermutation(perm: u32) -> u32 {\n  let group = perm >> 2u;\n  var word = Z_PERM_5;\n  ${[0,1,2,3,4].map(i => `word = select(word, Z_PERM_${i}, group == ${i}u);`).join(\"\\n  \")}\n  return (word >> ((perm & 3u) * 8u)) & 255u;\n}\nfn zSobolIndex(morton: u32, dim: u32, logSPP: u32) -> u32 {\n  let odd = logSPP & 1u;\n  let digits = 8u + ((logSPP + 1u) >> 1u);\n  var result = 0u;\n  for (var digit = i32(digits) - 1; digit >= i32(odd); digit--) {\n    let shift = 2u*u32(digit) - odd;\n    // A shift by 32 is undefined on GLSL and masks to zero on some GPUs.\n    var higher = 0u;\n    if (shift < 30u) { higher = morton >> (shift + 2u); }\n    let perm = (sampleHash(higher ^ (0x55555555u * dim)) >> 24u) % 24u;\n    let d = (morton >> shift) & 3u;\n    result |= ((zSobolPermutation(perm) >> (2u*d)) & 3u) << shift;\n  }\n  if (odd != 0u) {\n    result |= (morton & 1u) ^ (sampleHash((morton >> 1u) ^ (0x55555555u * dim)) & 1u);\n  }\n  return result;\n}\n// IDs count 2D domains, not scalar components. Bevel IDs follow camera IDs.\n// Bounce: light selector/position, lobe/direction, medium channel/distance,\n// phase direction, RR. Further candidate IDs are addressed, never consumed.\nfn bounceDim(slot: u32) -> u32 {\n  return CAMERA_BEVEL_BASE + u32(BEVEL_SAMPLES) + samplingBounce * BOUNCE_STRIDE + slot;\n}\nfn lightDim(candidate: u32, slot: u32) -> u32 {\n  if (candidate == 0u) {\n    if (slot == 2u) { return bounceDim(8u); }\n    return bounceDim(slot);\n  }\n  return bounceDim(9u + (candidate - 1u) * 3u + slot);\n}\n// Last-domain cache shares the index shuffle and x between scalar/pair reads.\n// Its keys also cover test shaders that change pixel/index within an invocation.\nvar<private> cachedSampleKey: vec4u;\nvar<private> cachedSampleLog: u32;\nvar<private> cachedSampleValid: bool = false;\nvar<private> cachedSampleYValid: bool = false;\nvar<private> cachedSampleIndex: u32;\nvar<private> cachedSampleSeed: u32;\nvar<private> cachedSample: vec2f;\nfn prepareStructuredSample(dim: u32) {\n\n  let pixelID = samplingPixel.x + samplingPixel.y * u32(rtUniform.outputSize.x);\n  let key = vec4u(dim, pixelSampleIndex, pixelID, rtUniform.sequenceSeed);\n  if (cachedSampleValid && all(cachedSampleKey == key) && cachedSampleLog == rtUniform.zSobolLogSPP) { return; }\n  cachedSampleKey = key; cachedSampleLog = rtUniform.zSobolLogSPP;\n  cachedSampleValid = true; cachedSampleYValid = false;\n  var seed = sampleSeed(sampleSeed(pixelID, dim), rtUniform.sequenceSeed);\n  var index = pixelSampleIndex;\n  if (SAMPLING_PATTERN == 1) {\n    var logSPP = rtUniform.zSobolLogSPP;\n    if (index == 0u) { logSPP = 0u; }\n    else { index -= 1u; }\n    // Independent sample blocks after the cap avoid repeated samples indefinitely.\n    var sequenceBlock = index >> logSPP;\n    let mask = (1u << logSPP) - 1u;\n    let morton = (morton2(samplingPixel) << logSPP) | (index & mask);\n    index = zSobolIndex(morton, dim, logSPP);\n    let tile = samplingPixel >> vec2u(8u);\n    seed = sampleSeed(sampleSeed(dim, rtUniform.sequenceSeed), sampleSeed(tile.x, tile.y));\n    // First and remaining streams must differ even at a two-sample budget.\n    if (pixelSampleIndex != 0u) { sequenceBlock += 1u; }\n    seed = sampleSeed(seed, sequenceBlock);\n  }\n  cachedSampleIndex = owen(index, sampleSeed(seed, 0u));\n  cachedSampleSeed = seed;\n  let x = reverseBits(lkPermute(cachedSampleIndex, sampleSeed(seed, 1u)));\n  cachedSample.x = f32(x >> 8u) * (1.0 / 16777216.0);\n}\nfn structuredSample(dim: u32) -> vec2f {\n  prepareStructuredSample(dim);\n  if (!cachedSampleYValid) {\n    let y = owen(sobolD1(cachedSampleIndex), sampleSeed(cachedSampleSeed, 2u));\n    cachedSample.y = f32(y >> 8u) * (1.0 / 16777216.0);\n    cachedSampleYValid = true;\n  }\n  return EPS + (1.0 - 2.0*EPS) * cachedSample;\n}\nfn sample1D(dim: u32) -> f32 {\n  if (SAMPLING_PATTERN == 2) { return EPS + (1.0 - 2.0*EPS)*rand(); }\n  prepareStructuredSample(dim);\n  return EPS + (1.0 - 2.0*EPS) * cachedSample.x;\n}\nfn sample2D(dim: u32) -> vec2f {\n  if (SAMPLING_PATTERN == 2) {\n    let x = sample1D(dim); let y = sample1D(dim);\n    return vec2f(x,y);\n  }\n  return structuredSample(dim);\n}\n// Variable traversal counts cannot move any of the structured dimensions.\nfn hashedSample(slot: u32) -> f32 {\n  let dim = sampleSeed(sampleSeed(samplingBounce, slot), hashedCounter) | 0x80000000u;\n  hashedCounter += 1u;\n  if (SAMPLING_PATTERN == 2) { return EPS + (1.0 - 2.0*EPS)*rand(); }\n  // Variable-count traversal has no spatial ZSobol ordering to preserve.\n  let pixelID = samplingPixel.x + samplingPixel.y * u32(rtUniform.outputSize.x);\n  let seed = sampleSeed(sampleSeed(pixelID, dim), rtUniform.sequenceSeed);\n  let i = owen(pixelSampleIndex, sampleSeed(seed, 0u));\n  let x = reverseBits(lkPermute(i, sampleSeed(seed, 1u)));\n  return EPS + (1.0 - 2.0*EPS) * (f32(x >> 8u) * (1.0 / 16777216.0));\n}\n`;\n"]}

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

@@ -0,0 +1,2 @@
+declare const _default: string;
+export default _default;

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

@@ -0,0 +1,42 @@
+import { uvProjectionConstants } from '../../MaterialTable.js';
+export default /* wgsl */ `
+
+fn sphericalProjection(pos: vec3f) -> vec2f {
+let n = normalize(pos);
+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);
+var uv = vec2f(0.0);
+if (dm.x > dm.y && dm.x > dm.z) {
+uv = pos.yz;
+} else if (dm.y > dm.x && dm.y > dm.z) {
+uv = pos.xz;
+} else {
+uv = pos.xy;
+}
+return uv;
+}
+
+
+
+
+fn hA(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}) {
+return sphericalProjection(pos);
+} else if (fh == ${uvProjectionConstants.cylindrical}) {
+return hA(pos, normal);
+}
+return vec2f(0.0);
+}
+`;
+//# sourceMappingURL=uvProjection.wgsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"uvProjection.wgsl.js","sourceRoot":"","sources":["../../../../src/renderer/wgsl/chunks/uvProjection.wgsl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAE/D,eAAe,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YA8BA,qBAAqB,CAAC,SAAS;;mBAExB,qBAAqB,CAAC,SAAS;;mBAE/B,qBAAqB,CAAC,WAAW;;;;;CAKjE,CAAC","sourcesContent":["import { uvProjectionConstants } from '../../MaterialTable.js';\n\nexport default /* wgsl */ `\n\nfn sphericalProjection(pos: vec3f) -> vec2f {\n  let n = normalize(pos);\n  let theta = atan2(n.x, n.z) / (2.0 * PI) + 0.5;\n  let phi = acos(n.y) / PI;\n  return vec2f(theta, 1.0 - phi);\n}\nfn triplanarProjection(pos: vec3f, normal: vec3f) -> vec2f {\n  let absNormal = abs(normal);\n  var uv = vec2f(0.0);\n  if (absNormal.x > absNormal.y && absNormal.x > absNormal.z) {\n    uv = pos.yz;\n  } else if (absNormal.y > absNormal.x && absNormal.y > absNormal.z) {\n    uv = pos.xz;\n  } else {\n    uv = pos.xy;\n  }\n  return uv;\n}\n\n\n\n\nfn cylindricalProjection(pos: vec3f, normal: vec3f) -> vec2f {\n  let theta = atan2(pos.z, pos.x) / (2.0 * PI) + 0.5;\n  return vec2f(theta, pos.y);\n}\n\nfn projectUV(projectionType: i32, pos: vec3f, normal: vec3f) -> vec2f {\n  if (projectionType == ${uvProjectionConstants.triplanar}) {\n    return triplanarProjection(pos, normal);\n  } else if (projectionType == ${uvProjectionConstants.spherical}) {\n    return sphericalProjection(pos);\n  } else if (projectionType == ${uvProjectionConstants.cylindrical}) {\n    return cylindricalProjection(pos, normal);\n  }\n  return vec2f(0.0);\n}\n`;\n"]}

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

@@ -0,0 +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 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";