@meimu/mutracer 0.1.4 → 0.1.5

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

@@ -94,20 +94,20 @@ bS: ptr<function, f32>
 *bS = -INF;
 
 let wd = maxDimension(abs(iO));
-let gP = mv(iO, wd);
+let gQ = mu(iO, wd);
 var tt: f32;
 
-tt = fL(
+tt = fM(
 pP, iO,
-fA(pC, pB, pA), wd, gP, INF
+fB(pC, pB, pA), wd, gQ, INF
 ).t;
 if (tt > 0.0) {
 *bT = min(*bT, tt);
 *bS = max(*bS, tt);
 }
-tt = fL(
+tt = fM(
 pP, iO,
-fA(pD, pE, pF), wd, gP, INF
+fB(pD, pE, pF), wd, gQ, INF
 ).t;
 if (tt > 0.0) {
 *bT = min(*bT, tt);
@@ -145,7 +145,7 @@ export default /* wgsl */ `
 
 ${displacementCommon}
 
-fn lQ(p: vec3f, p0: vec3f, p1: vec3f, p2: vec3f) -> vec3f {
+fn lP(p: vec3f, p0: vec3f, p1: vec3f, p2: vec3f) -> vec3f {
 let v0 = p1 - p0;
 let v1 = p2 - p0;
 let v2 = p - p0;
@@ -265,7 +265,7 @@ var step = 0;
 
 while (true) {
 
-let b = lQ(s, c0, c1, c2);
+let b = lP(s, c0, c1, c2);
 
 tF = _pA * b.x + _pB * b.y + _pC * b.z;
 
@@ -274,7 +274,7 @@ tS = distance(tF, s);
 var uv: vec2f;
 if (uvProjection > 0) {
 let n = normalize(_nA * b.x + _nB * b.y + _nC * b.z);
-uv = gH(uvProjection, tF - (_nA * b.x + _nB * b.y + _nC * b.z) * uJ, n) * uvScale;
+uv = gI(uvProjection, tF - (_nA * b.x + _nB * b.y + _nC * b.z) * uJ, n) * uvScale;
 }
 else {
 uv = vG * b.x + vH * b.y + vI * b.z;
@@ -309,7 +309,7 @@ let dtt = dt * (abs(qZ) / (abs(pY) + abs(qZ) + EPS));
 t = t - dtt;
 
 let wO = qr + qM * t;
-let b = lQ(wO, c0, c1, c2);
+let b = lP(wO, c0, c1, c2);
 
 let N = normalize(_nA * b.x + _nB * b.y + _nC * b.z);
 
@@ -325,9 +325,9 @@ if (uvProjection > 0) {
 let NA = normalize(_nA * b.x + _nB * b.y + _nC * b.z);
 let NB = normalize(_nA * (b.x + dbx) + _nB * b.y + _nC * (b.z - dbx));
 let NC = normalize(_nA * b.x + _nB * (b.y + dby) + _nC * (b.z - dby));  
-wg = gH(uvProjection, p_a - (_nA * b.x + _nB * b.y + _nC * b.z) * uJ, NA) * uvScale;
-wh = gH(uvProjection, p_b - (_nA * (b.x + dbx) + _nB * b.y + _nC * (b.z - dbx)) * uJ, NB) * uvScale;
-wi = gH(uvProjection, p_c - (_nA * b.x + _nB * (b.y + dby) + _nC * (b.z - dby)) * uJ, NC) * uvScale;
+wg = gI(uvProjection, p_a - (_nA * b.x + _nB * b.y + _nC * b.z) * uJ, NA) * uvScale;
+wh = gI(uvProjection, p_b - (_nA * (b.x + dbx) + _nB * b.y + _nC * (b.z - dbx)) * uJ, NB) * uvScale;
+wi = gI(uvProjection, p_c - (_nA * b.x + _nB * (b.y + dby) + _nC * (b.z - dby)) * uJ, NC) * uvScale;
 }
 else {
 wg = vG * b.x + vH * b.y + vI * b.z;

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

@@ -282,11 +282,11 @@ return packed[ls % 4];
 
 fn kR(dV: i32, uv: vec2f) -> f32 {
 if (dV < 0) { return 1.0; }
-let fP = fract(uv) * 128.0 - vec2f(0.5);
-let x0 = i32(floor(fP.x));
-let y0 = i32(floor(fP.y));
-let fx = fract(fP.x);
-let fy = fract(fP.y);
+let fQ = fract(uv) * 128.0 - vec2f(0.5);
+let x0 = i32(floor(fQ.x));
+let y0 = i32(floor(fQ.y));
+let fx = fract(fQ.x);
+let fy = fract(fQ.y);
 let xa = select(x0, 127, x0 < 0);
 let xb = select(x0 + 1, 0, x0 >= 127);
 let ya = select(y0, 127, y0 < 0);

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

@@ -1,7 +1,7 @@
 import { LIGHT_CHOICE_ANALYTIC, LIGHT_CHOICE_EMISSIVE_TRIANGLE, LIGHT_CHOICE_ENVIRONMENT } from '../../lightSampling.js';
 export default /*wgsl */ `
-fn eM(light: Light, fq: vec3f, iZ: vec2f, lightSample: ptr<function, LightSampleRec>) {
-let iw = light.position - fq;
+fn eM(light: Light, ft: vec3f, iZ: vec2f, lightSample: ptr<function, LightSampleRec>) {
+let iw = light.position - ft;
 let aj = length(iw);
 if (light.radiusOrSpread <= 0.0) {
 
@@ -27,13 +27,13 @@ return;
 }
 let radius = max(light.radiusOrSpread, 1e-6);
 (*lightSample).isDelta = false;
-var gJ: vec3f;
+var gK: vec3f;
 
 if (aj <= radius) {
 let z = 1.0 - 2.0 * iZ.x;
 let fl = sqrt(max(0.0, 1.0 - z * z));
 let br = TWOPI * iZ.y;
-gJ = vec3f(
+gK = vec3f(
 fl * cos(br),
 fl * sin(br),
 z
@@ -53,7 +53,7 @@ let br = TWOPI * iZ.y;
 var tangent: vec3f;
 var bitangent: vec3f;
 aL(sS, &tangent, &bitangent);
-gJ = sS * cc
+gK = sS * cc
 + tangent * (sinTheta * cos(br))
 + bitangent * (sinTheta * sin(br));
 (*lightSample).pdf = 1.0 / max(
@@ -62,15 +62,15 @@ TWOPI * (1.0 - cosThetaMax),
 );
 }
 
-let iz = dot(gJ, iw);
+let iz = dot(gK, iw);
 let qc = dot(iw, iw);
 let ej = iz * iz
 - qc + radius * radius;
 let cN = iz - sqrt(max(0.0, ej));
 let cC = iz + sqrt(max(0.0, ej));
 (*lightSample).dist = select(cC, cN, cN > 1e-6);
-(*lightSample).direction = gJ;
-let sd = fq + gJ * (*lightSample).dist;
+(*lightSample).direction = gK;
+let sd = ft + gK * (*lightSample).dist;
 (*lightSample).normal = normalize(sd - light.position);
 (*lightSample).emission = light.emission;
 }
@@ -105,8 +105,8 @@ let lowerLeft = light.position - 0.5 * (light.u + light.v);
 let spread = clamp(light.radiusOrSpread, 0.0, 1.0);
 
 if (spread <= 0.001) {
-let gf = dot(normal, shadingPoint - light.position);
-let surfacePoint = shadingPoint - normal * gf;
+let gg = dot(normal, shadingPoint - light.position);
+let surfacePoint = shadingPoint - normal * gg;
 let ib = surfacePoint - lowerLeft;
 let width = length(light.u);
 let height = length(light.v);
@@ -114,13 +114,13 @@ let uv = vec2f(
 dot(ib, light.u / width) / width,
 dot(ib, light.v / height) / height
 );
-if (gf <= 0.0 || any(uv < vec2f(0.0)) || any(uv > vec2f(1.0))) {
+if (gg <= 0.0 || any(uv < vec2f(0.0)) || any(uv > vec2f(1.0))) {
 (*result).emission = vec3f(0.0);
 (*result).pdf = 0.0;
 return;
 }
 (*result).direction = -normal;
-(*result).dist = gf;
+(*result).dist = gg;
 (*result).normal = normal;
 (*result).emission = light.emission;
 (*result).pdf = 1.0;
@@ -137,19 +137,19 @@ let hq = dot(offset, offset);
 (*result).dist = sqrt(hq);
 (*result).direction = offset / (*result).dist;
 (*result).normal = normal;
-let fZ = dot(-(*result).direction, normal);
-let oO = cos(0.5 * PI * spread);
-if (fZ <= 0.0 || fZ < oO) {
+let ga = dot(-(*result).direction, normal);
+let oN = cos(0.5 * PI * spread);
+if (ga <= 0.0 || ga < oN) {
 (*result).emission = vec3f(0.0);
 (*result).pdf = 0.0;
 return;
 }
 (*result).emission = light.emission;
-(*result).pdf = hq / max(light.area * fZ, 1e-8);
+(*result).pdf = hq / max(light.area * ga, 1e-8);
 da(light, surfacePoint, lowerLeft, result);
 }
 
-fn gc(
+fn gd(
 light: Light,
 result: ptr<function, LightSampleRec>
 ) {
@@ -193,13 +193,13 @@ jT(light, shadingPoint, samplePoint, result);
 return;
 }
 if (dP == DIRECTIONAL_LIGHT) {
-gc(light, result);
+gd(light, result);
 }
 }
 
-fn mH(iZ: vec2f, lightSample: ptr<function, LightSampleRec>) {
+fn mG(iZ: vec2f, lightSample: ptr<function, LightSampleRec>) {
 var uv: vec2f;
-(*lightSample).direction = oM(iZ, &uv, &(*lightSample).pdf);
+(*lightSample).direction = oL(iZ, &uv, &(*lightSample).pdf);
 (*lightSample).emission = textureLinear(envMap, uv).rgb;
 (*lightSample).dist = INF;
 }
@@ -240,11 +240,11 @@ bitcast<i32>(data.w)
 );
 }
 
-fn jB(ne: i32, index: i32) -> pe {
-return sp(ne + index);
+fn jB(nd: i32, index: i32) -> pe {
+return sp(nd + index);
 }
 
-fn mT(
+fn mS(
 rnd: vec3f,
 ca: u32,
 aV: u32
@@ -256,9 +256,9 @@ f32(count);
 return sU;
 }
 
-fn lX(
+fn lW(
 triangle: EmissiveTriangle,
-fq: vec3f,
+ft: vec3f,
 iZ: vec2f,
 lightSample: ptr<function, LightSampleRec>
 ) {
@@ -281,7 +281,7 @@ barycentric.x * triangle.secondaryUv0 +
 barycentric.y * triangle.secondaryUv1 +
 barycentric.z * triangle.secondaryUv2;
 let normal = normalize(cross(triangle.p1 - triangle.p0, triangle.p2 - triangle.p0));
-(*lightSample).direction = sZ - fq;
+(*lightSample).direction = sZ - ft;
 (*lightSample).dist = length((*lightSample).direction);
 if ((*lightSample).dist <= EPS) {
 (*lightSample).emission = vec3f(0.0);
@@ -296,7 +296,7 @@ if (pm <= 0.0) {
 (*lightSample).pdf = 0.0;
 return;
 }
-(*lightSample).emission = lO(
+(*lightSample).emission = lN(
 i32(triangle.materialIndex), uv, cX
 );
 (*lightSample).selectionPmf = triangle.selectionPmf;
@@ -306,11 +306,11 @@ max(triangle.area * pm, 1e-8);
 }
 
 fn ki(
-fq: vec3f,
+ft: vec3f,
 rnd: vec3f,
-ne: i32,
+nd: i32,
 pl: i32,
-nd: f32,
+mZ: f32,
 lightSample: ptr<function, LightSampleRec>
 ) {
 (*lightSample).emission = vec3f(0.0);
@@ -326,17 +326,17 @@ return;
 
 let rj = rnd.z * f32(pl);
 let column = min(i32(rj), pl - 1);
-let qS = jB(ne, column);
+let qS = jB(nd, column);
 let lc = select(
 qS.aliasIndex,
 column,
 fract(rj) < qS.probability
 );
-let pk = jB(ne, lc);
+let pk = jB(nd, lc);
 if (pk.sourceType == ${LIGHT_CHOICE_ENVIRONMENT}) {
 (*lightSample).sourceType = 0u;
 (*lightSample).sourceIndex = u32(pk.sourceIndex);
-mH(rnd.xy, lightSample);
+mG(rnd.xy, lightSample);
 (*lightSample).selectionPmf = rtUniform.envLightPmf;
 (*lightSample).pdf *= rtUniform.envLightPmf;
 }
@@ -344,32 +344,32 @@ else if (pk.sourceType == ${LIGHT_CHOICE_ANALYTIC}) {
 (*lightSample).sourceType = 2u;
 (*lightSample).sourceIndex = u32(pk.sourceIndex);
 let light = analyticLights[pk.sourceIndex];
-iQ(light, fq, rnd.xy, lightSample);
+iQ(light, ft, rnd.xy, lightSample);
 (*lightSample).selectionPmf = light.selectionPmf;
 (*lightSample).pdf *= light.selectionPmf;
 }
 else if (pk.sourceType == ${LIGHT_CHOICE_EMISSIVE_TRIANGLE}) {
 (*lightSample).sourceType = 1u;
 (*lightSample).sourceIndex = u32(pk.sourceIndex);
-lX(
+lW(
 qd(pk.sourceIndex),
-fq,
+ft,
 rnd.xy,
 lightSample
 );
 }
-(*lightSample).selectionPmf *= nd;
-(*lightSample).pdf *= nd;
+(*lightSample).selectionPmf *= mZ;
+(*lightSample).pdf *= mZ;
 }
 
 fn sampleLight(
-fq: vec3f,
+ft: vec3f,
 rnd: vec3f,
 lightSample: ptr<function, LightSampleRec>,
 sc: bool
 ) {
 ki(
-fq,
+ft,
 rnd,
 0,
 rtUniform.lightChoiceCount,
@@ -380,16 +380,16 @@ lightSample
 
 
 
-fn mI(
-fq: vec3f,
+fn mH(
+ft: vec3f,
 rnd: vec3f,
 ca: u32,
 aV: u32,
 lightSample: ptr<function, LightSampleRec>
 ) {
 ki(
-fq,
-mT(rnd, ca, aV),
+ft,
+mS(rnd, ca, aV),
 0,
 rtUniform.lightChoiceCount,
 1.0,

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

@@ -4,7 +4,7 @@
 export function createSampleMaterialWgsl(hasAnisotropyDirections = true, hasCoatNormals = false) {
     return /* wgsl */ `
 
-struct nf {
+struct ne {
 ray: Ray,
 maxDistance: f32,
 triangleIndex: i32,
@@ -22,18 +22,18 @@ ma: J,
 prepared: ag,
 aa: ptr<function, Path>,
 ffnormal: vec3f,
-gE: bool,
+gF: bool,
 ca: u32,
 aV: u32,
-gi: ptr<function, nf>
+gj: ptr<function, ne>
 ) -> bool {
-(*gi).valid = false;
-(*gi).lightSelectionPmf = 0.0;
-(*gi).risTarget = 0.0;
-let ln = vec3f(fo(rd(ca, 1u)), dz(rd(ca, 0u)));
+(*gj).valid = false;
+(*gj).lightSelectionPmf = 0.0;
+(*gj).risTarget = 0.0;
+let ln = vec3f(fp(rd(ca, 1u)), dz(rd(ca, 0u)));
 
 var lightSample: LightSampleRec;
-mI(
+mH(
 (*si).position,
 ln,
 ca,
@@ -43,13 +43,13 @@ aV,
 var Li = lightSample.emission;
 
 let lightDir = lightSample.direction;
-let oT = -(*aa).ray.d;
+let oS = -(*aa).ray.d;
 let fg = lightSample.pdf;
 let lightSelectionPmf = lightSample.selectionPmf;
 
 
 ${hasCoatNormals ? /* wgsl */ `var cosThetaL = dot(ffnormal, lightDir);
-if (gE && ma.coatNormalEnabled) { cosThetaL = dot(ma.geometricNormal, lightDir); }` : 'let cosThetaL = dot(ffnormal, lightDir);'}
+if (gF && ma.coatNormalEnabled) { cosThetaL = dot(ma.geometricNormal, lightDir); }` : 'let cosThetaL = dot(ffnormal, lightDir);'}
 
 if (fg <= 0.0 || lightSelectionPmf <= 0.0 ||
 max(max(Li.x, Li.y), Li.z) <= 0.0) {
@@ -58,7 +58,7 @@ return false;
 
 var scatteringPdf = 0.0;
 var f = vec3f(0.0);
-if (gE) {
+if (gF) {
 
 
 if (cosThetaL <= 0.0 && ma.transmissionWeight <= 0.0 && ma.subsurfaceWeight <= 0.0) {
@@ -68,7 +68,7 @@ f = bI(prepared, lightDir, &scatteringPdf);
 }
 else {
 scatteringPdf = bD(
-dot(oT, lightDir),
+dot(oS, lightDir),
 (*si).mediumAnisotropy
 );
 f = vec3f(scatteringPdf);
@@ -78,9 +78,9 @@ if (scatteringPdf <= 0.0 || max(max(f.x, f.y), f.z) <= 0.0) {
 return false;
 }
 
-var mA: Ray;
+var mz: Ray;
 var hi = (*si).position + EPS * lightDir;
-if (gE) {
+if (gF) {
 hi = rQ((*si).position, (*si).faceNormal, lightDir);
 let bZ = 0.1;
 var dr = dot((*si).normal, lightDir);
@@ -92,7 +92,7 @@ dr < 0.0
 );
 dr = abs(dr);
 let hS = dot(geometricNormal, lightDir);
-let oC = select(
+let oB = select(
 clamp(1.0 - hS / bZ, 0.0, 1.0),
 clamp(
 2.0 - (hS + dr) / bZ,
@@ -101,29 +101,29 @@ clamp(
 ),
 dr < bZ
 );
-hi += (*si).shadowOffset * oC;
+hi += (*si).shadowOffset * oB;
 }
 
 
 
 
-var lR = lightDir;
-var mP = lightSample.dist - EPS;
+var lQ = lightDir;
+var mO = lightSample.dist - EPS;
 if (lightSample.sourceType == 1u) {
 let sY =
 (*si).position + lightSample.direction * lightSample.dist;
 let qe = sY + EPS * lightSample.normal;
 let qp = qe - hi;
-mP = length(qp);
-lR = normalize(qp);
+mO = length(qp);
+lQ = normalize(qp);
 }
-iC(&mA, hi, lR);
+iC(&mz, hi, lQ);
 
 
 
 
-if (gE && cosThetaL < 0.0 && lightSample.sourceType == 0u) {
-let background = hH(mA);
+if (gF && cosThetaL < 0.0 && lightSample.sourceType == 0u) {
+let background = hH(mz);
 Li = background.rgb * background.a;
 }
 if (SPECTRAL) {
@@ -139,40 +139,40 @@ lightSample.isDelta
 );
 if (fa > 0.0) {
 let kq = Li * f / fg * (*aa).beta;
-(*gi).risTarget = max(
+(*gj).risTarget = max(
 dot(max(kq * lightSelectionPmf, vec3f(0.0)), luminance),
 0.0
 );
-(*gi).ray = mA;
-(*gi).maxDistance = mP;
-(*gi).triangleIndex = (*si).triangleIndex;
-(*gi).contribution = fa * kq;
-(*gi).lightSelectionPmf = lightSelectionPmf;
-(*gi).valid = true;
+(*gj).ray = mz;
+(*gj).maxDistance = mO;
+(*gj).triangleIndex = (*si).triangleIndex;
+(*gj).contribution = fa * kq;
+(*gj).lightSelectionPmf = lightSelectionPmf;
+(*gj).valid = true;
 return true;
 }
 return false;
 }
 
-fn mU(
+fn mT(
 si: ptr<function, ad>,
 ma: J,
 prepared: ag,
 aa: ptr<function, Path>,
 ffnormal: vec3f,
-gE: bool
+gF: bool
 ) {
 let aV = jX();
-var selected: nf;
+var selected: ne;
 selected.valid = false;
-var mJ = 0.0;
-var lI = 0.0;
+var mI = 0.0;
+var lH = 0.0;
 
 
 for (var ca = 0u; ca < aV; ca++) {
-var candidate: nf;
+var candidate: ne;
 let pj = qq(
-si, ma, prepared, aa, ffnormal, gE,
+si, ma, prepared, aa, ffnormal, gF,
 ca, aV, &candidate);
 if (aV == 1u) {
 if (!pj) { return; }
@@ -182,20 +182,20 @@ break;
 if (!pj) { continue; }
 let kj = candidate.risTarget / max(candidate.lightSelectionPmf, 1e-20);
 if (!(kj > 0.0) || kj != kj) { continue; }
-lI += kj;
+lH += kj;
 if (!selected.valid ||
-pK(ca) * lI <= kj) {
+pK(ca) * lH <= kj) {
 selected = candidate;
-mJ = candidate.risTarget;
+mI = candidate.risTarget;
 }
 }
 var qP = 1.0;
 if (aV > 1u) {
-if (!selected.valid || mJ <= 0.0) { return; }
+if (!selected.valid || mI <= 0.0) { return; }
 
 
-qP = selected.lightSelectionPmf * lI /
-(f32(aV) * mJ);
+qP = selected.lightSelectionPmf * lH /
+(f32(aV) * mI);
 }
 if (selected.valid &&
 !ex(selected.ray, selected.maxDistance, selected.triangleIndex)) {
@@ -222,13 +222,13 @@ return 1.0;
 let rY = distance((*si).position, (*aa).ray.o);
 let fg = samplingLuminance / rtUniform.lightWeightTotal *
 rY * rY / max(pm, 1e-8);
-return fW((*aa).scatteringPdf, fg);
+return fX((*aa).scatteringPdf, fg);
 }
 
 ${hasCoatNormals ? /* wgsl */ `
 
 
-fn fE(input: vec3f, tq: vec3f, view: vec3f) -> vec3f {
+fn fF(input: vec3f, tq: vec3f, view: vec3f) -> vec3f {
 let qY = dot(tq, view) >= 0.0;
 let uo = select(-tq, tq, qY);
 let qX = select(-input, input, qY);
@@ -236,14 +236,14 @@ if (dot(input, tq) <= 0.0 || dot(qX, view) <= 1e-6) { return uo; }
 return qX;
 }
 ` : ''}
-fn mc(
+fn mb(
 si: ptr<function, ad>,
 ma: ptr<function, J>,
 aa: ptr<function, Path>
 ) {
 ${hasCoatNormals ? /* wgsl */ `
 let bC = (*si).faceNormal;
-let mF = (*si).normal;
+let mE = (*si).normal;
 ` : ''}
 var rN: f32 = -dot((*si).faceNormal, (*aa).ray.d);
 var sG: f32 = -dot((*si).normal, (*aa).ray.d);
@@ -271,12 +271,12 @@ var ffnormal = select(-N, N, ndv >= 0.0);
 ${hasCoatNormals ? /* wgsl */ `
 if ((*ma).coatNormalEnabled) {
 let view = -(*aa).ray.d;
-let ga = dot(bC, view);
-(*ma).geometricNormal = select(-bC, bC, ga >= 0.0);
-ffnormal = fE(mF, bC, view);
-(*ma).coatNormal = fE((*si).coatNormal, bC, view);
-(*ma).inside = ga <= 0.0 && !(*ma).thinWalled;
-(*ma).relativeIor = select((*ma).specularIor, 1.0 / (*ma).specularIor, ga > 0.0 || (*ma).thinWalled);
+let gb = dot(bC, view);
+(*ma).geometricNormal = select(-bC, bC, gb >= 0.0);
+ffnormal = fF(mE, bC, view);
+(*ma).coatNormal = fF((*si).coatNormal, bC, view);
+(*ma).inside = gb <= 0.0 && !(*ma).thinWalled;
+(*ma).relativeIor = select((*ma).specularIor, 1.0 / (*ma).specularIor, gb > 0.0 || (*ma).thinWalled);
 }
 ` : ''}
 
@@ -290,36 +290,36 @@ var cG: vec3f;
 
 if (HAS_MEDIUM) {
 let d = distance((*si).position, (*aa).ray.o);
-let nv = (*aa).ray.o;
+let nu = (*aa).ray.o;
 let extinction = (*si).mediumExtinction;
 let scattering = min((*si).mediumScattering, extinction);
 let sC = max(max(extinction.x, extinction.y), extinction.z);
 if (mediumType > 0 && sC > 0.0) {
 
 
-let nk = min(i32(dz(cw(MEDIUM_CHANNEL)) * 3.0), 2);
-let fD = extinction[nk];
+let nj = min(i32(dz(cw(MEDIUM_CHANNEL)) * 3.0), 2);
+let fE = extinction[nj];
 let ih = select(
 d,
-min(-log(max(dz(cw(MEDIUM_DISTANCE)), 1e-7)) / fD, d),
-fD > 0.0
+min(-log(max(dz(cw(MEDIUM_DISTANCE)), 1e-7)) / fE, d),
+fE > 0.0
 );
 bl = ih < d;
 let ew = exp(-extinction * ih);
-let oa = select(
+let nZ = select(
 ew,
 extinction * ew,
 bl
 );
-let nL = max((oa.x + oa.y + oa.z) / 3.0, 1e-8);
+let nK = max((nZ.x + nZ.y + nZ.z) / 3.0, 1e-8);
 if (bl) {
-(*aa).beta *= ew * scattering / nL;
+(*aa).beta *= ew * scattering / nK;
 
-(*aa).ray.o = nv + ih * (*aa).ray.d;
+(*aa).ray.o = nu + ih * (*aa).ray.d;
 (*si).position = (*aa).ray.o;
 }
 else {
-(*aa).beta *= ew / nL;
+(*aa).beta *= ew / nK;
 }
 }
 }
@@ -343,13 +343,13 @@ ${hasAnisotropyDirections ? /* wgsl */ `
 ` : /* wgsl */ ``}
 prepared = eH((*si).tangent, *ma, -(*aa).ray.d, ffnormal);
 }
-mU(si, *ma, prepared, aa, ffnormal, !bl);
+mT(si, *ma, prepared, aa, ffnormal, !bl);
 if (bl) {
 
-cG = fp(
+cG = fq(
 -(*aa).ray.d,
 (*si).mediumAnisotropy,
-fo(cw(PHASE_DIRECTION))
+fp(cw(PHASE_DIRECTION))
 );
 scatteringPdf = bD(
 dot(cG, -(*aa).ray.d),
@@ -364,8 +364,8 @@ var aS = false;
 var bE = true;
 var aR = u32(OPENPBR_LOBE_DIFFUSE);
 var qI = 0.0;
-let ur = vec3f(fo(cw(BSDF_DIRECTION)), dz(cw(BSDF_LOBE)));
-var gX = vec3f(0.0);
+let ur = vec3f(fp(cw(BSDF_DIRECTION)), dz(cw(BSDF_LOBE)));
+var gY = vec3f(0.0);
 let f = dv(
 prepared,
 ur,
@@ -377,7 +377,7 @@ ur,
 &bE,
 &aR,
 &qI,
-&gX
+&gY
 );