@meimu/mutracer 0.3.0 → 0.3.1

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

@@ -1,56 +1,56 @@
 const displacementCommon = /*wgsl*/ `
 
 
-struct jI {
+struct kn {
 barycentric: vec3f,
 t: f32,
 normal: vec3f,
 
 }
 
-fn xp(
+fn zq(
 uu: f32,
-vK: vec3f, vL: vec3f,
+xC: vec3f, xE: vec3f,
 eAC: vec3f, eBD: vec3f,
-iM: vec3f,
-qK: f32,
-qM: ptr<function, f32>
+jn: vec3f,
+rZ: f32,
+sb: ptr<function, f32>
 ) -> bool {
 if (uu >= 0.0 && uu <= 1.0) {
-let pAB = mix(vK, vL, uu);
+let pAB = mix(xC, xE, uu);
 let pCD = mix(eAC, eBD, uu);
-var n = cross(iM, pCD);
-let xH = 1.0 / dot(n, n);
+var n = cross(jn, pCD);
+let zH = 1.0 / dot(n, n);
 n = cross(n, pAB);
-let tt = dot(n, pCD) * xH;
-let vv = dot(n, iM) * xH;
-if (vv >= 0.0 && vv <= 1.0 && tt > qK && tt < *qM) {
-*qM = tt;
+let tt = dot(n, pCD) * zH;
+let vv = dot(n, jn) * zH;
+if (vv >= 0.0 && vv <= 1.0 && tt > rZ && tt < *sb) {
+*sb = tt;
 return true;
 }
 }
 return false;
 }
 
-fn hc(
-qx: vec3f, iM: vec3f, qK: f32, uR: f32,
+fn hA(
+rK: vec3f, jn: vec3f, rZ: f32, wE: f32,
 pA: vec3f, pB: vec3f, pC: vec3f, pD: vec3f,
-qM: ptr<function, f32>
+sb: ptr<function, f32>
 ) -> bool {
 let eAB = pB - pA;
 let eAC = pC - pA;
 let eBD = pD - pB;
 let eCD = pD - pC;
-let vK = pA - qx;
-let vL = pB - qx;
+let xC = pA - rK;
+let xE = pB - rK;
 
 var u1: f32;
 var u2: f32;
 {
 let qN = cross(eAB, -eCD);
-let a = dot(qN, iM);
-var b = dot(cross(vL, iM), eBD);
-let c = dot(cross(vK, iM), eAC);
+let a = dot(qN, jn);
+var b = dot(cross(xE, jn), eBD);
+let c = dot(cross(xC, jn), 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 yg = sqrt(det);
-let yN = -0.5 * (b + sign(b) * yg);
-u1 = yN / a;
-u2 = c / yN;
+let Ad = sqrt(det);
+let AO = -0.5 * (b + sign(b) * Ad);
+u1 = AO / a;
+u2 = c / AO;
 }
 }
 
-*qM = uR;
+*sb = wE;
 
 var hit = false;
 
-hit = xp(u1, vK, vL, eAC, eBD, iM, qK, qM) || 
-xp(u2, vK, vL, eAC, eBD, iM, qK, qM);
+hit = zq(u1, xC, xE, eAC, eBD, jn, rZ, sb) || 
+zq(u2, xC, xE, eAC, eBD, jn, rZ, sb);
 if (!hit) {
 return false;
 }
@@ -82,8 +82,8 @@ return false;
 return true;
 }
 
-fn tO(
-qx: vec3f, iM: vec3f, qK: f32, uR: f32,
+fn vt(
+rK: vec3f, jn: vec3f, rZ: f32, wE: f32,
 pA: vec3f, pB: vec3f, pC: vec3f,
 pD: vec3f, pE: vec3f, pF: vec3f,
 
@@ -93,50 +93,50 @@ bN: ptr<function, f32>
 *bO = INF;
 *bN = -INF;
 
-let yv = maxDimension(abs(iM));
-let gH = mU(iM, yv);
+let Aw = maxDimension(abs(jn));
+let gZ = nV(jn, Aw);
 var tt: f32;
 
-tt = fM(
-qx, iM,
-fw(pC, pB, pA), yv, gH, INF
+tt = fY(
+rK, jn,
+fL(pC, pB, pA), Aw, gZ, INF
 ).t;
 if (tt > 0.0) {
 *bO = min(*bO, tt);
 *bN = max(*bN, tt);
 }
-tt = fM(
-qx, iM,
-fw(pD, pE, pF), yv, gH, INF
+tt = fY(
+rK, jn,
+fL(pD, pE, pF), Aw, gZ, INF
 ).t;
 if (tt > 0.0) {
 *bO = min(*bO, tt);
 *bN = max(*bN, tt);
 }
-if (hc(
-qx, iM, -INF, INF,
+if (hA(
+rK, jn, -INF, INF,
 pA, pB, pD, pE,
 &tt)) {
 *bO = min(*bO, tt);
 *bN = max(*bN, tt);
 }
-if (hc(
-qx, iM, -INF, INF,
+if (hA(
+rK, jn, -INF, INF,
 pB, pC, pE, pF,
 &tt)) {
 *bO = min(*bO, tt);
 *bN = max(*bN, tt);
 }
-if (hc(
-qx, iM, -INF, INF,
+if (hA(
+rK, jn, -INF, INF,
 pC, pA, pF, pD,
 &tt)) {
 *bO = min(*bO, tt);
 *bN = max(*bN, tt);
 }
 
-*bO = max(*bO, qK);
-*bN = min(*bN, uR);
+*bO = max(*bO, rZ);
+*bN = min(*bN, wE);
 
 return *bO <= *bN && *bN > 0.0;
 }
@@ -145,7 +145,7 @@ export default /* wgsl */ `
 
 ${displacementCommon}
 
-fn mg(p: vec3f, p0: vec3f, p1: vec3f, p2: vec3f) -> vec3f {
+fn mY(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 vF = 1.0 / (d00 * d11 - d01 * d01);
-let v = clamp((d11 * d20 - d01 * d21) * vF, 0.0, 1.0);
-let w = clamp((d00 * d21 - d01 * d20) * vF, 0.0, 1.0);
+let xt = 1.0 / (d00 * d11 - d01 * d01);
+let v = clamp((d11 * d20 - d01 * d21) * xt, 0.0, 1.0);
+let w = clamp((d00 * d21 - d01 * d20) * xt, 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 pS(
-rl: vec3f, rP: vec3f, yR: f32,
+fn qW(
+sC: vec3f, th: vec3f, AU: f32,
 _pA: vec3f, _pB: vec3f, _pC: vec3f,
 _nA: vec3f, _nB: vec3f, _nC: vec3f,
-xQ: vec2f, xR: vec2f, xS: vec2f,
+zN: vec2f, zO: vec2f, zP: vec2f,
 
-jW: i32,
-xP: vec2f,
+kC: i32,
+zM: vec2f,
 
-yE: f32, yD: f32,
+AC: f32, AB: f32,
 hScale: f32,
-wG: f32,
-vR: f32,
+yF: f32,
+xM: f32,
 uvProjection: i32,
 uvScale: vec2f,
-ym: bool,
-se: bool
-) -> jI {
+Ak: bool,
+tE: bool
+) -> kn {
 
 
 
-let DT = select(max(abs(hScale) / 32.0, 1e-12), vR, vR > 0.0);
-let dt = DT / length(rP);
+let DT = select(max(abs(hScale) / 32.0, 1e-12), xM, xM > 0.0);
+let dt = DT / length(th);
 let dbx = 0.001;
 let dby = 0.001;
 
-var result: jI;
+var result: kn;
 result.t = INF;
 
 var bO = INF;
 var bN = -INF;
 
-let sb = sign(hScale);
-let wZ = abs(hScale);
+let tC = sign(hScale);
+let yZ = abs(hScale);
 
-let uG = sb * normalize(cross(_pB - _pA, _pC - _pA));
+let wp = tC * normalize(cross(_pB - _pA, _pC - _pA));
 
 
-let dA = dot(_nA, uG);
-let dB = dot(_nB, uG);
-let dC = dot(_nC, uG);
+let dA = dot(_nA, wp);
+let dB = dot(_nB, wp);
+let dC = dot(_nC, wp);
 
-var minH = yE * hScale * min(min(dA, dB), dC);
-var maxH = yD * hScale * max(max(dA, dB), dC);
+var minH = AC * hScale * min(min(dA, dB), dC);
+var maxH = AB * hScale * max(max(dA, dB), dC);
 
 
 
 
-let vM = abs(maxH) - abs(minH);
+let xG = abs(maxH) - abs(minH);
 
 
 minH = sign(minH) * max(abs(minH) - DT * 2.0, 0.0);
-if (vM < DT * 2.0) {
+if (xG < DT * 2.0) {
 maxH = sign(maxH) * min(abs(maxH) + DT * 2.0, abs(hScale));
 }
 
@@ -230,8 +230,8 @@ let pD = _pA + _nA * maxH / dA;
 let pE = _pB + _nB * maxH / dB;
 let pF = _pC + _nC * maxH / dC;
 
-if (!tO(
-rl, rP, 0.0, INF,
+if (!vt(
+sC, th, 0.0, INF,
 pA, pB, pC,
 pD, pE, pF,
 
@@ -240,59 +240,59 @@ pD, pE, pF,
 return result;
 }
 
-var yO = false;
+var AQ = false;
 
 if (bN == bO) {
 bO = 0.0;
 }
 
-var t = bO + dt * ek(2u);
-var s = rl + rP * t;
-var vE = dot(s - _pA, uG);
-var hSurf = select(0.0, INF, sb < 0.0);
+var t = bO + dt * cm(2u);
+var s = sC + th * t;
+var xr = dot(s - _pA, wp);
+var hSurf = select(0.0, INF, tC < 0.0);
 
-var c0 = _pA + _nA * vE / dA;
-var c1 = _pB + _nB * vE / dB;
-var c2 = _pC + _nC * vE / dC;
+var c0 = _pA + _nA * xr / dA;
+var c1 = _pB + _nB * xr / dB;
+var c2 = _pC + _nC * xr / dC;
 
-var vc: vec3f;
+var wQ: vec3f;
 
-vE = abs(vE);
+xr = abs(xr);
 
-var hDiff = vE - hSurf;
-var qL = hDiff;
+var hDiff = xr - hSurf;
+var sa = hDiff;
 var step = 0;
 
 while (true) {
 
-let b = mg(s, c0, c1, c2);
+let b = mY(s, c0, c1, c2);
 
-vc = _pA * b.x + _pB * b.y + _pC * b.z;
+wQ = _pA * b.x + _pB * b.y + _pC * b.z;
 
-vE = distance(vc, s);
+xr = distance(wQ, s);
 
 var uv: vec2f;
 if (uvProjection > 0) {
 let n = normalize(_nA * b.x + _nB * b.y + _nC * b.z);
-uv = gE(uvProjection, vc - (_nA * b.x + _nB * b.y + _nC * b.z) * wG, n) * uvScale;
+uv = gW(uvProjection, wQ - (_nA * b.x + _nB * b.y + _nC * b.z) * yF, n) * uvScale;
 }
 else {
-uv = xQ * b.x + xR * b.y + xS * b.z;
+uv = zN * b.x + zO * b.y + zP * b.z;
 }
-let h = sampleMap(jW, uv).x;
+let h = sampleMap(kC, uv).x;
 
-hSurf = max(wZ * h, DT);
+hSurf = max(yZ * h, DT);
 
 
-let dh = dot(uG, s - c0);
+let dh = dot(wp, s - c0);
 c0 = c0 + _nA * dh / dA;
 c1 = c1 + _nB * dh / dB;
 c2 = c2 + _nC * dh / dC;
 
-qL = hDiff;
-hDiff = vE - hSurf;
+sa = hDiff;
+hDiff = xr - hSurf;
 
-if (!(select(hDiff * sb, hDiff * qL, se) > 0.0
+if (!(select(hDiff * tC, hDiff * sa, tE) > 0.0
 && t < bN + dt) 
 
 && step > 0) {
@@ -301,15 +301,15 @@ break;
 
 step++;
 t = t + dt;
-s = s + rP * dt;
+s = s + th * dt;
 }
 
-if (select(hDiff * sb, hDiff * qL, se) <= 0.0) {
-let dtt = dt * (abs(hDiff) / (abs(qL) + abs(hDiff) + EPS));
+if (select(hDiff * tC, hDiff * sa, tE) <= 0.0) {
+let dtt = dt * (abs(hDiff) / (abs(sa) + abs(hDiff) + EPS));
 t = t - dtt;
 
-let yP = rl + rP * t;
-let b = mg(yP, c0, c1, c2);
+let AS = sC + th * t;
+let b = mY(AS, 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 yA: vec2f;
-var yB: vec2f;
-var yC: vec2f;
+var Ay: vec2f;
+var Az: vec2f;
+var AA: 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));  
-yA = gE(uvProjection, p_a - (_nA * b.x + _nB * b.y + _nC * b.z) * wG, NA) * uvScale;
-yB = gE(uvProjection, p_b - (_nA * (b.x + dbx) + _nB * b.y + _nC * (b.z - dbx)) * wG, NB) * uvScale;
-yC = gE(uvProjection, p_c - (_nA * b.x + _nB * (b.y + dby) + _nC * (b.z - dby)) * wG, NC) * uvScale;
+Ay = gW(uvProjection, p_a - (_nA * b.x + _nB * b.y + _nC * b.z) * yF, NA) * uvScale;
+Az = gW(uvProjection, p_b - (_nA * (b.x + dbx) + _nB * b.y + _nC * (b.z - dbx)) * yF, NB) * uvScale;
+AA = gW(uvProjection, p_c - (_nA * b.x + _nB * (b.y + dby) + _nC * (b.z - dby)) * yF, NC) * uvScale;
 }
 else {
-yA = xQ * b.x + xR * b.y + xS * b.z;
-yB = xQ * (b.x + dbx) + xR * b.y + xS * (b.z - dbx);
-yC = xQ * b.x + xR * (b.y + dby) + xS * (b.z - dby);
+Ay = zN * b.x + zO * b.y + zP * b.z;
+Az = zN * (b.x + dbx) + zO * b.y + zP * (b.z - dbx);
+AA = zN * b.x + zO * (b.y + dby) + zP * (b.z - dby);
 }
 
-let s_a = p_a + sb * N * sampleMap(jW, yA).x * hScale;
-let s_b = p_b + sb * N * sampleMap(jW, yB).x * hScale;
-let s_c = p_c + sb * N * sampleMap(jW, yC).x * hScale;
+let s_a = p_a + tC * N * sampleMap(kC, Ay).x * hScale;
+let s_b = p_b + tC * N * sampleMap(kC, Az).x * hScale;
+let s_c = p_c + tC * N * sampleMap(kC, AA).x * hScale;
 
-let N_s = -sb * normalize(cross(s_c - s_a, s_b - s_a));
+let N_s = -tC * normalize(cross(s_c - s_a, s_b - s_a));
 
 result.t = t;
 result.barycentric = b;
-result.normal = normalize(N_s - uG + sb * N);
+result.normal = normalize(N_s - wp + tC * N);
 }
 
 return result;

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

@@ -4,13 +4,13 @@
 export default /* wgsl */ `
 var<private> s0: vec4u;
 
-fn fi(p: vec2u, frame: i32) {
+fn fA(p: vec2u, frame: i32) {
 
 s0 = vec4u(p, u32(frame), u32(p.x) + u32(p.y));
 }
 
 
-fn xF() {
+fn zF() {
 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 {
-xF(); return f32(s0.x)/f32(0xffffffffu);
+zF(); return f32(s0.x)/f32(0xffffffffu);
 }
 
 `;

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

@@ -1,7 +1,10 @@
-export default function rayTraceCore({ hasAnisotropyDirections, hasCoatNormals, hasSceneAlpha, caustics, lightCapabilities }: {
+export default function rayTraceCore({ independentTextures, compactVertices, hasAnisotropyDirections, hasCoatNormals, hasSceneAlpha, cameraProjectionInverse, caustics, lightCapabilities }: {
+    independentTextures?: boolean;
+    compactVertices?: boolean;
     hasAnisotropyDirections?: boolean;
     hasCoatNormals?: boolean;
     hasSceneAlpha?: boolean;
+    cameraProjectionInverse?: boolean;
     caustics?: boolean;
     lightCapabilities?: number;
 }): string;

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

@@ -1,8 +1,11 @@
+import { vertexAttributeReaders } from './vertexAttributes.wgsl.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 '../../lightConstants.js';
-export default function rayTraceCore({ hasAnisotropyDirections = true, hasCoatNormals = false, hasSceneAlpha = true, caustics = false, lightCapabilities = ALL_LIGHT_SHADER_CAPABILITIES }) {
+export default function rayTraceCore({ 
+// Independent mapInfo starts with image width, height and binding-array index.
+independentTextures = false, compactVertices = false, hasAnisotropyDirections = true, hasCoatNormals = false, hasSceneAlpha = true, cameraProjectionInverse = false, caustics = false, lightCapabilities = ALL_LIGHT_SHADER_CAPABILITIES }) {
     return /*wgsl*/ `
 
 const luminance = vec3f(0.2126, 0.7152, 0.0722);
@@ -149,6 +152,8 @@ thinWalled: bool,
 };
 
 struct Path {
+
+scatteringMediumEntered: bool,
 ray: Ray,
 li: vec3f,
 alpha: f32,
@@ -219,7 +224,7 @@ secondaryUv1: vec2f,
 secondaryUv2: vec2f,
 };
 
-struct pW {
+struct ra {
 probability: f32,
 aliasIndex: i32,
 sourceType: i32,
@@ -232,7 +237,7 @@ struct CameraUniform {
 viewProjectionInv: mat4x4<f32>,
 viewInv: mat4x4<f32>,
 apertureRadius: f32,
-focusDistance: f32,
+focusDistance: f32,${cameraProjectionInverse ? '\n  projectionInv: mat4x4<f32>,' : ''}
 };
 
 struct RayTraceUniform {
@@ -277,15 +282,16 @@ backgroundMapRotation: mat4x4f,
 
 @group(0) @binding(0) var<storage, read> bvhBuffer: array<vec4f>;
 @group(0) @binding(1) var<storage, read> instancesBuffer: array<vec4f>;
-@group(0) @binding(2) var<storage, read> attrBuffers: array<${hasAnisotropyDirections ? /* wgsl */ `vec4f` : /* wgsl */ `vec3f`}>;
+@group(0) @binding(2) var<storage, read> attrBuffers: array<${compactVertices ? 'u32' : hasAnisotropyDirections ? 'vec4f' : 'vec3f'}>;
+${vertexAttributeReaders(compactVertices, hasAnisotropyDirections)}
 @group(0) @binding(3) var<storage, read> materialsBuffer: array<MaterialBuffer>;
 
 
 @group(1) @binding(0) var mapSampler: sampler;
-@group(1) @binding(1) var map: texture_2d_array<f32>;
+@group(1) @binding(1) var map: ${independentTextures ? 'binding_array<texture_2d<f32>>' : 'texture_2d_array<f32>'};
 
 
-@group(1) @binding(3) var<uniform> mapInfo: array<vec4f, NUM_MAPS * 3>;
+@group(1) @binding(3) var<${independentTextures ? 'storage, read' : 'uniform'}> mapInfo: array<vec4f, NUM_MAPS * 3>;
 @group(1) @binding(4) var envMap: texture_2d<f32>;
 @group(1) @binding(5) var envMapDistribution: texture_2d<f32>;
 @group(1) @binding(6) var backgroundMap: texture_2d<f32>;
@@ -293,15 +299,15 @@ backgroundMapRotation: mat4x4f,
 @group(1) @binding(9) var openPbrEnergyLut: texture_2d<f32>;
 @group(1) @binding(10) var adaptiveSampleTargets: texture_2d<f32>;
 
-fn cF(dV: i32, lK: i32) -> f32 {
-let im = dV + lK / 4;
+fn cI(ec: i32, mC: i32) -> f32 {
+let iR = ec + mC / 4;
 let width = rtUniform.lightSamplingTextureWidth;
-let packed = textureLoad(lightSamplingData, vec2i(im % width, im / width), 0);
-return packed[lK % 4];
+let packed = textureLoad(lightSamplingData, vec2i(iR % width, iR / width), 0);
+return packed[mC % 4];
 }
 
-fn ld(dV: i32, uv: vec2f) -> f32 {
-if (dV < 0) { return 1.0; }
+fn lW(ec: i32, uv: vec2f) -> f32 {
+if (ec < 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));
@@ -311,26 +317,26 @@ 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 = cF(dV, ya * 128 + xa);
-let b = cF(dV, ya * 128 + xb);
-let c = cF(dV, yb * 128 + xa);
-let d = cF(dV, yb * 128 + xb);
+let a = cI(ec, ya * 128 + xa);
+let b = cI(ec, ya * 128 + xb);
+let c = cI(ec, yb * 128 + xa);
+let d = cI(ec, yb * 128 + xb);
 return mix(mix(a, b, fx), mix(c, d, fx), fy);
 }
 
-fn evaluateSpotEmissionMultiplier(light: Light, dI: vec3f) -> f32 {
+fn evaluateSpotEmissionMultiplier(light: Light, dL: vec3f) -> f32 {
 let axis = normalize(light.u);
-let ct = dot(axis, dI);
-var vw = select(0.0, 1.0, ct >= light.v.x);
+let cv = dot(axis, dL);
+var xm = select(0.0, 1.0, cv >= light.v.x);
 if (light.v.y > light.v.x + 1e-6) {
-vw = smoothstep(light.v.x, light.v.y, ct);
+xm = smoothstep(light.v.x, light.v.y, cv);
 }
-if (vw <= 0.0 || light.textureIndex < 0.0) { return vw; }
-let vX = light.iesReference;
-let xN = cross(axis, vX);
-let vertical = acos(clamp(ct, -1.0, 1.0));
-let horizontal = atan2(dot(dI, xN), dot(dI, vX));
-return vw * ld(i32(light.textureIndex), vec2f(vertical / PI, horizontal / TWOPI + 0.5));
+if (xm <= 0.0 || light.textureIndex < 0.0) { return xm; }
+let xT = light.iesReference;
+let zK = cross(axis, xT);
+let vertical = acos(clamp(cv, -1.0, 1.0));
+let horizontal = atan2(dot(dL, zK), dot(dL, xT));
+return xm * lW(i32(light.textureIndex), vec2f(vertical / PI, horizontal / TWOPI + 0.5));
 }