@meimu/mutracer 0.2.0 → 0.3.0

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,+BAA+B,CAAC;AACnE,OAAO,EAAC,6BAA6B,EAAE,yBAAyB,EAAC,MAAM,6BAA6B,CAAC;AACrG,OAAO,EAAE,qBAAqB,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC7E,OAAO,EACL,0BAA0B,EAC1B,mBAAmB,EACnB,qBAAqB,EACrB,mBAAmB,EACpB,MAAM,yBAAyB,CAAC;AAEjC,MAAM,CAAC,OAAO,UAAU,YAAY,CAAC,EACnC,uBAAuB,GAAG,IAAI,EAC9B,cAAc,GAAG,KAAK,EACtB,aAAa,GAAG,IAAI,EACpB,iBAAiB,GAAG,6BAA6B,EAMlD;IACC,OAAO,QAAQ,CAAC;;;;;;gBAMF,aAAa;yBACJ,qBAAqB;;qBAEzB,mBAAmB;uBACjB,qBAAqB;4BAChB,0BAA0B;qBACjC,mBAAmB;iCACP,CAAC,iBAAiB,GAAG,yBAAyB,CAAC,WAAW,CAAC,KAAK,CAAC;+BACnE,CAAC,iBAAiB,GAAG,yBAAyB,CAAC,SAAS,CAAC,KAAK,CAAC;+BAC/D,CAAC,iBAAiB,GAAG,yBAAyB,CAAC,SAAS,CAAC,KAAK,CAAC;sCACxD,CAAC,iBAAiB,GAAG,yBAAyB,CAAC,gBAAgB,CAAC,KAAK,CAAC;mCACzE,CAAC,iBAAiB,GAAG,yBAAyB,CAAC,QAAQ,CAAC,KAAK,CAAC;;;;;;;;;;;;;;;EAe/F,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DAmDwC,uBAAuB,CAAC,CAAC,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,UAAU,CAAC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqE9H,CAAC;AACF,CAAC","sourcesContent":["import { materialBufferWgsl } from '../../materialLayoutSchema.js';\nimport {ALL_LIGHT_SHADER_CAPABILITIES, LIGHT_SHADER_CAPABILITIES} from '../../shaderCapabilities.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 '../../lightConstants.js';\n\nexport default function rayTraceCore({\n  hasAnisotropyDirections = true,\n  hasCoatNormals = false,\n  hasSceneAlpha = true,\n  lightCapabilities = ALL_LIGHT_SHADER_CAPABILITIES\n}: {\n  hasAnisotropyDirections?: boolean;\n  hasCoatNormals?: boolean;\n  hasSceneAlpha?: boolean;\n  lightCapabilities?: number;\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};\nconst HAS_SCENE_SPHERE_LIGHT = ${(lightCapabilities & LIGHT_SHADER_CAPABILITIES.SphereLight) !== 0};\nconst HAS_SCENE_RECT_LIGHT = ${(lightCapabilities & LIGHT_SHADER_CAPABILITIES.RectLight) !== 0};\nconst HAS_SCENE_SPOT_LIGHT = ${(lightCapabilities & LIGHT_SHADER_CAPABILITIES.SpotLight) !== 0};\nconst HAS_SCENE_DIRECTIONAL_LIGHT = ${(lightCapabilities & LIGHT_SHADER_CAPABILITIES.DirectionalLight) !== 0};\nconst HAS_SCENE_EMISSIVE_LIGHT = ${(lightCapabilities & LIGHT_SHADER_CAPABILITIES.emissive) !== 0};\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  // Shadow-catcher light table, relative to lightChoiceTexelOffset.\n  shadowCatcherChoiceOffset: i32,\n  shadowCatcherChoiceCount: i32,\n  environmentRotation: mat4x4f,\n  backgroundMapTransform: vec4f,\n  backgroundMapRotation: mat4x4f,\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"]}
+{"version":3,"file":"rayTraceCore.wgsl.js","sourceRoot":"","sources":["../../../../src/renderer/wgsl/chunks/rayTraceCore.wgsl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AACnE,OAAO,EAAC,6BAA6B,EAAE,yBAAyB,EAAC,MAAM,6BAA6B,CAAC;AACrG,OAAO,EAAE,qBAAqB,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC7E,OAAO,EACL,0BAA0B,EAC1B,mBAAmB,EACnB,qBAAqB,EACrB,mBAAmB,EACpB,MAAM,yBAAyB,CAAC;AAEjC,MAAM,CAAC,OAAO,UAAU,YAAY,CAAC,EACnC,uBAAuB,GAAG,IAAI,EAC9B,cAAc,GAAG,KAAK,EACtB,aAAa,GAAG,IAAI,EACpB,QAAQ,GAAG,KAAK,EAChB,iBAAiB,GAAG,6BAA6B,EAOlD;IACC,OAAO,QAAQ,CAAC;;;;;;gBAMF,aAAa;yBACJ,qBAAqB;;qBAEzB,mBAAmB;uBACjB,qBAAqB;4BAChB,0BAA0B;qBACjC,mBAAmB;iCACP,CAAC,iBAAiB,GAAG,yBAAyB,CAAC,WAAW,CAAC,KAAK,CAAC;+BACnE,CAAC,iBAAiB,GAAG,yBAAyB,CAAC,SAAS,CAAC,KAAK,CAAC;+BAC/D,CAAC,iBAAiB,GAAG,yBAAyB,CAAC,SAAS,CAAC,KAAK,CAAC;sCACxD,CAAC,iBAAiB,GAAG,yBAAyB,CAAC,gBAAgB,CAAC,KAAK,CAAC;mCACzE,CAAC,iBAAiB,GAAG,yBAAyB,CAAC,QAAQ,CAAC,KAAK,CAAC;;;;;;;;;;;;;;;EAe/F,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAiCU,QAAQ,CAAC,CAAC,CAAC,UAAU,CAAC;;2BAEpB,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BhC,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;;;;;;;;;;;;;;;;;;;;;;;yBAuBf,QAAQ,CAAC,CAAC,CAAC,UAAU,CAAC;;;;;;2BAMpB,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+DhC,kBAAkB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DAmDwC,uBAAuB,CAAC,CAAC,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,UAAU,CAAC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqE9H,CAAC;AACF,CAAC","sourcesContent":["import { materialBufferWgsl } from '../../materialLayoutSchema.js';\nimport {ALL_LIGHT_SHADER_CAPABILITIES, LIGHT_SHADER_CAPABILITIES} from '../../shaderCapabilities.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 '../../lightConstants.js';\n\nexport default function rayTraceCore({\n  hasAnisotropyDirections = true,\n  hasCoatNormals = false,\n  hasSceneAlpha = true,\n  caustics = false,\n  lightCapabilities = ALL_LIGHT_SHADER_CAPABILITIES\n}: {\n  hasAnisotropyDirections?: boolean;\n  hasCoatNormals?: boolean;\n  hasSceneAlpha?: boolean;\n  caustics?: boolean;\n  lightCapabilities?: number;\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};\nconst HAS_SCENE_SPHERE_LIGHT = ${(lightCapabilities & LIGHT_SHADER_CAPABILITIES.SphereLight) !== 0};\nconst HAS_SCENE_RECT_LIGHT = ${(lightCapabilities & LIGHT_SHADER_CAPABILITIES.RectLight) !== 0};\nconst HAS_SCENE_SPOT_LIGHT = ${(lightCapabilities & LIGHT_SHADER_CAPABILITIES.SpotLight) !== 0};\nconst HAS_SCENE_DIRECTIONAL_LIGHT = ${(lightCapabilities & LIGHT_SHADER_CAPABILITIES.DirectionalLight) !== 0};\nconst HAS_SCENE_EMISSIVE_LIGHT = ${(lightCapabilities & LIGHT_SHADER_CAPABILITIES.emissive) !== 0};\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  // RGB channel a spectral path carries, 1 to 3. Zero keeps full RGB.\n  spectralChannel: i32,\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,${caustics ? /* wgsl */ `\n  causticRoughness: f32,\n  causticNormalMapped: bool,` : ''}\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,${caustics ? /* wgsl */ `\n  causticK: u32,\n  causticSingleT: bool,\n  causticReceiverPrimary: bool,\n  causticHasReceiver: bool,\n  causticPhotonReceiver:bool,\n  causticMneeReceiver: 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  // Shadow-catcher light table, relative to lightChoiceTexelOffset.\n  shadowCatcherChoiceOffset: i32,\n  shadowCatcherChoiceCount: i32,\n  environmentRotation: mat4x4f,\n  backgroundMapTransform: vec4f,\n  backgroundMapRotation: mat4x4f,\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.d.ts

@@ -1,2 +1,2 @@
-declare const _default: "\nfn light_sample_sphere(light: Light, scatterPos: vec3f, randomV2: vec2f, lightSample: ptr<function, LightSampleRec>) {\n  let centerOffset = light.position - scatterPos;\n  let centerDistance = length(centerOffset);\n  if (light.radiusOrSpread <= 0.0) {\n    // A zero-radius sphere is a point emitter. The stored emission is\n    // luminous intensity, so convert it to incident radiance here rather\n    // than approximating the delta source as a tiny area sphere.\n    if (centerDistance <= 1e-6) {\n      (*lightSample).direction = vec3f(0.0, 0.0, 1.0);\n      (*lightSample).normal = vec3f(0.0, 0.0, -1.0);\n      (*lightSample).dist = 0.0;\n      (*lightSample).pdf = 1.0;\n      (*lightSample).emission = vec3f(0.0);\n      (*lightSample).isDelta = true;\n      return;\n    }\n    (*lightSample).direction = centerOffset / centerDistance;\n    (*lightSample).normal = -(*lightSample).direction;\n    (*lightSample).dist = centerDistance;\n    (*lightSample).pdf = 1.0;\n    (*lightSample).emission = light.emission /\n      max(centerDistance * centerDistance, 1e-8);\n    (*lightSample).isDelta = true;\n    return;\n  }\n  let radius = max(light.radiusOrSpread, 1e-6);\n  (*lightSample).isDelta = false;\n  var sampledDirection: vec3f;\n\n  if (centerDistance <= radius) {\n    let z = 1.0 - 2.0 * randomV2.x;\n    let radial = sqrt(max(0.0, 1.0 - z * z));\n    let azimuth = TWOPI * randomV2.y;\n    sampledDirection = vec3f(\n      radial * cos(azimuth),\n      radial * sin(azimuth),\n      z\n    );\n    (*lightSample).pdf = INV4PI;\n  }\n  else {\n    let sphereAxis = centerOffset / centerDistance;\n    let sinThetaMaxSquared = min(\n      1.0,\n      radius * radius / (centerDistance * centerDistance)\n    );\n    let cosThetaMax = sqrt(max(0.0, 1.0 - sinThetaMaxSquared));\n    let cosTheta = mix(1.0, cosThetaMax, randomV2.x);\n    let sinTheta = sqrt(max(0.0, 1.0 - cosTheta * cosTheta));\n    let azimuth = TWOPI * randomV2.y;\n    var tangent: vec3f;\n    var bitangent: vec3f;\n    sampling_orthonormal_basis(sphereAxis, &tangent, &bitangent);\n    sampledDirection = sphereAxis * cosTheta\n      + tangent * (sinTheta * cos(azimuth))\n      + bitangent * (sinTheta * sin(azimuth));\n    (*lightSample).pdf = 1.0 / max(\n      TWOPI * (1.0 - cosThetaMax),\n      1e-8\n    );\n  }\n\n  let centerProjection = dot(sampledDirection, centerOffset);\n  let centerOffsetSquared = dot(centerOffset, centerOffset);\n  let discriminant = centerProjection * centerProjection\n    - centerOffsetSquared + radius * radius;\n  let nearDistance = centerProjection - sqrt(max(0.0, discriminant));\n  let farDistance = centerProjection + sqrt(max(0.0, discriminant));\n  (*lightSample).dist = select(farDistance, nearDistance, nearDistance > 1e-6);\n  (*lightSample).direction = sampledDirection;\n  let lightSurfacePos = scatterPos + sampledDirection * (*lightSample).dist;\n  (*lightSample).normal = normalize(lightSurfacePos - light.position);\n  (*lightSample).emission = light.emission;\n}\n\nfn light_apply_rect_texture(\n  light: Light,\n  surfacePoint: vec3f,\n  lowerLeft: vec3f,\n  result: ptr<function, LightSampleRec>\n) {\n  if (light.textureIndex < 0.0) {\n    return;\n  }\n  let width = length(light.u);\n  let height = length(light.v);\n  let relative = surfacePoint - lowerLeft;\n  let uv = vec2f(\n    dot(relative, light.u / width) / width,\n    dot(relative, light.v / height) / height\n  );\n  (*result).emission *= sampleMap(i32(light.textureIndex), uv).rgb;\n}\n\nfn light_sample_rect(\n  light: Light,\n  shadingPoint: vec3f,\n  samplePoint: vec2f,\n  result: ptr<function, LightSampleRec>\n) {\n  let normal = normalize(cross(light.u, light.v));\n  let lowerLeft = light.position - 0.5 * (light.u + light.v);\n  let spread = clamp(light.radiusOrSpread, 0.0, 1.0);\n\n  if (spread <= 0.001) {\n    let planeDistance = dot(normal, shadingPoint - light.position);\n    let surfacePoint = shadingPoint - normal * planeDistance;\n    let relative = surfacePoint - lowerLeft;\n    let width = length(light.u);\n    let height = length(light.v);\n    let uv = vec2f(\n      dot(relative, light.u / width) / width,\n      dot(relative, light.v / height) / height\n    );\n    if (planeDistance <= 0.0 || any(uv < vec2f(0.0)) || any(uv > vec2f(1.0))) {\n      (*result).emission = vec3f(0.0);\n      (*result).pdf = 0.0;\n      return;\n    }\n    (*result).direction = -normal;\n    (*result).dist = planeDistance;\n    (*result).normal = normal;\n    (*result).emission = light.emission;\n    (*result).pdf = 1.0;\n    (*result).isDelta = true;\n    light_apply_rect_texture(light, surfacePoint, lowerLeft, result);\n    return;\n  }\n\n  let surfacePoint = lowerLeft\n    + light.u * samplePoint.x\n    + light.v * samplePoint.y;\n  let offset = surfacePoint - shadingPoint;\n  let distanceSquared = dot(offset, offset);\n  (*result).dist = sqrt(distanceSquared);\n  (*result).direction = offset / (*result).dist;\n  (*result).normal = normal;\n  let emitterCosine = dot(-(*result).direction, normal);\n  let spreadCosine = cos(0.5 * PI * spread);\n  if (emitterCosine <= 0.0 || emitterCosine < spreadCosine) {\n    (*result).emission = vec3f(0.0);\n    (*result).pdf = 0.0;\n    return;\n  }\n  (*result).emission = light.emission;\n  (*result).pdf = distanceSquared / max(light.area * emitterCosine, 1e-8);\n  light_apply_rect_texture(light, surfacePoint, lowerLeft, result);\n}\n\nfn light_sample_directional(\n  light: Light,\n  result: ptr<function, LightSampleRec>\n) {\n  (*result).direction = normalize(-light.u);\n  (*result).normal = -(*result).direction;\n  (*result).emission = light.emission;\n  (*result).dist = INF;\n  (*result).pdf = 1.0;\n  (*result).isDelta = true;\n}\n\nfn light_sample_spot(\n  light: Light,\n  shadingPoint: vec3f,\n  samplePoint: vec2f,\n  result: ptr<function, LightSampleRec>\n) {\n  light_sample_sphere(light, shadingPoint, samplePoint, result);\n  let surfacePoint = shadingPoint + (*result).direction * (*result).dist;\n  let lightToSurface = normalize(shadingPoint - surfacePoint);\n  (*result).emission *= evaluateSpotEmissionMultiplier(light, lightToSurface);\n}\n\nfn sampleAnalyticLight(\n  light: Light,\n  shadingPoint: vec3f,\n  samplePoint: vec2f,\n  result: ptr<function, LightSampleRec>\n) {\n  let lightType = i32(light.litType);\n  if (HAS_SCENE_RECT_LIGHT && lightType == RECT_LIGHT) {\n    light_sample_rect(light, shadingPoint, samplePoint, result);\n    return;\n  }\n  if (HAS_SCENE_SPHERE_LIGHT && lightType == SPHERE_LIGHT) {\n    light_sample_sphere(light, shadingPoint, samplePoint, result);\n    return;\n  }\n  if (HAS_SCENE_SPOT_LIGHT && lightType == SPOT_LIGHT) {\n    light_sample_spot(light, shadingPoint, samplePoint, result);\n    return;\n  }\n  if (HAS_SCENE_DIRECTIONAL_LIGHT && lightType == DIRECTIONAL_LIGHT) {\n    light_sample_directional(light, result);\n  }\n}\n\nfn sampleEnvLight(randomV2: vec2f, lightSample: ptr<function, LightSampleRec>) {\n  var uv: vec2f;\n  // Naga's SPIR-V writer cannot pass a struct-member pointer as a call argument.\n  var pdf: f32;\n  let direction = sampleEnvmap(randomV2, &uv, &pdf);\n  (*lightSample).pdf = pdf;\n  (*lightSample).direction = direction;\n  (*lightSample).emission = textureLinear(envMap, uv).rgb;\n  (*lightSample).dist = INF;\n}\n\nfn loadLightSamplingTexel(texelIndex: i32) -> vec4f {\n  let width = rtUniform.lightSamplingTextureWidth;\n  return textureLoad(\n    lightSamplingData,\n    vec2i(texelIndex % width, texelIndex / width),\n    0\n  );\n}\n\nfn getEmissiveTriangle(index: i32) -> EmissiveTriangle {\n  let offset = index * 6;\n  let a = loadLightSamplingTexel(offset);\n  let b = loadLightSamplingTexel(offset + 1);\n  let c = loadLightSamplingTexel(offset + 2);\n  let d = loadLightSamplingTexel(offset + 3);\n  let e = loadLightSamplingTexel(offset + 4);\n  let f = loadLightSamplingTexel(offset + 5);\n  return EmissiveTriangle(\n    a.xyz, a.w,\n    b.xyz, b.w,\n    c.xyz, c.w,\n    d.xy, d.zw, e.xy,\n    e.zw, f.xy, f.zw\n  );\n}\n\nfn getLightChoice(index: i32) -> LightChoice {\n  let data = loadLightSamplingTexel(rtUniform.lightChoiceTexelOffset + index);\n  return LightChoice(\n    data.x,\n    bitcast<i32>(data.y),\n    bitcast<i32>(data.z),\n    bitcast<i32>(data.w)\n  );\n}\n\nfn getLightChoiceFromTable(tableOffset: i32, index: i32) -> LightChoice {\n  return getLightChoice(tableOffset + index);\n}\n\nfn stratifyLightChoiceRandom(\n  rnd: vec3f,\n  candidateIndex: u32,\n  candidateCount: u32\n) -> vec3f {\n  var stratified = rnd;\n  let count = max(candidateCount, 1u);\n  stratified.z = (rnd.z + f32(min(candidateIndex, count - 1u))) /\n    f32(count);\n  return stratified;\n}\n\nfn sampleEmissiveTriangleLight(\n  triangle: EmissiveTriangle,\n  scatterPos: vec3f,\n  randomV2: vec2f,\n  lightSample: ptr<function, LightSampleRec>\n) {\n  let sqrtU = sqrt(randomV2.x);\n  let barycentric = vec3f(\n    1.0 - sqrtU,\n    sqrtU * (1.0 - randomV2.y),\n    sqrtU * randomV2.y\n  );\n  let lightPosition =\n    barycentric.x * triangle.p0 +\n    barycentric.y * triangle.p1 +\n    barycentric.z * triangle.p2;\n  let uv =\n    barycentric.x * triangle.uv0 +\n    barycentric.y * triangle.uv1 +\n    barycentric.z * triangle.uv2;\n  let secondaryUv =\n    barycentric.x * triangle.secondaryUv0 +\n    barycentric.y * triangle.secondaryUv1 +\n    barycentric.z * triangle.secondaryUv2;\n  let normal = normalize(cross(triangle.p1 - triangle.p0, triangle.p2 - triangle.p0));\n  (*lightSample).direction = lightPosition - scatterPos;\n  (*lightSample).dist = length((*lightSample).direction);\n  if ((*lightSample).dist <= EPS) {\n    (*lightSample).emission = vec3f(0.0);\n    (*lightSample).pdf = 0.0;\n    return;\n  }\n  (*lightSample).direction /= (*lightSample).dist;\n  (*lightSample).normal = normal;\n  let cosLight = dot(normal, -(*lightSample).direction);\n  if (cosLight <= 0.0) {\n    (*lightSample).emission = vec3f(0.0);\n    (*lightSample).pdf = 0.0;\n    return;\n  }\n  (*lightSample).emission = getMaterialEmission(\n    i32(triangle.materialIndex), uv, secondaryUv\n  );\n  (*lightSample).selectionPmf = triangle.selectionPmf;\n  (*lightSample).pdf = triangle.selectionPmf *\n    ((*lightSample).dist * (*lightSample).dist) /\n    max(triangle.area * cosLight, 1e-8);\n}\n\nfn sampleLightChoiceTable(\n  scatterPos: vec3f,\n  rnd: vec3f,\n  tableOffset: i32,\n  choiceCount: i32,\n  selectionPmfScale: f32,\n  lightSample: ptr<function, LightSampleRec>\n) {\n  (*lightSample).emission = vec3f(0.0);\n  (*lightSample).pdf = 0.0;\n  (*lightSample).selectionPmf = 0.0;\n  (*lightSample).dist = INF;\n  (*lightSample).isDelta = false;\n  (*lightSample).sourceType = 0u;\n  (*lightSample).sourceIndex = 0xffffffffu;\n  if (choiceCount <= 0) {\n    return;\n  }\n\n  let scaledChoice = rnd.z * f32(choiceCount);\n  let column = min(i32(scaledChoice), choiceCount - 1);\n  let columnChoice = getLightChoiceFromTable(tableOffset, column);\n  let selectedIndex = select(\n    columnChoice.aliasIndex,\n    column,\n    fract(scaledChoice) < columnChoice.probability\n  );\n  let choice = getLightChoiceFromTable(tableOffset, selectedIndex);\n  if (USE_ENVMAP && choice.sourceType == 1) {\n    (*lightSample).sourceType = 0u;\n    (*lightSample).sourceIndex = u32(choice.sourceIndex);\n    sampleEnvLight(rnd.xy, lightSample);\n    (*lightSample).selectionPmf = rtUniform.envLightPmf;\n    (*lightSample).pdf *= rtUniform.envLightPmf;\n  }\n  else if (choice.sourceType == 2) {\n    (*lightSample).sourceType = 2u;\n    (*lightSample).sourceIndex = u32(choice.sourceIndex);\n    let light = analyticLights[choice.sourceIndex];\n    sampleAnalyticLight(light, scatterPos, rnd.xy, lightSample);\n    (*lightSample).selectionPmf = light.selectionPmf;\n    (*lightSample).pdf *= light.selectionPmf;\n  }\n  else if (HAS_SCENE_EMISSIVE_LIGHT && choice.sourceType == 3) {\n    (*lightSample).sourceType = 1u;\n    (*lightSample).sourceIndex = u32(choice.sourceIndex);\n    sampleEmissiveTriangleLight(\n      getEmissiveTriangle(choice.sourceIndex),\n      scatterPos,\n      rnd.xy,\n      lightSample\n    );\n  }\n  (*lightSample).selectionPmf *= selectionPmfScale;\n  (*lightSample).pdf *= selectionPmfScale;\n}\n\nfn sampleLight(\n  scatterPos: vec3f,\n  rnd: vec3f,\n  lightSample: ptr<function, LightSampleRec>,\n  distByIntensity: bool\n) {\n  sampleLightChoiceTable(\n    scatterPos,\n    rnd,\n    0,\n    rtUniform.lightChoiceCount,\n    1.0,\n    lightSample\n  );\n}\n\n// Light choice for one of the resampled NEE candidates. The selection random\n// number is stratified across the candidates.\nfn sampleLightForNEECandidate(\n  scatterPos: vec3f,\n  rnd: vec3f,\n  candidateIndex: u32,\n  candidateCount: u32,\n  lightSample: ptr<function, LightSampleRec>\n) {\n  sampleLightChoiceTable(\n    scatterPos,\n    stratifyLightChoiceRandom(rnd, candidateIndex, candidateCount),\n    0,\n    rtUniform.lightChoiceCount,\n    1.0,\n    lightSample\n  );\n}\n";
+declare const _default: "\nfn light_sample_sphere(light: Light, scatterPos: vec3f, randomV2: vec2f, lightSample: ptr<function, LightSampleRec>) {\n  let centerOffset = light.position - scatterPos;\n  let centerDistance = length(centerOffset);\n  if (light.radiusOrSpread <= 0.0) {\n    // A zero-radius sphere is a point emitter. The stored emission is\n    // luminous intensity, so convert it to incident radiance here rather\n    // than approximating the delta source as a tiny area sphere.\n    if (centerDistance <= 1e-6) {\n      (*lightSample).direction = vec3f(0.0, 0.0, 1.0);\n      (*lightSample).normal = vec3f(0.0, 0.0, -1.0);\n      (*lightSample).dist = 0.0;\n      (*lightSample).pdf = 1.0;\n      (*lightSample).emission = vec3f(0.0);\n      (*lightSample).isDelta = true;\n      return;\n    }\n    (*lightSample).direction = centerOffset / centerDistance;\n    (*lightSample).normal = -(*lightSample).direction;\n    (*lightSample).dist = centerDistance;\n    (*lightSample).pdf = 1.0;\n    (*lightSample).emission = light.emission /\n      max(centerDistance * centerDistance, 1e-8);\n    (*lightSample).isDelta = true;\n    return;\n  }\n  let radius = max(light.radiusOrSpread, 1e-6);\n  (*lightSample).isDelta = false;\n  var sampledDirection: vec3f;\n\n  if (centerDistance <= radius) {\n    let z = 1.0 - 2.0 * randomV2.x;\n    let radial = sqrt(max(0.0, 1.0 - z * z));\n    let azimuth = TWOPI * randomV2.y;\n    sampledDirection = vec3f(\n      radial * cos(azimuth),\n      radial * sin(azimuth),\n      z\n    );\n    (*lightSample).pdf = INV4PI;\n  }\n  else {\n    let sphereAxis = centerOffset / centerDistance;\n    let sinThetaMaxSquared = min(\n      1.0,\n      radius * radius / (centerDistance * centerDistance)\n    );\n    let cosThetaMax = sqrt(max(0.0, 1.0 - sinThetaMaxSquared));\n    // Rationalize 1 - cos(thetaMax): subtracting nearly equal f32 values\n    // quantizes small emitters' solid angles into visible irradiance bands.\n    let oneMinusCosThetaMax = sinThetaMaxSquared / (1.0 + cosThetaMax);\n    let oneMinusCosTheta = randomV2.x * oneMinusCosThetaMax;\n    let cosTheta = 1.0 - oneMinusCosTheta;\n    let sinTheta = sqrt(max(0.0, oneMinusCosTheta * (2.0 - oneMinusCosTheta)));\n    let azimuth = TWOPI * randomV2.y;\n    var tangent: vec3f;\n    var bitangent: vec3f;\n    sampling_orthonormal_basis(sphereAxis, &tangent, &bitangent);\n    sampledDirection = sphereAxis * cosTheta\n      + tangent * (sinTheta * cos(azimuth))\n      + bitangent * (sinTheta * sin(azimuth));\n    (*lightSample).pdf = 1.0 / max(\n      TWOPI * oneMinusCosThetaMax,\n      1e-8\n    );\n  }\n\n  let centerProjection = dot(sampledDirection, centerOffset);\n  let centerOffsetSquared = dot(centerOffset, centerOffset);\n  let discriminant = centerProjection * centerProjection\n    - centerOffsetSquared + radius * radius;\n  let nearDistance = centerProjection - sqrt(max(0.0, discriminant));\n  let farDistance = centerProjection + sqrt(max(0.0, discriminant));\n  (*lightSample).dist = select(farDistance, nearDistance, nearDistance > 1e-6);\n  (*lightSample).direction = sampledDirection;\n  let lightSurfacePos = scatterPos + sampledDirection * (*lightSample).dist;\n  (*lightSample).normal = normalize(lightSurfacePos - light.position);\n  (*lightSample).emission = light.emission;\n}\n\nfn light_apply_rect_texture(\n  light: Light,\n  surfacePoint: vec3f,\n  lowerLeft: vec3f,\n  result: ptr<function, LightSampleRec>\n) {\n  if (light.textureIndex < 0.0) {\n    return;\n  }\n  let width = length(light.u);\n  let height = length(light.v);\n  let relative = surfacePoint - lowerLeft;\n  let uv = vec2f(\n    dot(relative, light.u / width) / width,\n    dot(relative, light.v / height) / height\n  );\n  (*result).emission *= sampleMap(i32(light.textureIndex), uv).rgb;\n}\n\nfn light_sample_rect(\n  light: Light,\n  shadingPoint: vec3f,\n  samplePoint: vec2f,\n  result: ptr<function, LightSampleRec>\n) {\n  let normal = normalize(cross(light.u, light.v));\n  let lowerLeft = light.position - 0.5 * (light.u + light.v);\n  let spread = clamp(light.radiusOrSpread, 0.0, 1.0);\n\n  if (spread <= 0.001) {\n    let planeDistance = dot(normal, shadingPoint - light.position);\n    let surfacePoint = shadingPoint - normal * planeDistance;\n    let relative = surfacePoint - lowerLeft;\n    let width = length(light.u);\n    let height = length(light.v);\n    let uv = vec2f(\n      dot(relative, light.u / width) / width,\n      dot(relative, light.v / height) / height\n    );\n    if (planeDistance <= 0.0 || any(uv < vec2f(0.0)) || any(uv > vec2f(1.0))) {\n      (*result).emission = vec3f(0.0);\n      (*result).pdf = 0.0;\n      return;\n    }\n    (*result).direction = -normal;\n    (*result).dist = planeDistance;\n    (*result).normal = normal;\n    (*result).emission = light.emission;\n    (*result).pdf = 1.0;\n    (*result).isDelta = true;\n    light_apply_rect_texture(light, surfacePoint, lowerLeft, result);\n    return;\n  }\n\n  let surfacePoint = lowerLeft\n    + light.u * samplePoint.x\n    + light.v * samplePoint.y;\n  let offset = surfacePoint - shadingPoint;\n  let distanceSquared = dot(offset, offset);\n  (*result).dist = sqrt(distanceSquared);\n  (*result).direction = offset / (*result).dist;\n  (*result).normal = normal;\n  let emitterCosine = dot(-(*result).direction, normal);\n  let spreadCosine = cos(0.5 * PI * spread);\n  if (emitterCosine <= 0.0 || emitterCosine < spreadCosine) {\n    (*result).emission = vec3f(0.0);\n    (*result).pdf = 0.0;\n    return;\n  }\n  (*result).emission = light.emission;\n  (*result).pdf = distanceSquared / max(light.area * emitterCosine, 1e-8);\n  light_apply_rect_texture(light, surfacePoint, lowerLeft, result);\n}\n\nfn light_sample_directional(\n  light: Light,\n  result: ptr<function, LightSampleRec>\n) {\n  (*result).direction = normalize(-light.u);\n  (*result).normal = -(*result).direction;\n  (*result).emission = light.emission;\n  (*result).dist = INF;\n  (*result).pdf = 1.0;\n  (*result).isDelta = true;\n}\n\nfn light_sample_spot(\n  light: Light,\n  shadingPoint: vec3f,\n  samplePoint: vec2f,\n  result: ptr<function, LightSampleRec>\n) {\n  light_sample_sphere(light, shadingPoint, samplePoint, result);\n  let surfacePoint = shadingPoint + (*result).direction * (*result).dist;\n  let lightToSurface = normalize(shadingPoint - surfacePoint);\n  (*result).emission *= evaluateSpotEmissionMultiplier(light, lightToSurface);\n}\n\nfn sampleAnalyticLight(\n  light: Light,\n  shadingPoint: vec3f,\n  samplePoint: vec2f,\n  result: ptr<function, LightSampleRec>\n) {\n  let lightType = i32(light.litType);\n  if (HAS_SCENE_RECT_LIGHT && lightType == RECT_LIGHT) {\n    light_sample_rect(light, shadingPoint, samplePoint, result);\n    return;\n  }\n  if (HAS_SCENE_SPHERE_LIGHT && lightType == SPHERE_LIGHT) {\n    light_sample_sphere(light, shadingPoint, samplePoint, result);\n    return;\n  }\n  if (HAS_SCENE_SPOT_LIGHT && lightType == SPOT_LIGHT) {\n    light_sample_spot(light, shadingPoint, samplePoint, result);\n    return;\n  }\n  if (HAS_SCENE_DIRECTIONAL_LIGHT && lightType == DIRECTIONAL_LIGHT) {\n    light_sample_directional(light, result);\n  }\n}\n\nfn sampleEnvLight(randomV2: vec2f, lightSample: ptr<function, LightSampleRec>) {\n  var uv: vec2f;\n  // Naga's SPIR-V writer cannot pass a struct-member pointer as a call argument.\n  var pdf: f32;\n  let direction = sampleEnvmap(randomV2, &uv, &pdf);\n  (*lightSample).pdf = pdf;\n  (*lightSample).direction = direction;\n  (*lightSample).emission = textureLinear(envMap, uv).rgb;\n  (*lightSample).dist = INF;\n}\n\nfn loadLightSamplingTexel(texelIndex: i32) -> vec4f {\n  let width = rtUniform.lightSamplingTextureWidth;\n  return textureLoad(\n    lightSamplingData,\n    vec2i(texelIndex % width, texelIndex / width),\n    0\n  );\n}\n\nfn getEmissiveTriangle(index: i32) -> EmissiveTriangle {\n  let offset = index * 6;\n  let a = loadLightSamplingTexel(offset);\n  let b = loadLightSamplingTexel(offset + 1);\n  let c = loadLightSamplingTexel(offset + 2);\n  let d = loadLightSamplingTexel(offset + 3);\n  let e = loadLightSamplingTexel(offset + 4);\n  let f = loadLightSamplingTexel(offset + 5);\n  return EmissiveTriangle(\n    a.xyz, a.w,\n    b.xyz, b.w,\n    c.xyz, c.w,\n    d.xy, d.zw, e.xy,\n    e.zw, f.xy, f.zw\n  );\n}\n\nfn getLightChoice(index: i32) -> LightChoice {\n  let data = loadLightSamplingTexel(rtUniform.lightChoiceTexelOffset + index);\n  return LightChoice(\n    data.x,\n    bitcast<i32>(data.y),\n    bitcast<i32>(data.z),\n    bitcast<i32>(data.w)\n  );\n}\n\nfn getLightChoiceFromTable(tableOffset: i32, index: i32) -> LightChoice {\n  return getLightChoice(tableOffset + index);\n}\n\nfn stratifyLightChoiceRandom(\n  rnd: vec3f,\n  candidateIndex: u32,\n  candidateCount: u32\n) -> vec3f {\n  var stratified = rnd;\n  let count = max(candidateCount, 1u);\n  stratified.z = (rnd.z + f32(min(candidateIndex, count - 1u))) /\n    f32(count);\n  return stratified;\n}\n\nfn sampleEmissiveTriangleLight(\n  triangle: EmissiveTriangle,\n  scatterPos: vec3f,\n  randomV2: vec2f,\n  lightSample: ptr<function, LightSampleRec>\n) {\n  let sqrtU = sqrt(randomV2.x);\n  let barycentric = vec3f(\n    1.0 - sqrtU,\n    sqrtU * (1.0 - randomV2.y),\n    sqrtU * randomV2.y\n  );\n  let lightPosition =\n    barycentric.x * triangle.p0 +\n    barycentric.y * triangle.p1 +\n    barycentric.z * triangle.p2;\n  let uv =\n    barycentric.x * triangle.uv0 +\n    barycentric.y * triangle.uv1 +\n    barycentric.z * triangle.uv2;\n  let secondaryUv =\n    barycentric.x * triangle.secondaryUv0 +\n    barycentric.y * triangle.secondaryUv1 +\n    barycentric.z * triangle.secondaryUv2;\n  let normal = normalize(cross(triangle.p1 - triangle.p0, triangle.p2 - triangle.p0));\n  (*lightSample).direction = lightPosition - scatterPos;\n  (*lightSample).dist = length((*lightSample).direction);\n  if ((*lightSample).dist <= EPS) {\n    (*lightSample).emission = vec3f(0.0);\n    (*lightSample).pdf = 0.0;\n    return;\n  }\n  (*lightSample).direction /= (*lightSample).dist;\n  (*lightSample).normal = normal;\n  let cosLight = dot(normal, -(*lightSample).direction);\n  if (cosLight <= 0.0) {\n    (*lightSample).emission = vec3f(0.0);\n    (*lightSample).pdf = 0.0;\n    return;\n  }\n  (*lightSample).emission = getMaterialEmission(\n    i32(triangle.materialIndex), uv, secondaryUv\n  );\n  (*lightSample).selectionPmf = triangle.selectionPmf;\n  (*lightSample).pdf = triangle.selectionPmf *\n    ((*lightSample).dist * (*lightSample).dist) /\n    max(triangle.area * cosLight, 1e-8);\n}\n\nfn sampleLightChoiceTable(\n  scatterPos: vec3f,\n  rnd: vec3f,\n  tableOffset: i32,\n  choiceCount: i32,\n  selectionPmfScale: f32,\n  lightSample: ptr<function, LightSampleRec>\n) {\n  (*lightSample).emission = vec3f(0.0);\n  (*lightSample).pdf = 0.0;\n  (*lightSample).selectionPmf = 0.0;\n  (*lightSample).dist = INF;\n  (*lightSample).isDelta = false;\n  (*lightSample).sourceType = 0u;\n  (*lightSample).sourceIndex = 0xffffffffu;\n  if (choiceCount <= 0) {\n    return;\n  }\n\n  let scaledChoice = rnd.z * f32(choiceCount);\n  let column = min(i32(scaledChoice), choiceCount - 1);\n  let columnChoice = getLightChoiceFromTable(tableOffset, column);\n  let selectedIndex = select(\n    columnChoice.aliasIndex,\n    column,\n    fract(scaledChoice) < columnChoice.probability\n  );\n  let choice = getLightChoiceFromTable(tableOffset, selectedIndex);\n  if (USE_ENVMAP && choice.sourceType == 1) {\n    (*lightSample).sourceType = 0u;\n    (*lightSample).sourceIndex = u32(choice.sourceIndex);\n    sampleEnvLight(rnd.xy, lightSample);\n    (*lightSample).selectionPmf = rtUniform.envLightPmf;\n    (*lightSample).pdf *= rtUniform.envLightPmf;\n  }\n  else if (choice.sourceType == 2) {\n    (*lightSample).sourceType = 2u;\n    (*lightSample).sourceIndex = u32(choice.sourceIndex);\n    let light = analyticLights[choice.sourceIndex];\n    sampleAnalyticLight(light, scatterPos, rnd.xy, lightSample);\n    (*lightSample).selectionPmf = light.selectionPmf;\n    (*lightSample).pdf *= light.selectionPmf;\n  }\n  else if (HAS_SCENE_EMISSIVE_LIGHT && choice.sourceType == 3) {\n    (*lightSample).sourceType = 1u;\n    (*lightSample).sourceIndex = u32(choice.sourceIndex);\n    sampleEmissiveTriangleLight(\n      getEmissiveTriangle(choice.sourceIndex),\n      scatterPos,\n      rnd.xy,\n      lightSample\n    );\n  }\n  (*lightSample).selectionPmf *= selectionPmfScale;\n  (*lightSample).pdf *= selectionPmfScale;\n}\n\nfn sampleLight(\n  scatterPos: vec3f,\n  rnd: vec3f,\n  lightSample: ptr<function, LightSampleRec>,\n  distByIntensity: bool\n) {\n  sampleLightChoiceTable(\n    scatterPos,\n    rnd,\n    0,\n    rtUniform.lightChoiceCount,\n    1.0,\n    lightSample\n  );\n}\n\n// Light choice for one of the resampled NEE candidates. The selection random\n// number is stratified across the candidates.\nfn sampleLightForNEECandidate(\n  scatterPos: vec3f,\n  rnd: vec3f,\n  candidateIndex: u32,\n  candidateCount: u32,\n  lightSample: ptr<function, LightSampleRec>\n) {\n  sampleLightChoiceTable(\n    scatterPos,\n    stratifyLightChoiceRandom(rnd, candidateIndex, candidateCount),\n    0,\n    rtUniform.lightChoiceCount,\n    1.0,\n    lightSample\n  );\n}\n";
 export default _default;

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

@@ -1,13 +1,13 @@
 import { LIGHT_CHOICE_ANALYTIC, LIGHT_CHOICE_EMISSIVE_TRIANGLE, LIGHT_CHOICE_ENVIRONMENT } from '../../lightConstants.js';
 export default /*wgsl */ `
-fn eY(light: Light, fI: vec3f, jt: vec2f, lightSample: ptr<function, LightSampleRec>) {
-let iQ = light.position - fI;
-let ak = length(iQ);
+fn eH(light: Light, fk: vec3f, iY: vec2f, lightSample: ptr<function, LightSampleRec>) {
+let iz = light.position - fk;
+let ao = length(iz);
 if (light.radiusOrSpread <= 0.0) {
 
 
 
-if (ak <= 1e-6) {
+if (ao <= 1e-6) {
 (*lightSample).direction = vec3f(0.0, 0.0, 1.0);
 (*lightSample).normal = vec3f(0.0, 0.0, -1.0);
 (*lightSample).dist = 0.0;
@@ -16,66 +16,70 @@ if (ak <= 1e-6) {
 (*lightSample).isDelta = true;
 return;
 }
-(*lightSample).direction = iQ / ak;
+(*lightSample).direction = iz / ao;
 (*lightSample).normal = -(*lightSample).direction;
-(*lightSample).dist = ak;
+(*lightSample).dist = ao;
 (*lightSample).pdf = 1.0;
 (*lightSample).emission = light.emission /
-max(ak * ak, 1e-8);
+max(ao * ao, 1e-8);
 (*lightSample).isDelta = true;
 return;
 }
 let radius = max(light.radiusOrSpread, 1e-6);
 (*lightSample).isDelta = false;
-var gX: vec3f;
+var gG: vec3f;
 
-if (ak <= radius) {
-let z = 1.0 - 2.0 * jt.x;
-let ex = sqrt(max(0.0, 1.0 - z * z));
-let azimuth = TWOPI * jt.y;
-gX = vec3f(
-ex * cos(azimuth),
-ex * sin(azimuth),
+if (ao <= radius) {
+let z = 1.0 - 2.0 * iY.x;
+let dr = sqrt(max(0.0, 1.0 - z * z));
+let azimuth = TWOPI * iY.y;
+gG = vec3f(
+dr * cos(azimuth),
+dr * sin(azimuth),
 z
 );
 (*lightSample).pdf = INV4PI;
 }
 else {
-let ui = iQ / ak;
-let jV = min(
+let uk = iz / ao;
+let sinThetaMaxSquared = min(
 1.0,
-radius * radius / (ak * ak)
+radius * radius / (ao * ao)
 );
-let cosThetaMax = sqrt(max(0.0, 1.0 - jV));
-let ci = mix(1.0, cosThetaMax, jt.x);
-let sinTheta = sqrt(max(0.0, 1.0 - ci * ci));
-let azimuth = TWOPI * jt.y;
+let cosThetaMax = sqrt(max(0.0, 1.0 - sinThetaMaxSquared));
+
+
+let oneMinusCosThetaMax = sinThetaMaxSquared / (1.0 + cosThetaMax);
+let kZ = iY.x * oneMinusCosThetaMax;
+let ct = 1.0 - kZ;
+let sinTheta = sqrt(max(0.0, kZ * (2.0 - kZ)));
+let azimuth = TWOPI * iY.y;
 var tangent: vec3f;
 var bitangent: vec3f;
-aP(ui, &tangent, &bitangent);
-gX = ui * ci
+sampling_orthonormal_basis(uk, &tangent, &bitangent);
+gG = uk * ct
 + tangent * (sinTheta * cos(azimuth))
 + bitangent * (sinTheta * sin(azimuth));
 (*lightSample).pdf = 1.0 / max(
-TWOPI * (1.0 - cosThetaMax),
+TWOPI * oneMinusCosThetaMax,
 1e-8
 );
 }
 
-let iR = dot(gX, iQ);
-let ra = dot(iQ, iQ);
-let br = iR * iR
-- ra + radius * radius;
-let cV = iR - sqrt(max(0.0, br));
-let cM = iR + sqrt(max(0.0, br));
-(*lightSample).dist = select(cM, cV, cV > 1e-6);
-(*lightSample).direction = gX;
-let tl = fI + gX * (*lightSample).dist;
+let iA = dot(gG, iz);
+let qT = dot(iz, iz);
+let bj = iA * iA
+- qT + radius * radius;
+let cI = iA - sqrt(max(0.0, bj));
+let cw = iA + sqrt(max(0.0, bj));
+(*lightSample).dist = select(cw, cI, cI > 1e-6);
+(*lightSample).direction = gG;
+let tl = fk + gG * (*lightSample).dist;
 (*lightSample).normal = normalize(tl - light.position);
 (*lightSample).emission = light.emission;
 }
 
-fn dn(
+fn bC(
 light: Light,
 surfacePoint: vec3f,
 lowerLeft: vec3f,
@@ -86,15 +90,15 @@ return;
 }
 let width = length(light.u);
 let height = length(light.v);
-let ek = surfacePoint - lowerLeft;
+let dU = surfacePoint - lowerLeft;
 let uv = vec2f(
-dot(ek, light.u / width) / width,
-dot(ek, light.v / height) / height
+dot(dU, light.u / width) / width,
+dot(dU, light.v / height) / height
 );
 (*result).emission *= sampleMap(i32(light.textureIndex), uv).rgb;
 }
 
-fn kw(
+fn jZ(
 light: Light,
 shadingPoint: vec3f,
 samplePoint: vec2f,
@@ -105,27 +109,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 gw = dot(normal, shadingPoint - light.position);
-let surfacePoint = shadingPoint - normal * gw;
-let ek = surfacePoint - lowerLeft;
+let gg = dot(normal, shadingPoint - light.position);
+let surfacePoint = shadingPoint - normal * gg;
+let dU = surfacePoint - lowerLeft;
 let width = length(light.u);
 let height = length(light.v);
 let uv = vec2f(
-dot(ek, light.u / width) / width,
-dot(ek, light.v / height) / height
+dot(dU, light.u / width) / width,
+dot(dU, light.v / height) / height
 );
-if (gw <= 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 = gw;
+(*result).dist = gg;
 (*result).normal = normal;
 (*result).emission = light.emission;
 (*result).pdf = 1.0;
 (*result).isDelta = true;
-dn(light, surfacePoint, lowerLeft, result);
+bC(light, surfacePoint, lowerLeft, result);
 return;
 }
 
@@ -133,23 +137,23 @@ let surfacePoint = lowerLeft
 + light.u * samplePoint.x
 + light.v * samplePoint.y;
 let offset = surfacePoint - shadingPoint;
-let hE = dot(offset, offset);
-(*result).dist = sqrt(hE);
+let bG = dot(offset, offset);
+(*result).dist = sqrt(bG);
 (*result).direction = offset / (*result).dist;
 (*result).normal = normal;
-let gn = dot(-(*result).direction, normal);
-let pK = cos(0.5 * PI * spread);
-if (gn <= 0.0 || gn < pK) {
+let fY = dot(-(*result).direction, normal);
+let pp = cos(0.5 * PI * spread);
+if (fY <= 0.0 || fY < pp) {
 (*result).emission = vec3f(0.0);
 (*result).pdf = 0.0;
 return;
 }
 (*result).emission = light.emission;
-(*result).pdf = hE / max(light.area * gn, 1e-8);
-dn(light, surfacePoint, lowerLeft, result);
+(*result).pdf = bG / max(light.area * fY, 1e-8);
+bC(light, surfacePoint, lowerLeft, result);
 }
 
-fn gs(
+fn gc(
 light: Light,
 result: ptr<function, LightSampleRec>
 ) {
@@ -161,70 +165,70 @@ result: ptr<function, LightSampleRec>
 (*result).isDelta = true;
 }
 
-fn kx(
+fn ka(
 light: Light,
 shadingPoint: vec3f,
 samplePoint: vec2f,
 result: ptr<function, LightSampleRec>
 ) {
-eY(light, shadingPoint, samplePoint, result);
+eH(light, shadingPoint, samplePoint, result);
 let surfacePoint = shadingPoint + (*result).direction * (*result).dist;
-let dV = normalize(shadingPoint - surfacePoint);
-(*result).emission *= bP(light, dV);
+let dI = normalize(shadingPoint - surfacePoint);
+(*result).emission *= evaluateSpotEmissionMultiplier(light, dI);
 }
 
-fn jg(
+fn sampleAnalyticLight(
 light: Light,
 shadingPoint: vec3f,
 samplePoint: vec2f,
 result: ptr<function, LightSampleRec>
 ) {
-let ec = i32(light.litType);
-if (HAS_SCENE_RECT_LIGHT && ec == RECT_LIGHT) {
-kw(light, shadingPoint, samplePoint, result);
+let dO = i32(light.litType);
+if (HAS_SCENE_RECT_LIGHT && dO == RECT_LIGHT) {
+jZ(light, shadingPoint, samplePoint, result);
 return;
 }
-if (HAS_SCENE_SPHERE_LIGHT && ec == SPHERE_LIGHT) {
-eY(light, shadingPoint, samplePoint, result);
+if (HAS_SCENE_SPHERE_LIGHT && dO == SPHERE_LIGHT) {
+eH(light, shadingPoint, samplePoint, result);
 return;
 }
-if (HAS_SCENE_SPOT_LIGHT && ec == SPOT_LIGHT) {
-kx(light, shadingPoint, samplePoint, result);
+if (HAS_SCENE_SPOT_LIGHT && dO == SPOT_LIGHT) {
+ka(light, shadingPoint, samplePoint, result);
 return;
 }
-if (HAS_SCENE_DIRECTIONAL_LIGHT && ec == DIRECTIONAL_LIGHT) {
-gs(light, result);
+if (HAS_SCENE_DIRECTIONAL_LIGHT && dO == DIRECTIONAL_LIGHT) {
+gc(light, result);
 }
 }
 
-fn nD(jt: vec2f, lightSample: ptr<function, LightSampleRec>) {
+fn ig(iY: vec2f, lightSample: ptr<function, LightSampleRec>) {
 var uv: vec2f;
 
 var pdf: f32;
-let direction = pI(jt, &uv, &pdf);
+let direction = pn(iY, &uv, &pdf);
 (*lightSample).pdf = pdf;
 (*lightSample).direction = direction;
 (*lightSample).emission = textureLinear(envMap, uv).rgb;
 (*lightSample).dist = INF;
 }
 
-fn ca(iK: i32) -> vec4f {
+fn loadLightSamplingTexel(im: i32) -> vec4f {
 let width = rtUniform.lightSamplingTextureWidth;
 return textureLoad(
 lightSamplingData,
-vec2i(iK % width, iK / width),
+vec2i(im % width, im / width),
 0
 );
 }
 
-fn rb(index: i32) -> EmissiveTriangle {
+fn getEmissiveTriangle(index: i32) -> EmissiveTriangle {
 let offset = index * 6;
-let a = ca(offset);
-let b = ca(offset + 1);
-let c = ca(offset + 2);
-let d = ca(offset + 3);
-let e = ca(offset + 4);
-let f = ca(offset + 5);
+let a = loadLightSamplingTexel(offset);
+let b = loadLightSamplingTexel(offset + 1);
+let c = loadLightSamplingTexel(offset + 2);
+let d = loadLightSamplingTexel(offset + 3);
+let e = loadLightSamplingTexel(offset + 4);
+let f = loadLightSamplingTexel(offset + 5);
 return EmissiveTriangle(
 a.xyz, a.w,
 b.xyz, b.w,
@@ -234,9 +238,9 @@ e.zw, f.xy, f.zw
 );
 }
 
-fn tI(index: i32) -> qb {
-let data = ca(rtUniform.lightChoiceTexelOffset + index);
-return qb(
+fn tJ(index: i32) -> pW {
+let data = loadLightSamplingTexel(rtUniform.lightChoiceTexelOffset + index);
+return pW(
 data.x,
 bitcast<i32>(data.y),
 bitcast<i32>(data.z),
@@ -244,35 +248,35 @@ bitcast<i32>(data.w)
 );
 }
 
-fn ka(nZ: i32, index: i32) -> qb {
-return tI(nZ + index);
+fn jG(nP: i32, index: i32) -> pW {
+return tJ(nP + index);
 }
 
-fn nR(
+fn nG(
 rnd: vec3f,
-mS: u32,
+mE: u32,
 candidateCount: u32
 ) -> vec3f {
-var uk = rnd;
+var um = rnd;
 let count = max(candidateCount, 1u);
-uk.z = (rnd.z + f32(min(mS, count - 1u))) /
+um.z = (rnd.z + f32(min(mE, count - 1u))) /
 f32(count);
-return uk;
+return um;
 }
 
-fn mH(
+fn mr(
 triangle: EmissiveTriangle,
-fI: vec3f,
-jt: vec2f,
+fk: vec3f,
+iY: vec2f,
 lightSample: ptr<function, LightSampleRec>
 ) {
-let xh = sqrt(jt.x);
+let xJ = sqrt(iY.x);
 let barycentric = vec3f(
-1.0 - xh,
-xh * (1.0 - jt.y),
-xh * jt.y
+1.0 - xJ,
+xJ * (1.0 - iY.y),
+xJ * iY.y
 );
-let uq =
+let ut =
 barycentric.x * triangle.p0 +
 barycentric.y * triangle.p1 +
 barycentric.z * triangle.p2;
@@ -280,12 +284,12 @@ let uv =
 barycentric.x * triangle.uv0 +
 barycentric.y * triangle.uv1 +
 barycentric.z * triangle.uv2;
-let dj =
+let cQ =
 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 = uq - fI;
+(*lightSample).direction = ut - fk;
 (*lightSample).dist = length((*lightSample).direction);
 if ((*lightSample).dist <= EPS) {
 (*lightSample).emission = vec3f(0.0);
@@ -294,27 +298,27 @@ return;
 }
 (*lightSample).direction /= (*lightSample).dist;
 (*lightSample).normal = normal;
-let qi = dot(normal, -(*lightSample).direction);
-if (qi <= 0.0) {
+let om = dot(normal, -(*lightSample).direction);
+if (om <= 0.0) {
 (*lightSample).emission = vec3f(0.0);
 (*lightSample).pdf = 0.0;
 return;
 }
 (*lightSample).emission = getMaterialEmission(
-i32(triangle.materialIndex), uv, dj
+i32(triangle.materialIndex), uv, cQ
 );
 (*lightSample).selectionPmf = triangle.selectionPmf;
 (*lightSample).pdf = triangle.selectionPmf *
 ((*lightSample).dist * (*lightSample).dist) /
-max(triangle.area * qi, 1e-8);
+max(triangle.area * om, 1e-8);
 }
 
-fn hv(
-fI: vec3f,
+fn hb(
+fk: vec3f,
 rnd: vec3f,
-nZ: i32,
+nP: i32,
 choiceCount: i32,
-nX: f32,
+nN: f32,
 lightSample: ptr<function, LightSampleRec>
 ) {
 (*lightSample).emission = vec3f(0.0);
@@ -328,52 +332,52 @@ if (choiceCount <= 0) {
 return;
 }
 
-let sq = rnd.z * f32(choiceCount);
-let column = min(i32(sq), choiceCount - 1);
-let rW = ka(nZ, column);
-let lM = select(
-rW.aliasIndex,
+let sk = rnd.z * f32(choiceCount);
+let column = min(i32(sk), choiceCount - 1);
+let rS = jG(nP, column);
+let jc = select(
+rS.aliasIndex,
 column,
-fract(sq) < rW.probability
+fract(sk) < rS.probability
 );
-let qh = ka(nZ, lM);
-if (USE_ENVMAP && qh.sourceType == ${LIGHT_CHOICE_ENVIRONMENT}) {
+let choice = jG(nP, jc);
+if (USE_ENVMAP && choice.sourceType == ${LIGHT_CHOICE_ENVIRONMENT}) {
 (*lightSample).sourceType = 0u;
-(*lightSample).sourceIndex = u32(qh.sourceIndex);
-nD(rnd.xy, lightSample);
+(*lightSample).sourceIndex = u32(choice.sourceIndex);
+ig(rnd.xy, lightSample);
 (*lightSample).selectionPmf = rtUniform.envLightPmf;
 (*lightSample).pdf *= rtUniform.envLightPmf;
 }
-else if (qh.sourceType == ${LIGHT_CHOICE_ANALYTIC}) {
+else if (choice.sourceType == ${LIGHT_CHOICE_ANALYTIC}) {
 (*lightSample).sourceType = 2u;
-(*lightSample).sourceIndex = u32(qh.sourceIndex);
-let light = analyticLights[qh.sourceIndex];
-jg(light, fI, rnd.xy, lightSample);
+(*lightSample).sourceIndex = u32(choice.sourceIndex);
+let light = analyticLights[choice.sourceIndex];
+sampleAnalyticLight(light, fk, rnd.xy, lightSample);
 (*lightSample).selectionPmf = light.selectionPmf;
 (*lightSample).pdf *= light.selectionPmf;
 }
-else if (HAS_SCENE_EMISSIVE_LIGHT && qh.sourceType == ${LIGHT_CHOICE_EMISSIVE_TRIANGLE}) {
+else if (HAS_SCENE_EMISSIVE_LIGHT && choice.sourceType == ${LIGHT_CHOICE_EMISSIVE_TRIANGLE}) {
 (*lightSample).sourceType = 1u;
-(*lightSample).sourceIndex = u32(qh.sourceIndex);
-mH(
-rb(qh.sourceIndex),
-fI,
+(*lightSample).sourceIndex = u32(choice.sourceIndex);
+mr(
+getEmissiveTriangle(choice.sourceIndex),
+fk,
 rnd.xy,
 lightSample
 );
 }
-(*lightSample).selectionPmf *= nX;
-(*lightSample).pdf *= nX;
+(*lightSample).selectionPmf *= nN;
+(*lightSample).pdf *= nN;
 }
 
 fn sampleLight(
-fI: vec3f,
+fk: vec3f,
 rnd: vec3f,
 lightSample: ptr<function, LightSampleRec>,
 tk: bool
 ) {
-hv(
-fI,
+hb(
+fk,
 rnd,
 0,
 rtUniform.lightChoiceCount,
@@ -384,16 +388,16 @@ lightSample
 
 
 
-fn nE(
-fI: vec3f,
+fn nk(
+fk: vec3f,
 rnd: vec3f,
-mS: u32,
+mE: u32,
 candidateCount: u32,
 lightSample: ptr<function, LightSampleRec>
 ) {
-hv(
-fI,
-nR(rnd, mS, candidateCount),
+hb(
+fk,
+nG(rnd, mE, candidateCount),
 0,
 rtUniform.lightChoiceCount,
 1.0,