@meimu/mutracer 0.2.0 → 0.3.1

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

@@ -22,18 +22,18 @@ const T_SIZE = vec2u(256, 64);
 const MS_ALTITUDES = 32u;
 const SV_SIZE = vec2u(96, 192);
 
-fn br(r: f32, mu: f32, radius: f32) -> f32 { return (radius - r) * (radius + r) + r * r * mu * mu; }
-fn np(r: f32, mu: f32) -> bool { return mu < 0.0 && br(r, mu, R_GROUND) >= 0.0; }
-fn ll(r: f32, mu: f32) -> f32 { return max(-r * mu - sqrt(max(br(r, mu, R_GROUND), 0.0)), 0.0); }
-fn jm(r: f32, mu: f32) -> f32 { return max(-r * mu + sqrt(max(br(r, mu, R_TOP), 0.0)), 0.0); }
-fn oz(r: f32) -> vec3f {
+fn bk(r: f32, mu: f32, radius: f32) -> f32 { return (radius - r) * (radius + r) + r * r * mu * mu; }
+fn nW(r: f32, mu: f32) -> bool { return mu < 0.0 && bk(r, mu, R_GROUND) >= 0.0; }
+fn lM(r: f32, mu: f32) -> f32 { return max(-r * mu - sqrt(max(bk(r, mu, R_GROUND), 0.0)), 0.0); }
+fn jx(r: f32, mu: f32) -> f32 { return max(-r * mu + sqrt(max(bk(r, mu, R_TOP), 0.0)), 0.0); }
+fn pj(r: f32) -> vec3f {
 let h = max(r - R_GROUND, 0.0);
 return vec3f(exp(-h / 8.0), exp(-h / 1.2) * ${TURBIDITY}, max(0.0, 1.0 - abs(h - 25.0) / 15.0));
 }
 fn extinction(d: vec3f) -> vec3f { return RAYLEIGH * d.x + MIE_EXTINCTION * d.y + OZONE * d.z; }
-fn mP(x: f32) -> f32 { return x * x * (R_TOP - R_GROUND); }
-fn hR(h: f32) -> f32 { return sqrt(clamp(h / (R_TOP - R_GROUND), 0.0, 1.0)); }
-fn fh(table: texture_2d<f32>, p: vec2f) -> vec3f {
+fn nE(x: f32) -> f32 { return x * x * (R_TOP - R_GROUND); }
+fn hT(h: f32) -> f32 { return sqrt(clamp(h / (R_TOP - R_GROUND), 0.0, 1.0)); }
+fn fd(table: texture_2d<f32>, p: vec2f) -> vec3f {
 let size = vec2i(textureDimensions(table));
 let q = clamp(p, vec2f(0.0), vec2f(size - 1));
 let i = min(vec2i(floor(q)), max(size - 2, vec2i(0)));
@@ -45,25 +45,25 @@ let c = textureLoad(table, vec2i(i.x, j.y), 0).rgb;
 let d = textureLoad(table, j, 0).rgb;
 return mix(mix(a, b, f.x), mix(c, d, f.x), f.y);
 }
-fn fO(r: f32, mu: f32) -> vec3f {
-return fh(transmittanceTable, vec2f((clamp(mu, -1.0, 1.0) + 1.0) * 0.5 * f32(T_SIZE.x - 1u), hR(r - R_GROUND) * f32(T_SIZE.y - 1u)));
+fn fK(r: f32, mu: f32) -> vec3f {
+return fd(transmittanceTable, vec2f((clamp(mu, -1.0, 1.0) + 1.0) * 0.5 * f32(T_SIZE.x - 1u), hT(r - R_GROUND) * f32(T_SIZE.y - 1u)));
 }
-fn mW(nu: f32) -> f32 {
+fn nK(nu: f32) -> f32 {
 let g2 = MIE_G * MIE_G;
 return 3.0 / (8.0 * PI) * ((1.0 - g2) * (1.0 + nu * nu)) / ((2.0 + g2) * pow(1.0 + g2 - 2.0 * MIE_G * nu, 1.5));
 }
-struct xJ { radiance: vec3f, throughput: vec3f }
-fn vt(origin: vec3f, dir: vec3f, steps: u32, full: bool, uw: vec3f) -> xJ {
+struct Ai { radiance: vec3f, throughput: vec3f }
+fn xu(origin: vec3f, dir: vec3f, steps: u32, full: bool, wl: vec3f) -> Ai {
 let r = length(origin);
 let mu = dot(origin, dir) / r;
-let ground = np(r, mu);
-var len = jm(r, mu);
-if (ground) { len = ll(r, mu); }
+let ground = nW(r, mu);
+var len = jx(r, mu);
+if (ground) { len = lM(r, mu); }
 let nu = dot(dir, params.sun.xyz);
-var jv = 1.0 / (4.0 * PI);
-var sn = jv;
-if (full) { jv = 3.0 / (16.0 * PI) * (1.0 + nu * nu); sn = mW(nu); }
-var result = xJ(vec3f(0.0), vec3f(0.0));
+var jF = 1.0 / (4.0 * PI);
+var tH = jF;
+if (full) { jF = 3.0 / (16.0 * PI) * (1.0 + nu * nu); tH = nK(nu); }
+var result = Ai(vec3f(0.0), vec3f(0.0));
 var view = vec3f(1.0);
 var previous = 0.0;
 for (var i = 0u; i < steps; i++) {
@@ -73,34 +73,34 @@ let dt = next - previous;
 let p = origin + dir * (0.5 * (previous + next));
 previous = next;
 let pr = length(p);
-let d = oz(pr);
+let d = pj(pr);
 let e = extinction(d);
-let vb = fO(pr, dot(p, params.sun.xyz) / pr);
-let nG = RAYLEIGH * d.x;
-let nF = MIE_SCATTERING * d.y;
+let wZ = fK(pr, dot(p, params.sun.xyz) / pr);
+let om = RAYLEIGH * d.x;
+let ol = MIE_SCATTERING * d.y;
 var ms = vec3f(0.0);
-if (full) { ms = fh(multipleTable, vec2f(hR(pr - R_GROUND) * f32(MS_ALTITUDES - 1u), 0.0)); }
-let source = vb * (nG * jv + nF * sn) + (nG + nF) * ms;
-let st = exp(-e * dt);
-let weight = (1.0 - st) / max(e, vec3f(1e-9));
+if (full) { ms = fd(multipleTable, vec2f(hT(pr - R_GROUND) * f32(MS_ALTITUDES - 1u), 0.0)); }
+let source = wZ * (om * jF + ol * tH) + (om + ol) * ms;
+let segment = exp(-e * dt);
+let weight = (1.0 - segment) / max(e, vec3f(1e-9));
 result.radiance += view * source * weight;
-result.throughput += view * (nG + nF) * weight;
-view *= st;
+result.throughput += view * (om + ol) * weight;
+view *= segment;
 }
 if (ground) {
 let p = origin + dir * len;
 let pr = length(p);
-let tC = dot(p, params.sun.xyz) / pr;
-let irradiance = fO(pr, tC) * max(tC, 0.0) + uw;
+let vd = dot(p, params.sun.xyz) / pr;
+let irradiance = fK(pr, vd) * max(vd, 0.0) + wl;
 result.radiance += view * ALBEDO / PI * irradiance;
 }
 return result;
 }
-fn qk(row: f32) -> f32 {
+fn rl(row: f32) -> f32 {
 let x = row / f32(SV_SIZE.y - 1u) * 2.0 - 1.0;
 return sign(x) * x * x * (PI / 2.0);
 }
-fn ik(e: f32) -> f32 {
+fn ir(e: f32) -> f32 {
 let x = sign(e) * sqrt(abs(e) / (PI / 2.0));
 return clamp((x + 1.0) * 0.5, 0.0, 1.0) * f32(SV_SIZE.y - 1u);
 }
@@ -108,40 +108,40 @@ return clamp((x + 1.0) * 0.5, 0.0, 1.0) * f32(SV_SIZE.y - 1u);
 fn transmittance(@builtin(global_invocation_id) id: vec3u) {
 if (any(id.xy >= T_SIZE)) { return; }
 let mu = f32(id.x) / f32(T_SIZE.x - 1u) * 2.0 - 1.0;
-let r = R_GROUND + mP(f32(id.y) / f32(T_SIZE.y - 1u));
-if (np(r, mu)) { textureStore(output, vec2i(id.xy), vec4f(0.0, 0.0, 0.0, 1.0)); return; }
-let len = jm(r, mu);
+let r = R_GROUND + nE(f32(id.y) / f32(T_SIZE.y - 1u));
+if (nW(r, mu)) { textureStore(output, vec2i(id.xy), vec4f(0.0, 0.0, 0.0, 1.0)); return; }
+let len = jx(r, mu);
 var depth = vec3f(0.0);
 for (var i = 0u; i < 48u; i++) {
 let t = (f32(i) + 0.5) / 48.0 * len;
-depth += extinction(oz(sqrt(t * t + 2.0 * r * mu * t + r * r))) * (len / 48.0);
+depth += extinction(pj(sqrt(t * t + 2.0 * r * mu * t + r * r))) * (len / 48.0);
 }
 textureStore(output, vec2i(id.xy), vec4f(exp(-depth), 1.0));
 }
 @compute @workgroup_size(8, 8)
 fn multiple(@builtin(global_invocation_id) id: vec3u) {
 if (id.x >= MS_ALTITUDES || id.y > 0u) { return; }
-let r = R_GROUND + mP(f32(id.x) / f32(MS_ALTITUDES - 1u));
+let r = R_GROUND + nE(f32(id.x) / f32(MS_ALTITUDES - 1u));
 var second = vec3f(0.0);
-var qK = vec3f(0.0);
+var rQ = vec3f(0.0);
 for (var i = 0u; i < 64u; i++) {
 let mu = 1.0 - 2.0 * (f32(i) + 0.5) / 64.0;
 let phi = f32(i) * PI * (3.0 - sqrt(5.0));
 let s = sqrt(1.0 - mu * mu);
-let result = vt(vec3f(0.0, r, 0.0), vec3f(s * cos(phi), mu, s * sin(phi)), 20u, false, vec3f(0.0));
+let result = xu(vec3f(0.0, r, 0.0), vec3f(s * cos(phi), mu, s * sin(phi)), 20u, false, vec3f(0.0));
 second += result.radiance / 64.0;
-qK += result.throughput / 64.0;
+rQ += result.throughput / 64.0;
 }
-textureStore(output, vec2i(id.xy), vec4f(second / (1.0 - qK), 1.0));
+textureStore(output, vec2i(id.xy), vec4f(second / (1.0 - rQ), 1.0));
 }
 @compute @workgroup_size(8, 8)
 fn skyView(@builtin(global_invocation_id) id: vec3u) {
 if (any(id.xy >= SV_SIZE)) { return; }
-let e = qk(f32(id.y));
+let e = rl(f32(id.y));
 let phi = f32(id.x) / f32(SV_SIZE.x - 1u) * PI;
 var sky = vec3f(0.0);
 if (params.size.w > 0.0) { sky = textureLoad(irradianceTable, vec2i(0), 0).rgb; }
-let result = vt(vec3f(0.0, R_GROUND + CAMERA_ALTITUDE, 0.0), vec3f(cos(e) * cos(phi), sin(e), cos(e) * sin(phi)), 40u, true, sky);
+let result = xu(vec3f(0.0, R_GROUND + CAMERA_ALTITUDE, 0.0), vec3f(cos(e) * cos(phi), sin(e), cos(e) * sin(phi)), 40u, true, sky);
 textureStore(output, vec2i(id.xy), vec4f(result.radiance, 1.0));
 }
 @compute @workgroup_size(8, 8)
@@ -153,44 +153,44 @@ let e = (f32(i) + 0.5) / 128.0 * (PI / 2.0);
 let weight = 2.0 * sin(e) * cos(e) * (PI / 2.0 / 128.0) * (PI / 48.0);
 for (var j = 0u; j < 48u; j++) {
 let phi = (f32(j) + 0.5) / 48.0 * PI;
-sky += fh(skyTable, vec2f(phi / PI * f32(SV_SIZE.x - 1u), ik(e))) * weight;
+sky += fd(skyTable, vec2f(phi / PI * f32(SV_SIZE.x - 1u), ir(e))) * weight;
 }
 }
 if (id.x == 0u) { textureStore(output, vec2i(id.xy), vec4f(sky, 1.0)); return; }
-let vb = fO(R_GROUND + CAMERA_ALTITUDE, params.sun.y);
-let xc = vec3f(0.2126, 0.7152, 0.0722);
-let horizontal = dot(sky, xc) + dot(vb, xc) * max(params.sun.y, 0.0);
+let wZ = fK(R_GROUND + CAMERA_ALTITUDE, params.sun.y);
+let lQ = vec3f(0.2126, 0.7152, 0.0722);
+let horizontal = dot(sky, lQ) + dot(wZ, lQ) * max(params.sun.y, 0.0);
 let scale = ${ILLUMINANCE} / sqrt(max(horizontal, ${REFERENCE_ILLUMINANCE} * 1e-3) * ${REFERENCE_ILLUMINANCE});
-textureStore(output, vec2i(id.xy), vec4f(vb, scale));
+textureStore(output, vec2i(id.xy), vec4f(wZ, scale));
 }
-fn hn(dk: vec2f) -> vec3f {
-let theta = dk.y / params.size.y * PI;
-let phi = dk.x / params.size.x * 2.0 * PI;
+fn hs(texel: vec2f) -> vec3f {
+let theta = texel.y / params.size.y * PI;
+let phi = texel.x / params.size.x * 2.0 * PI;
 return vec3f(-sin(theta) * cos(phi), cos(theta), -sin(theta) * sin(phi));
 }
 @compute @workgroup_size(8, 8)
 fn map(@builtin(global_invocation_id) id: vec3u) {
 if (any(id.xy >= vec2u(params.size.xy))) { return; }
-let dk = vec2f(id.xy) + 0.5;
-let dir = hn(dk);
-let th = abs(atan2(dir.z, dir.x) - params.sun.w);
-let wr = th - floor(th / (2.0 * PI)) * (2.0 * PI);
-let ek = min(wr, 2.0 * PI - wr);
+let texel = vec2f(id.xy) + 0.5;
+let dir = hs(texel);
+let uJ = abs(atan2(dir.z, dir.x) - params.sun.w);
+let yP = uJ - floor(uJ / (2.0 * PI)) * (2.0 * PI);
+let ea = min(yP, 2.0 * PI - yP);
 let e = asin(clamp(dir.y, -1.0, 1.0));
-var radiance = fh(skyTable, vec2f(ek / PI * f32(SV_SIZE.x - 1u), ik(e)));
+var radiance = fd(skyTable, vec2f(ea / PI * f32(SV_SIZE.x - 1u), ir(e)));
 let sun = textureLoad(irradianceTable, vec2i(1, 0), 0);
 let radius = params.sunWorld.w;
-let rP = PI / params.size.y;
-if (acos(clamp(dot(dir, params.sunWorld.xyz), -1.0, 1.0)) < radius + 3.0 * rP / max(sqrt(1.0 - dir.y * dir.y), 0.05)) {
+let tc = PI / params.size.y;
+if (acos(clamp(dot(dir, params.sunWorld.xyz), -1.0, 1.0)) < radius + 3.0 * tc / max(sqrt(1.0 - dir.y * dir.y), 0.05)) {
 var coverage = 0.0;
 for (var y = 0u; y < 6u; y++) { for (var x = 0u; x < 6u; x++) {
-let d = hn(dk - 0.5 + (vec2f(f32(x), f32(y)) + 0.5) / 6.0);
+let d = hs(texel - 0.5 + (vec2f(f32(x), f32(y)) + 0.5) / 6.0);
 let angle = 2.0 * asin(min(length(d - params.sunWorld.xyz) * 0.5, 1.0));
 let t = angle / radius;
 if (t < 1.0) { coverage += 1.0 - 0.6 * (1.0 - sqrt(1.0 - t * t)); }
 } }
-let rO = 2.0 * PI * (1.0 - cos(radius));
-radiance += coverage / 36.0 / (rO * (1.0 - 0.6 / 3.0)) * sun.rgb;
+let ta = 2.0 * PI * (1.0 - cos(radius));
+radiance += coverage / 36.0 / (ta * (1.0 - 0.6 / 3.0)) * sun.rgb;
 }
 textureStore(output, vec2i(id.xy), vec4f(radiance * sun.a * params.scale.xyz + params.ambient.xyz, 1.0));
 }

package/lib/renderer/wgsl/rayTrace.compute.d.ts

@@ -9,7 +9,29 @@ export interface RayTraceInputHooks {
     uniformJitter: boolean;
 }
 export interface RayTraceShaderOptions {
+    /** Internal host budget. Default 20 preserves the native AOT contract. */
+    maxPathEvents?: number;
+    /** Web TLAS leaf boxes. Default false retains the native layout. */
+    perInstanceBounds?: boolean;
+    /** Full RGB reservoir targets for browser spectral paths. Default false. */
+    channelIndependentRis?: boolean;
+    /** Reuse browser RGB paths until the first wavelength-dependent IOR. Default false. */
+    shareSpectralPrefix?: boolean;
+    independentTextures?: boolean;
+    /** WebGPU display AOV storage specialization. Default false preserves the native/default shader. */
+    displayAovStorage?: boolean;
     hasDisplacement: boolean;
+    /** Browser camera extension; false preserves the native uniform layout. */
+    cameraProjectionInverse?: boolean;
+    compactVertices?: boolean;
+    debugGroup?: number;
+    /** Invocation block edge; the native host matches dispatch to this value. Default 8. */
+    workgroupSize?: number;
+    lightTracing?: boolean;
+    photonMapping?: boolean;
+    photonMaxDepth?: number;
+    /** Internal A/B override for directly visible PM receivers. Default true; ignored with light tracing. */
+    photonDirectSubset?: boolean;
     /** Include direction frames only when used, preserving the legacy shader arithmetic otherwise. */
     hasAnisotropyDirections?: boolean;
     /** Include independent coat normals only when a material uses that slot. */
@@ -29,4 +51,4 @@ export interface RayTraceShaderOptions {
     lightCapabilities?: number;
 }
 /** Generates the WebGPU megakernel path tracing compute shader. */
-export default function rayTraceCompute({ hasDisplacement, hasAnisotropyDirections, hasCoatNormals, hasAlpha, hasSceneAlpha, blasLayoutMask, spectral, sceneCapabilities, dynamicEnvironment, materialCapabilities, lightCapabilities }: RayTraceShaderOptions, sceneIntersections?: string, pathDiagnostic?: boolean, inputHooks?: RayTraceInputHooks): string;
+export default function rayTraceCompute(options: RayTraceShaderOptions, sceneIntersections?: string, pathDiagnostic?: boolean, inputHooks?: RayTraceInputHooks): string;