@meimu/mutracer 0.3.0 → 0.3.1

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

@@ -50,28 +50,28 @@ padding2: u32,
 @group(0)@binding(1)var<storage,read_write>grid:array<Bucket>;
 @group(0)@binding(2)var<uniform>parameters:Parameters;
 @group(0)@binding(4)var headers:texture_storage_2d<r32uint,write>;
-fn xu(yp:vec3i)->u32 {
-let p=bitcast<vec3u>(yp);
+fn zv(sF:vec3i)->u32 {
+let p=bitcast<vec3u>(sF);
 return ((p.x*73856093u)^(p.y*19349663u)^(p.z*83492791u))&(parameters.buckets-1u);
 }
-fn tM(p:vec3f,layer:u32)->u32 {
+fn vq(p:vec3f,layer:u32)->u32 {
 let radius=select(parameters.radius,parameters.fineRadius,layer==1u);
-let lv=select(radius,2.0*radius,layer==1u);
-return xu(vec3i(floor(p/lv)));
+let mo=select(radius,2.0*radius,layer==1u);
+return zv(vec3i(floor(p/mo)));
 }
-fn os(layer:u32)->u32 {
+fn pl(layer:u32)->u32 {
 return layer*(parameters.buckets+parameters.buckets/256u);
 }
-fn fm(i:u32,value:u32) {
+fn fE(i:u32,value:u32) {
 let width=textureDimensions(headers).x;
 textureStore(headers,vec2i(vec2u(i%width,i/width)),vec4u(value));
 }
-fn pi(i:u32)->vec4u {
+fn qs(i:u32)->vec4u {
 let width=textureDimensions(photons).x;
 return textureLoad(photons,vec2i(vec2u(i%width,i/width)),0);
 }
-fn qv(i:u32)->vec3f {
-return bitcast<vec3f>(pi(i).xyz);
+fn rI(i:u32)->vec3f {
+return bitcast<vec3f>(qs(i).xyz);
 }
 @compute @workgroup_size(64)
 fn count(@builtin(global_invocation_id)id:vec3u) {
@@ -79,16 +79,16 @@ if(id.x+id.y*4194240u>=parameters.count) {
 return;
 }
 let index=id.x+id.y*4194240u;
-if(pi(index).w==0u) {
+if(qs(index).w==0u) {
 return;
 }
 for(var layer=0u;layer<2u;layer++) {
-atomicAdd(&grid[os(layer)+tM(qv(index),layer)].count,1u);
+atomicAdd(&grid[pl(layer)+vq(rI(index),layer)].count,1u);
 }
 }
 
 var<workgroup> scan:array<u32,256>;
-fn iU(local:u32,value:u32)->u32 {
+fn jA(local:u32,value:u32)->u32 {
 scan[local]=value;
 workgroupBarrier();
 for(var stride=1u;stride<256u;stride*=2u) {
@@ -104,80 +104,80 @@ return scan[local];
 }
 @compute @workgroup_size(256)
 fn scanBlocks(@builtin(local_invocation_index)local:u32,@builtin(workgroup_id)group:vec3u) {
-let index=os(group.y)+group.x*256u+local;
+let index=pl(group.y)+group.x*256u+local;
 let count=atomicLoad(&grid[index].count);
-let prefix=iU(local,count);
+let prefix=jA(local,count);
 grid[index].offset=prefix-count;
 if(local==255u) {
-atomicStore(&grid[os(group.y)+parameters.buckets+group.x].count,prefix);
+atomicStore(&grid[pl(group.y)+parameters.buckets+group.x].count,prefix);
 }
 }
 @compute @workgroup_size(256)
 fn scanSums(@builtin(local_invocation_index)local:u32,@builtin(workgroup_id)group:vec3u) {
 let blocks=parameters.buckets/256u;
-let xo=(blocks+255u)/256u;
-let first=local*xo;
-let start=os(group.y)+parameters.buckets;
+let chunk=(blocks+255u)/256u;
+let first=local*chunk;
+let start=pl(group.y)+parameters.buckets;
 var count=0u;
-for(var i=first;i<min(first+xo,blocks);i++) {
+for(var i=first;i<min(first+chunk,blocks);i++) {
 count+=atomicLoad(&grid[start+i].count);
 }
-let prefix=iU(local,count);
+let prefix=jA(local,count);
 var offset=prefix-count;
-for(var i=first;i<min(first+xo,blocks);i++) {
+for(var i=first;i<min(first+chunk,blocks);i++) {
 grid[start+i].offset=offset;
 offset+=atomicLoad(&grid[start+i].count);
 }
 if(local==255u&&group.y==0u) {
-fm(0u,bitcast<u32>(parameters.radius));
-fm(1u,prefix);
-fm(2u,bitcast<u32>(parameters.screenPixels));
-fm(3u,bitcast<u32>(parameters.skipQuery));
-fm(4u,parameters.count);
-fm(5u,parameters.buckets);
-fm(6u,bitcast<u32>(parameters.fineRadius));
-fm(7u,parameters.experiments);
+fE(0u,bitcast<u32>(parameters.radius));
+fE(1u,prefix);
+fE(2u,bitcast<u32>(parameters.screenPixels));
+fE(3u,bitcast<u32>(parameters.skipQuery));
+fE(4u,parameters.count);
+fE(5u,parameters.buckets);
+fE(6u,bitcast<u32>(parameters.fineRadius));
+fE(7u,parameters.experiments);
 }
 }
 @compute @workgroup_size(64)
 fn scatter(@builtin(global_invocation_id)id:vec3u) {
-let eA=id.x+id.y*4194240u;
+let eJ=id.x+id.y*4194240u;
 for(var layer=0u;layer<2u;layer++) {
-let start=os(layer);
-if(eA<parameters.buckets) {
-let offset=grid[start+eA].offset+grid[start+parameters.buckets+eA/256u].offset;
-fm(8u+layer*parameters.buckets*2u+eA*2u,offset);
-fm(9u+layer*parameters.buckets*2u+eA*2u,atomicLoad(&grid[start+eA].count));
+let start=pl(layer);
+if(eJ<parameters.buckets) {
+let offset=grid[start+eJ].offset+grid[start+parameters.buckets+eJ/256u].offset;
+fE(8u+layer*parameters.buckets*2u+eJ*2u,offset);
+fE(9u+layer*parameters.buckets*2u+eJ*2u,atomicLoad(&grid[start+eJ].count));
 }
-if(eA<parameters.count&&pi(eA).w!=0u) {
-let su=tM(qv(eA),layer);
-let index=grid[start+su].offset+grid[start+parameters.buckets+su/256u].offset+atomicAdd(&grid[start+su].cursor,1u);
-fm(8u+parameters.buckets*4u+layer*parameters.count+index,eA);
+if(eJ<parameters.count&&qs(eJ).w!=0u) {
+let tU=vq(rI(eJ),layer);
+let index=grid[start+tU].offset+grid[start+parameters.buckets+tU/256u].offset+atomicAdd(&grid[start+tU].cursor,1u);
+fE(8u+parameters.buckets*4u+layer*parameters.count+index,eJ);
 }
 }
 }
 `;
 /** Packed photon payload: position f32 x3, RGBE8 flux, two octahedral directions. */
 export const photonPackingWgsl = /* wgsl */ `
-fn rd(v:vec2f)->vec2f {
+fn sv(v:vec2f)->vec2f {
 return select(vec2f(-1.0),vec2f(1.0),v>=vec2f(0.0));
 }
-fn pN(n:vec3f)->vec2f {
+fn qR(n:vec3f)->vec2f {
 let p=n/(abs(n.x)+abs(n.y)+abs(n.z));
-let uv=select(p.xy,(vec2f(1.0)-abs(p.yx))*rd(p.xy),p.z<0.0);
+let uv=select(p.xy,(vec2f(1.0)-abs(p.yx))*sv(p.xy),p.z<0.0);
 return uv*.5+.5;
 }
-fn pM(uv:vec2f)->vec3f {
+fn qQ(uv:vec2f)->vec3f {
 let p=uv*2.0-1.0;
 var n=vec3f(p,1.0-abs(p.x)-abs(p.y));
 if(n.z<0.0) {
-n=vec3f((vec2f(1.0)-abs(n.yx))*rd(n.xy),n.z);
+n=vec3f((vec2f(1.0)-abs(n.yx))*sv(n.xy),n.z);
 }
 return normalize(n);
 }
 
 
-fn sS(value:vec3f)->u32 {
+fn us(value:vec3f)->u32 {
 let peak=max(max(value.x,value.y),value.z);
 if(!(peak>0.0)) {
 return 0u;
@@ -204,8 +204,8 @@ fn photonIndexWord(i:u32)->u32 {
 let width=textureDimensions(photonMapGrid).x;
 return textureLoad(photonMapGrid,vec2i(vec2u(i%width,i/width)),0).x;
 }
-fn wp(yp:vec3i)->u32 {
-let p=bitcast<vec3u>(yp);
+fn ym(sF:vec3i)->u32 {
+let p=bitcast<vec3u>(sF);
 return ((p.x*73856093u)^(p.y*19349663u)^(p.z*83492791u))&(photonIndexWord(5u)-1u);
 }
 
@@ -220,77 +220,77 @@ let offset=b.xyz/b.w;
 let eye=cameraUniform.viewInv[3].xyz;
 let forward=normalize(cameraUniform.viewInv[2].xyz);
 let depth=abs(dot(si.position-eye,forward));
-let xe=max(abs(dot(origin-eye,forward)),1e-8);
+let zg=max(abs(dot(origin-eye,forward)),1e-8);
 let perspective=abs(inverse[2].w)>1e-8;
-let footprint=length(offset-origin)*select(1.0,depth/xe,perspective);
+let footprint=length(offset-origin)*select(1.0,depth/zg,perspective);
 let cosine=abs(dot(si.faceNormal,normalize(si.position-eye)));
 return max(1e-8,footprint/sqrt(max(.0625,cosine)));
 }
-fn rI(si:SurfaceInteraction,prepared:OpenPbrPreparedBsdf,vb:bool,visible:bool)->vec3f {
+fn sY(si:SurfaceInteraction,prepared:OpenPbrPreparedBsdf,wP:bool,visible:bool)->vec3f {
 if(samplingBounce>CAUSTIC_PHOTON_MAX_DEPTH||isCausticSpecular(prepared.material)||prepared.material.materialType==SHADOW_CATCHER) {
 return vec3f(0.0);
 }
-if(CAUSTIC_LIGHT_TRACING&&vb) {
+if(CAUSTIC_LIGHT_TRACING&&wP) {
 return vec3f(0.0);
 }
-let mn=bitcast<f32>(photonIndexWord(0u));
+let ni=bitcast<f32>(photonIndexWord(0u));
 let screenPixels=bitcast<f32>(photonIndexWord(2u));
-if(!(mn>0.0)||bitcast<f32>(photonIndexWord(3u))==1.0||(bitcast<f32>(photonIndexWord(3u))==2.0&&visible)) {
+if(!(ni>0.0)||bitcast<f32>(photonIndexWord(3u))==1.0||(bitcast<f32>(photonIndexWord(3u))==2.0&&visible)) {
 return vec3f(0.0);
 }
-var radius=mn;
+var radius=ni;
 let experiments=photonIndexWord(7u);
-let wa=f32(experiments>>8u);
-let tf=select(wa,screenPixels,visible);
-if(tf>0.0) {
-radius=min(radius,photonPixelFootprint(si)*tf);
+let xW=f32(experiments>>8u);
+let uI=select(xW,screenPixels,visible);
+if(uI>0.0) {
+radius=min(radius,photonPixelFootprint(si)*uI);
 }
 let layer=select(0u,1u,visible&&screenPixels>0.0);
-let lv=select(mn,2.0*bitcast<f32>(photonIndexWord(6u)),layer==1u);
-let sG=vec3i(floor((si.position-vec3f(radius))/lv));
-let tS=vec3i(floor((si.position+vec3f(radius))/lv));
+let mo=select(ni,2.0*bitcast<f32>(photonIndexWord(6u)),layer==1u);
+let uf=vec3i(floor((si.position-vec3f(radius))/mo));
+let vB=vec3i(floor((si.position+vec3f(radius))/mo));
 let buckets=photonIndexWord(5u);
-let tb=8u+layer*buckets*2u;
+let uE=8u+layer*buckets*2u;
 let indexStart=8u+buckets*4u+layer*photonIndexWord(4u);
 let emitted=f32(photonIndexWord(4u));
 var sum=vec3f(0.0);
-for(var z=sG.z;z<=tS.z;z++) {
-for(var y=sG.y;y<=tS.y;y++) {
-for(var x=sG.x;x<=tS.x;x++) {
-let sU=vec3i(x,y,z);
+for(var z=uf.z;z<=vB.z;z++) {
+for(var y=uf.y;y<=vB.y;y++) {
+for(var x=uf.x;x<=vB.x;x++) {
+let uw=vec3i(x,y,z);
 
 
-let uP=vec3f(sU)*lv;
-let padding=max(vec3f(lv*1e-5),abs(uP)*1e-6);
-let xV=clamp(si.position,uP-padding,uP+vec3f(lv)+padding);
-if(distance(xV,si.position)>=radius) { continue; }
-let su=wp(sU);
-let offset=photonIndexWord(tb+su*2u);
-let count=photonIndexWord(tb+1u+su*2u);
+let wy=vec3f(uw)*mo;
+let padding=max(vec3f(mo*1e-5),abs(wy)*1e-6);
+let pQ=clamp(si.position,wy-padding,wy+vec3f(mo)+padding);
+if(distance(pQ,si.position)>=radius) { continue; }
+let tU=ym(uw);
+let offset=photonIndexWord(uE+tU*2u);
+let count=photonIndexWord(uE+1u+tU*2u);
 for(var i=offset;i<offset+count;i++) {
 let index=photonIndexWord(indexStart+i);
 let record=photonLoad(index);
 let position=bitcast<vec3f>(record.xyz);
 
-if(any(vec3i(floor(position/lv))!=sU)||distance(position,si.position)>=radius) {
+if(any(vec3i(floor(position/mo))!=uw)||distance(position,si.position)>=radius) {
 continue;
 }
-var jY=radius;
+var kE=radius;
 if((experiments&1u)!=0u) {
 let scale=bitcast<f32>(photonIndexWord(8u+buckets*4u+u32(emitted)*3u+index));
-jY=min(radius,mn*scale);
-if(!(jY>0.0)||distance(position,si.position)>=jY) { continue; }
+kE=min(radius,ni*scale);
+if(!(kE>0.0)||distance(position,si.position)>=kE) { continue; }
 }
 let directions=photonIndexWord(8u+buckets*4u+u32(emitted)*2u+index);
-let normal=pM(vec2f(f32(directions&255u)/255.0,f32((directions>>8u)&127u)/127.0));
+let normal=qQ(vec2f(f32(directions&255u)/255.0,f32((directions>>8u)&127u)/127.0));
 if(dot(normal,si.faceNormal)<0.9) {
 continue;
 }
 if(CAUSTIC_MNEE&&samplingBounce<=CAUSTIC_MNEE_MAX_DEPTH&&(directions&32768u)!=0u&&prepared.material.baseWeight*(1.0-prepared.material.baseMetalness)*(1.0-prepared.material.transmissionWeight)>0.0&&prepared.material.subsurfaceWeight==0.0) {
 continue;
 }
-let hQ=pM(vec2f(f32((directions>>16u)&255u),f32(directions>>24u))/255.0);
-let cosine=abs(dot(si.faceNormal,hQ));
+let iA=qQ(vec2f(f32((directions>>16u)&255u),f32(directions>>24u))/255.0);
+let cosine=abs(dot(si.faceNormal,iA));
 if(cosine<=0.0) {
 continue;
 }
@@ -299,8 +299,8 @@ if(SPECTRAL) {
 flux=sampling_spectral_rgb_filter(flux,si.spectralChannel);
 }
 var pdf:f32;
-let response=openpbr_eval_prepared(prepared,hQ,&pdf);
-sum+=response*flux/cosine*(radius*radius)/(jY*jY);
+let response=openpbr_eval_prepared(prepared,iA,&pdf);
+sum+=response*flux/cosine*(radius*radius)/(kE*kE);
 }
 }
 }
@@ -317,15 +317,15 @@ export function photonDirectQuerySource(enabled = false) {
     if (!enabled)
         return photonQueryWgsl;
     return photonQueryWgsl
-        .replace('var sum=vec3f(0.0);', `let rL=ak(aC,rtUniform.sequenceSeed^0x91e10da5u);
-let vT=vec2u(cB(rL^0x68bc21ebu),cB(rL^0x967a889bu));
-let tj=aI+vT;
-let vS=(tj.x&1u)|((tj.y&1u)<<1u);
+        .replace('var sum=vec3f(0.0);', `let tb=ak(aC,rtUniform.sequenceSeed^0x91e10da5u);
+let xO=vec2u(cD(tb^0x68bc21ebu),cD(tb^0x967a889bu));
+let uL=aJ+xO;
+let xN=(uL.x&1u)|((uL.y&1u)<<1u);
 var sum=vec3f(0.0);`)
-        .replace('let record=photonLoad(index);', `if(vb&&(ak(index,rL^0x02e5be93u)&3u)!=vS) { continue; }
+        .replace('let record=photonLoad(index);', `if(wP&&(ak(index,tb^0x02e5be93u)&3u)!=xN) { continue; }
 let record=photonLoad(index);`)
         .replace('var flux=photonDecodeFlux(record.w)/emitted;', `var flux=photonDecodeFlux(record.w)/emitted;
-if(vb) { flux*=4.0; }`);
+if(wP) { flux*=4.0; }`);
 }
 /** Evidence-only per-query counters; no extra bindings or public render options. */
 export function photonQuerySource(debugGroup = -1, directSubset = false) {

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 bj(r: f32, mu: f32, radius: f32) -> f32 { return (radius - r) * (radius + r) + r * r * mu * mu; }
-fn mV(r: f32, mu: f32) -> bool { return mu < 0.0 && bj(r, mu, R_GROUND) >= 0.0; }
-fn kT(r: f32, mu: f32) -> f32 { return max(-r * mu - sqrt(max(bj(r, mu, R_GROUND), 0.0)), 0.0); }
-fn iS(r: f32, mu: f32) -> f32 { return max(-r * mu + sqrt(max(bj(r, mu, R_TOP), 0.0)), 0.0); }
-fn oo(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 mB(x: f32) -> f32 { return x * x * (R_TOP - R_GROUND); }
-fn hy(h: f32) -> f32 { return sqrt(clamp(h / (R_TOP - R_GROUND), 0.0, 1.0)); }
-fn eR(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 fv(r: f32, mu: f32) -> vec3f {
-return eR(transmittanceTable, vec2f((clamp(mu, -1.0, 1.0) + 1.0) * 0.5 * f32(T_SIZE.x - 1u), hy(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 mI(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 yk { radiance: vec3f, throughput: vec3f }
-fn vG(origin: vec3f, dir: vec3f, steps: u32, full: bool, uD: vec3f) -> yk {
+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 = mV(r, mu);
-var len = iS(r, mu);
-if (ground) { len = kT(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 ja = 1.0 / (4.0 * PI);
-var sh = ja;
-if (full) { ja = 3.0 / (16.0 * PI) * (1.0 + nu * nu); sh = mI(nu); }
-var result = yk(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 = oo(pr);
+let d = pj(pr);
 let e = extinction(d);
-let vk = fv(pr, dot(p, params.sun.xyz) / pr);
-let np = RAYLEIGH * d.x;
-let nl = 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 = eR(multipleTable, vec2f(hy(pr - R_GROUND) * f32(MS_ALTITUDES - 1u), 0.0)); }
-let source = vk * (np * ja + nl * sh) + (np + nl) * ms;
+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 * (np + nl) * weight;
+result.throughput += view * (om + ol) * weight;
 view *= segment;
 }
 if (ground) {
 let p = origin + dir * len;
 let pr = length(p);
-let tD = dot(p, params.sun.xyz) / pr;
-let irradiance = fv(pr, tD) * max(tD, 0.0) + uD;
+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 qd(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 hL(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 + mB(f32(id.y) / f32(T_SIZE.y - 1u));
-if (mV(r, mu)) { textureStore(output, vec2i(id.xy), vec4f(0.0, 0.0, 0.0, 1.0)); return; }
-let len = iS(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(oo(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 + mB(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 qC = 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 = vG(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;
-qC += result.throughput / 64.0;
+rQ += result.throughput / 64.0;
 }
-textureStore(output, vec2i(id.xy), vec4f(second / (1.0 - qC), 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 = qd(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 = vG(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 += eR(skyTable, vec2f(phi / PI * f32(SV_SIZE.x - 1u), hL(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 vk = fv(R_GROUND + CAMERA_ALTITUDE, params.sun.y);
-let xE = vec3f(0.2126, 0.7152, 0.0722);
-let horizontal = dot(sky, xE) + dot(vk, xE) * 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(vk, scale));
+textureStore(output, vec2i(id.xy), vec4f(wZ, scale));
 }
-fn gU(cR: vec2f) -> vec3f {
-let theta = cR.y / params.size.y * PI;
-let phi = cR.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 cR = vec2f(id.xy) + 0.5;
-let dir = gU(cR);
-let tg = abs(atan2(dir.z, dir.x) - params.sun.w);
-let wO = tg - floor(tg / (2.0 * PI)) * (2.0 * PI);
-let dU = min(wO, 2.0 * PI - wO);
+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 = eR(skyTable, vec2f(dU / PI * f32(SV_SIZE.x - 1u), hL(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 rM = PI / params.size.y;
-if (acos(clamp(dot(dir, params.sunWorld.xyz), -1.0, 1.0)) < radius + 3.0 * rM / 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 = gU(cR - 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 rK = 2.0 * PI * (1.0 - cos(radius));
-radiance += coverage / 36.0 / (rK * (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,21 @@ 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;