@meimu/mutracer 0.1.3 → 0.1.5

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

@@ -47,6 +47,7 @@ geometryBitangent: vec3f,
 ` : /* wgsl */ ``}
 uv: vec2f,
 uv1: vec2f,
+vertexColor: vec3f,
 
 triangleIndex: i32,
 instanceIndex: i32,
@@ -202,7 +203,7 @@ secondaryUv1: vec2f,
 secondaryUv2: vec2f,
 };
 
-struct oV {
+struct pe {
 probability: f32,
 aliasIndex: i32,
 sourceType: i32,
@@ -249,6 +250,8 @@ sceneFeatureFlags: u32,
 sequenceSeed: u32,
 zSobolLogSPP: u32,
 sampleSequenceOffset: u32,
+environmentRotation: mat4x4f,
+backgroundMapTransform: vec4f,
 }
 
 
@@ -270,20 +273,20 @@ sampleSequenceOffset: u32,
 @group(1) @binding(9) var openPbrEnergyLut: texture_2d<f32>;
 @group(1) @binding(10) var adaptiveSampleTargets: texture_2d<f32>;
 
-fn cL(dV: i32, lh: i32) -> f32 {
-let ih = dV + lh / 4;
+fn cL(dV: i32, ls: i32) -> f32 {
+let im = dV + ls / 4;
 let width = rtUniform.lightSamplingTextureWidth;
-let packed = textureLoad(lightSamplingData, vec2i(ih % width, ih / width), 0);
-return packed[lh % 4];
+let packed = textureLoad(lightSamplingData, vec2i(im % width, im / width), 0);
+return packed[ls % 4];
 }
 
-fn kI(dV: i32, uv: vec2f) -> f32 {
+fn kR(dV: i32, uv: vec2f) -> f32 {
 if (dV < 0) { return 1.0; }
-let fM = fract(uv) * 128.0 - vec2f(0.5);
-let x0 = i32(floor(fM.x));
-let y0 = i32(floor(fM.y));
-let fx = fract(fM.x);
-let fy = fract(fM.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);
@@ -295,19 +298,19 @@ let d = cL(dV, yb * 128 + xb);
 return mix(mix(a, b, fx), mix(c, d, fx), fy);
 }
 
-fn bL(light: Light, dJ: vec3f) -> f32 {
+fn bL(light: Light, dK: vec3f) -> f32 {
 let axis = normalize(light.u);
-let cc = dot(axis, dJ);
-var tI = select(0.0, 1.0, cc >= light.v.x);
-if (light.v.y > 1e-6) {
-tI = smoothstep(light.v.x, light.v.x + light.v.y, cc);
+let cc = dot(axis, dK);
+var tP = select(0.0, 1.0, cc >= light.v.x);
+if (light.v.y > light.v.x + 1e-6) {
+tP = smoothstep(light.v.x, light.v.y, cc);
 }
-if (tI <= 0.0 || light.textureIndex < 0.0) { return tI; }
-let uc = light.iesReference;
-let vu = cross(axis, uc);
+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(dJ, vu), dot(dJ, uc));
-return tI * kI(i32(light.textureIndex), vec2f(vertical / PI, horizontal / TWOPI + 0.5));
+let horizontal = atan2(dot(dK, vD), dot(dK, uj));
+return tP * kR(i32(light.textureIndex), vec2f(vertical / PI, horizontal / TWOPI + 0.5));
 }
 
 
@@ -319,7 +322,7 @@ return tI * kI(i32(light.textureIndex), vec2f(vertical / PI, horizontal / TWOPI
 @group(2) @binding(2) var<uniform> analyticLights: array<Light, NUM_UNIFORM_LIGHTS>;
 
 
-fn iw(ray: ptr<function, Ray>, origin: vec3f, direction: vec3f) {
+fn iC(ray: ptr<function, Ray>, origin: vec3f, direction: vec3f) {
 (*ray).o = origin;
 (*ray).d = direction;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"rayTraceCore.wgsl.js","sourceRoot":"","sources":["../../../../src/renderer/wgsl/chunks/rayTraceCore.wgsl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAE,qBAAqB,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC7E,OAAO,EACL,0BAA0B,EAC1B,mBAAmB,EACnB,qBAAqB,EACrB,mBAAmB,EACpB,MAAM,qBAAqB,CAAC;AAE7B,MAAM,CAAC,OAAO,UAAU,YAAY,CAAC,EACnC,uBAAuB,GAAG,IAAI,EAC9B,cAAc,GAAG,KAAK,EACtB,aAAa,GAAG,IAAI,EAKrB;IACC,OAAO,QAAQ,CAAC;;;;;;gBAMF,aAAa;yBACJ,qBAAqB;;qBAEzB,mBAAmB;uBACjB,qBAAqB;4BAChB,0BAA0B;qBACjC,mBAAmB;;;;;;;;;;;;;;;EAetC,cAAc,CAAC,CAAC,CAAC,UAAU,CAAC;;CAE7B,CAAC,CAAC,CAAC,EAAE;;;;;;;;EAQJ,uBAAuB,CAAC,CAAC,CAAC,UAAU,CAAC;;;;;CAKtC,CAAC,CAAC,CAAC,UAAU,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0Df,uBAAuB,CAAC,CAAC,CAAC,UAAU,CAAC;;;;EAIrC,uBAAuB,CAAC,CAAC,CAAC,UAAU,CAAC;;;;;CAKtC,CAAC,CAAC,CAAC,UAAU,CAAC,EAAE;CAChB,CAAC,CAAC,CAAC,UAAU,CAAC,EAAE;EACf,cAAc,CAAC,CAAC,CAAC,UAAU,CAAC;;;;CAI7B,CAAC,CAAC,CAAC,EAAE;;;;;;EAMF,aAAa,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsFxC,kBAAkB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DA6CwC,uBAAuB,CAAC,CAAC,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,UAAU,CAAC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqE9H,CAAC;AACF,CAAC","sourcesContent":["import { materialBufferWgsl } from '../../materialLayout.js';\nimport { ShadowCatcherMaterial, UnlitMaterial } from '../../../constants.js';\nimport {\n  CONSTANT_DIRECTIONAL_LIGHT,\n  CONSTANT_RECT_LIGHT,\n  CONSTANT_SPHERE_LIGHT,\n  CONSTANT_SPOT_LIGHT\n} from '../../lightsUtil.js';\n\nexport default function rayTraceCore({\n  hasAnisotropyDirections = true,\n  hasCoatNormals = false,\n  hasSceneAlpha = true\n}: {\n  hasAnisotropyDirections?: boolean;\n  hasCoatNormals?: boolean;\n  hasSceneAlpha?: boolean;\n}) {\n  return /*wgsl*/ `\n// https://www.w3.org/WAI/GL/wiki/Relative_luminance\nconst luminance = vec3f(0.2126, 0.7152, 0.0722);\nconst RAY_MAX_DISTANCE = 9999.0;\n\nconst STANDARD = 0;\nconst UNLIT = ${UnlitMaterial};\nconst SHADOW_CATCHER = ${ShadowCatcherMaterial};\n\nconst RECT_LIGHT = ${CONSTANT_RECT_LIGHT};\nconst SPHERE_LIGHT = ${CONSTANT_SPHERE_LIGHT};\nconst DIRECTIONAL_LIGHT = ${CONSTANT_DIRECTIONAL_LIGHT};\nconst SPOT_LIGHT = ${CONSTANT_SPOT_LIGHT};\n\nstruct Ray {\n  o: vec3f,\n  d: vec3f,\n};\n\nstruct SurfaceInteraction {\n  position: vec3f,\n  // For perfect specular or transmission surface\n  // We use the albedo and normal of first diffuse or glossy surface hit instead for denoising\n  // See albedo section in https://www.openimagedenoise.org/documentation.html\n  albedoSampled: bool,\n\n  normal: vec3f, // material shading normal\n${hasCoatNormals ? /* wgsl */ `\n  coatNormal: vec3f, // independent, built before base normal mapping\n` : ''}\n  vertexNormal: vec3f, // interpolated mesh normal before normal mapping\n  shadowOffset: vec3f, // smooth-surface offset for direct-light shadow rays\n\n  faceNormal: vec3f, // normal of the triangle\n  hit: bool,\n\n  tangent: vec3f,\n${hasAnisotropyDirections ? /* wgsl */ `\n  directionTangent: vec3f,\n  directionBitangent: vec3f,\n  geometryTangent: vec3f,\n  geometryBitangent: vec3f,\n` : /* wgsl */ ``}\n  uv: vec2f,\n  uv1: vec2f,\n\n  triangleIndex: i32,\n  instanceIndex: i32,\n  materialIndex: i32,\n  barycentrics: vec2f,\n\n  wavelength: f32,\n\n  mediumType: i32,\n  mediumExtinction: vec3f,\n  mediumScattering: vec3f,\n  mediumAnisotropy: f32,\n\n};\n\n// Texture-resolved OpenPBR inputs used by the surface integrator. The storage\n// buffer keeps its compact legacy layout; getMaterial() is the compatibility\n// boundary that maps it to these canonical names.\nstruct OpenPbrResolvedMaterial {\n  baseColor: vec3f,\n  transmissionWeight: f32,\n\n  emission: vec3f,\n  specularAnisotropy: f32,\n\n  baseMetalness: f32,\n  specularIor: f32,\n  specularRoughness: f32,\n\n  transmissionDispersionScale: f32,\n  dispersionAbbeNumber: f32,\n  thinFilmThickness: f32,\n  thinFilmIor: f32,\n  thinFilmWeight: f32,\n\n  // Medium\n  mediumType: i32,\n  mediumExtinction: vec3f,\n  mediumScattering: vec3f,\n  mediumAnisotropy: f32,\n\n  baseWeight: f32,\n  diffuseRoughness: f32,\n  specularWeight: f32,\n  specularColor: vec3f,\n  subsurfaceWeight: f32,\n  subsurfaceColor: vec3f,\n  transmissionColor: vec3f,\n  fuzzWeight: f32,\n  fuzzColor: vec3f,\n  fuzzRoughness: f32,\n  coatWeight: f32,\n  coatColor: vec3f,\n  coatRoughness: f32,\n  coatAnisotropy: f32,\n${hasAnisotropyDirections ? /* wgsl */ `\n  anisotropyDirection: vec2f,\n  anisotropyDirectionEnabled: bool,\n  coatAnisotropyRotation: f32,\n${hasAnisotropyDirections ? /* wgsl */ `\n  directionTangent: vec3f,\n  directionBitangent: vec3f,\n  geometryTangent: vec3f,\n  geometryBitangent: vec3f,\n` : /* wgsl */ ``}\n` : /* wgsl */ ``}\n${hasCoatNormals ? /* wgsl */ `\n  coatNormal: vec3f,\n  coatNormalEnabled: bool,\n  geometricNormal: vec3f, // face normal oriented toward the view\n` : ''}\n  coatIor: f32,\n  coatDarkening: f32,\n\n  // Alpha\n  alpha: f32,\n  ${hasSceneAlpha ? 'alphaMode: i32,' : ''}\n\n  materialType: i32,\n\n  bevel: f32,\n\n  relativeIor: f32,\n  inside: bool,\n\n  alphaX: f32,\n  alphaY: f32,\n  thinWalled: bool,\n};\n\nstruct Path {\n  ray: Ray,\n  li: vec3f,\n  alpha: f32,\n  beta: vec3f,\n  fromEye: bool,\n  abort: bool,\n  scatteringPdf: f32,\n  scatteringIsDelta: bool,\n  isNextRefraction: bool,\n};\n\nstruct LightSampleRec {\n  normal: vec3f,\n  emission: vec3f,\n  direction: vec3f,\n  dist: f32,\n  pdf: f32,\n  // Discrete probability of selecting this light before sampling its\n  // conditional point/direction. Light RIS excludes this term from the target\n  // and carries it in the unbiased contribution weight instead.\n  selectionPmf: f32,\n  isDelta: bool,\n  // Light source type: environment=0, emissive triangle=1, analytic=2.\n  sourceType: u32,\n  sourceIndex: u32,\n};\n\nstruct Light {\n  position: vec3f,\n  litType: f32,\n\n  emission: vec3f,\n  area: f32,\n\n  u: vec3f,\n  // Radius for sphere light, spread for rect light\n  radiusOrSpread: f32,\n\n  v: vec3f,\n  textureIndex: f32,\n\n  selectionPmf: f32,\n  _samplingPadding0: f32,\n  _samplingPadding1: f32,\n  _samplingPadding2: f32,\n  iesReference: vec3f,\n  _iesPadding: f32,\n};\n\nstruct EmissiveTriangle {\n  p0: vec3f,\n  selectionPmf: f32,\n  p1: vec3f,\n  area: f32,\n  p2: vec3f,\n  materialIndex: f32,\n  uv0: vec2f,\n  uv1: vec2f,\n  uv2: vec2f,\n  secondaryUv0: vec2f,\n  secondaryUv1: vec2f,\n  secondaryUv2: vec2f,\n};\n\nstruct LightChoice {\n  probability: f32,\n  aliasIndex: i32,\n  sourceType: i32,\n  sourceIndex: i32,\n};\n\n${materialBufferWgsl()}\n\nstruct CameraUniform {\n  viewProjectionInv: mat4x4<f32>,\n  viewInv: mat4x4<f32>,\n  apertureRadius: f32,\n  focusDistance: f32,\n};\n\nstruct RayTraceUniform {\n  outputSize: vec2f,\n  sampleCount: f32,\n  scaleOffset: vec4f,\n  lightsCount: i32,\n  transmissiveOutputAlphaMin: f32,\n  jitter: vec2f,\n  backgroundColor: vec4f,\n  groundedBackgroundParams: vec4f,\n  groundedBackgroundCenter: vec2f,\n  blasOffset: i32,\n  isEmpty: i32,\n  bevel: i32,\n  dispersionWavelengths: i32,\n  envLightPmf: f32,\n  lightChoiceCount: i32,\n  lightWeightTotal: f32,\n  lightSamplingTextureWidth: i32,\n  lightChoiceTexelOffset: i32,\n  bounces: i32,\n  varianceMoments: i32,\n  adaptiveSampling: i32,\n  clamping: f32,\n  directLightCandidates: i32,\n  backgroundFlags: i32,\n  // Fixed at 4: runtime trip bounds discourage thin-film loop unrolling.\n  loopUnrollGuard: u32,\n  sceneFeatureFlags: u32,\n  sequenceSeed: u32,\n  zSobolLogSPP: u32,\n  sampleSequenceOffset: u32,\n}\n\n// Buffers\n@group(0) @binding(0) var<storage, read> bvhBuffer: array<vec4f>;\n@group(0) @binding(1) var<storage, read> instancesBuffer: array<vec4f>;\n@group(0) @binding(2) var<storage, read> attrBuffers: array<${hasAnisotropyDirections ? /* wgsl */ `vec4f` : /* wgsl */ `vec3f`}>;\n@group(0) @binding(3) var<storage, read> materialsBuffer: array<MaterialBuffer>;\n\n// Textures\n@group(1) @binding(0) var mapSampler: sampler;\n@group(1) @binding(1) var map: texture_2d_array<f32>;\n// The first NUM_MAPS entries contain atlas placement; the second half stores\n// per-texture UV scale/offset; the third block stores the UV channel in x.\n@group(1) @binding(3) var<uniform> mapInfo: array<vec4f, NUM_MAPS * 3>;\n@group(1) @binding(4) var envMap: texture_2d<f32>;\n@group(1) @binding(5) var envMapDistribution: texture_2d<f32>;\n@group(1) @binding(6) var backgroundMap: texture_2d<f32>;\n@group(1) @binding(8) var lightSamplingData: texture_2d<f32>;\n@group(1) @binding(9) var openPbrEnergyLut: texture_2d<f32>;\n@group(1) @binding(10) var adaptiveSampleTargets: texture_2d<f32>;\n\nfn iesProfileScalar(baseTexel: i32, scalarIndex: i32) -> f32 {\n  let texelIndex = baseTexel + scalarIndex / 4;\n  let width = rtUniform.lightSamplingTextureWidth;\n  let packed = textureLoad(lightSamplingData, vec2i(texelIndex % width, texelIndex / width), 0);\n  return packed[scalarIndex % 4];\n}\n\nfn sampleIESProfile(baseTexel: i32, uv: vec2f) -> f32 {\n  if (baseTexel < 0) { return 1.0; }\n  let pixel = fract(uv) * 128.0 - vec2f(0.5);\n  let x0 = i32(floor(pixel.x));\n  let y0 = i32(floor(pixel.y));\n  let fx = fract(pixel.x);\n  let fy = fract(pixel.y);\n  let xa = select(x0, 127, x0 < 0);\n  let xb = select(x0 + 1, 0, x0 >= 127);\n  let ya = select(y0, 127, y0 < 0);\n  let yb = select(y0 + 1, 0, y0 >= 127);\n  let a = iesProfileScalar(baseTexel, ya * 128 + xa);\n  let b = iesProfileScalar(baseTexel, ya * 128 + xb);\n  let c = iesProfileScalar(baseTexel, yb * 128 + xa);\n  let d = iesProfileScalar(baseTexel, yb * 128 + xb);\n  return mix(mix(a, b, fx), mix(c, d, fx), fy);\n}\n\nfn evaluateSpotEmissionMultiplier(light: Light, lightToSurface: vec3f) -> f32 {\n  let axis = normalize(light.u);\n  let cosTheta = dot(axis, lightToSurface);\n  var cone = select(0.0, 1.0, cosTheta >= light.v.x);\n  if (light.v.y > 1e-6) {\n    cone = smoothstep(light.v.x, light.v.x + light.v.y, cosTheta);\n  }\n  if (cone <= 0.0 || light.textureIndex < 0.0) { return cone; }\n  let xAxis = light.iesReference;\n  let yAxis = cross(axis, xAxis);\n  let vertical = acos(clamp(cosTheta, -1.0, 1.0));\n  let horizontal = atan2(dot(lightToSurface, yAxis), dot(lightToSurface, xAxis));\n  return cone * sampleIESProfile(i32(light.textureIndex), vec2f(vertical / PI, horizontal / TWOPI + 0.5));\n}\n\n\n  \n// Uniforms\n@group(2) @binding(0) var<uniform> cameraUniform: CameraUniform;\n@group(2) @binding(1) var<uniform> rtUniform: RayTraceUniform;\n\n@group(2) @binding(2) var<uniform> analyticLights: array<Light, NUM_UNIFORM_LIGHTS>;\n// TODO uniform must be aligned to 16 bytes.\n\nfn initRay(ray: ptr<function, Ray>, origin: vec3f, direction: vec3f) {\n  (*ray).o = origin;\n  (*ray).d = direction;\n}\n`;\n}\n"]}
+{"version":3,"file":"rayTraceCore.wgsl.js","sourceRoot":"","sources":["../../../../src/renderer/wgsl/chunks/rayTraceCore.wgsl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAE,qBAAqB,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC7E,OAAO,EACL,0BAA0B,EAC1B,mBAAmB,EACnB,qBAAqB,EACrB,mBAAmB,EACpB,MAAM,qBAAqB,CAAC;AAE7B,MAAM,CAAC,OAAO,UAAU,YAAY,CAAC,EACnC,uBAAuB,GAAG,IAAI,EAC9B,cAAc,GAAG,KAAK,EACtB,aAAa,GAAG,IAAI,EAKrB;IACC,OAAO,QAAQ,CAAC;;;;;;gBAMF,aAAa;yBACJ,qBAAqB;;qBAEzB,mBAAmB;uBACjB,qBAAqB;4BAChB,0BAA0B;qBACjC,mBAAmB;;;;;;;;;;;;;;;EAetC,cAAc,CAAC,CAAC,CAAC,UAAU,CAAC;;CAE7B,CAAC,CAAC,CAAC,EAAE;;;;;;;;EAQJ,uBAAuB,CAAC,CAAC,CAAC,UAAU,CAAC;;;;;CAKtC,CAAC,CAAC,CAAC,UAAU,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2Df,uBAAuB,CAAC,CAAC,CAAC,UAAU,CAAC;;;;EAIrC,uBAAuB,CAAC,CAAC,CAAC,UAAU,CAAC;;;;;CAKtC,CAAC,CAAC,CAAC,UAAU,CAAC,EAAE;CAChB,CAAC,CAAC,CAAC,UAAU,CAAC,EAAE;EACf,cAAc,CAAC,CAAC,CAAC,UAAU,CAAC;;;;CAI7B,CAAC,CAAC,CAAC,EAAE;;;;;;EAMF,aAAa,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsFxC,kBAAkB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DA+CwC,uBAAuB,CAAC,CAAC,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,UAAU,CAAC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqE9H,CAAC;AACF,CAAC","sourcesContent":["import { materialBufferWgsl } from '../../materialLayout.js';\nimport { ShadowCatcherMaterial, UnlitMaterial } from '../../../constants.js';\nimport {\n  CONSTANT_DIRECTIONAL_LIGHT,\n  CONSTANT_RECT_LIGHT,\n  CONSTANT_SPHERE_LIGHT,\n  CONSTANT_SPOT_LIGHT\n} from '../../lightsUtil.js';\n\nexport default function rayTraceCore({\n  hasAnisotropyDirections = true,\n  hasCoatNormals = false,\n  hasSceneAlpha = true\n}: {\n  hasAnisotropyDirections?: boolean;\n  hasCoatNormals?: boolean;\n  hasSceneAlpha?: boolean;\n}) {\n  return /*wgsl*/ `\n// https://www.w3.org/WAI/GL/wiki/Relative_luminance\nconst luminance = vec3f(0.2126, 0.7152, 0.0722);\nconst RAY_MAX_DISTANCE = 9999.0;\n\nconst STANDARD = 0;\nconst UNLIT = ${UnlitMaterial};\nconst SHADOW_CATCHER = ${ShadowCatcherMaterial};\n\nconst RECT_LIGHT = ${CONSTANT_RECT_LIGHT};\nconst SPHERE_LIGHT = ${CONSTANT_SPHERE_LIGHT};\nconst DIRECTIONAL_LIGHT = ${CONSTANT_DIRECTIONAL_LIGHT};\nconst SPOT_LIGHT = ${CONSTANT_SPOT_LIGHT};\n\nstruct Ray {\n  o: vec3f,\n  d: vec3f,\n};\n\nstruct SurfaceInteraction {\n  position: vec3f,\n  // For perfect specular or transmission surface\n  // We use the albedo and normal of first diffuse or glossy surface hit instead for denoising\n  // See albedo section in https://www.openimagedenoise.org/documentation.html\n  albedoSampled: bool,\n\n  normal: vec3f, // material shading normal\n${hasCoatNormals ? /* wgsl */ `\n  coatNormal: vec3f, // independent, built before base normal mapping\n` : ''}\n  vertexNormal: vec3f, // interpolated mesh normal before normal mapping\n  shadowOffset: vec3f, // smooth-surface offset for direct-light shadow rays\n\n  faceNormal: vec3f, // normal of the triangle\n  hit: bool,\n\n  tangent: vec3f,\n${hasAnisotropyDirections ? /* wgsl */ `\n  directionTangent: vec3f,\n  directionBitangent: vec3f,\n  geometryTangent: vec3f,\n  geometryBitangent: vec3f,\n` : /* wgsl */ ``}\n  uv: vec2f,\n  uv1: vec2f,\n  vertexColor: vec3f,\n\n  triangleIndex: i32,\n  instanceIndex: i32,\n  materialIndex: i32,\n  barycentrics: vec2f,\n\n  wavelength: f32,\n\n  mediumType: i32,\n  mediumExtinction: vec3f,\n  mediumScattering: vec3f,\n  mediumAnisotropy: f32,\n\n};\n\n// Texture-resolved OpenPBR inputs used by the surface integrator. The storage\n// buffer keeps its compact legacy layout; getMaterial() is the compatibility\n// boundary that maps it to these canonical names.\nstruct OpenPbrResolvedMaterial {\n  baseColor: vec3f,\n  transmissionWeight: f32,\n\n  emission: vec3f,\n  specularAnisotropy: f32,\n\n  baseMetalness: f32,\n  specularIor: f32,\n  specularRoughness: f32,\n\n  transmissionDispersionScale: f32,\n  dispersionAbbeNumber: f32,\n  thinFilmThickness: f32,\n  thinFilmIor: f32,\n  thinFilmWeight: f32,\n\n  // Medium\n  mediumType: i32,\n  mediumExtinction: vec3f,\n  mediumScattering: vec3f,\n  mediumAnisotropy: f32,\n\n  baseWeight: f32,\n  diffuseRoughness: f32,\n  specularWeight: f32,\n  specularColor: vec3f,\n  subsurfaceWeight: f32,\n  subsurfaceColor: vec3f,\n  transmissionColor: vec3f,\n  fuzzWeight: f32,\n  fuzzColor: vec3f,\n  fuzzRoughness: f32,\n  coatWeight: f32,\n  coatColor: vec3f,\n  coatRoughness: f32,\n  coatAnisotropy: f32,\n${hasAnisotropyDirections ? /* wgsl */ `\n  anisotropyDirection: vec2f,\n  anisotropyDirectionEnabled: bool,\n  coatAnisotropyRotation: f32,\n${hasAnisotropyDirections ? /* wgsl */ `\n  directionTangent: vec3f,\n  directionBitangent: vec3f,\n  geometryTangent: vec3f,\n  geometryBitangent: vec3f,\n` : /* wgsl */ ``}\n` : /* wgsl */ ``}\n${hasCoatNormals ? /* wgsl */ `\n  coatNormal: vec3f,\n  coatNormalEnabled: bool,\n  geometricNormal: vec3f, // face normal oriented toward the view\n` : ''}\n  coatIor: f32,\n  coatDarkening: f32,\n\n  // Alpha\n  alpha: f32,\n  ${hasSceneAlpha ? 'alphaMode: i32,' : ''}\n\n  materialType: i32,\n\n  bevel: f32,\n\n  relativeIor: f32,\n  inside: bool,\n\n  alphaX: f32,\n  alphaY: f32,\n  thinWalled: bool,\n};\n\nstruct Path {\n  ray: Ray,\n  li: vec3f,\n  alpha: f32,\n  beta: vec3f,\n  fromEye: bool,\n  abort: bool,\n  scatteringPdf: f32,\n  scatteringIsDelta: bool,\n  isNextRefraction: bool,\n};\n\nstruct LightSampleRec {\n  normal: vec3f,\n  emission: vec3f,\n  direction: vec3f,\n  dist: f32,\n  pdf: f32,\n  // Discrete probability of selecting this light before sampling its\n  // conditional point/direction. Light RIS excludes this term from the target\n  // and carries it in the unbiased contribution weight instead.\n  selectionPmf: f32,\n  isDelta: bool,\n  // Light source type: environment=0, emissive triangle=1, analytic=2.\n  sourceType: u32,\n  sourceIndex: u32,\n};\n\nstruct Light {\n  position: vec3f,\n  litType: f32,\n\n  emission: vec3f,\n  area: f32,\n\n  u: vec3f,\n  // Radius for sphere light, spread for rect light\n  radiusOrSpread: f32,\n\n  v: vec3f,\n  textureIndex: f32,\n\n  selectionPmf: f32,\n  _samplingPadding0: f32,\n  _samplingPadding1: f32,\n  _samplingPadding2: f32,\n  iesReference: vec3f,\n  _iesPadding: f32,\n};\n\nstruct EmissiveTriangle {\n  p0: vec3f,\n  selectionPmf: f32,\n  p1: vec3f,\n  area: f32,\n  p2: vec3f,\n  materialIndex: f32,\n  uv0: vec2f,\n  uv1: vec2f,\n  uv2: vec2f,\n  secondaryUv0: vec2f,\n  secondaryUv1: vec2f,\n  secondaryUv2: vec2f,\n};\n\nstruct LightChoice {\n  probability: f32,\n  aliasIndex: i32,\n  sourceType: i32,\n  sourceIndex: i32,\n};\n\n${materialBufferWgsl()}\n\nstruct CameraUniform {\n  viewProjectionInv: mat4x4<f32>,\n  viewInv: mat4x4<f32>,\n  apertureRadius: f32,\n  focusDistance: f32,\n};\n\nstruct RayTraceUniform {\n  outputSize: vec2f,\n  sampleCount: f32,\n  scaleOffset: vec4f,\n  lightsCount: i32,\n  transmissiveOutputAlphaMin: f32,\n  jitter: vec2f,\n  backgroundColor: vec4f,\n  groundedBackgroundParams: vec4f,\n  groundedBackgroundCenter: vec2f,\n  blasOffset: i32,\n  isEmpty: i32,\n  bevel: i32,\n  dispersionWavelengths: i32,\n  envLightPmf: f32,\n  lightChoiceCount: i32,\n  lightWeightTotal: f32,\n  lightSamplingTextureWidth: i32,\n  lightChoiceTexelOffset: i32,\n  bounces: i32,\n  varianceMoments: i32,\n  adaptiveSampling: i32,\n  clamping: f32,\n  directLightCandidates: i32,\n  backgroundFlags: i32,\n  // Fixed at 4: runtime trip bounds discourage thin-film loop unrolling.\n  loopUnrollGuard: u32,\n  sceneFeatureFlags: u32,\n  sequenceSeed: u32,\n  zSobolLogSPP: u32,\n  sampleSequenceOffset: u32,\n  environmentRotation: mat4x4f,\n  backgroundMapTransform: vec4f,\n}\n\n// Buffers\n@group(0) @binding(0) var<storage, read> bvhBuffer: array<vec4f>;\n@group(0) @binding(1) var<storage, read> instancesBuffer: array<vec4f>;\n@group(0) @binding(2) var<storage, read> attrBuffers: array<${hasAnisotropyDirections ? /* wgsl */ `vec4f` : /* wgsl */ `vec3f`}>;\n@group(0) @binding(3) var<storage, read> materialsBuffer: array<MaterialBuffer>;\n\n// Textures\n@group(1) @binding(0) var mapSampler: sampler;\n@group(1) @binding(1) var map: texture_2d_array<f32>;\n// The first NUM_MAPS entries contain atlas placement; the second half stores\n// per-texture UV scale/offset; the third block stores the UV channel in x.\n@group(1) @binding(3) var<uniform> mapInfo: array<vec4f, NUM_MAPS * 3>;\n@group(1) @binding(4) var envMap: texture_2d<f32>;\n@group(1) @binding(5) var envMapDistribution: texture_2d<f32>;\n@group(1) @binding(6) var backgroundMap: texture_2d<f32>;\n@group(1) @binding(8) var lightSamplingData: texture_2d<f32>;\n@group(1) @binding(9) var openPbrEnergyLut: texture_2d<f32>;\n@group(1) @binding(10) var adaptiveSampleTargets: texture_2d<f32>;\n\nfn iesProfileScalar(baseTexel: i32, scalarIndex: i32) -> f32 {\n  let texelIndex = baseTexel + scalarIndex / 4;\n  let width = rtUniform.lightSamplingTextureWidth;\n  let packed = textureLoad(lightSamplingData, vec2i(texelIndex % width, texelIndex / width), 0);\n  return packed[scalarIndex % 4];\n}\n\nfn sampleIESProfile(baseTexel: i32, uv: vec2f) -> f32 {\n  if (baseTexel < 0) { return 1.0; }\n  let pixel = fract(uv) * 128.0 - vec2f(0.5);\n  let x0 = i32(floor(pixel.x));\n  let y0 = i32(floor(pixel.y));\n  let fx = fract(pixel.x);\n  let fy = fract(pixel.y);\n  let xa = select(x0, 127, x0 < 0);\n  let xb = select(x0 + 1, 0, x0 >= 127);\n  let ya = select(y0, 127, y0 < 0);\n  let yb = select(y0 + 1, 0, y0 >= 127);\n  let a = iesProfileScalar(baseTexel, ya * 128 + xa);\n  let b = iesProfileScalar(baseTexel, ya * 128 + xb);\n  let c = iesProfileScalar(baseTexel, yb * 128 + xa);\n  let d = iesProfileScalar(baseTexel, yb * 128 + xb);\n  return mix(mix(a, b, fx), mix(c, d, fx), fy);\n}\n\nfn evaluateSpotEmissionMultiplier(light: Light, lightToSurface: vec3f) -> f32 {\n  let axis = normalize(light.u);\n  let cosTheta = dot(axis, lightToSurface);\n  var cone = select(0.0, 1.0, cosTheta >= light.v.x);\n  if (light.v.y > light.v.x + 1e-6) {\n    cone = smoothstep(light.v.x, light.v.y, cosTheta);\n  }\n  if (cone <= 0.0 || light.textureIndex < 0.0) { return cone; }\n  let xAxis = light.iesReference;\n  let yAxis = cross(axis, xAxis);\n  let vertical = acos(clamp(cosTheta, -1.0, 1.0));\n  let horizontal = atan2(dot(lightToSurface, yAxis), dot(lightToSurface, xAxis));\n  return cone * sampleIESProfile(i32(light.textureIndex), vec2f(vertical / PI, horizontal / TWOPI + 0.5));\n}\n\n\n  \n// Uniforms\n@group(2) @binding(0) var<uniform> cameraUniform: CameraUniform;\n@group(2) @binding(1) var<uniform> rtUniform: RayTraceUniform;\n\n@group(2) @binding(2) var<uniform> analyticLights: array<Light, NUM_UNIFORM_LIGHTS>;\n// TODO uniform must be aligned to 16 bytes.\n\nfn initRay(ray: ptr<function, Ray>, origin: vec3f, direction: vec3f) {\n  (*ray).o = origin;\n  (*ray).d = direction;\n}\n`;\n}\n"]}

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

@@ -1,8 +1,8 @@
 import { LIGHT_CHOICE_ANALYTIC, LIGHT_CHOICE_EMISSIVE_TRIANGLE, LIGHT_CHOICE_ENVIRONMENT } from '../../lightSampling.js';
 export default /*wgsl */ `
-fn eJ(light: Light, fm: vec3f, iU: vec2f, lightSample: ptr<function, LightSampleRec>) {
-let iq = light.position - fm;
-let aj = length(iq);
+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) {
 
 
@@ -16,7 +16,7 @@ if (aj <= 1e-6) {
 (*lightSample).isDelta = true;
 return;
 }
-(*lightSample).direction = iq / aj;
+(*lightSample).direction = iw / aj;
 (*lightSample).normal = -(*lightSample).direction;
 (*lightSample).dist = aj;
 (*lightSample).pdf = 1.0;
@@ -27,33 +27,33 @@ return;
 }
 let radius = max(light.radiusOrSpread, 1e-6);
 (*lightSample).isDelta = false;
-var gF: vec3f;
+var gK: vec3f;
 
 if (aj <= radius) {
-let z = 1.0 - 2.0 * iU.x;
-let fi = sqrt(max(0.0, 1.0 - z * z));
-let br = TWOPI * iU.y;
-gF = vec3f(
-fi * cos(br),
-fi * sin(br),
+let z = 1.0 - 2.0 * iZ.x;
+let fl = sqrt(max(0.0, 1.0 - z * z));
+let br = TWOPI * iZ.y;
+gK = vec3f(
+fl * cos(br),
+fl * sin(br),
 z
 );
 (*lightSample).pdf = INV4PI;
 }
 else {
-let sK = iq / aj;
-let jp = min(
+let sS = iw / aj;
+let jv = min(
 1.0,
 radius * radius / (aj * aj)
 );
-let cosThetaMax = sqrt(max(0.0, 1.0 - jp));
-let cc = mix(1.0, cosThetaMax, iU.x);
+let cosThetaMax = sqrt(max(0.0, 1.0 - jv));
+let cc = mix(1.0, cosThetaMax, iZ.x);
 let sinTheta = sqrt(max(0.0, 1.0 - cc * cc));
-let br = TWOPI * iU.y;
+let br = TWOPI * iZ.y;
 var tangent: vec3f;
 var bitangent: vec3f;
-aL(sK, &tangent, &bitangent);
-gF = sK * cc
+aL(sS, &tangent, &bitangent);
+gK = sS * cc
 + tangent * (sinTheta * cos(br))
 + bitangent * (sinTheta * sin(br));
 (*lightSample).pdf = 1.0 / max(
@@ -62,20 +62,20 @@ TWOPI * (1.0 - cosThetaMax),
 );
 }
 
-let ir = dot(gF, iq);
-let pU = dot(iq, iq);
-let ej = ir * ir
-- pU + radius * radius;
-let cN = ir - sqrt(max(0.0, ej));
-let cC = ir + sqrt(max(0.0, ej));
+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 = gF;
-let rV = fm + gF * (*lightSample).dist;
-(*lightSample).normal = normalize(rV - light.position);
+(*lightSample).direction = gK;
+let sd = ft + gK * (*lightSample).dist;
+(*lightSample).normal = normalize(sd - light.position);
 (*lightSample).emission = light.emission;
 }
 
-fn cZ(
+fn da(
 light: Light,
 surfacePoint: vec3f,
 lowerLeft: vec3f,
@@ -86,15 +86,15 @@ return;
 }
 let width = length(light.u);
 let height = length(light.v);
-let hX = surfacePoint - lowerLeft;
+let ib = surfacePoint - lowerLeft;
 let uv = vec2f(
-dot(hX, light.u / width) / width,
-dot(hX, light.v / height) / height
+dot(ib, light.u / width) / width,
+dot(ib, light.v / height) / height
 );
 (*result).emission *= sampleMap(i32(light.textureIndex), uv).rgb;
 }
 
-fn jL(
+fn jS(
 light: Light,
 shadingPoint: vec3f,
 samplePoint: vec2f,
@@ -105,27 +105,27 @@ let lowerLeft = light.position - 0.5 * (light.u + light.v);
 let spread = clamp(light.radiusOrSpread, 0.0, 1.0);
 
 if (spread <= 0.001) {
-let gb = dot(normal, shadingPoint - light.position);
-let surfacePoint = shadingPoint - normal * gb;
-let hX = surfacePoint - lowerLeft;
+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);
 let uv = vec2f(
-dot(hX, light.u / width) / width,
-dot(hX, light.v / height) / height
+dot(ib, light.u / width) / width,
+dot(ib, light.v / height) / height
 );
-if (gb <= 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 = gb;
+(*result).dist = gg;
 (*result).normal = normal;
 (*result).emission = light.emission;
 (*result).pdf = 1.0;
 (*result).isDelta = true;
-cZ(light, surfacePoint, lowerLeft, result);
+da(light, surfacePoint, lowerLeft, result);
 return;
 }
 
@@ -133,23 +133,23 @@ let surfacePoint = lowerLeft
 + light.u * samplePoint.x
 + light.v * samplePoint.y;
 let offset = surfacePoint - shadingPoint;
-let hl = dot(offset, offset);
-(*result).dist = sqrt(hl);
+let hq = dot(offset, offset);
+(*result).dist = sqrt(hq);
 (*result).direction = offset / (*result).dist;
 (*result).normal = normal;
-let fV = dot(-(*result).direction, normal);
-let oF = cos(0.5 * PI * spread);
-if (fV <= 0.0 || fV < oF) {
+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 = hl / max(light.area * fV, 1e-8);
-cZ(light, surfacePoint, lowerLeft, result);
+(*result).pdf = hq / max(light.area * ga, 1e-8);
+da(light, surfacePoint, lowerLeft, result);
 }
 
-fn fY(
+fn gd(
 light: Light,
 result: ptr<function, LightSampleRec>
 ) {
@@ -161,59 +161,59 @@ result: ptr<function, LightSampleRec>
 (*result).isDelta = true;
 }
 
-fn jM(
+fn jT(
 light: Light,
 shadingPoint: vec3f,
 samplePoint: vec2f,
 result: ptr<function, LightSampleRec>
 ) {
-eJ(light, shadingPoint, samplePoint, result);
+eM(light, shadingPoint, samplePoint, result);
 let surfacePoint = shadingPoint + (*result).direction * (*result).dist;
-let dJ = normalize(shadingPoint - surfacePoint);
-(*result).emission *= bL(light, dJ);
+let dK = normalize(shadingPoint - surfacePoint);
+(*result).emission *= bL(light, dK);
 }
 
-fn iL(
+fn iQ(
 light: Light,
 shadingPoint: vec3f,
 samplePoint: vec2f,
 result: ptr<function, LightSampleRec>
 ) {
-let dO = i32(light.litType);
-if (dO == RECT_LIGHT) {
-jL(light, shadingPoint, samplePoint, result);
+let dP = i32(light.litType);
+if (dP == RECT_LIGHT) {
+jS(light, shadingPoint, samplePoint, result);
 return;
 }
-if (dO == SPHERE_LIGHT) {
-eJ(light, shadingPoint, samplePoint, result);
+if (dP == SPHERE_LIGHT) {
+eM(light, shadingPoint, samplePoint, result);
 return;
 }
-if (dO == SPOT_LIGHT) {
-jM(light, shadingPoint, samplePoint, result);
+if (dP == SPOT_LIGHT) {
+jT(light, shadingPoint, samplePoint, result);
 return;
 }
-if (dO == DIRECTIONAL_LIGHT) {
-fY(light, result);
+if (dP == DIRECTIONAL_LIGHT) {
+gd(light, result);
 }
 }
 
-fn mx(iU: vec2f, lightSample: ptr<function, LightSampleRec>) {
+fn mG(iZ: vec2f, lightSample: ptr<function, LightSampleRec>) {
 var uv: vec2f;
-(*lightSample).direction = oD(iU, &uv, &(*lightSample).pdf);
+(*lightSample).direction = oL(iZ, &uv, &(*lightSample).pdf);
 (*lightSample).emission = textureLinear(envMap, uv).rgb;
 (*lightSample).dist = INF;
 }
 
-fn bV(ih: i32) -> vec4f {
+fn bV(im: i32) -> vec4f {
 let width = rtUniform.lightSamplingTextureWidth;
 return textureLoad(
 lightSamplingData,
-vec2i(ih % width, ih / width),
+vec2i(im % width, im / width),
 0
 );
 }
 
-fn pV(index: i32) -> EmissiveTriangle {
+fn qd(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 sf(index: i32) -> oV {
+fn sp(index: i32) -> pe {
 let data = bV(rtUniform.lightChoiceTexelOffset + index);
-return oV(
+return pe(
 data.x,
 bitcast<i32>(data.y),
 bitcast<i32>(data.z),
@@ -240,35 +240,35 @@ bitcast<i32>(data.w)
 );
 }
 
-fn jv(mQ: i32, index: i32) -> oV {
-return sf(mQ + index);
+fn jB(nd: i32, index: i32) -> pe {
+return sp(nd + index);
 }
 
-fn mI(
+fn mS(
 rnd: vec3f,
 ca: u32,
-aW: u32
+aV: u32
 ) -> vec3f {
-var sM = rnd;
-let count = max(aW, 1u);
-sM.z = (rnd.z + f32(min(ca, count - 1u))) /
+var sU = rnd;
+let count = max(aV, 1u);
+sU.z = (rnd.z + f32(min(ca, count - 1u))) /
 f32(count);
-return sM;
+return sU;
 }
 
-fn lN(
+fn lW(
 triangle: EmissiveTriangle,
-fm: vec3f,
-iU: vec2f,
+ft: vec3f,
+iZ: vec2f,
 lightSample: ptr<function, LightSampleRec>
 ) {
-let vt = sqrt(iU.x);
+let vC = sqrt(iZ.x);
 let barycentric = vec3f(
-1.0 - vt,
-vt * (1.0 - iU.y),
-vt * iU.y
+1.0 - vC,
+vC * (1.0 - iZ.y),
+vC * iZ.y
 );
-let sS =
+let sZ =
 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 = sS - fm;
+(*lightSample).direction = sZ - ft;
 (*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 pd = dot(normal, -(*lightSample).direction);
-if (pd <= 0.0) {
+let pm = dot(normal, -(*lightSample).direction);
+if (pm <= 0.0) {
 (*lightSample).emission = vec3f(0.0);
 (*lightSample).pdf = 0.0;
 return;
 }
-(*lightSample).emission = lE(
+(*lightSample).emission = lN(
 i32(triangle.materialIndex), uv, cX
 );
 (*lightSample).selectionPmf = triangle.selectionPmf;
 (*lightSample).pdf = triangle.selectionPmf *
 ((*lightSample).dist * (*lightSample).dist) /
-max(triangle.area * pd, 1e-8);
+max(triangle.area * pm, 1e-8);
 }
 
-fn kb(
-fm: vec3f,
+fn ki(
+ft: vec3f,
 rnd: vec3f,
-mQ: i32,
-pc: i32,
-mP: f32,
+nd: i32,
+pl: i32,
+mZ: f32,
 lightSample: ptr<function, LightSampleRec>
 ) {
 (*lightSample).emission = vec3f(0.0);
@@ -320,56 +320,56 @@ lightSample: ptr<function, LightSampleRec>
 (*lightSample).isDelta = false;
 (*lightSample).sourceType = 0u;
 (*lightSample).sourceIndex = 0xffffffffu;
-if (pc <= 0) {
+if (pl <= 0) {
 return;
 }
 
-let qZ = rnd.z * f32(pc);
-let column = min(i32(qZ), pc - 1);
-let qJ = jv(mQ, column);
-let kT = select(
-qJ.aliasIndex,
+let rj = rnd.z * f32(pl);
+let column = min(i32(rj), pl - 1);
+let qS = jB(nd, column);
+let lc = select(
+qS.aliasIndex,
 column,
-fract(qZ) < qJ.probability
+fract(rj) < qS.probability
 );
-let pb = jv(mQ, kT);
-if (pb.sourceType == ${LIGHT_CHOICE_ENVIRONMENT}) {
+let pk = jB(nd, lc);
+if (pk.sourceType == ${LIGHT_CHOICE_ENVIRONMENT}) {
 (*lightSample).sourceType = 0u;
-(*lightSample).sourceIndex = u32(pb.sourceIndex);
-mx(rnd.xy, lightSample);
+(*lightSample).sourceIndex = u32(pk.sourceIndex);
+mG(rnd.xy, lightSample);
 (*lightSample).selectionPmf = rtUniform.envLightPmf;
 (*lightSample).pdf *= rtUniform.envLightPmf;
 }
-else if (pb.sourceType == ${LIGHT_CHOICE_ANALYTIC}) {
+else if (pk.sourceType == ${LIGHT_CHOICE_ANALYTIC}) {
 (*lightSample).sourceType = 2u;
-(*lightSample).sourceIndex = u32(pb.sourceIndex);
-let light = analyticLights[pb.sourceIndex];
-iL(light, fm, rnd.xy, lightSample);
+(*lightSample).sourceIndex = u32(pk.sourceIndex);
+let light = analyticLights[pk.sourceIndex];
+iQ(light, ft, rnd.xy, lightSample);
 (*lightSample).selectionPmf = light.selectionPmf;
 (*lightSample).pdf *= light.selectionPmf;
 }
-else if (pb.sourceType == ${LIGHT_CHOICE_EMISSIVE_TRIANGLE}) {
+else if (pk.sourceType == ${LIGHT_CHOICE_EMISSIVE_TRIANGLE}) {
 (*lightSample).sourceType = 1u;
-(*lightSample).sourceIndex = u32(pb.sourceIndex);
-lN(
-pV(pb.sourceIndex),
-fm,
+(*lightSample).sourceIndex = u32(pk.sourceIndex);
+lW(
+qd(pk.sourceIndex),
+ft,
 rnd.xy,
 lightSample
 );
 }
-(*lightSample).selectionPmf *= mP;
-(*lightSample).pdf *= mP;
+(*lightSample).selectionPmf *= mZ;
+(*lightSample).pdf *= mZ;
 }
 
 fn sampleLight(
-fm: vec3f,
+ft: vec3f,
 rnd: vec3f,
 lightSample: ptr<function, LightSampleRec>,
-rU: bool
+sc: bool
 ) {
-kb(
-fm,
+ki(
+ft,
 rnd,
 0,
 rtUniform.lightChoiceCount,
@@ -380,16 +380,16 @@ lightSample
 
 
 
-fn my(
-fm: vec3f,
+fn mH(
+ft: vec3f,
 rnd: vec3f,
 ca: u32,
-aW: u32,
+aV: u32,
 lightSample: ptr<function, LightSampleRec>
 ) {
-kb(
-fm,
-mI(rnd, ca, aW),
+ki(
+ft,
+mS(rnd, ca, aV),
 0,
 rtUniform.lightChoiceCount,
 1.0,