@meimu/mutracer 0.2.0 → 0.3.1

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

@@ -16,41 +16,41 @@ const BOUNCE_STRIDE = 64u;
 
 
 
-var<private> aZ: vec2u;
-var<private> aQ: u32;
-var<private> bT: u32 = 0u;
-var<private> cP: u32 = 0u;
-fn dG(kW: u32) -> u32 {
-var x = kW;
+var<private> aJ: vec2u;
+var<private> aC: u32;
+var<private> samplingBounce: u32 = 0u;
+var<private> hashedCounter: u32 = 0u;
+fn cD(lm: u32) -> u32 {
+var x = lm;
 x ^= x >> 16u; x *= 0x7feb352du;
 x ^= x >> 15u; x *= 0x846ca68bu;
 return x ^ (x >> 16u);
 }
-fn ar(a: u32, b: u32) -> u32 {
-return dG(a ^ dG(b + 0x9e3779b9u));
+fn ak(a: u32, b: u32) -> u32 {
+return cD(a ^ cD(b + 0x9e3779b9u));
 }
-fn iV(kW: u32, seed: u32) -> u32 {
-var x = kW + seed;
+fn jc(lm: u32, seed: u32) -> u32 {
+var x = lm + seed;
 x ^= x * 0x6c50b47cu; x ^= x * 0xb82f1e52u;
 x ^= x * 0xc7afe638u; x ^= x * 0x8d22f6e6u;
 return x;
 }
-fn ua(x: u32, seed: u32) -> u32 {
-return reverseBits(iV(reverseBits(x), seed));
+fn vN(x: u32, seed: u32) -> u32 {
+return reverseBits(jc(reverseBits(x), seed));
 }
 
-fn su(kW: u32) -> u32 {
-var r = reverseBits(kW);
+fn tP(lm: u32) -> u32 {
+var r = reverseBits(lm);
 ${sobolD1Steps.map(([shift, mask]) => `r ^= (r << ${shift}u) & 0x${mask.toString(16)}u;`).join("\n  ")}
 return r;
 }
-fn xE(index: u32, seed: u32) -> vec2f {
-let i = ua(index, ar(seed, 0u));
-let x = reverseBits(iV(i, ar(seed, 1u)));
-let y = ua(su(i), ar(seed, 2u));
+fn Ac(index: u32, seed: u32) -> vec2f {
+let i = vN(index, ak(seed, 0u));
+let x = reverseBits(jc(i, ak(seed, 1u)));
+let y = vN(tP(i), ak(seed, 2u));
 return vec2f(f32(x >> 8u), f32(y >> 8u)) * (1.0 / 16777216.0);
 }
-fn uR(p: vec2u) -> u32 {
+fn wL(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 la(uU: u32) -> u32 {
-let group = uU >> 2u;
+fn lq(wO: u32) -> u32 {
+let group = wO >> 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 >> ((uU & 3u) * 8u)) & 255u;
+return (word >> ((wO & 3u) * 8u)) & 255u;
 }
-fn qS(lu: u32, dim: u32, logSPP: u32) -> u32 {
+fn rX(lS: u32, dim: u32, logSPP: u32) -> u32 {
 let odd = logSPP & 1u;
-let vN = 8u + ((logSPP + 1u) >> 1u);
+let xX = 8u + ((logSPP + 1u) >> 1u);
 var result = 0u;
-for (var digit = i32(vN) - 1; digit >= i32(odd); digit--) {
+for (var digit = i32(xX) - 1; digit >= i32(odd); digit--) {
 let shift = 2u*u32(digit) - odd;
 
-var tL = 0u;
-if (shift < 30u) { tL = lu >> (shift + 2u); }
-let uU = (dG(tL ^ (0x55555555u * dim)) >> 24u) % 24u;
-let d = (lu >> shift) & 3u;
-result |= ((la(uU) >> (2u*d)) & 3u) << shift;
+var vs = 0u;
+if (shift < 30u) { vs = lS >> (shift + 2u); }
+let wO = (cD(vs ^ (0x55555555u * dim)) >> 24u) % 24u;
+let d = (lS >> shift) & 3u;
+result |= ((lq(wO) >> (2u*d)) & 3u) << shift;
 }
 if (odd != 0u) {
-result |= (lu & 1u) ^ (dG((lu >> 1u) ^ (0x55555555u * dim)) & 1u);
+result |= (lS & 1u) ^ (cD((lS >> 1u) ^ (0x55555555u * dim)) & 1u);
 }
 return result;
 }
 
 
 
-fn cE(slot: u32) -> u32 {
-return CAMERA_BEVEL_BASE + u32(BEVEL_SAMPLES) + bT * BOUNCE_STRIDE + slot;
+fn aX(slot: u32) -> u32 {
+return CAMERA_BEVEL_BASE + u32(BEVEL_SAMPLES) + samplingBounce * BOUNCE_STRIDE + slot;
 }
-fn sl(candidate: u32, slot: u32) -> u32 {
+fn tF(candidate: u32, slot: u32) -> u32 {
 if (candidate == 0u) {
-if (slot == 2u) { return cE(8u); }
-return cE(slot);
+if (slot == 2u) { return aX(8u); }
+return aX(slot);
 }
-return cE(9u + (candidate - 1u) * 3u + slot);
+return aX(9u + (candidate - 1u) * 3u + slot);
 }
 
 
-var<private> hA: vec4u;
-var<private> hB: u32;
-var<private> fQ: bool = false;
-var<private> dv: bool = false;
-var<private> dQ: u32;
-var<private> gK: u32;
-var<private> fa: vec2f;
-fn dN(dim: u32) {
+var<private> hC: vec4u;
+var<private> hD: u32;
+var<private> fM: bool = false;
+var<private> cZ: bool = false;
+var<private> dF: u32;
+var<private> gM: u32;
+var<private> eT: vec2f;
+fn ds(dim: u32) {
 
-let kI = aZ.x + aZ.y * u32(rtUniform.outputSize.x);
-let key = vec4u(dim, aQ, kI, rtUniform.sequenceSeed);
-if (fQ && all(hA == key) && hB == rtUniform.zSobolLogSPP) { return; }
-hA = key; hB = rtUniform.zSobolLogSPP;
-fQ = true; dv = false;
-var seed = ar(ar(kI, dim), rtUniform.sequenceSeed);
-var index = aQ;
+let kT = aJ.x + aJ.y * u32(rtUniform.outputSize.x);
+let key = vec4u(dim, aC, kT, rtUniform.sequenceSeed);
+if (fM && all(hC == key) && hD == rtUniform.zSobolLogSPP) { return; }
+hC = key; hD = rtUniform.zSobolLogSPP;
+fM = true; cZ = false;
+var seed = ak(ak(kT, dim), rtUniform.sequenceSeed);
+var index = aC;
 if (SAMPLING_PATTERN == 1) {
 var logSPP = rtUniform.zSobolLogSPP;
 if (index == 0u) { logSPP = 0u; }
 else { index -= 1u; }
 
-var jw = index >> logSPP;
+var jH = index >> logSPP;
 let mask = (1u << logSPP) - 1u;
-let lu = (uR(aZ) << logSPP) | (index & mask);
-index = qS(lu, dim, logSPP);
-let tile = aZ >> vec2u(8u);
-seed = ar(ar(dim, rtUniform.sequenceSeed), ar(tile.x, tile.y));
+let lS = (wL(aJ) << logSPP) | (index & mask);
+index = rX(lS, dim, logSPP);
+let tile = aJ >> vec2u(8u);
+seed = ak(ak(dim, rtUniform.sequenceSeed), ak(tile.x, tile.y));
 
-if (aQ != 0u) { jw += 1u; }
-seed = ar(seed, jw);
+if (aC != 0u) { jH += 1u; }
+seed = ak(seed, jH);
 }
-dQ = ua(index, ar(seed, 0u));
-gK = seed;
-let x = reverseBits(iV(dQ, ar(seed, 1u)));
-fa.x = f32(x >> 8u) * (1.0 / 16777216.0);
+dF = vN(index, ak(seed, 0u));
+gM = seed;
+let x = reverseBits(jc(dF, ak(seed, 1u)));
+eT.x = f32(x >> 8u) * (1.0 / 16777216.0);
 }
-fn lC(dim: u32) -> vec2f {
-dN(dim);
-if (!dv) {
-let y = ua(su(dQ), ar(gK, 2u));
-fa.y = f32(y >> 8u) * (1.0 / 16777216.0);
-dv = true;
+fn lZ(dim: u32) -> vec2f {
+ds(dim);
+if (!cZ) {
+let y = vN(tP(dF), ak(gM, 2u));
+eT.y = f32(y >> 8u) * (1.0 / 16777216.0);
+cZ = true;
 }
-return EPS + (1.0 - 2.0*EPS) * fa;
+return EPS + (1.0 - 2.0*EPS) * eT;
 }
-fn dp(dim: u32) -> f32 {
+fn sample1D(dim: u32) -> f32 {
 if (SAMPLING_PATTERN == 2) { return EPS + (1.0 - 2.0*EPS)*rand(); }
-dN(dim);
-return EPS + (1.0 - 2.0*EPS) * fa.x;
+ds(dim);
+return EPS + (1.0 - 2.0*EPS) * eT.x;
 }
-fn dZ(dim: u32) -> vec2f {
+fn sample2D(dim: u32) -> vec2f {
 if (SAMPLING_PATTERN == 2) {
-let x = dp(dim); let y = dp(dim);
+let x = sample1D(dim); let y = sample1D(dim);
 return vec2f(x,y);
 }
-return lC(dim);
+return lZ(dim);
 }
 
-fn eC(slot: u32) -> f32 {
-let dim = ar(ar(bT, slot), cP) | 0x80000000u;
-cP += 1u;
+fn cm(slot: u32) -> f32 {
+let dim = ak(ak(samplingBounce, slot), hashedCounter) | 0x80000000u;
+hashedCounter += 1u;
 if (SAMPLING_PATTERN == 2) { return EPS + (1.0 - 2.0*EPS)*rand(); }
 
-let kI = aZ.x + aZ.y * u32(rtUniform.outputSize.x);
-let seed = ar(ar(kI, dim), rtUniform.sequenceSeed);
-let i = ua(aQ, ar(seed, 0u));
-let x = reverseBits(iV(i, ar(seed, 1u)));
+let kT = aJ.x + aJ.y * u32(rtUniform.outputSize.x);
+let seed = ak(ak(kT, dim), rtUniform.sequenceSeed);
+let i = vN(aC, ak(seed, 0u));
+let x = reverseBits(jc(i, ak(seed, 1u)));
 return EPS + (1.0 - 2.0*EPS) * (f32(x >> 8u) * (1.0 / 16777216.0));
 }
 `;

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

@@ -0,0 +1,6 @@
+export declare function spectralPrefixWgsl(shareSecondary?: boolean): string;
+export type PrefixBindings = Record<string, [type: string, expression: string]>;
+export declare const prefixRandomBindings: PrefixBindings;
+export declare function prefixCheckpoint(name: string, bindings: PrefixBindings): string;
+export declare function prefixSave(name: string, bindings: PrefixBindings): string;
+export declare function prefixRestore(name: string, bindings: PrefixBindings): string;

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

@@ -0,0 +1,66 @@
+// Browser-only checkpoint source. Native and nonspectral generation omit it.
+// Structured-sample caches are pure dimension lookups; only PCG, hashed draws
+// and the two current-bounce indices need restoring.
+export function spectralPrefixWgsl(shareSecondary = true) {
+    return /* wgsl */ `
+struct eE {
+ready: bool,
+result: vec4f,
+aux: RayTraceAuxiliary,
+rng: vec4u,
+counter: u32,
+bounce: u32,
+vertex: u32,
+}
+var<private> eB: array<eE, 2>;
+var<private> spActive: bool;
+var<private> sd: bool;
+var<private> spChannel: i32;
+var<private> lg: f32;
+var<private> qz: i32;
+var<private> fC: i32 = -1;
+
+fn wY(channel: i32, wavelength: f32, xF: bool) {
+sd = SPECTRAL && rtUniform.dispersionWavelengths != 1${shareSecondary ? '' : ' && false'};
+spChannel = channel; lg = wavelength;
+spActive = sd && !xF;
+qz = 0;
+}
+fn gf(ma: OpenPbrResolvedMaterial) -> bool {
+return ma.transmissionDispersionScale > 0.0 && ma.specularIor != 1.0;
+}
+fn qA(path: ptr<function, Path>, si: ptr<function, SurfaceInteraction>) {
+spActive = false;
+(*path).li = sampling_spectral_rgb_filter((*path).li, spChannel);
+(*si).spectralChannel = spChannel; (*si).wavelength = lg;
+}
+fn rN(slot: i32, aux: ptr<function, RayTraceAuxiliary>) -> vec4f {
+let oM = eB[slot];
+*aux = oM.aux;
+s0 = oM.rng; hashedCounter = oM.counter;
+samplingBounce = oM.bounce; bounceIndex = oM.vertex;
+return vec4f(sampling_spectral_rgb_filter(oM.result.rgb, spChannel), oM.result.a);
+}
+fn spFinish(slot: i32, result: vec4f, aux: RayTraceAuxiliary) -> vec4f {
+if (!spActive) { return result; }
+if (spChannel == 1) {
+eB[slot] = eE(true, result, aux, s0, hashedCounter, samplingBounce, bounceIndex);
+}
+return vec4f(sampling_spectral_rgb_filter(result.rgb, spChannel), result.a);
+}
+`;
+}
+export const prefixRandomBindings = {
+    rng: ['vec4u', 's0'], counter: ['u32', 'hashedCounter'],
+    bounce: ['u32', 'samplingBounce'], vertex: ['u32', 'bounceIndex']
+};
+export function prefixCheckpoint(name, bindings) {
+    return `struct ${name}State {\n${Object.entries(bindings).map(([key, [type]]) => `  ${key}: ${type},`).join('\n')}\n}\nvar<private> ${name}: ${name}State;\n`;
+}
+export function prefixSave(name, bindings) {
+    return Object.entries(bindings).map(([key, [, value]]) => `${name}.${key} = ${value};`).join('\n');
+}
+export function prefixRestore(name, bindings) {
+    return Object.entries(bindings).map(([key, [, value]]) => `${value} = ${name}.${key};`).join('\n');
+}
+//# sourceMappingURL=spectralPrefix.wgsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"spectralPrefix.wgsl.js","sourceRoot":"","sources":["../../../../src/renderer/wgsl/chunks/spectralPrefix.wgsl.ts"],"names":[],"mappings":"AAAA,6EAA6E;AAC7E,8EAA8E;AAC9E,qDAAqD;AACrD,MAAM,UAAU,kBAAkB,CAAC,cAAc,GAAG,IAAI;IAAI,OAAO,UAAU,CAAC;;;;;;;;;;;;;;;;;;;uDAmBd,cAAc,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BhG,CAAC;AAAC,CAAC;AAGJ,MAAM,CAAC,MAAM,oBAAoB,GAAmB;IAClD,GAAG,EAAE,CAAC,OAAO,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,eAAe,CAAC;IACvD,MAAM,EAAE,CAAC,KAAK,EAAE,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC,KAAK,EAAE,aAAa,CAAC;CAClE,CAAC;AACF,MAAM,UAAU,gBAAgB,CAAC,IAAY,EAAE,QAAwB;IACrE,OAAO,UAAU,IAAI,YAAY,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,GAAG,KAAK,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,qBAAqB,IAAI,KAAK,IAAI,UAAU,CAAC;AAChK,CAAC;AACD,MAAM,UAAU,UAAU,CAAC,IAAY,EAAE,QAAwB;IAC/D,OAAO,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,IAAI,IAAI,GAAG,MAAM,KAAK,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACrG,CAAC;AACD,MAAM,UAAU,aAAa,CAAC,IAAY,EAAE,QAAwB;IAClE,OAAO,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,KAAK,MAAM,IAAI,IAAI,GAAG,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACrG,CAAC","sourcesContent":["// Browser-only checkpoint source. Native and nonspectral generation omit it.\n// Structured-sample caches are pure dimension lookups; only PCG, hashed draws\n// and the two current-bounce indices need restoring.\nexport function spectralPrefixWgsl(shareSecondary = true) { return /* wgsl */ `\nstruct SpectralCompleted {\n  ready: bool,\n  result: vec4f,\n  aux: RayTraceAuxiliary,\n  rng: vec4u,\n  counter: u32,\n  bounce: u32,\n  vertex: u32,\n}\nvar<private> spCompleted: array<SpectralCompleted, 2>;\nvar<private> spActive: bool;\nvar<private> spEnabled: bool;\nvar<private> spChannel: i32;\nvar<private> spWavelength: f32;\nvar<private> spCall: i32;\nvar<private> spForkCall: i32 = -1;\n\nfn spBegin(channel: i32, wavelength: f32, primaryFork: bool) {\n  spEnabled = SPECTRAL && rtUniform.dispersionWavelengths != 1${shareSecondary ? '' : ' && false'};\n  spChannel = channel; spWavelength = wavelength;\n  spActive = spEnabled && !primaryFork;\n  spCall = 0;\n}\nfn spDisperses(ma: OpenPbrResolvedMaterial) -> bool {\n  return ma.transmissionDispersionScale > 0.0 && ma.specularIor != 1.0;\n}\nfn spFork(path: ptr<function, Path>, si: ptr<function, SurfaceInteraction>) {\n  spActive = false;\n  (*path).li = sampling_spectral_rgb_filter((*path).li, spChannel);\n  (*si).spectralChannel = spChannel; (*si).wavelength = spWavelength;\n}\nfn spReplay(slot: i32, aux: ptr<function, RayTraceAuxiliary>) -> vec4f {\n  let saved = spCompleted[slot];\n  *aux = saved.aux;\n  s0 = saved.rng; hashedCounter = saved.counter;\n  samplingBounce = saved.bounce; bounceIndex = saved.vertex;\n  return vec4f(sampling_spectral_rgb_filter(saved.result.rgb, spChannel), saved.result.a);\n}\nfn spFinish(slot: i32, result: vec4f, aux: RayTraceAuxiliary) -> vec4f {\n  if (!spActive) { return result; }\n  if (spChannel == 1) {\n    spCompleted[slot] = SpectralCompleted(true, result, aux, s0, hashedCounter, samplingBounce, bounceIndex);\n  }\n  return vec4f(sampling_spectral_rgb_filter(result.rgb, spChannel), result.a);\n}\n`; }\n\nexport type PrefixBindings = Record<string, [type: string, expression: string]>;\nexport const prefixRandomBindings: PrefixBindings = {\n  rng: ['vec4u', 's0'], counter: ['u32', 'hashedCounter'],\n  bounce: ['u32', 'samplingBounce'], vertex: ['u32', 'bounceIndex']\n};\nexport function prefixCheckpoint(name: string, bindings: PrefixBindings) {\n  return `struct ${name}State {\\n${Object.entries(bindings).map(([key, [type]]) => `  ${key}: ${type},`).join('\\n')}\\n}\\nvar<private> ${name}: ${name}State;\\n`;\n}\nexport function prefixSave(name: string, bindings: PrefixBindings) {\n  return Object.entries(bindings).map(([key, [, value]]) => `${name}.${key} = ${value};`).join('\\n');\n}\nexport function prefixRestore(name: string, bindings: PrefixBindings) {\n  return Object.entries(bindings).map(([key, [, value]]) => `${value} = ${name}.${key};`).join('\\n');\n}\n"]}

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 jh(pos: vec3f, normal: vec3f) -> vec2f {
-let dI = abs(normal);
+fn jq(pos: vec3f, normal: vec3f) -> vec2f {
+let dj = abs(normal);
 var uv = vec2f(0.0);
-if (dI.x > dI.y && dI.x > dI.z) {
+if (dj.x > dj.y && dj.x > dj.z) {
 uv = pos.yz;
-} else if (dI.y > dI.x && dI.y > dI.z) {
+} else if (dj.y > dj.x && dj.y > dj.z) {
 uv = pos.xz;
 } else {
 uv = pos.xy;
@@ -23,18 +23,18 @@ return uv;
 
 
 
-fn hT(pos: vec3f, normal: vec3f) -> vec2f {
+fn hW(pos: vec3f, normal: vec3f) -> vec2f {
 let theta = atan2(pos.z, pos.x) / (2.0 * PI) + 0.5;
 return vec2f(theta, pos.y);
 }
 
-fn gU(fE: i32, pos: vec3f, normal: vec3f) -> vec2f {
-if (fE == ${uvProjectionConstants.triplanar}) {
-return jh(pos, normal);
-} else if (fE == ${uvProjectionConstants.spherical}) {
+fn gW(fu: i32, pos: vec3f, normal: vec3f) -> vec2f {
+if (fu == ${uvProjectionConstants.triplanar}) {
+return jq(pos, normal);
+} else if (fu == ${uvProjectionConstants.spherical}) {
 return sphericalProjection(pos);
-} else if (fE == ${uvProjectionConstants.cylindrical}) {
-return hT(pos, normal);
+} else if (fu == ${uvProjectionConstants.cylindrical}) {
+return hW(pos, normal);
 }
 return vec2f(0.0);
 }

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

@@ -0,0 +1,2 @@
+/** Readers share word offsets with compactVertices; legacy hosts keep vec4-slot offsets. */
+export declare function vertexAttributeReaders(compact: boolean, frames: boolean): string;

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

@@ -0,0 +1,61 @@
+/** Readers share word offsets with compactVertices; legacy hosts keep vec4-slot offsets. */
+export function vertexAttributeReaders(compact, frames) {
+    if (!compact)
+        return /* wgsl */ `
+fn vertexPosition(i:i32)->vec3f {return attrBuffers[i*ATTR_STRIDE+POSITION_OFF].xyz;}
+fn vertexNormal(i:i32)->vec3f {return attrBuffers[i*ATTR_STRIDE+NORMAL_OFF].xyz;}
+fn hd(i:i32)->vec2f {return attrBuffers[i*ATTR_STRIDE+UV_OFF].xy;}
+fn hV(i:i32)->vec2f {return attrBuffers[i*ATTR_STRIDE+UV1_OFF].xy;}
+fn vertexColor(i:i32)->vec3f {return attrBuffers[i*ATTR_STRIDE+COLOR_OFF].xyz;}
+fn gC(i:i32)->vec4f {return ${frames ? 'attrBuffers[i*ATTR_STRIDE+TANGENT_OFF]' : 'vec4f(attrBuffers[i*ATTR_STRIDE+TANGENT_OFF],0.0)'};}
+`;
+    return /* wgsl */ `
+fn tI(a:i32,b:i32,maximum:f32)->vec3f {
+if (a == -i32(maximum)-1 && b == -i32(maximum)-1) {return vec3f(0.0);}
+var v=vec3f(f32(a)/maximum,f32(b)/maximum,0.0);
+v.z=1.0-abs(v.x)-abs(v.y);
+if(v.z<0.0) {v=vec3f((vec2f(1.0)-abs(v.yx))*select(vec2f(-1.0),vec2f(1.0),v.xy>=vec2f(0.0)),v.z);}
+return normalize(v);
+}
+fn vertexPosition(i:i32)->vec3f {
+let o=i*ATTR_STRIDE+POSITION_OFF;
+return bitcast<vec3f>(vec3u(attrBuffers[o],attrBuffers[o+1],attrBuffers[o+2]));
+}
+fn vertexNormal(i:i32)->vec3f {
+let o=i*ATTR_STRIDE+NORMAL_OFF;
+if(NORMAL_FLOAT) {return bitcast<vec3f>(vec3u(attrBuffers[o],attrBuffers[o+1],attrBuffers[o+2]));}
+let w=attrBuffers[o];
+return tI(i32(w<<16u)>>16,i32(w)>>16,32767.0);
+}
+fn hd(i:i32)->vec2f {
+if(!HAS_VERTEX_UV) {return vec2f(0.0);}
+let o=i*ATTR_STRIDE+UV_OFF;
+return bitcast<vec2f>(vec2u(attrBuffers[o],attrBuffers[o+1]));
+}
+fn hV(i:i32)->vec2f {
+if(!HAS_VERTEX_UV) {return vec2f(0.0);}
+let o=i*ATTR_STRIDE+UV1_OFF;
+return bitcast<vec2f>(vec2u(attrBuffers[o],attrBuffers[o+1]));
+}
+fn vertexColor(i:i32)->vec3f {
+if(!USE_VERTEX_COLOR) {return vec3f(1.0);}
+let o=i*ATTR_STRIDE+COLOR_OFF;
+if(COLOR_FLOAT) {return bitcast<vec3f>(vec3u(attrBuffers[o],attrBuffers[o+1],attrBuffers[o+2]));}
+return unpack4x8unorm(attrBuffers[o]).xyz;
+}
+fn gC(i:i32)->vec4f {
+if(!HAS_VERTEX_TANGENT) {return vec4f(0.0);}
+let w=attrBuffers[i*ATTR_STRIDE+TANGENT_OFF];
+let direction=tI(i32(w<<17u)>>17,i32(w<<2u)>>17,16383.0);
+let AN=array<f32,4>(0.0,1.0,-1.0,2.0);
+return vec4f(direction,AN[w>>30u]);
+}
+fn pJ(fallback:i32,record:i32)->i32 {
+if(!HAS_TRIANGLE_MATERIAL) {return fallback;}
+let material=attrBuffers[MATERIALINDEX_OFF+record];
+if(material==0u) {return fallback;}
+return i32(material-1u);
+}
+`;
+}
+//# sourceMappingURL=vertexAttributes.wgsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"vertexAttributes.wgsl.js","sourceRoot":"","sources":["../../../../src/renderer/wgsl/chunks/vertexAttributes.wgsl.ts"],"names":[],"mappings":"AAAA,4FAA4F;AAC5F,MAAM,UAAU,sBAAsB,CAAC,OAAgB,EAAE,MAAe;IACtE,IAAI,CAAC,OAAO;QAAE,OAAO,UAAU,CAAC;;;;;;8BAMO,MAAM,CAAC,CAAC,CAAC,wCAAwC,CAAC,CAAC,CAAC,mDAAmD;CAC/I,CAAC;IACA,OAAO,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+CnB,CAAC;AACF,CAAC","sourcesContent":["/** Readers share word offsets with compactVertices; legacy hosts keep vec4-slot offsets. */\nexport function vertexAttributeReaders(compact: boolean, frames: boolean) {\n  if (!compact) return /* wgsl */ `\nfn vertexPosition(i:i32)->vec3f {return attrBuffers[i*ATTR_STRIDE+POSITION_OFF].xyz;}\nfn vertexNormal(i:i32)->vec3f {return attrBuffers[i*ATTR_STRIDE+NORMAL_OFF].xyz;}\nfn vertexUv(i:i32)->vec2f {return attrBuffers[i*ATTR_STRIDE+UV_OFF].xy;}\nfn vertexUv1(i:i32)->vec2f {return attrBuffers[i*ATTR_STRIDE+UV1_OFF].xy;}\nfn vertexColor(i:i32)->vec3f {return attrBuffers[i*ATTR_STRIDE+COLOR_OFF].xyz;}\nfn vertexTangent(i:i32)->vec4f {return ${frames ? 'attrBuffers[i*ATTR_STRIDE+TANGENT_OFF]' : 'vec4f(attrBuffers[i*ATTR_STRIDE+TANGENT_OFF],0.0)'};}\n`;\n  return /* wgsl */ `\nfn octDirection(a:i32,b:i32,maximum:f32)->vec3f {\n  if (a == -i32(maximum)-1 && b == -i32(maximum)-1) {return vec3f(0.0);}\n  var v=vec3f(f32(a)/maximum,f32(b)/maximum,0.0);\n  v.z=1.0-abs(v.x)-abs(v.y);\n  if(v.z<0.0) {v=vec3f((vec2f(1.0)-abs(v.yx))*select(vec2f(-1.0),vec2f(1.0),v.xy>=vec2f(0.0)),v.z);}\n  return normalize(v);\n}\nfn vertexPosition(i:i32)->vec3f {\n  let o=i*ATTR_STRIDE+POSITION_OFF;\n  return bitcast<vec3f>(vec3u(attrBuffers[o],attrBuffers[o+1],attrBuffers[o+2]));\n}\nfn vertexNormal(i:i32)->vec3f {\n  let o=i*ATTR_STRIDE+NORMAL_OFF;\n  if(NORMAL_FLOAT) {return bitcast<vec3f>(vec3u(attrBuffers[o],attrBuffers[o+1],attrBuffers[o+2]));}\n  let w=attrBuffers[o];\n  return octDirection(i32(w<<16u)>>16,i32(w)>>16,32767.0);\n}\nfn vertexUv(i:i32)->vec2f {\n  if(!HAS_VERTEX_UV) {return vec2f(0.0);}\n  let o=i*ATTR_STRIDE+UV_OFF;\n  return bitcast<vec2f>(vec2u(attrBuffers[o],attrBuffers[o+1]));\n}\nfn vertexUv1(i:i32)->vec2f {\n  if(!HAS_VERTEX_UV) {return vec2f(0.0);}\n  let o=i*ATTR_STRIDE+UV1_OFF;\n  return bitcast<vec2f>(vec2u(attrBuffers[o],attrBuffers[o+1]));\n}\nfn vertexColor(i:i32)->vec3f {\n  if(!USE_VERTEX_COLOR) {return vec3f(1.0);}\n  let o=i*ATTR_STRIDE+COLOR_OFF;\n  if(COLOR_FLOAT) {return bitcast<vec3f>(vec3u(attrBuffers[o],attrBuffers[o+1],attrBuffers[o+2]));}\n  return unpack4x8unorm(attrBuffers[o]).xyz;\n}\nfn vertexTangent(i:i32)->vec4f {\n  if(!HAS_VERTEX_TANGENT) {return vec4f(0.0);}\n  let w=attrBuffers[i*ATTR_STRIDE+TANGENT_OFF];\n  let direction=octDirection(i32(w<<17u)>>17,i32(w<<2u)>>17,16383.0);\n  let signs=array<f32,4>(0.0,1.0,-1.0,2.0);\n  return vec4f(direction,signs[w>>30u]);\n}\nfn triangleMaterial(fallback:i32,record:i32)->i32 {\n  if(!HAS_TRIANGLE_MATERIAL) {return fallback;}\n  let material=attrBuffers[MATERIALINDEX_OFF+record];\n  if(material==0u) {return fallback;}\n  return i32(material-1u);\n}\n`;\n}\n"]}

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

@@ -1,3 +1,5 @@
+/** Mode indices understood by applyToneMapping. */
+export declare const TONE_MAPPING_MODES: Readonly<Record<string, number>>;
 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 function createComposeMain(sdrEncoding?: 'gamma22' | 'srgb'): string;