@meimu/mutracer 0.1.1 → 0.1.3

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

@@ -1,6 +1,6 @@
 import { LIGHT_CHOICE_ANALYTIC, LIGHT_CHOICE_EMISSIVE_TRIANGLE, LIGHT_CHOICE_ENVIRONMENT } from '../../lightSampling.js';
 export default /*wgsl */ `
-fn eJ(light: Light, fm: vec3f, iT: vec2f, lightSample: ptr<function, LightSampleRec>) {
+fn eJ(light: Light, fm: vec3f, iU: vec2f, lightSample: ptr<function, LightSampleRec>) {
 let iq = light.position - fm;
 let aj = length(iq);
 if (light.radiusOrSpread <= 0.0) {
@@ -27,13 +27,13 @@ return;
 }
 let radius = max(light.radiusOrSpread, 1e-6);
 (*lightSample).isDelta = false;
-var gC: vec3f;
+var gF: vec3f;
 
 if (aj <= radius) {
-let z = 1.0 - 2.0 * iT.x;
+let z = 1.0 - 2.0 * iU.x;
 let fi = sqrt(max(0.0, 1.0 - z * z));
-let br = TWOPI * iT.y;
-gC = vec3f(
+let br = TWOPI * iU.y;
+gF = vec3f(
 fi * cos(br),
 fi * sin(br),
 z
@@ -41,19 +41,19 @@ z
 (*lightSample).pdf = INV4PI;
 }
 else {
-let sF = iq / aj;
-let jn = min(
+let sK = iq / aj;
+let jp = min(
 1.0,
 radius * radius / (aj * aj)
 );
-let cosThetaMax = sqrt(max(0.0, 1.0 - jn));
-let cc = mix(1.0, cosThetaMax, iT.x);
+let cosThetaMax = sqrt(max(0.0, 1.0 - jp));
+let cc = mix(1.0, cosThetaMax, iU.x);
 let sinTheta = sqrt(max(0.0, 1.0 - cc * cc));
-let br = TWOPI * iT.y;
+let br = TWOPI * iU.y;
 var tangent: vec3f;
 var bitangent: vec3f;
-aK(sF, &tangent, &bitangent);
-gC = sF * cc
+aL(sK, &tangent, &bitangent);
+gF = sK * cc
 + tangent * (sinTheta * cos(br))
 + bitangent * (sinTheta * sin(br));
 (*lightSample).pdf = 1.0 / max(
@@ -62,16 +62,16 @@ TWOPI * (1.0 - cosThetaMax),
 );
 }
 
-let ir = dot(gC, iq);
-let pQ = dot(iq, iq);
+let ir = dot(gF, iq);
+let pU = dot(iq, iq);
 let ej = ir * ir
-- pQ + radius * radius;
+- pU + radius * radius;
 let cN = ir - sqrt(max(0.0, ej));
-let cB = ir + sqrt(max(0.0, ej));
-(*lightSample).dist = select(cB, cN, cN > 1e-6);
-(*lightSample).direction = gC;
-let rQ = fm + gC * (*lightSample).dist;
-(*lightSample).normal = normalize(rQ - light.position);
+let cC = ir + sqrt(max(0.0, ej));
+(*lightSample).dist = select(cC, cN, cN > 1e-6);
+(*lightSample).direction = gF;
+let rV = fm + gF * (*lightSample).dist;
+(*lightSample).normal = normalize(rV - light.position);
 (*lightSample).emission = light.emission;
 }
 
@@ -86,15 +86,15 @@ return;
 }
 let width = length(light.u);
 let height = length(light.v);
-let hY = surfacePoint - lowerLeft;
+let hX = surfacePoint - lowerLeft;
 let uv = vec2f(
-dot(hY, light.u / width) / width,
-dot(hY, light.v / height) / height
+dot(hX, light.u / width) / width,
+dot(hX, light.v / height) / height
 );
 (*result).emission *= sampleMap(i32(light.textureIndex), uv).rgb;
 }
 
-fn jJ(
+fn jL(
 light: Light,
 shadingPoint: vec3f,
 samplePoint: vec2f,
@@ -105,22 +105,22 @@ let lowerLeft = light.position - 0.5 * (light.u + light.v);
 let spread = clamp(light.radiusOrSpread, 0.0, 1.0);
 
 if (spread <= 0.001) {
-let ga = dot(normal, shadingPoint - light.position);
-let surfacePoint = shadingPoint - normal * ga;
-let hY = surfacePoint - lowerLeft;
+let gb = dot(normal, shadingPoint - light.position);
+let surfacePoint = shadingPoint - normal * gb;
+let hX = surfacePoint - lowerLeft;
 let width = length(light.u);
 let height = length(light.v);
 let uv = vec2f(
-dot(hY, light.u / width) / width,
-dot(hY, light.v / height) / height
+dot(hX, light.u / width) / width,
+dot(hX, light.v / height) / height
 );
-if (ga <= 0.0 || any(uv < vec2f(0.0)) || any(uv > vec2f(1.0))) {
+if (gb <= 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 = ga;
+(*result).dist = gb;
 (*result).normal = normal;
 (*result).emission = light.emission;
 (*result).pdf = 1.0;
@@ -138,8 +138,8 @@ let hl = dot(offset, offset);
 (*result).direction = offset / (*result).dist;
 (*result).normal = normal;
 let fV = dot(-(*result).direction, normal);
-let oC = cos(0.5 * PI * spread);
-if (fV <= 0.0 || fV < oC) {
+let oF = cos(0.5 * PI * spread);
+if (fV <= 0.0 || fV < oF) {
 (*result).emission = vec3f(0.0);
 (*result).pdf = 0.0;
 return;
@@ -149,7 +149,7 @@ return;
 cZ(light, surfacePoint, lowerLeft, result);
 }
 
-fn fX(
+fn fY(
 light: Light,
 result: ptr<function, LightSampleRec>
 ) {
@@ -161,7 +161,7 @@ result: ptr<function, LightSampleRec>
 (*result).isDelta = true;
 }
 
-fn jK(
+fn jM(
 light: Light,
 shadingPoint: vec3f,
 samplePoint: vec2f,
@@ -173,7 +173,7 @@ let dJ = normalize(shadingPoint - surfacePoint);
 (*result).emission *= bL(light, dJ);
 }
 
-fn iK(
+fn iL(
 light: Light,
 shadingPoint: vec3f,
 samplePoint: vec2f,
@@ -181,7 +181,7 @@ result: ptr<function, LightSampleRec>
 ) {
 let dO = i32(light.litType);
 if (dO == RECT_LIGHT) {
-jJ(light, shadingPoint, samplePoint, result);
+jL(light, shadingPoint, samplePoint, result);
 return;
 }
 if (dO == SPHERE_LIGHT) {
@@ -189,31 +189,31 @@ eJ(light, shadingPoint, samplePoint, result);
 return;
 }
 if (dO == SPOT_LIGHT) {
-jK(light, shadingPoint, samplePoint, result);
+jM(light, shadingPoint, samplePoint, result);
 return;
 }
 if (dO == DIRECTIONAL_LIGHT) {
-fX(light, result);
+fY(light, result);
 }
 }
 
-fn mu(iT: vec2f, lightSample: ptr<function, LightSampleRec>) {
+fn mx(iU: vec2f, lightSample: ptr<function, LightSampleRec>) {
 var uv: vec2f;
-(*lightSample).direction = oA(iT, &uv, &(*lightSample).pdf);
+(*lightSample).direction = oD(iU, &uv, &(*lightSample).pdf);
 (*lightSample).emission = textureLinear(envMap, uv).rgb;
 (*lightSample).dist = INF;
 }
 
-fn bV(ij: i32) -> vec4f {
+fn bV(ih: i32) -> vec4f {
 let width = rtUniform.lightSamplingTextureWidth;
 return textureLoad(
 lightSamplingData,
-vec2i(ij % width, ij / width),
+vec2i(ih % width, ih / width),
 0
 );
 }
 
-fn pR(index: i32) -> EmissiveTriangle {
+fn pV(index: i32) -> EmissiveTriangle {
 let offset = index * 6;
 let a = bV(offset);
 let b = bV(offset + 1);
@@ -230,9 +230,9 @@ e.zw, f.xy, f.zw
 );
 }
 
-fn sa(index: i32) -> oR {
+fn sf(index: i32) -> oV {
 let data = bV(rtUniform.lightChoiceTexelOffset + index);
-return oR(
+return oV(
 data.x,
 bitcast<i32>(data.y),
 bitcast<i32>(data.z),
@@ -240,35 +240,35 @@ bitcast<i32>(data.w)
 );
 }
 
-fn jt(mN: i32, index: i32) -> oR {
-return sa(mN + index);
+fn jv(mQ: i32, index: i32) -> oV {
+return sf(mQ + index);
 }
 
-fn mF(
+fn mI(
 rnd: vec3f,
 ca: u32,
 aW: u32
 ) -> vec3f {
-var sH = rnd;
+var sM = rnd;
 let count = max(aW, 1u);
-sH.z = (rnd.z + f32(min(ca, count - 1u))) /
+sM.z = (rnd.z + f32(min(ca, count - 1u))) /
 f32(count);
-return sH;
+return sM;
 }
 
-fn lK(
+fn lN(
 triangle: EmissiveTriangle,
 fm: vec3f,
-iT: vec2f,
+iU: vec2f,
 lightSample: ptr<function, LightSampleRec>
 ) {
-let vl = sqrt(iT.x);
+let vt = sqrt(iU.x);
 let barycentric = vec3f(
-1.0 - vl,
-vl * (1.0 - iT.y),
-vl * iT.y
+1.0 - vt,
+vt * (1.0 - iU.y),
+vt * iU.y
 );
-let sN =
+let sS =
 barycentric.x * triangle.p0 +
 barycentric.y * triangle.p1 +
 barycentric.z * triangle.p2;
@@ -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 = sN - fm;
+(*lightSample).direction = sS - fm;
 (*lightSample).dist = length((*lightSample).direction);
 if ((*lightSample).dist <= EPS) {
 (*lightSample).emission = vec3f(0.0);
@@ -290,27 +290,27 @@ return;
 }
 (*lightSample).direction /= (*lightSample).dist;
 (*lightSample).normal = normal;
-let oZ = dot(normal, -(*lightSample).direction);
-if (oZ <= 0.0) {
+let pd = dot(normal, -(*lightSample).direction);
+if (pd <= 0.0) {
 (*lightSample).emission = vec3f(0.0);
 (*lightSample).pdf = 0.0;
 return;
 }
-(*lightSample).emission = lB(
+(*lightSample).emission = lE(
 i32(triangle.materialIndex), uv, cX
 );
 (*lightSample).selectionPmf = triangle.selectionPmf;
 (*lightSample).pdf = triangle.selectionPmf *
 ((*lightSample).dist * (*lightSample).dist) /
-max(triangle.area * oZ, 1e-8);
+max(triangle.area * pd, 1e-8);
 }
 
-fn jZ(
+fn kb(
 fm: vec3f,
 rnd: vec3f,
-mN: i32,
-oY: i32,
-mM: f32,
+mQ: i32,
+pc: i32,
+mP: f32,
 lightSample: ptr<function, LightSampleRec>
 ) {
 (*lightSample).emission = vec3f(0.0);
@@ -320,55 +320,55 @@ lightSample: ptr<function, LightSampleRec>
 (*lightSample).isDelta = false;
 (*lightSample).sourceType = 0u;
 (*lightSample).sourceIndex = 0xffffffffu;
-if (oY <= 0) {
+if (pc <= 0) {
 return;
 }
 
-let qV = rnd.z * f32(oY);
-let column = min(i32(qV), oY - 1);
-let qF = jt(mN, column);
-let kQ = select(
-qF.aliasIndex,
+let qZ = rnd.z * f32(pc);
+let column = min(i32(qZ), pc - 1);
+let qJ = jv(mQ, column);
+let kT = select(
+qJ.aliasIndex,
 column,
-fract(qV) < qF.probability
+fract(qZ) < qJ.probability
 );
-let oX = jt(mN, kQ);
-if (oX.sourceType == ${LIGHT_CHOICE_ENVIRONMENT}) {
+let pb = jv(mQ, kT);
+if (pb.sourceType == ${LIGHT_CHOICE_ENVIRONMENT}) {
 (*lightSample).sourceType = 0u;
-(*lightSample).sourceIndex = u32(oX.sourceIndex);
-mu(rnd.xy, lightSample);
+(*lightSample).sourceIndex = u32(pb.sourceIndex);
+mx(rnd.xy, lightSample);
 (*lightSample).selectionPmf = rtUniform.envLightPmf;
 (*lightSample).pdf *= rtUniform.envLightPmf;
 }
-else if (oX.sourceType == ${LIGHT_CHOICE_ANALYTIC}) {
+else if (pb.sourceType == ${LIGHT_CHOICE_ANALYTIC}) {
 (*lightSample).sourceType = 2u;
-(*lightSample).sourceIndex = u32(oX.sourceIndex);
-let light = analyticLights[oX.sourceIndex];
-iK(light, fm, rnd.xy, lightSample);
+(*lightSample).sourceIndex = u32(pb.sourceIndex);
+let light = analyticLights[pb.sourceIndex];
+iL(light, fm, rnd.xy, lightSample);
 (*lightSample).selectionPmf = light.selectionPmf;
 (*lightSample).pdf *= light.selectionPmf;
 }
-else if (oX.sourceType == ${LIGHT_CHOICE_EMISSIVE_TRIANGLE}) {
+else if (pb.sourceType == ${LIGHT_CHOICE_EMISSIVE_TRIANGLE}) {
 (*lightSample).sourceType = 1u;
-(*lightSample).sourceIndex = u32(oX.sourceIndex);
-lK(
-pR(oX.sourceIndex),
+(*lightSample).sourceIndex = u32(pb.sourceIndex);
+lN(
+pV(pb.sourceIndex),
 fm,
 rnd.xy,
 lightSample
 );
 }
-(*lightSample).selectionPmf *= mM;
-(*lightSample).pdf *= mM;
+(*lightSample).selectionPmf *= mP;
+(*lightSample).pdf *= mP;
 }
 
 fn sampleLight(
 fm: vec3f,
 rnd: vec3f,
 lightSample: ptr<function, LightSampleRec>,
-rP: bool
+rU: bool
 ) {
-jZ(
+kb(
 fm,
 rnd,
 0,
@@ -380,16 +380,16 @@ lightSample
 
 
 
-fn mv(
+fn my(
 fm: vec3f,
 rnd: vec3f,
 ca: u32,
 aW: u32,
 lightSample: ptr<function, LightSampleRec>
 ) {
-jZ(
+kb(
 fm,
-mF(rnd, ca, aW),
+mI(rnd, ca, aW),
 0,
 rtUniform.lightChoiceCount,
 1.0,