@meimu/mutracer 0.1.4 → 0.1.5

package/lib/renderer/glsl/rayTrace.frag.js

@@ -93,7 +93,7 @@ ${envMap.main}
 ${samplingGlsl}
 ${openPbrBsdfGlsl}
 
-float mw;
+float mv;
 float bf;
 
 ${sampleLightGlsl}
@@ -178,9 +178,9 @@ outAux.isBlank = bg.a < 0.01;
 }
 else {
 Ray cam = hC(v_Texcoord + sa());
-bool mM = dot(cam.d, aa.ray.d) > 0.0;
+bool mL = dot(cam.d, aa.ray.d) > 0.0;
 if (transmissiveOutputAlphaMin < 1.0) {
-if (mM) {
+if (mL) {
 aa.alpha = max(aa.alpha, bg.a);
 } else {
 aa.alpha = 1.0;
@@ -188,7 +188,7 @@ aa.alpha = 1.0;
 }
 #if !defined(USE_ENVMAP)
 
-if (mM) {
+if (mL) {
 aa.li = aa.beta * aG(aa.scatteringPdf, 1.0) * bg.rgb;
 }
 #endif
@@ -214,7 +214,7 @@ cH = true;
 }
 }
 if (!cH) {
-mc(si, mat, aa);
+mb(si, mat, aa);
 }
 else {
 aa.ray.o = si.position + aa.ray.d * EPS;
@@ -245,8 +245,8 @@ si.albedoSampled = true;
 #ifdef USE_RR
 if (depth >= RR_MAX && !cH) {
 
-float oz = max(max(aa.beta.x, aa.beta.y), aa.beta.z);
-float q = max(0.0, 1.0 - oz);
+float oy = max(max(aa.beta.x, aa.beta.y), aa.beta.z);
+float q = max(0.0, 1.0 - oy);
 if (dz(cw(RUSSIAN_ROULETTE)) < q) {
 
 
@@ -272,7 +272,7 @@ si.isTransparency = mat.transmissionWeight > 0.001 || mat.subsurfaceWeight > 0.0
 
 
 if (dispersionWavelengths == 1 && si.hit && mat.transmissionWeight > 0.001 && mat.transmissionDispersionScale > 0.001) {
-bf = mw;
+bf = mv;
 }
 if (mat.transmissionWeight > 0.001 && bf > 0.0) {
 mat.specularIor = eN(
@@ -294,9 +294,9 @@ LightSampleRec lightSample;
 for (int i = 0; i < NUM_LIGHTS; i++) {
 
 Light light = qx(i);
-float d = mz(aa.ray, light, lightSample);
-bool mD = si.hit && d > distance(si.position, aa.ray.o);
-if (d != INF && !(mD && hy)) {
+float d = my(aa.ray, light, lightSample);
+bool mC = si.hit && d > distance(si.position, aa.ray.o);
+if (d != INF && !(mC && hy)) {
 lightSample.pdf *= light.selectionPmf;
 float fa = aG(aa.scatteringPdf, lightSample.pdf);
 lightSample.emission = ai(lightSample.emission, bf);
@@ -347,15 +347,15 @@ depth++;
 
 vec2 kz(float radius, float xi) {
 float x = 0.25;
-for (int nH = 0; nH < 10; nH++) {
+for (int nG = 0; nG < 10; nG++) {
 float x2 = x * x;
 float x3 = x2 * x;
 float kP = 1.0 - x;
 float value = 10.0 * x2 - 20.0 * x3 + 15.0 * x2 * x2 -
 4.0 * x2 * x3 - xi;
-float mk = 20.0 * x * kP * kP * kP;
-if (abs(value) < 1e-6 || mk == 0.0) break;
-x = clamp(x - value / mk, 0.0, 1.0);
+float mj = 20.0 * x * kP * kP * kP;
+if (abs(value) < 1e-6 || mj == 0.0) break;
+x = clamp(x - value / mj, 0.0, 1.0);
 }
 float jo = x * radius;
 return vec2(
@@ -364,14 +364,14 @@ sqrt(max(radius * radius - jo * jo, 0.0))
 );
 }
 
-float iT(float radius, float gw) {
-if (gw >= radius) return 0.0;
-float oh = radius - gw;
-return oh * oh * oh;
+float iT(float radius, float gx) {
+if (gx >= radius) return 0.0;
+float og = radius - gx;
+return og * og * og;
 }
 
 
-vec3 mu(ad source, float radius) {
+vec3 mt(ad source, float radius) {
 vec3 geometricNormal = source.faceNormal;
 if (dot(geometricNormal, source.vertexNormal) < 0.0) geometricNormal = -geometricNormal;
 vec3 tangent;
@@ -380,43 +380,43 @@ aL(geometricNormal, tangent, bitangent);
 vec3 iF = vec3(0.0);
 
 for (int ig = 0; ig < BEVEL_SAMPLES; ig++) {
-vec2 ph = fo(CAMERA_BEVEL_BASE + uint(ig));
+vec2 ph = fp(CAMERA_BEVEL_BASE + uint(ig));
 float cA = ph.x;
-float oG = ph.y;
+float oF = ph.y;
 vec3 dj = geometricNormal;
-vec3 fH = tangent;
+vec3 fI = tangent;
 vec3 ek = bitangent;
-float ge = 0.5;
+float gf = 0.5;
 float hY = 0.25;
-float gG = 0.25;
+float gH = 0.25;
 if (cA < 0.5) {
 cA *= 2.0;
 }
 else if (cA < 0.75) {
-vec3 mK = dj;
-dj = fH;
-fH = mK;
-ge = 0.25;
+vec3 mJ = dj;
+dj = fI;
+fI = mJ;
+gf = 0.25;
 hY = 0.5;
 cA = (cA - 0.5) * 4.0;
 }
 else {
-vec3 mK = dj;
+vec3 mJ = dj;
 dj = ek;
-ek = mK;
-ge = 0.25;
-gG = 0.5;
+ek = mJ;
+gf = 0.25;
+gH = 0.5;
 cA = (cA - 0.75) * 4.0;
 }
 
-vec2 gU = kz(radius, oG);
+vec2 gV = kz(radius, oF);
 float phi = TWOPI * cA;
-vec3 qv = gU.x *
-(cos(phi) * fH + sin(phi) * ek);
+vec3 qv = gV.x *
+(cos(phi) * fI + sin(phi) * ek);
 Ray ray;
 iC(
 ray,
-source.position + dj * gU.y + qv,
+source.position + dj * gV.y + qv,
 -dj
 );
 ad hit;
@@ -424,20 +424,20 @@ iM(
 ray,
 hit,
 source.instanceIndex,
-max(2.0 * gU.y, EPS)
+max(2.0 * gV.y, EPS)
 );
 if (!hit.hit) continue;
 
-float kQ = ge * abs(dot(dj, hit.faceNormal));
-float mG = hY * abs(dot(fH, hit.faceNormal));
-float kb = gG * abs(dot(ek, hit.faceNormal));
+float kQ = gf * abs(dot(dj, hit.faceNormal));
+float mF = hY * abs(dot(fI, hit.faceNormal));
+float kb = gH * abs(dot(ek, hit.faceNormal));
 float weight = kQ / max(
-kQ * kQ + mG * mG +
+kQ * kQ + mF * mF +
 kb * kb,
 1e-8
 );
 weight *= iT(radius, distance(hit.position, source.position)) /
-max(iT(radius, gU.x), 1e-8);
+max(iT(radius, gV.x), 1e-8);
 iF += weight * hit.vertexNormal;
 }
 
@@ -473,29 +473,29 @@ return bw(si, ray, mat, outAux);
 
 
 
-Ray nY = ray;
-nY.o = si.position + ray.d * (EPS * 0.02);
+Ray nX = ray;
+nX.o = si.position + ray.d * (EPS * 0.02);
 ad dE = si;
 dE.albedoSampled = false;
-cZ(nY, dE, false);
-J nX;
-eX(nX, dE.materialIndex, dE.uv, dE.uv1, dE.instanceIndex, dE.vertexColor);
-RayTraceAuxiliary gm = outAux;
-if (dE.hit && (nX.materialType == STANDARD || nX.materialType == UNLIT)) {
-gm.albedo = nX.transmissionWeight > 0.5
+cZ(nX, dE, false);
+J nW;
+eX(nW, dE.materialIndex, dE.uv, dE.uv1, dE.instanceIndex, dE.vertexColor);
+RayTraceAuxiliary gn = outAux;
+if (dE.hit && (nW.materialType == STANDARD || nW.materialType == UNLIT)) {
+gn.albedo = nW.transmissionWeight > 0.5
 ? vec3(1.0)
-: nX.baseColor;
-gm.normal = dot(
+: nW.baseColor;
+gn.normal = dot(
 dE.normal,
 dE.position - vec3(viewInv[3])
 ) > 0.0
 ? -dE.normal
 : dE.normal;
-dE.albedoSampled = nX.transmissionWeight > 0.5;
+dE.albedoSampled = nW.transmissionWeight > 0.5;
 }
-vec4 back = bw(dE, nY, nX, gm);
+vec4 back = bw(dE, nX, nW, gn);
 if (coverage <= 0.0) {
-outAux = gm;
+outAux = gn;
 return back;
 }
 
@@ -504,18 +504,18 @@ J tR = mat;
 tR.alpha = 1.0;
 RayTraceAuxiliary iW = outAux;
 vec4 qY = bw(tu, ray, tR, iW);
-outAux.albedo = mix(gm.albedo, iW.albedo, coverage);
-vec3 fV = mix(gm.normal, iW.normal, coverage);
-outAux.normal = dot(fV, fV) > 1e-12
-? normalize(fV)
+outAux.albedo = mix(gn.albedo, iW.albedo, coverage);
+vec3 fW = mix(gn.normal, iW.normal, coverage);
+outAux.normal = dot(fW, fW) > 1e-12
+? normalize(fW)
 : vec3(0.0);
-outAux.isBlank = gm.isBlank && iW.isBlank;
+outAux.isBlank = gn.isBlank && iW.isBlank;
 return mix(back, qY, coverage);
 }
 
 
 
-vec4 my(Ray ray, out RayTraceAuxiliary outAux) {
+vec4 mx(Ray ray, out RayTraceAuxiliary outAux) {
 
 ad si;
 J mat;
@@ -534,7 +534,7 @@ si.isTransparency = mat.transmissionWeight > 0.001 || mat.subsurfaceWeight > 0.0
 
 #ifdef HAS_BEVEL
 if (bevelEnabled && mat.bevel > 0.0) {
-si.normal = mu(si, mat.bevel);
+si.normal = mt(si, mat.bevel);
 }
 #endif
 
@@ -568,15 +568,15 @@ kh(v_Texcoord * viewportSize, int(uint(sampleCount) ^ eg(uint(sequenceSeed))));
 
 
 bf = dispersionWavelengths == 1 ? 0.0 : wavelength;
-mw = wavelength;
+mv = wavelength;
 if (dispersionWavelengths == 1 && wavelength > 0.0) {
 float channel = floor(dz(CAMERA_WAVELENGTH) * 3.0);
-mw = channel < 1.0 ? 650.0 : channel < 2.0 ? 510.0 : 475.0;
+mv = channel < 1.0 ? 650.0 : channel < 2.0 ? 510.0 : 475.0;
 }
 
 
 
-Ray cam = nN();
+Ray cam = nM();
 
 RayTraceAuxiliary outAux;
 outAux.albedo = vec3(0.0);
@@ -584,7 +584,7 @@ outAux.normal = vec3(0.0);
 outAux.isBlank = false;
 outAux.isShadowCatcher = false;
 
-vec4 aF = my(cam, outAux);
+vec4 aF = mx(cam, outAux);
 
 
 

package/lib/renderer/glsl/shadowCatcher.frag.js

@@ -52,7 +52,7 @@ ${cameraRayGlsl}
 
 
 
-vec4 my(inout Ray ray, out vec4 background) {
+vec4 mx(inout Ray ray, out vec4 background) {
 background = vec4(0.0);
 Path aa;
 aa.ray = ray;
@@ -94,9 +94,9 @@ su();
 kh(v_Texcoord * viewportSize, int(uint(sampleCount) ^ eg(uint(sequenceSeed))));
 
 if (dispersionWavelengths == 1 && wavelength > 0.0) { dz(CAMERA_WAVELENGTH); }
-Ray cam = nN();
+Ray cam = nM();
 vec4 background;
-vec4 aF = my(cam, background);
+vec4 aF = mx(cam, background);
 
 if (!(aF.x < INF && aF.x > -EPS)) {
 aF = vec4(0, 0, 0, 1);

package/lib/renderer/glsl/webglPipeline.frag.js

@@ -59,7 +59,7 @@ color = max(vec3(0.0), color - 0.004);
 return pow((color * (6.2 * color + 0.5)) /
 (color * (6.2 * color + 1.7) + 0.06), vec3(2.2));
 }
-vec3 oJ(vec3 value) {
+vec3 oI(vec3 value) {
 vec3 kO = value * (value + 0.0245786) - 0.000090537;
 vec3 ap = value * (0.983729 * value + 0.4329510) + 0.238081;
 return kO / ap;
@@ -70,13 +70,13 @@ vec3(0.59719, 0.07600, 0.02840),
 vec3(0.35458, 0.90834, 0.13383),
 vec3(0.04823, 0.01566, 0.83777)
 );
-const mat3 oE = mat3(
+const mat3 oD = mat3(
 vec3(1.60475, -0.10208, -0.00327),
 vec3(-0.53108, 1.10813, -0.07276),
 vec3(-0.07367, -0.00605, 1.07602)
 );
 color = pw * (color / 0.6);
-return clamp(oE * oJ(color), 0.0, 1.0);
+return clamp(oD * oI(color), 0.0, 1.0);
 }
 const mat3 LINEAR_REC2020_TO_LINEAR_SRGB = mat3(
 vec3(1.6605, -0.1246, -0.0182),
@@ -88,27 +88,27 @@ vec3(0.6274, 0.0691, 0.0164),
 vec3(0.3293, 0.9195, 0.0880),
 vec3(0.0433, 0.0113, 0.8956)
 );
-vec3 fT(vec3 value) {
-vec3 mO = value * value;
-vec3 qK = mO * mO;
-return 15.5 * qK * mO - 40.14 * qK * value
-+ 31.96 * qK - 6.868 * mO * value
-+ 0.4298 * mO + 0.1191 * value - 0.00232;
+vec3 fU(vec3 value) {
+vec3 mN = value * value;
+vec3 qK = mN * mN;
+return 15.5 * qK * mN - 40.14 * qK * value
++ 31.96 * qK - 6.868 * mN * value
++ 0.4298 * mN + 0.1191 * value - 0.00232;
 }
-vec3 me(vec3 color) {
+vec3 mc(vec3 color) {
 const mat3 pH = mat3(
 vec3(0.856627153315983, 0.137318972929847, 0.11189821299995),
 vec3(0.0951212405381588, 0.761241990602591, 0.0767994186031903),
 vec3(0.0482516061458583, 0.101439036467562, 0.811302368396859)
 );
-const mat3 oF = mat3(
+const mat3 oE = mat3(
 vec3(1.1271005818144368, -0.1413297634984383, -0.14132976349843826),
 vec3(-0.11060664309660323, 1.157823702216272, -0.11060664309660294),
 vec3(-0.016493938717834573, -0.016493938717834257, 1.2519364065950405)
 );
 color = pH * (LINEAR_SRGB_TO_LINEAR_REC2020 * color);
 color = clamp((log2(max(color, 1e-10)) + 12.47393) / 16.5, 0.0, 1.0);
-color = oF * fT(color);
+color = oE * fU(color);
 color = pow(max(color, 0.0), vec3(2.2));
 return clamp(LINEAR_REC2020_TO_LINEAR_SRGB * color, 0.0, 1.0);
 }
@@ -117,9 +117,9 @@ if (toneMappingMode == 1) return lv(color);
 if (toneMappingMode == 2) return jJ(color);
 if (toneMappingMode == 3) return iP(color);
 if (toneMappingMode == 4) return jU(color);
-return me(color);
+return mc(color);
 }
-vec3 gb(vec3 color) {
+vec3 gc(vec3 color) {
 vec3 tj = vec3(
 1.0 + temperature * 0.16 + tint * 0.04,
 1.0 - tint * 0.12,
@@ -141,7 +141,7 @@ return;
 vec4 color = sample_colorTex(uv);
 vec4 bloom = sample_bloomTex(uv) * bloomIntensity;
 color.rgb += bloom.rgb;
-color.rgb = gb(color.rgb * exposure);
+color.rgb = gc(color.rgb * exposure);
 if (sRGBOutput) {
 float edge = smoothstep(0.2, 0.72, distance(uv, vec2(0.5)));
 color.rgb *= 1.0 - vignette * edge;
@@ -154,15 +154,15 @@ if (shadowCatcherEnabled > 0.5) {
 float coverage = clamp(shadow.r, 0.0, 1.0);
 
 
-float fR = clamp(
+float fS = clamp(
 (1.0 - shadow.a) / max(coverage, 0.000001), 0.0, 1.0
 );
-fR = max(fR - (1.0 - shadowCatcherAlpha), 0.0);
+fS = max(fS - (1.0 - shadowCatcherAlpha), 0.0);
 if (coverage > 0.0) {
 vec4 foreground = sample_foregroundTex(uv);
 vec4 background = sample_catcherBackgroundTex(uv);
-vec3 bK = gb((foreground.rgb + bloom.rgb) * exposure);
-vec3 backgroundColor = gb((background.rgb / max(background.a, 0.000001) + bloom.rgb) * exposure);
+vec3 bK = gc((foreground.rgb + bloom.rgb) * exposure);
+vec3 backgroundColor = gc((background.rgb / max(background.a, 0.000001) + bloom.rgb) * exposure);
 if (sRGBOutput) {
 float edge = smoothstep(0.2, 0.72, distance(uv, vec2(0.5)));
 bK *= 1.0 - vignette * edge;
@@ -171,15 +171,15 @@ bK = pow(max(cl(bK), 0.0), vec3(1.0 / 2.2));
 backgroundColor = pow(max(cl(backgroundColor), 0.0), vec3(1.0 / 2.2));
 }
 
-float opacity = fR;
-fR *= coverage;
-float mg = clamp(dot(bloom.rgb, vec3(0.2125, 0.7154, 0.0721)), 0.0, 1.0);
-float hv = max(foreground.a, mg * (1.0 - coverage));
-float jd = max(background.a, mg * coverage);
-float alpha = hv + jd * (1.0 - opacity) + fR;
+float opacity = fS;
+fS *= coverage;
+float mf = clamp(dot(bloom.rgb, vec3(0.2125, 0.7154, 0.0721)), 0.0, 1.0);
+float hv = max(foreground.a, mf * (1.0 - coverage));
+float jd = max(background.a, mf * coverage);
+float alpha = hv + jd * (1.0 - opacity) + fS;
 vec3 premultiplied = bK * hv
 + backgroundColor * jd * (1.0 - opacity)
-+ shadowCatcherColor * fR;
++ shadowCatcherColor * fS;
 color = vec4(premultiplied / max(alpha, 0.000001), alpha);
 }
 }

package/lib/renderer/scratchSampling.js

@@ -4,18 +4,18 @@ export function scratchWGSLFunctions(textures, samplers, scratch = false) {
 fn ${name}Region() -> vec2u {
 return ${scratch ? `imageRegions[${index}].xy` : `textureDimensions(${name})`};
 }
-fn load_${name}(fP: vec2i, level: i32) -> vec4f {
-${scratch ? `if (any(fP < vec2i(0)) || any(fP >= vec2i(${name}Region()))) { return vec4f(0.0); }` : ''}
-return textureLoad(${name}, fP, level);
+fn load_${name}(fQ: vec2i, level: i32) -> vec4f {
+${scratch ? `if (any(fQ < vec2i(0)) || any(fQ >= vec2i(${name}Region()))) { return vec4f(0.0); }` : ''}
+return textureLoad(${name}, fQ, level);
 }
 ${samplers.map(sampler => /* wgsl */ `
-fn sample_${name}_${sampler}(fG: vec2f) -> vec4f {
+fn sample_${name}_${sampler}(fH: vec2f) -> vec4f {
 ${scratch ? /* wgsl */ `
 let kc = textureDimensions(${name});
-if (all(kc == ${name}Region())) { return textureSampleLevel(${name}, ${sampler}, fG, 0.0); }
-let fP = clamp(fG * vec2f(${name}Region()), vec2f(0.5), vec2f(${name}Region()) - vec2f(0.5));
-return textureSampleLevel(${name}, ${sampler}, fP / vec2f(kc), 0.0);`
-        : `return textureSample(${name}, ${sampler}, fG);`}
+if (all(kc == ${name}Region())) { return textureSampleLevel(${name}, ${sampler}, fH, 0.0); }
+let fQ = clamp(fH * vec2f(${name}Region()), vec2f(0.5), vec2f(${name}Region()) - vec2f(0.5));
+return textureSampleLevel(${name}, ${sampler}, fQ / vec2f(kc), 0.0);`
+        : `return textureSample(${name}, ${sampler}, fH);`}
 }`).join('')}`).join('');
 }
 export function scratchGLSLFunctions(textures, scratch = false) {
@@ -23,17 +23,17 @@ export function scratchGLSLFunctions(textures, scratch = false) {
 ivec2 ${name}Region() {
 return ${scratch ? `${name}RegionSize` : `textureSize(${name}, 0)`};
 }
-vec4 load_${name}(ivec2 fP, int level) {
-${scratch ? `if (any(lessThan(fP, ivec2(0))) || any(greaterThanEqual(fP, ${name}Region()))) return vec4(0.0);` : ''}
-return texelFetch(${name}, fP, level);
+vec4 load_${name}(ivec2 fQ, int level) {
+${scratch ? `if (any(lessThan(fQ, ivec2(0))) || any(greaterThanEqual(fQ, ${name}Region()))) return vec4(0.0);` : ''}
+return texelFetch(${name}, fQ, level);
 }
-vec4 sample_${name}(vec2 fG) {
+vec4 sample_${name}(vec2 fH) {
 ${scratch ? /* glsl */ `
 ivec2 kc = textureSize(${name}, 0);
-if (all(equal(kc, ${name}Region()))) return texture(${name}, fG);
-vec2 fP = clamp(fG * vec2(${name}Region()), vec2(0.5), vec2(${name}Region()) - vec2(0.5));
-return texture(${name}, fP / vec2(kc));`
-        : `return texture(${name}, fG);`}
+if (all(equal(kc, ${name}Region()))) return texture(${name}, fH);
+vec2 fQ = clamp(fH * vec2(${name}Region()), vec2(0.5), vec2(${name}Region()) - vec2(0.5));
+return texture(${name}, fQ / vec2(kc));`
+        : `return texture(${name}, fH);`}
 }`).join('');
 }
 //# sourceMappingURL=scratchSampling.js.map

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

@@ -27,12 +27,12 @@ return mix(mix(s1, s2, f.x), mix(s3, s4, f.x), f.y);
 
 }
 
-fn eL(gg: vec3f) -> vec2f {
-var phi = atan2(-gg.z, -gg.x);
+fn eL(gh: vec3f) -> vec2f {
+var phi = atan2(-gh.z, -gh.x);
 if (phi < 0.0) {
 phi += TWOPI;
 }
-let theta = acos(clamp(gg.y, -1.0, 1.0));
+let theta = acos(clamp(gh.y, -1.0, 1.0));
 return vec2f(phi * 0.5 * INVPI, theta * INVPI);
 }
 
@@ -40,8 +40,8 @@ fn jN() -> mat3x3f {
 return mat3x3f(rtUniform.environmentRotation[0].xyz, rtUniform.environmentRotation[1].xyz, rtUniform.environmentRotation[2].xyz);
 }
 
-fn cY(mQ: vec3f) -> vec2f {
-return eL(transpose(jN()) * mQ);
+fn cY(mP: vec3f) -> vec2f {
+return eL(transpose(jN()) * mP);
 }
 
 fn qB(u: f32, vOffset: ptr<function, i32>, pdf: ptr<function, vec2f>) -> f32 {
@@ -84,25 +84,25 @@ left = mid + 1;
 right = mid;
 }
 }
-let oS = left - 1;
+let oR = left - 1;
 
 
 
-let s0 = textureLoad(envMapDistribution, vec2i(1 + oS, vOffset), 0).xy;
-let s1 = textureLoad(envMapDistribution, vec2i(1 + oS + 1, vOffset), 0).xy;
+let s0 = textureLoad(envMapDistribution, vec2i(1 + oR, vOffset), 0).xy;
+let s1 = textureLoad(envMapDistribution, vec2i(1 + oR + 1, vOffset), 0).xy;
 
 (*pdf).x = s0.y;
 
-return (f32(oS) + (u - s0.x) / (s1.x - s0.x)) / f32(size.x);
+return (f32(oR) + (u - s0.x) / (s1.x - s0.x)) / f32(size.x);
 }
 
 
-fn oM(random: vec2f, uv: ptr<function, vec2f>, pdf: ptr<function, f32>) -> vec3f {
-var hd: vec2f;
+fn oL(random: vec2f, uv: ptr<function, vec2f>, pdf: ptr<function, f32>) -> vec3f {
+var he: vec2f;
 var vOffset: i32;
 
-(*uv).y = qB(random.x, &vOffset, &hd);
-(*uv).x = qA(random.y, vOffset, &hd);
+(*uv).y = qB(random.x, &vOffset, &he);
+(*uv).x = qA(random.y, vOffset, &he);
 
 let phi = (*uv).x * TWOPI;
 let theta = (*uv).y * PI;
@@ -113,7 +113,7 @@ let uw = sin(phi);
 
 let dir = vec3f(-sinTheta * ul, cc, -sinTheta * uw);
 
-*pdf = hd.x * hd.y * INVPI2 / (2.0 * sinTheta);
+*pdf = he.x * he.y * INVPI2 / (2.0 * sinTheta);
 
 return jN() * dir;
 }