@meimu/mutracer 0.3.0 → 0.3.1

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

@@ -1,99 +1,99 @@
-export default /* wgsl */ `fn di(point: vec3f, height: f32, radius: f32) -> f32 {
-let fQ = length(point);
-if (fQ < 0.00001) {
+export default /* wgsl */ `fn dk(point: vec3f, height: f32, radius: f32) -> f32 {
+let gc = length(point);
+if (gc < 0.00001) {
 return -radius;
 }
 
-let iG = radius * point.y / fQ;
-let iq = -1.5 * height;
-var eq: f32;
-if (iG >= 0.0) {
-eq = radius;
+let jf = radius * point.y / gc;
+let iS = -1.5 * height;
+var ez: f32;
+if (jf >= 0.0) {
+ez = radius;
 }
-else if (iG < iq) {
-eq = -height * fQ / point.y;
+else if (jf < iS) {
+ez = -height * gc / point.y;
 }
 else {
-let cv = 1.0
-- iG * iG / (3.0 * iq * iq);
-eq = radius * cv;
+let cA = 1.0
+- jf * jf / (3.0 * iS * iS);
+ez = radius * cA;
 }
-return fQ - eq;
+return gc - ez;
 }
 
-fn eM(origin: vec3f, direction: vec3f) -> vec3f {
+fn eW(origin: vec3f, direction: vec3f) -> vec3f {
 if (!USE_GROUNDED_BACKGROUND) {
 return direction;
 }
 let params = rtUniform.groundedBackgroundParams;
-let bS = normalize(direction);
+let bT = normalize(direction);
 let center = vec3f(
 rtUniform.groundedBackgroundCenter.x,
 params.z + params.x,
 rtUniform.groundedBackgroundCenter.y
 );
-let bs = origin - center;
-let eE = dot(bs, bS);
-let bj = eE * eE
-- dot(bs, bs) + params.y * params.y;
+let bA = origin - center;
+let eN = dot(bA, bT);
+let bk = eN * eN
+- dot(bA, bA) + params.y * params.y;
 if (
-bj <= 0.0
-|| di(bs, params.x, params.y) > 0.0
+bk <= 0.0
+|| dk(bA, params.x, params.y) > 0.0
 ) {
 return direction;
 }
 
-var cw = -eE + sqrt(bj);
-if (cw <= 0.0) {
+var cB = -eN + sqrt(bk);
+if (cB <= 0.0) {
 return direction;
 }
 
-let oA = bs + bS * cw;
-if (oA.y >= 0.0) {
-return normalize(oA);
+let pw = bA + bT * cB;
+if (pw.y >= 0.0) {
+return normalize(pw);
 }
 
-if (bS.y < -0.00001 && params.y > 1.5 * params.x) {
-let hP = (-params.x - bs.y) / bS.y;
-let ot = bs + bS * hP;
-let oT = (2.0 / 3.0)
+if (bT.y < -0.00001 && params.y > 1.5 * params.x) {
+let iz = (-params.x - bA.y) / bT.y;
+let pm = bA + bT * iz;
+let qb = (2.0 / 3.0)
 * sqrt(params.y * params.y - 2.25 * params.x * params.x);
-if (hP > 0.0 && length(ot.xz) <= oT) {
-return normalize(ot);
+if (iz > 0.0 && length(pm.xz) <= qb) {
+return normalize(pm);
 }
 }
 
-var cI = 0.0;
+var cK = 0.0;
 for (var i = 0; i < 14; i++) {
-let fd = (cI + cw) * 0.5;
-let qq = bs + bS * fd;
-if (di(qq, params.x, params.y) > 0.0) {
-cw = fd;
+let fp = (cK + cB) * 0.5;
+let rD = bA + bT * fp;
+if (dk(rD, params.x, params.y) > 0.0) {
+cB = fp;
 }
 else {
-cI = fd;
+cK = fp;
 }
 }
-let hit = bs + bS * ((cI + cw) * 0.5);
+let hit = bA + bT * ((cK + cB) * 0.5);
 return normalize(hit);
 }
 
-fn ft(ray: Ray) -> vec4f {
+fn fI(ray: Ray) -> vec4f {
 var bg = vec4f(0.0);
 if (USE_BACKGROUND_MAP) {
-let d = eM(ray.o, ray.d);
+let d = eW(ray.o, ray.d);
 let t = rtUniform.backgroundMapTransform;
-let qS = vec3f(t.x * d.x - t.y * d.z, d.y, t.y * d.x + t.x * d.z);
+let sh = vec3f(t.x * d.x - t.y * d.z, d.y, t.y * d.x + t.x * d.z);
 let rotation = rtUniform.backgroundMapRotation;
-let gU = transpose(mat3x3f(rotation[0].xyz, rotation[1].xyz, rotation[2].xyz)) * qS;
-let aW = textureLinear(backgroundMap, eF(gU));
+let hs = transpose(mat3x3f(rotation[0].xyz, rotation[1].xyz, rotation[2].xyz)) * sh;
+let aW = textureLinear(backgroundMap, eP(hs));
 bg = vec4f(aW.rgb * t.z, aW.a);
 }
 else if (USE_BACKGROUND) {
 bg = rtUniform.backgroundColor;
 }
 else if (USE_ENVMAP) {
-bg = textureLinear(envMap, cT(ray.d));
+bg = textureLinear(envMap, cU(ray.d));
 }
 return bg;
 }

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

@@ -2,11 +2,11 @@
 // view is toward the preceding light vertex, outgoing toward the camera.
 // Reference: Veach 1997, thesis section 5.3 (mathematical formula, no copied code).
 export default /* wgsl */ `
-fn causticAdjoint(view:vec3f,vJ:vec3f,shading:vec3f,geometric:vec3f)->f32 {
-let iF=abs(dot(view,shading)*dot(vJ,geometric));
-let ah=abs(dot(view,geometric)*dot(vJ,shading));
+fn causticAdjoint(view:vec3f,xB:vec3f,shading:vec3f,geometric:vec3f)->f32 {
+let je=abs(dot(view,shading)*dot(xB,geometric));
+let ah=abs(dot(view,geometric)*dot(xB,shading));
 if(ah==0.0){return 0.0;}
-return iF/ah;
+return je/ah;
 }
 `;
 //# sourceMappingURL=causticAdjoint.wgsl.js.map

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

@@ -1,13 +1,13 @@
 // Float32 addition implemented with u32 compare/exchange works on baseline
 // WebGPU, without a fixed radiance quantum or the Q16.16 saturation ceiling.
 export default /* wgsl */ `
-fn kM(index:u32,value:f32) {
+fn lF(index:u32,value:f32) {
 if(!(value>0.0)||!(value<3.402823e38)){return;}
 var previous=atomicLoad(&splats[index]);
 loop {
 let sum=bitcast<f32>(previous)+value;
-let vN=bitcast<u32>(sum);
-let result=atomicCompareExchangeWeak(&splats[index],previous,vN);
+let xH=bitcast<u32>(sum);
+let result=atomicCompareExchangeWeak(&splats[index],previous,xH);
 if(result.exchanged){break;}
 previous=result.old_value;
 }

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

@@ -13,9 +13,9 @@ return isCausticSpecular(m) && m.transmissionWeight == 1.0 && m.causticRoughness
 fn isCausticR(m:OpenPbrResolvedMaterial)->bool{
 return isCausticSpecular(m)&&m.causticRoughness==0.0&&!m.causticNormalMapped&&m.alpha>=1.0;
 }
-fn causticHitOwned(path: Path, xd: bool, vl: bool) -> bool {
-let r1 = ${mnee} && xd && path.causticMneeReceiver && path.causticK == 1u && path.causticSingleT;
-let r2 = ${lightTracing} && vl && path.causticK > 0u && path.causticReceiverPrimary;
+fn causticHitOwned(path: Path, zf: bool, xc: bool) -> bool {
+let r1 = ${mnee} && zf && path.causticMneeReceiver && path.causticK == 1u && path.causticSingleT;
+let r2 = ${lightTracing} && xc && path.causticK > 0u && path.causticReceiverPrimary;
 let r3=${photonMapping}&&path.causticPhotonReceiver&&path.causticK>0u;
 return path.causticHasReceiver && (r1 || r2 || r3);
 }

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

@@ -11,12 +11,12 @@ const ROUGHNESS_MIN = 0.001;
 
 
 
-fn sO(position: vec3f, geometricNormal: vec3f, direction: vec3f) -> vec3f {
+fn un(position: vec3f, geometricNormal: vec3f, direction: vec3f) -> vec3f {
 let normal = select(-geometricNormal, geometricNormal, dot(geometricNormal, direction) >= 0.0);
-let rb = vec3i(256.0 * normal);
+let st = vec3i(256.0 * normal);
 let bits = bitcast<vec3i>(position);
-let ye = bitcast<vec3f>(bits + select(rb, -rb, position < vec3f(0.0)));
-return select(ye, position + normal / 65536.0, abs(position) < vec3f(1.0 / 32.0));
+let Aa = bitcast<vec3f>(bits + select(st, -st, position < vec3f(0.0)));
+return select(Aa, position + normal / 65536.0, abs(position) < vec3f(1.0 / 32.0));
 }
 
 `;

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

@@ -12,39 +12,39 @@ fn textureLinear(tex: texture_2d<f32>, _uv: vec2f) -> vec4f {
 let size = vec2f(textureDimensions(tex, 0));
 
 let uv2f = _uv * size - vec2f(0.5);
-let yj = floor(uv2f);
+let Ah = floor(uv2f);
 let f = fract(uv2f);
-let yi = vec2i(yj);
+let Ag = vec2i(Ah);
 let maximum = vec2i(size) - vec2i(1);
 
 
-let s1 = textureLoad(tex, clamp(yi + vec2i(0, 0), vec2i(0), maximum), 0);
-let s2 = textureLoad(tex, clamp(yi + vec2i(1, 0), vec2i(0), maximum), 0);
-let s3 = textureLoad(tex, clamp(yi + vec2i(0, 1), vec2i(0), maximum), 0);
-let s4 = textureLoad(tex, clamp(yi + vec2i(1, 1), vec2i(0), maximum), 0);
+let s1 = textureLoad(tex, clamp(Ag + vec2i(0, 0), vec2i(0), maximum), 0);
+let s2 = textureLoad(tex, clamp(Ag + vec2i(1, 0), vec2i(0), maximum), 0);
+let s3 = textureLoad(tex, clamp(Ag + vec2i(0, 1), vec2i(0), maximum), 0);
+let s4 = textureLoad(tex, clamp(Ag + vec2i(1, 1), vec2i(0), maximum), 0);
 
 return mix(mix(s1, s2, f.x), mix(s3, s4, f.x), f.y);
 
 }
 
-fn eF(gh: vec3f) -> vec2f {
-var phi = atan2(-gh.z, -gh.x);
+fn eP(gz: vec3f) -> vec2f {
+var phi = atan2(-gz.z, -gz.x);
 if (phi < 0.0) {
 phi += TWOPI;
 }
-let theta = acos(clamp(gh.y, -1.0, 1.0));
+let theta = acos(clamp(gz.y, -1.0, 1.0));
 return vec2f(phi * 0.5 * INVPI, theta * INVPI);
 }
 
-fn jS() -> mat3x3f {
+fn ky() -> mat3x3f {
 return mat3x3f(rtUniform.environmentRotation[0].xyz, rtUniform.environmentRotation[1].xyz, rtUniform.environmentRotation[2].xyz);
 }
 
-fn cT(nD: vec3f) -> vec2f {
-return eF(transpose(jS()) * nD);
+fn cU(oA: vec3f) -> vec2f {
+return eP(transpose(ky()) * oA);
 }
 
-fn rv(u: f32, vOffset: ptr<function, i32>, pdf: ptr<function, vec2f>) -> f32 {
+fn sN(u: f32, vOffset: ptr<function, i32>, pdf: ptr<function, vec2f>) -> f32 {
 let size = vec2i(textureDimensions(envMap, 0));
 
 var left = 0;
@@ -70,7 +70,7 @@ let s1 = textureLoad(envMapDistribution, vec2i(0, *vOffset + 1), 0).xy;
 return (f32(*vOffset) +  (u - s0.x) / (s1.x - s0.x)) / f32(size.y);
 }
 
-fn ru(u: f32, vOffset: i32, pdf: ptr<function, vec2f>) -> f32 {
+fn sM(u: f32, vOffset: i32, pdf: ptr<function, vec2f>) -> f32 {
 let size = vec2i(textureDimensions(envMap, 0));
 
 var left = 0;
@@ -84,16 +84,16 @@ left = mid + 1;
 right = mid;
 }
 }
-let pw = left - 1;
+let qG = left - 1;
 
 
 
-let s0 = textureLoad(envMapDistribution, vec2i(1 + pw, vOffset), 0).xy;
-let s1 = textureLoad(envMapDistribution, vec2i(1 + pw + 1, vOffset), 0).xy;
+let s0 = textureLoad(envMapDistribution, vec2i(1 + qG, vOffset), 0).xy;
+let s1 = textureLoad(envMapDistribution, vec2i(1 + qG + 1, vOffset), 0).xy;
 
 (*pdf).x = s0.y;
 
-return (f32(pw) + (u - s0.x) / (s1.x - s0.x)) / f32(size.x);
+return (f32(qG) + (u - s0.x) / (s1.x - s0.x)) / f32(size.x);
 }
 
 
@@ -105,36 +105,36 @@ return partialPdf.x * partialPdf.y * INVPI2 / (2.0 * sinTheta);
 }
 
 
-fn pn(random: vec2f, uv: ptr<function, vec2f>, pdf: ptr<function, f32>) -> vec3f {
+fn qx(random: vec2f, uv: ptr<function, vec2f>, pdf: ptr<function, f32>) -> vec3f {
 var partialPdf: vec2f;
 var vOffset: i32;
 
-(*uv).y = rv(random.x, &vOffset, &partialPdf);
-(*uv).x = ru(random.y, vOffset, &partialPdf);
+(*uv).y = sN(random.x, &vOffset, &partialPdf);
+(*uv).x = sM(random.y, vOffset, &partialPdf);
 
 let phi = (*uv).x * TWOPI;
 let theta = (*uv).y * PI;
-let ct = cos(theta);
+let cv = cos(theta);
 let sinTheta = sin(theta);
-let vZ = cos(phi);
-let wr = sin(phi);
+let xV = cos(phi);
+let yo = sin(phi);
 
-let dir = vec3f(-sinTheta * vZ, ct, -sinTheta * wr);
+let dir = vec3f(-sinTheta * xV, cv, -sinTheta * yo);
 
 *pdf = envMapSolidAnglePdf(partialPdf, (*uv).y);
 
-return jS() * dir;
+return ky() * dir;
 }
 
 fn envMapPdf(_uv: vec2f) -> f32 {
 let size = vec2f(textureDimensions(envMap, 0));
 
-let yn = clamp(vec2i(_uv * size), vec2i(0), vec2i(size) - vec2i(1));
+let Al = clamp(vec2i(_uv * size), vec2i(0), vec2i(size) - vec2i(1));
 
-let ue = textureLoad(envMapDistribution, vec2i(1 + yn.x, yn.y), 0).y;
-let uf = textureLoad(envMapDistribution, vec2i(0, yn.y), 0).y;
+let vO = textureLoad(envMapDistribution, vec2i(1 + Al.x, Al.y), 0).y;
+let vP = textureLoad(envMapDistribution, vec2i(0, Al.y), 0).y;
 
-return envMapSolidAnglePdf(vec2f(ue, uf), _uv.y);
+return envMapSolidAnglePdf(vec2f(vO, vP), _uv.y);
 }
 
 

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

@@ -1,5 +1,7 @@
 export declare function createSceneHitQueryWgsl(hasAnisotropyDirections?: boolean): string;
-export declare function createSceneIntersectionsWgsl({ hasDisplacement, hasAnisotropyDirections, hasCoatNormals, blasLayoutMask, closestName, shadowName, bevelName, closestHitHook }: {
+export declare function createSceneIntersectionsWgsl({ perInstanceBounds, compactVertices, hasDisplacement, hasAnisotropyDirections, hasCoatNormals, blasLayoutMask, closestName, shadowName, bevelName, closestHitHook }: {
+    perInstanceBounds?: boolean;
+    compactVertices?: boolean;
     hasDisplacement: boolean;
     hasAnisotropyDirections?: boolean;
     hasCoatNormals?: boolean;
@@ -9,10 +11,12 @@ export declare function createSceneIntersectionsWgsl({ hasDisplacement, hasAniso
     bevelName?: string;
     closestHitHook?: string;
 }): string;
-export default function getIntersectCode({ hasDisplacement, hasAnisotropyDirections, hasCoatNormals, blasLayoutMask, sceneIntersections }: {
+export default function getIntersectCode({ perInstanceBounds, compactVertices, hasDisplacement, hasAnisotropyDirections, hasCoatNormals, blasLayoutMask, sceneIntersections }: {
+    perInstanceBounds?: boolean;
     hasDisplacement: boolean;
     hasAnisotropyDirections?: boolean;
     hasCoatNormals?: boolean;
     blasLayoutMask?: number;
     sceneIntersections?: string;
+    compactVertices?: boolean;
 }): string;