@meimu/mutracer 0.1.4 → 0.2.0

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

@@ -1,56 +1,56 @@
 const displacementCommon = /*wgsl*/ `
 
 
-struct jD {
+struct kc {
 barycentric: vec3f,
 t: f32,
 normal: vec3f,
 
 }
 
-fn uX(
+fn wO(
 uu: f32,
-tX: vec3f, tY: vec3f,
+vA: vec3f, vB: vec3f,
 eAC: vec3f, eBD: vec3f,
-iO: vec3f,
-pX: f32,
-pZ: ptr<function, f32>
+je: vec3f,
+qT: f32,
+qV: ptr<function, f32>
 ) -> bool {
 if (uu >= 0.0 && uu <= 1.0) {
-let pAB = mix(tX, tY, uu);
+let pAB = mix(vA, vB, uu);
 let pCD = mix(eAC, eBD, uu);
-var n = cross(iO, pCD);
-let vA = 1.0 / dot(n, n);
+var n = cross(je, pCD);
+let xf = 1.0 / dot(n, n);
 n = cross(n, pAB);
-let tt = dot(n, pCD) * vA;
-let vv = dot(n, iO) * vA;
-if (vv >= 0.0 && vv <= 1.0 && tt > pX && tt < *pZ) {
-*pZ = tt;
+let tt = dot(n, pCD) * xf;
+let vv = dot(n, je) * xf;
+if (vv >= 0.0 && vv <= 1.0 && tt > qT && tt < *qV) {
+*qV = tt;
 return true;
 }
 }
 return false;
 }
 
-fn hj(
-pP: vec3f, iO: vec3f, pX: f32, tn: f32,
+fn hx(
+qF: vec3f, je: vec3f, qT: f32, uM: f32,
 pA: vec3f, pB: vec3f, pC: vec3f, pD: vec3f,
-pZ: ptr<function, f32>
+qV: ptr<function, f32>
 ) -> bool {
 let eAB = pB - pA;
 let eAC = pC - pA;
 let eBD = pD - pB;
 let eCD = pD - pC;
-let tX = pA - pP;
-let tY = pB - pP;
+let vA = pA - qF;
+let vB = pB - qF;
 
 var u1: f32;
 var u2: f32;
 {
 let qN = cross(eAB, -eCD);
-let a = dot(qN, iO);
-var b = dot(cross(tY, iO), eBD);
-let c = dot(cross(tX, iO), eAC);
+let a = dot(qN, je);
+var b = dot(cross(vB, je), eBD);
+let c = dot(cross(vA, je), eAC);
 b -= a + c;
 
 let det = b * b - 4.0 * a * c;
@@ -62,19 +62,19 @@ if (a == 0.0) {
 u1 = -c / b;
 u2 = -1.0;
 } else {
-let vQ = sqrt(det);
-let wL = -0.5 * (b + sign(b) * vQ);
-u1 = wL / a;
-u2 = c / wL;
+let xF = sqrt(det);
+let yo = -0.5 * (b + sign(b) * xF);
+u1 = yo / a;
+u2 = c / yo;
 }
 }
 
-*pZ = tn;
+*qV = uM;
 
 var hit = false;
 
-hit = uX(u1, tX, tY, eAC, eBD, iO, pX, pZ) || 
-uX(u2, tX, tY, eAC, eBD, iO, pX, pZ);
+hit = wO(u1, vA, vB, eAC, eBD, je, qT, qV) || 
+wO(u2, vA, vB, eAC, eBD, je, qT, qV);
 if (!hit) {
 return false;
 }
@@ -82,70 +82,70 @@ return false;
 return true;
 }
 
-fn sv(
-pP: vec3f, iO: vec3f, pX: f32, tn: f32,
+fn tM(
+qF: vec3f, je: vec3f, qT: f32, uM: f32,
 pA: vec3f, pB: vec3f, pC: vec3f,
 pD: vec3f, pE: vec3f, pF: vec3f,
 
-bT: ptr<function, f32>,
-bS: ptr<function, f32>
+bX: ptr<function, f32>,
+bW: ptr<function, f32>
 ) -> bool {
-*bT = INF;
-*bS = -INF;
+*bX = INF;
+*bW = -INF;
 
-let wd = maxDimension(abs(iO));
-let gP = mv(iO, wd);
+let xV = maxDimension(abs(je));
+let gY = nk(je, xV);
 var tt: f32;
 
-tt = fL(
-pP, iO,
-fA(pC, pB, pA), wd, gP, INF
+tt = ga(
+qF, je,
+fP(pC, pB, pA), xV, gY, INF
 ).t;
 if (tt > 0.0) {
-*bT = min(*bT, tt);
-*bS = max(*bS, tt);
+*bX = min(*bX, tt);
+*bW = max(*bW, tt);
 }
-tt = fL(
-pP, iO,
-fA(pD, pE, pF), wd, gP, INF
+tt = ga(
+qF, je,
+fP(pD, pE, pF), xV, gY, INF
 ).t;
 if (tt > 0.0) {
-*bT = min(*bT, tt);
-*bS = max(*bS, tt);
+*bX = min(*bX, tt);
+*bW = max(*bW, tt);
 }
-if (hj(
-pP, iO, -INF, INF,
+if (hx(
+qF, je, -INF, INF,
 pA, pB, pD, pE,
 &tt)) {
-*bT = min(*bT, tt);
-*bS = max(*bS, tt);
+*bX = min(*bX, tt);
+*bW = max(*bW, tt);
 }
-if (hj(
-pP, iO, -INF, INF,
+if (hx(
+qF, je, -INF, INF,
 pB, pC, pE, pF,
 &tt)) {
-*bT = min(*bT, tt);
-*bS = max(*bS, tt);
+*bX = min(*bX, tt);
+*bW = max(*bW, tt);
 }
-if (hj(
-pP, iO, -INF, INF,
+if (hx(
+qF, je, -INF, INF,
 pC, pA, pF, pD,
 &tt)) {
-*bT = min(*bT, tt);
-*bS = max(*bS, tt);
+*bX = min(*bX, tt);
+*bW = max(*bW, tt);
 }
 
-*bT = max(*bT, pX);
-*bS = min(*bS, tn);
+*bX = max(*bX, qT);
+*bW = min(*bW, uM);
 
-return *bT <= *bS && *bS > 0.0;
+return *bX <= *bW && *bW > 0.0;
 }
 `;
 export default /* wgsl */ `
 
 ${displacementCommon}
 
-fn lQ(p: vec3f, p0: vec3f, p1: vec3f, p2: vec3f) -> vec3f {
+fn mz(p: vec3f, p0: vec3f, p1: vec3f, p2: vec3f) -> vec3f {
 let v0 = p1 - p0;
 let v1 = p2 - p0;
 let v2 = p - p0;
@@ -156,9 +156,9 @@ let d11 = dot(v1, v1);
 let d20 = dot(v2, v0);
 let d21 = dot(v2, v1);
 
-let tT = 1.0 / (d00 * d11 - d01 * d01);
-let v = clamp((d11 * d20 - d01 * d21) * tT, 0.0, 1.0);
-let w = clamp((d00 * d21 - d01 * d20) * tT, 0.0, 1.0);
+let vs = 1.0 / (d00 * d11 - d01 * d01);
+let v = clamp((d11 * d20 - d01 * d21) * vs, 0.0, 1.0);
+let w = clamp((d00 * d21 - d01 * d20) * vs, 0.0, 1.0);
 let u = 1.0 - v - w;
 
 return vec3f(u, v, w);
@@ -166,59 +166,59 @@ return vec3f(u, v, w);
 
 
 
-fn pc(
-qr: vec3f, qM: vec3f, wQ: f32,
+fn pY(
+rs: vec3f, rS: vec3f, yt: f32,
 _pA: vec3f, _pB: vec3f, _pC: vec3f,
 _nA: vec3f, _nB: vec3f, _nC: vec3f,
-vG: vec2f, vH: vec2f, vI: vec2f,
+xm: vec2f, xn: vec2f, xo: vec2f,
 
-jQ: i32,
-vF: vec2f,
+ku: i32,
+xl: vec2f,
 
-wk: f32, wj: f32,
+yd: f32, yc: f32,
 hScale: f32,
-uJ: f32,
-uf: f32,
+wk: f32,
+vH: f32,
 uvProjection: i32,
 uvScale: vec2f,
-vV: bool,
-rc: bool
-) -> jD {
+xM: bool,
+sk: bool
+) -> kc {
 
 
 
-let DT = select(max(abs(hScale) / 32.0, 1e-12), uf, uf > 0.0);
-let dt = DT / length(qM);
+let DT = select(max(abs(hScale) / 32.0, 1e-12), vH, vH > 0.0);
+let dt = DT / length(rS);
 let dbx = 0.001;
 let dby = 0.001;
 
-var result: jD;
+var result: kc;
 result.t = INF;
 
-var bT = INF;
-var bS = -INF;
+var bX = INF;
+var bW = -INF;
 
-let ra = sign(hScale);
-let uP = abs(hScale);
+let sg = sign(hScale);
+let wC = abs(hScale);
 
-let te = ra * normalize(cross(_pB - _pA, _pC - _pA));
+let uC = sg * normalize(cross(_pB - _pA, _pC - _pA));
 
 
-let dA = dot(_nA, te);
-let dB = dot(_nB, te);
-let dC = dot(_nC, te);
+let dA = dot(_nA, uC);
+let dB = dot(_nB, uC);
+let dC = dot(_nC, uC);
 
-var minH = wk * hScale * min(min(dA, dB), dC);
-var maxH = wj * hScale * max(max(dA, dB), dC);
+var minH = yd * hScale * min(min(dA, dB), dC);
+var maxH = yc * hScale * max(max(dA, dB), dC);
 
 
 
 
-let tZ = abs(maxH) - abs(minH);
+let vC = abs(maxH) - abs(minH);
 
 
 minH = sign(minH) * max(abs(minH) - DT * 2.0, 0.0);
-if (tZ < DT * 2.0) {
+if (vC < DT * 2.0) {
 maxH = sign(maxH) * min(abs(maxH) + DT * 2.0, abs(hScale));
 }
 
@@ -230,70 +230,70 @@ let pD = _pA + _nA * maxH / dA;
 let pE = _pB + _nB * maxH / dB;
 let pF = _pC + _nC * maxH / dC;
 
-if (!sv(
-qr, qM, 0.0, INF,
+if (!tM(
+rs, rS, 0.0, INF,
 pA, pB, pC,
 pD, pE, pF,
 
-&bT, &bS
+&bX, &bW
 )) {
 return result;
 }
 
-var wM = false;
+var yp = false;
 
-if (bS == bT) {
-bT = 0.0;
+if (bW == bX) {
+bX = 0.0;
 }
 
-var t = bT + dt * eo(2u);
-var s = qr + qM * t;
-var tS = dot(s - _pA, te);
-var vd = select(0.0, INF, ra < 0.0);
+var t = bX + dt * eC(2u);
+var s = rs + rS * t;
+var vq = dot(s - _pA, uC);
+var wV = select(0.0, INF, sg < 0.0);
 
-var c0 = _pA + _nA * tS / dA;
-var c1 = _pB + _nB * tS / dB;
-var c2 = _pC + _nC * tS / dC;
+var c0 = _pA + _nA * vq / dA;
+var c1 = _pB + _nB * vq / dB;
+var c2 = _pC + _nC * vq / dC;
 
-var tF: vec3f;
+var uV: vec3f;
 
-tS = abs(tS);
+vq = abs(vq);
 
-var qZ = tS - vd;
-var pY = qZ;
+var sf = vq - wV;
+var qU = sf;
 var step = 0;
 
 while (true) {
 
-let b = lQ(s, c0, c1, c2);
+let b = mz(s, c0, c1, c2);
 
-tF = _pA * b.x + _pB * b.y + _pC * b.z;
+uV = _pA * b.x + _pB * b.y + _pC * b.z;
 
-tS = distance(tF, s);
+vq = distance(uV, 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 = gU(uvProjection, uV - (_nA * b.x + _nB * b.y + _nC * b.z) * wk, n) * uvScale;
 }
 else {
-uv = vG * b.x + vH * b.y + vI * b.z;
+uv = xm * b.x + xn * b.y + xo * b.z;
 }
-let h = sampleMap(jQ, uv).x;
+let h = sampleMap(ku, uv).x;
 
-vd = max(uP * h, DT);
+wV = max(wC * h, DT);
 
 
-let dh = dot(te, s - c0);
+let dh = dot(uC, s - c0);
 c0 = c0 + _nA * dh / dA;
 c1 = c1 + _nB * dh / dB;
 c2 = c2 + _nC * dh / dC;
 
-pY = qZ;
-qZ = tS - vd;
+qU = sf;
+sf = vq - wV;
 
-if (!(select(qZ * ra, qZ * pY, rc) > 0.0
-&& t < bS + dt) 
+if (!(select(sf * sg, sf * qU, sk) > 0.0
+&& t < bW + dt) 
 
 && step > 0) {
 break;
@@ -301,15 +301,15 @@ break;
 
 step++;
 t = t + dt;
-s = s + qM * dt;
+s = s + rS * dt;
 }
 
-if (select(qZ * ra, qZ * pY, rc) <= 0.0) {
-let dtt = dt * (abs(qZ) / (abs(pY) + abs(qZ) + EPS));
+if (select(sf * sg, sf * qU, sk) <= 0.0) {
+let dtt = dt * (abs(sf) / (abs(qU) + abs(sf) + EPS));
 t = t - dtt;
 
-let wO = qr + qM * t;
-let b = lQ(wO, c0, c1, c2);
+let yr = rs + rS * t;
+let b = mz(yr, c0, c1, c2);
 
 let N = normalize(_nA * b.x + _nB * b.y + _nC * b.z);
 
@@ -317,33 +317,33 @@ let p_a = _pA * b.x + _pB * b.y + _pC * b.z;
 let p_b = _pA * (b.x + dbx) + _pB * b.y + _pC * (b.z - dbx);
 let p_c = _pA * b.x + _pB * (b.y + dby) + _pC * (b.z - dby);
 
-var wg: vec2f;
-var wh: vec2f;
-var wi: vec2f;
+var xX: vec2f;
+var xY: vec2f;
+var xZ: vec2f;
 
 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;
+xX = gU(uvProjection, p_a - (_nA * b.x + _nB * b.y + _nC * b.z) * wk, NA) * uvScale;
+xY = gU(uvProjection, p_b - (_nA * (b.x + dbx) + _nB * b.y + _nC * (b.z - dbx)) * wk, NB) * uvScale;
+xZ = gU(uvProjection, p_c - (_nA * b.x + _nB * (b.y + dby) + _nC * (b.z - dby)) * wk, NC) * uvScale;
 }
 else {
-wg = vG * b.x + vH * b.y + vI * b.z;
-wh = vG * (b.x + dbx) + vH * b.y + vI * (b.z - dbx);
-wi = vG * b.x + vH * (b.y + dby) + vI * (b.z - dby);
+xX = xm * b.x + xn * b.y + xo * b.z;
+xY = xm * (b.x + dbx) + xn * b.y + xo * (b.z - dbx);
+xZ = xm * b.x + xn * (b.y + dby) + xo * (b.z - dby);
 }
 
-let s_a = p_a + ra * N * sampleMap(jQ, wg).x * hScale;
-let s_b = p_b + ra * N * sampleMap(jQ, wh).x * hScale;
-let s_c = p_c + ra * N * sampleMap(jQ, wi).x * hScale;
+let s_a = p_a + sg * N * sampleMap(ku, xX).x * hScale;
+let s_b = p_b + sg * N * sampleMap(ku, xY).x * hScale;
+let s_c = p_c + sg * N * sampleMap(ku, xZ).x * hScale;
 
-let N_s = -ra * normalize(cross(s_c - s_a, s_b - s_a));
+let N_s = -sg * normalize(cross(s_c - s_a, s_b - s_a));
 
 result.t = t;
 result.barycentric = b;
-result.normal = normalize(N_s - te + ra * N);
+result.normal = normalize(N_s - uC + sg * N);
 }
 
 return result;

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

@@ -4,13 +4,13 @@
 export default /* wgsl */ `
 var<private> s0: vec4u;
 
-fn kh(p: vec2u, frame: i32) {
+fn gW(p: vec2u, frame: i32) {
 
 s0 = vec4u(p, u32(frame), u32(p.x) + u32(p.y));
 }
 
 
-fn vx() {
+fn xd() {
 s0 = s0 * 1664525u + 1013904223u;
 s0.x += s0.y*s0.w; s0.y += s0.z*s0.x; s0.z += s0.x*s0.y; s0.w += s0.y*s0.z;
 s0 = s0 ^ (s0>>vec4(16u));
@@ -18,7 +18,7 @@ s0.x += s0.y*s0.w; s0.y += s0.z*s0.x; s0.z += s0.x*s0.y; s0.w += s0.y*s0.z;
 }
 
 fn rand() -> f32 {
-vx(); return f32(s0.x)/f32(0xffffffffu);
+xd(); return f32(s0.x)/f32(0xffffffffu);
 }
 
 `;

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

@@ -1,5 +1,6 @@
-export default function rayTraceCore({ hasAnisotropyDirections, hasCoatNormals, hasSceneAlpha }: {
+export default function rayTraceCore({ hasAnisotropyDirections, hasCoatNormals, hasSceneAlpha, lightCapabilities }: {
     hasAnisotropyDirections?: boolean;
     hasCoatNormals?: boolean;
     hasSceneAlpha?: boolean;
+    lightCapabilities?: number;
 }): string;

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

@@ -1,7 +1,8 @@
-import { materialBufferWgsl } from '../../materialLayout.js';
+import { materialBufferWgsl } from '../../materialLayoutSchema.js';
+import { ALL_LIGHT_SHADER_CAPABILITIES, LIGHT_SHADER_CAPABILITIES } from '../../shaderCapabilities.js';
 import { ShadowCatcherMaterial, UnlitMaterial } from '../../../constants.js';
-import { CONSTANT_DIRECTIONAL_LIGHT, CONSTANT_RECT_LIGHT, CONSTANT_SPHERE_LIGHT, CONSTANT_SPOT_LIGHT } from '../../lightsUtil.js';
-export default function rayTraceCore({ hasAnisotropyDirections = true, hasCoatNormals = false, hasSceneAlpha = true }) {
+import { CONSTANT_DIRECTIONAL_LIGHT, CONSTANT_RECT_LIGHT, CONSTANT_SPHERE_LIGHT, CONSTANT_SPOT_LIGHT } from '../../lightConstants.js';
+export default function rayTraceCore({ hasAnisotropyDirections = true, hasCoatNormals = false, hasSceneAlpha = true, lightCapabilities = ALL_LIGHT_SHADER_CAPABILITIES }) {
     return /*wgsl*/ `
 
 const luminance = vec3f(0.2126, 0.7152, 0.0722);
@@ -15,13 +16,18 @@ const RECT_LIGHT = ${CONSTANT_RECT_LIGHT};
 const SPHERE_LIGHT = ${CONSTANT_SPHERE_LIGHT};
 const DIRECTIONAL_LIGHT = ${CONSTANT_DIRECTIONAL_LIGHT};
 const SPOT_LIGHT = ${CONSTANT_SPOT_LIGHT};
+const HAS_SCENE_SPHERE_LIGHT = ${(lightCapabilities & LIGHT_SHADER_CAPABILITIES.SphereLight) !== 0};
+const HAS_SCENE_RECT_LIGHT = ${(lightCapabilities & LIGHT_SHADER_CAPABILITIES.RectLight) !== 0};
+const HAS_SCENE_SPOT_LIGHT = ${(lightCapabilities & LIGHT_SHADER_CAPABILITIES.SpotLight) !== 0};
+const HAS_SCENE_DIRECTIONAL_LIGHT = ${(lightCapabilities & LIGHT_SHADER_CAPABILITIES.DirectionalLight) !== 0};
+const HAS_SCENE_EMISSIVE_LIGHT = ${(lightCapabilities & LIGHT_SHADER_CAPABILITIES.emissive) !== 0};
 
 struct Ray {
 o: vec3f,
 d: vec3f,
 };
 
-struct ad {
+struct SurfaceInteraction {
 position: vec3f,
 
 
@@ -66,7 +72,7 @@ mediumAnisotropy: f32,
 
 
 
-struct J {
+struct OpenPbrResolvedMaterial {
 baseColor: vec3f,
 transmissionWeight: f32,
 
@@ -203,7 +209,7 @@ secondaryUv1: vec2f,
 secondaryUv2: vec2f,
 };
 
-struct pe {
+struct qb {
 probability: f32,
 aliasIndex: i32,
 sourceType: i32,
@@ -250,8 +256,12 @@ sceneFeatureFlags: u32,
 sequenceSeed: u32,
 zSobolLogSPP: u32,
 sampleSequenceOffset: u32,
+
+shadowCatcherChoiceOffset: i32,
+shadowCatcherChoiceCount: i32,
 environmentRotation: mat4x4f,
 backgroundMapTransform: vec4f,
+backgroundMapRotation: mat4x4f,
 }
 
 
@@ -273,44 +283,44 @@ backgroundMapTransform: vec4f,
 @group(1) @binding(9) var openPbrEnergyLut: texture_2d<f32>;
 @group(1) @binding(10) var adaptiveSampleTargets: texture_2d<f32>;
 
-fn cL(dV: i32, ls: i32) -> f32 {
-let im = dV + ls / 4;
+fn cS(el: i32, mc: i32) -> f32 {
+let iK = el + mc / 4;
 let width = rtUniform.lightSamplingTextureWidth;
-let packed = textureLoad(lightSamplingData, vec2i(im % width, im / width), 0);
-return packed[ls % 4];
+let packed = textureLoad(lightSamplingData, vec2i(iK % width, iK / width), 0);
+return packed[mc % 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);
+fn lB(el: i32, uv: vec2f) -> f32 {
+if (el < 0) { return 1.0; }
+let pixel = fract(uv) * 128.0 - vec2f(0.5);
+let x0 = i32(floor(pixel.x));
+let y0 = i32(floor(pixel.y));
+let fx = fract(pixel.x);
+let fy = fract(pixel.y);
 let xa = select(x0, 127, x0 < 0);
 let xb = select(x0 + 1, 0, x0 >= 127);
 let ya = select(y0, 127, y0 < 0);
 let yb = select(y0 + 1, 0, y0 >= 127);
-let a = cL(dV, ya * 128 + xa);
-let b = cL(dV, ya * 128 + xb);
-let c = cL(dV, yb * 128 + xa);
-let d = cL(dV, yb * 128 + xb);
+let a = cS(el, ya * 128 + xa);
+let b = cS(el, ya * 128 + xb);
+let c = cS(el, yb * 128 + xa);
+let d = cS(el, yb * 128 + xb);
 return mix(mix(a, b, fx), mix(c, d, fx), fy);
 }
 
-fn bL(light: Light, dK: vec3f) -> f32 {
+fn bP(light: Light, dV: vec3f) -> f32 {
 let axis = normalize(light.u);
-let cc = dot(axis, dK);
-var tP = select(0.0, 1.0, cc >= light.v.x);
+let ci = dot(axis, dV);
+var vm = select(0.0, 1.0, ci >= light.v.x);
 if (light.v.y > light.v.x + 1e-6) {
-tP = smoothstep(light.v.x, light.v.y, cc);
+vm = smoothstep(light.v.x, light.v.y, ci);
 }
-if (tP <= 0.0 || light.textureIndex < 0.0) { return tP; }
-let uj = light.iesReference;
-let vD = cross(axis, uj);
-let vertical = acos(clamp(cc, -1.0, 1.0));
-let horizontal = atan2(dot(dK, vD), dot(dK, uj));
-return tP * kR(i32(light.textureIndex), vec2f(vertical / PI, horizontal / TWOPI + 0.5));
+if (vm <= 0.0 || light.textureIndex < 0.0) { return vm; }
+let vK = light.iesReference;
+let xj = cross(axis, vK);
+let vertical = acos(clamp(ci, -1.0, 1.0));
+let horizontal = atan2(dot(dV, xj), dot(dV, vK));
+return vm * lB(i32(light.textureIndex), vec2f(vertical / PI, horizontal / TWOPI + 0.5));
 }
 
 
@@ -322,7 +332,7 @@ return tP * kR(i32(light.textureIndex), vec2f(vertical / PI, horizontal / TWOPI
 @group(2) @binding(2) var<uniform> analyticLights: array<Light, NUM_UNIFORM_LIGHTS>;
 
 
-fn iC(ray: ptr<function, Ray>, origin: vec3f, direction: vec3f) {
+fn gC(ray: ptr<function, Ray>, origin: vec3f, direction: vec3f) {
 (*ray).o = origin;
 (*ray).d = direction;
 }