@meimu/mutracer 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,439 @@
+// Next-event estimation with resampled importance sampling over the light
+// candidates, followed by BSDF (or phase function) sampling, as described in
+// http://www.pbr-book.org/3ed-2018/Light_Transport_I_Surface_Reflection/Direct_Lighting.html#EstimatingtheDirectLightingIntegral
+export function createSampleMaterialWgsl(hasAnisotropyDirections = true, hasCoatNormals = false) {
+    return /* wgsl */ `
+
+struct mO {
+ray: Ray,
+maxDistance: f32,
+triangleIndex: i32,
+contribution: vec3f,
+
+
+risTarget: f32,
+lightSelectionPmf: f32,
+valid: bool,
+}
+
+fn qe(
+si: ptr<function, ad>,
+ma: J,
+prepared: ag,
+aa: ptr<function, Path>,
+ffnormal: vec3f,
+gw: bool,
+ca: u32,
+aW: u32,
+gd: ptr<function, mO>
+) -> bool {
+(*gd).valid = false;
+(*gd).lightSelectionPmf = 0.0;
+(*gd).risTarget = 0.0;
+let kZ = vec3f(fk(qR(ca, 1u)), dz(qR(ca, 0u)));
+
+var lightSample: LightSampleRec;
+mv(
+(*si).position,
+kZ,
+ca,
+aW,
+&lightSample
+);
+var Li = lightSample.emission;
+
+let lightDir = lightSample.direction;
+let oH = -(*aa).ray.d;
+let fd = lightSample.pdf;
+let lightSelectionPmf = lightSample.selectionPmf;
+
+
+${hasCoatNormals ? /* wgsl */ `var cosThetaL = dot(ffnormal, lightDir);
+if (gw && ma.coatNormalEnabled) { cosThetaL = dot(ma.geometricNormal, lightDir); }` : 'let cosThetaL = dot(ffnormal, lightDir);'}
+
+if (fd <= 0.0 || lightSelectionPmf <= 0.0 ||
+max(max(Li.x, Li.y), Li.z) <= 0.0) {
+return false;
+}
+
+var scatteringPdf = 0.0;
+var f = vec3f(0.0);
+if (gw) {
+
+
+if (cosThetaL <= 0.0 && ma.transmissionWeight <= 0.0 && ma.subsurfaceWeight <= 0.0) {
+return false;
+}
+f = bI(prepared, lightDir, &scatteringPdf);
+}
+else {
+scatteringPdf = bD(
+dot(oH, lightDir),
+(*si).mediumAnisotropy
+);
+f = vec3f(scatteringPdf);
+}
+
+if (scatteringPdf <= 0.0 || max(max(f.x, f.y), f.z) <= 0.0) {
+return false;
+}
+
+var ml: Ray;
+var hc = (*si).position + EPS * lightDir;
+if (gw) {
+hc = rD((*si).position, (*si).faceNormal, lightDir);
+let bZ = 0.1;
+var dr = dot((*si).normal, lightDir);
+${hasCoatNormals ? /* wgsl */ `    if (ma.coatNormalEnabled) { dr = dot((*si).faceNormal, lightDir); }` : ''}
+let geometricNormal = select(
+(*si).faceNormal,
+-(*si).faceNormal,
+dr < 0.0
+);
+dr = abs(dr);
+let hP = dot(geometricNormal, lightDir);
+let oo = select(
+clamp(1.0 - hP / bZ, 0.0, 1.0),
+clamp(
+2.0 - (hP + dr) / bZ,
+0.0,
+1.0
+),
+dr < bZ
+);
+hc += (*si).shadowOffset * oo;
+}
+
+
+
+
+var lE = lightDir;
+var mC = lightSample.dist - EPS;
+if (lightSample.sourceType == 1u) {
+let sM =
+(*si).position + lightSample.direction * lightSample.dist;
+let pS = sM + EPS * lightSample.normal;
+let qd = pS - hc;
+mC = length(qd);
+lE = normalize(qd);
+}
+iw(&ml, hc, lE);
+
+
+
+
+if (gw && cosThetaL < 0.0 && lightSample.sourceType == 0u) {
+let background = hE(ml);
+Li = background.rgb * background.a;
+}
+if (SPECTRAL) {
+Li = ai(Li, (*si).wavelength);
+}
+
+
+
+let eW = select(
+tk(fd, scatteringPdf),
+1.0,
+lightSample.isDelta
+);
+if (eW > 0.0) {
+let kh = Li * f / fd * (*aa).beta;
+(*gd).risTarget = max(
+dot(max(kh * lightSelectionPmf, vec3f(0.0)), luminance),
+0.0
+);
+(*gd).ray = ml;
+(*gd).maxDistance = mC;
+(*gd).triangleIndex = (*si).triangleIndex;
+(*gd).contribution = eW * kh;
+(*gd).lightSelectionPmf = lightSelectionPmf;
+(*gd).valid = true;
+return true;
+}
+return false;
+}
+
+fn mG(
+si: ptr<function, ad>,
+ma: J,
+prepared: ag,
+aa: ptr<function, Path>,
+ffnormal: vec3f,
+gw: bool
+) {
+let aW = jO();
+var selected: mO;
+selected.valid = false;
+var mw = 0.0;
+var ls = 0.0;
+
+
+for (var ca = 0u; ca < aW; ca++) {
+var candidate: mO;
+let oW = qe(
+si, ma, prepared, aa, ffnormal, gw,
+ca, aW, &candidate);
+if (aW == 1u) {
+if (!oW) { return; }
+selected = candidate;
+break;
+}
+if (!oW) { continue; }
+let ka = candidate.risTarget / max(candidate.lightSelectionPmf, 1e-20);
+if (!(ka > 0.0) || ka != ka) { continue; }
+ls += ka;
+if (!selected.valid ||
+po(ca) * ls <= ka) {
+selected = candidate;
+mw = candidate.risTarget;
+}
+}
+var qC = 1.0;
+if (aW > 1u) {
+if (!selected.valid || mw <= 0.0) { return; }
+
+
+qC = selected.lightSelectionPmf * ls /
+(f32(aW) * mw);
+}
+if (selected.valid &&
+!ex(selected.ray, selected.maxDistance, selected.triangleIndex)) {
+(*aa).li += selected.contribution * qC;
+}
+}
+
+fn pc(
+si: ptr<function, ad>,
+aa: ptr<function, Path>
+) -> f32 {
+if ((*aa).fromEye || rtUniform.lightWeightTotal <= 0.0 ||
+i32(materialsBuffer[(*si).materialIndex].matType) == UNLIT) {
+return 1.0;
+}
+let samplingLuminance = dot(
+materialsBuffer[(*si).materialIndex].emission,
+luminance
+);
+let oZ = dot((*si).faceNormal, -(*aa).ray.d);
+if (samplingLuminance <= 0.0 || oZ <= 0.0) {
+return 1.0;
+}
+let rL = distance((*si).position, (*aa).ray.o);
+let fd = samplingLuminance / rtUniform.lightWeightTotal *
+rL * rL / max(oZ, 1e-8);
+return fS((*aa).scatteringPdf, fd);
+}
+
+${hasCoatNormals ? /* wgsl */ `
+
+
+fn fB(input: vec3f, tc: vec3f, view: vec3f) -> vec3f {
+let qL = dot(tc, view) >= 0.0;
+let ub = select(-tc, tc, qL);
+let qK = select(-input, input, qL);
+if (dot(input, tc) <= 0.0 || dot(qK, view) <= 1e-6) { return ub; }
+return qK;
+}
+` : ''}
+fn lO(
+si: ptr<function, ad>,
+ma: ptr<function, J>,
+aa: ptr<function, Path>
+) {
+${hasCoatNormals ? /* wgsl */ `
+let bC = (*si).faceNormal;
+let mr = (*si).normal;
+` : ''}
+var rA: f32 = -dot((*si).faceNormal, (*aa).ray.d);
+var sq: f32 = -dot((*si).normal, (*aa).ray.d);
+if (((*ma).transmissionWeight > 0.0 || (*ma).subsurfaceWeight > 0.0) && (*ma).thinWalled) {
+
+if (rA < 0.0) {
+(*si).faceNormal = -(*si).faceNormal;
+rA = -rA;
+}
+if (sq < 0.0) {
+(*si).normal = -(*si).normal;
+sq = -sq;
+}
+}
+
+
+var pI: bool = rA >= 0.0 && sq < 0.0;
+var ndv: f32 = select(sq, rA, pI);
+var N: vec3f = select((*si).normal, (*si).faceNormal, pI);
+
+(*ma).inside = ndv <= 0.0 && !(*ma).thinWalled;
+
+(*ma).relativeIor = select((*ma).specularIor, (1.0 / (*ma).specularIor), ndv > 0.0);
+var ffnormal = select(-N, N, ndv >= 0.0);
+${hasCoatNormals ? /* wgsl */ `
+if ((*ma).coatNormalEnabled) {
+let view = -(*aa).ray.d;
+let fW = dot(bC, view);
+(*ma).geometricNormal = select(-bC, bC, fW >= 0.0);
+ffnormal = fB(mr, bC, view);
+(*ma).coatNormal = fB((*si).coatNormal, bC, view);
+(*ma).inside = fW <= 0.0 && !(*ma).thinWalled;
+(*ma).relativeIor = select((*ma).specularIor, 1.0 / (*ma).specularIor, fW > 0.0 || (*ma).thinWalled);
+}
+` : ''}
+
+(*aa).scatteringIsDelta = false;
+var bl = false;
+var hj = false;
+let mediumType = (*si).mediumType;
+
+var scatteringPdf: f32;
+var cF: vec3f;
+
+if (HAS_MEDIUM) {
+let d = distance((*si).position, (*aa).ray.o);
+let ne = (*aa).ray.o;
+let extinction = (*si).mediumExtinction;
+let scattering = min((*si).mediumScattering, extinction);
+let sl = max(max(extinction.x, extinction.y), extinction.z);
+if (mediumType > 0 && sl > 0.0) {
+
+
+let mT = min(i32(dz(cv(MEDIUM_CHANNEL)) * 3.0), 2);
+let fA = extinction[mT];
+let ic = select(
+d,
+min(-log(max(dz(cv(MEDIUM_DISTANCE)), 1e-7)) / fA, d),
+fA > 0.0
+);
+bl = ic < d;
+let ew = exp(-extinction * ic);
+let nM = select(
+ew,
+extinction * ew,
+bl
+);
+let nt = max((nM.x + nM.y + nM.z) / 3.0, 1e-8);
+if (bl) {
+(*aa).beta *= ew * scattering / nt;
+
+(*aa).ray.o = ne + ic * (*aa).ray.d;
+(*si).position = (*aa).ray.o;
+}
+else {
+(*aa).beta *= ew / nt;
+}
+}
+}
+
+if (!bl) {
+(*aa).li += pc(si, aa) * (*ma).emission * (*aa).beta;
+}
+if ((*ma).materialType == UNLIT) {
+(*aa).abort = true;
+return;
+}
+
+
+var prepared: ag;
+if (!bl) {
+${hasAnisotropyDirections ? /* wgsl */ `
+(*ma).directionTangent = (*si).directionTangent;
+(*ma).directionBitangent = (*si).directionBitangent;
+(*ma).geometryTangent = (*si).geometryTangent;
+(*ma).geometryBitangent = (*si).geometryBitangent;
+` : /* wgsl */ ``}
+prepared = eG((*si).tangent, *ma, -(*aa).ray.d, ffnormal);
+}
+mG(si, *ma, prepared, aa, ffnormal, !bl);
+if (bl) {
+
+cF = fl(
+-(*aa).ray.d,
+(*si).mediumAnisotropy,
+fk(cv(PHASE_DIRECTION))
+);
+scatteringPdf = bD(
+dot(cF, -(*aa).ray.d),
+(*si).mediumAnisotropy
+);
+}
+else {
+
+var isNextRefraction: bool;
+var aA = 1.0;
+var aT = false;
+var bE = true;
+var aR = u32(OPENPBR_LOBE_DIFFUSE);
+var qw = 0.0;
+let ud = vec3f(fk(cv(BSDF_DIRECTION)), dz(cv(BSDF_LOBE)));
+var gR = vec3f(0.0);
+let f = dv(
+prepared,
+ud,
+&cF,
+&scatteringPdf,
+&isNextRefraction,
+&aA,
+&aT,
+&bE,
+&aR,
+&qw,
+&gR
+);
+
+
+
+
+if (!(scatteringPdf > 0.0) ||
+!all(f == f) || !all(abs(f) < vec3f(3.402823e38)) ||
+dot(cF, cF) < 0.5) {
+(*aa).scatteringPdf = 0.0;
+(*aa).abort = true;
+return;
+}
+
+
+(*aa).scatteringIsDelta = !prepared.material.thinWalled &&
+abs(prepared.material.relativeIor - 1.0) <= 1e-6 &&
+prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] >= 1.0 - 1e-6;
+(*aa).beta *= f / scatteringPdf;
+
+hj = isNextRefraction && !(*ma).thinWalled;
+(*aa).isNextRefraction = isNextRefraction;
+
+
+(*aa).ray.o = (*si).position + EPS * cF;
+${hasCoatNormals ? /* wgsl */ `
+if ((*ma).coatNormalEnabled) { (*aa).ray.o = (*si).position + EPS * select(-bC, bC, dot(bC, cF) >= 0.0); }
+` : ''}
+}
+(*aa).scatteringPdf = scatteringPdf;
+(*aa).ray.d = cF;
+if (bl) {
+(*aa).isNextRefraction = false;
+}
+
+(*aa).fromEye = false;
+
+if (HAS_MEDIUM) {
+
+
+if (!bl && hj && (*ma).mediumType > 0) {
+if (rA >= 0.0) {
+(*si).mediumType = (*ma).mediumType;
+(*si).mediumExtinction = (*ma).mediumExtinction;
+(*si).mediumScattering = (*ma).mediumScattering;
+(*si).mediumAnisotropy = (*ma).mediumAnisotropy;
+}
+else {
+(*si).mediumType = 0;
+(*si).mediumExtinction = vec3f(0.0);
+(*si).mediumScattering = vec3f(0.0);
+(*si).mediumAnisotropy = 0.0;
+}
+}
+}
+}
+`;
+}
+export default createSampleMaterialWgsl();
+//# sourceMappingURL=sampleMaterial.wgsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sampleMaterial.wgsl.js","sourceRoot":"","sources":["../../../../src/renderer/wgsl/chunks/sampleMaterial.wgsl.ts"],"names":[],"mappings":"AAAA,0EAA0E;AAC1E,6EAA6E;AAC7E,iIAAiI;AACjI,MAAM,UAAU,wBAAwB,CAAC,uBAAuB,GAAG,IAAI,EAAE,cAAc,GAAG,KAAK;IAC7F,OAAO,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8ChB,cAAc,CAAC,CAAC,CAAC,UAAU,CAAC;mFAC4D,CAAC,CAAC,CAAC,0CAA0C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmCvI,cAAc,CAAC,CAAC,CAAC,UAAU,CAAC,yEAAkF,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6InH,cAAc,CAAC,CAAC,CAAC,UAAU,CAAC;;;;;;;;;;CAU7B,CAAC,CAAC,CAAC,EAAE;;;;;;EAMJ,cAAc,CAAC,CAAC,CAAC,UAAU,CAAC;;;CAG7B,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;EAwBJ,cAAc,CAAC,CAAC,CAAC,UAAU,CAAC;;;;;;;;;;CAU7B,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyDJ,uBAAuB,CAAC,CAAC,CAAC,UAAU,CAAC;;;;;CAKtC,CAAC,CAAC,CAAC,UAAU,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8Df,cAAc,CAAC,CAAC,CAAC,UAAU,CAAC;;CAE7B,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BL,CAAC;AAEF,CAAC;AAED,eAAe,wBAAwB,EAAE,CAAC","sourcesContent":["// Next-event estimation with resampled importance sampling over the light\n// candidates, followed by BSDF (or phase function) sampling, as described in\n// http://www.pbr-book.org/3ed-2018/Light_Transport_I_Surface_Reflection/Direct_Lighting.html#EstimatingtheDirectLightingIntegral\nexport function createSampleMaterialWgsl(hasAnisotropyDirections = true, hasCoatNormals = false) {\n  return /* wgsl */ `\n\nstruct ShadowRayWork {\n  ray: Ray,\n  maxDistance: f32,\n  triangleIndex: i32,\n  contribution: vec3f,\n  // RIS target of the candidate. The discrete light-selection PMF is excluded\n  // and represented by the candidate's unbiased contribution weight instead.\n  risTarget: f32,\n  lightSelectionPmf: f32,\n  valid: bool,\n}\n\nfn PrepareDirectLight(\n  si: ptr<function, SurfaceInteraction>,\n  ma: OpenPbrResolvedMaterial,\n  prepared: OpenPbrPreparedBsdf,\n  path: ptr<function, Path>,\n  ffnormal: vec3f,\n  isSurface: bool,\n  candidateIndex: u32,\n  candidateCount: u32,\n  shadowWork: ptr<function, ShadowRayWork>\n) -> bool {\n  (*shadowWork).valid = false;\n  (*shadowWork).lightSelectionPmf = 0.0;\n  (*shadowWork).risTarget = 0.0;\n  let lightRnd = vec3f(sample2D(lightDim(candidateIndex, 1u)), sample1D(lightDim(candidateIndex, 0u)));\n\n  var lightSample: LightSampleRec;\n  sampleLightForNEECandidate(\n    (*si).position,\n    lightRnd,\n    candidateIndex,\n    candidateCount,\n    &lightSample\n  );\n  var Li = lightSample.emission;\n\n  let lightDir = lightSample.direction;\n  let viewDir = -(*path).ray.d;\n  let lightPdf = lightSample.pdf;\n  let lightSelectionPmf = lightSample.selectionPmf;\n  // Keep direct-light culling consistent with the two-sided BSDF evaluation.\n  // The raw imported normal can point away from the camera on interior walls.\n  ${hasCoatNormals ? /* wgsl */ `var cosThetaL = dot(ffnormal, lightDir);\n  if (isSurface && ma.coatNormalEnabled) { cosThetaL = dot(ma.geometricNormal, lightDir); }` : 'let cosThetaL = dot(ffnormal, lightDir);'}\n\n  if (lightPdf <= 0.0 || lightSelectionPmf <= 0.0 ||\n      max(max(Li.x, Li.y), Li.z) <= 0.0) {\n    return false;\n  }\n\n  var scatteringPdf = 0.0;\n  var f = vec3f(0.0);\n  if (isSurface) {\n    // Evaluate the cheap BSDF terms before paying for a scene traversal.\n    // Back-facing, delta, and otherwise zero-contribution samples can stop here.\n    if (cosThetaL <= 0.0 && ma.transmissionWeight <= 0.0 && ma.subsurfaceWeight <= 0.0) {\n      return false;\n    }\n    f = openpbr_eval_prepared(prepared, lightDir, &scatteringPdf);\n  }\n  else {\n    scatteringPdf = sampling_henyey_greenstein_phase(\n      dot(viewDir, lightDir),\n      (*si).mediumAnisotropy\n    );\n    f = vec3f(scatteringPdf);\n  }\n\n  if (scatteringPdf <= 0.0 || max(max(f.x, f.y), f.z) <= 0.0) {\n    return false;\n  }\n\n  var lightRay: Ray;\n  var shadowOrigin = (*si).position + EPS * lightDir;\n  if (isSurface) {\n    shadowOrigin = offsetSurfaceRay((*si).position, (*si).faceNormal, lightDir);\n    let shadowTerminatorCutoff = 0.1;\n    var normalLight = dot((*si).normal, lightDir);\n${hasCoatNormals ? /* wgsl */ `    if (ma.coatNormalEnabled) { normalLight = dot((*si).faceNormal, lightDir); }` : ''}\n    let geometricNormal = select(\n      (*si).faceNormal,\n      -(*si).faceNormal,\n      normalLight < 0.0\n    );\n    normalLight = abs(normalLight);\n    let geometricLight = dot(geometricNormal, lightDir);\n    let offsetAmount = select(\n      clamp(1.0 - geometricLight / shadowTerminatorCutoff, 0.0, 1.0),\n      clamp(\n        2.0 - (geometricLight + normalLight) / shadowTerminatorCutoff,\n        0.0,\n        1.0\n      ),\n      normalLight < shadowTerminatorCutoff\n    );\n    shadowOrigin += (*si).shadowOffset * offsetAmount;\n  }\n  // Falcor offsets sampled emissive positions along the light normal, then\n  // derives the visibility ray from that offset endpoint. Without the target\n  // offset, our any-hit traversal sees the sampled light triangle itself and\n  // rejects virtually every emissive NEE sample as occluded.\n  var visibilityDirection = lightDir;\n  var visibilityDistance = lightSample.dist - EPS;\n  if (lightSample.sourceType == 1u) {\n    let lightEndpoint =\n      (*si).position + lightSample.direction * lightSample.dist;\n    let offsetLightEndpoint = lightEndpoint + EPS * lightSample.normal;\n    let toOffsetLight = offsetLightEndpoint - shadowOrigin;\n    visibilityDistance = length(toOffsetLight);\n    visibilityDirection = normalize(toOffsetLight);\n  }\n  initRay(&lightRay, shadowOrigin, visibilityDirection);\n\n  // The continuation of a surface transmission sees the displayed background.\n  // Evaluate that same endpoint for the environment proposal, so both MIS\n  // strategies estimate the same radiance even for a separate/grounded skybox.\n  if (isSurface && cosThetaL < 0.0 && lightSample.sourceType == 0u) {\n    let background = sampleSceneBackground(lightRay);\n    Li = background.rgb * background.a;\n  }\n  if (SPECTRAL) {\n    Li = sampling_spectral_rgb_filter(Li, (*si).wavelength);\n  }\n\n  // A directional source is a delta distribution and cannot be reached by\n  // the BSDF-sampling strategy, so its light-sampled contribution has weight 1.\n  let misWeight = select(\n    neeMISWeight(lightPdf, scatteringPdf),\n    1.0,\n    lightSample.isDelta\n  );\n  if (misWeight > 0.0) {\n    let unweightedContribution = Li * f / lightPdf * (*path).beta;\n    (*shadowWork).risTarget = max(\n      dot(max(unweightedContribution * lightSelectionPmf, vec3f(0.0)), luminance),\n      0.0\n    );\n    (*shadowWork).ray = lightRay;\n    (*shadowWork).maxDistance = visibilityDistance;\n    (*shadowWork).triangleIndex = (*si).triangleIndex;\n    (*shadowWork).contribution = misWeight * unweightedContribution;\n    (*shadowWork).lightSelectionPmf = lightSelectionPmf;\n    (*shadowWork).valid = true;\n    return true;\n  }\n  return false;\n}\n\nfn DirectLight(\n  si: ptr<function, SurfaceInteraction>,\n  ma: OpenPbrResolvedMaterial,\n  prepared: OpenPbrPreparedBsdf,\n  path: ptr<function, Path>,\n  ffnormal: vec3f,\n  isSurface: bool\n) {\n  let candidateCount = neeCandidateCount();\n  var selected: ShadowRayWork;\n  selected.valid = false;\n  var selectedTarget = 0.0;\n  var scalarWeightSum = 0.0;\n  // Streaming weighted reservoir sampling over the light candidates. Only the\n  // selected candidate traces a shadow ray.\n  for (var candidateIndex = 0u; candidateIndex < candidateCount; candidateIndex++) {\n    var candidate: ShadowRayWork;\n    let candidateValid = PrepareDirectLight(\n      si, ma, prepared, path, ffnormal, isSurface,\n      candidateIndex, candidateCount, &candidate);\n    if (candidateCount == 1u) {\n      if (!candidateValid) { return; }\n      selected = candidate;\n      break;\n    }\n    if (!candidateValid) { continue; }\n    let scalarWeight = candidate.risTarget / max(candidate.lightSelectionPmf, 1e-20);\n    if (!(scalarWeight > 0.0) || scalarWeight != scalarWeight) { continue; }\n    scalarWeightSum += scalarWeight;\n    if (!selected.valid ||\n        lightCandidateRandom(candidateIndex) * scalarWeightSum <= scalarWeight) {\n      selected = candidate;\n      selectedTarget = candidate.risTarget;\n    }\n  }\n  var candidateUCW = 1.0;\n  if (candidateCount > 1u) {\n    if (!selected.valid || selectedTarget <= 0.0) { return; }\n    // RIS unbiased contribution weight, normalized by the target rather than\n    // target / selection PMF.\n    candidateUCW = selected.lightSelectionPmf * scalarWeightSum /\n      (f32(candidateCount) * selectedTarget);\n  }\n  if (selected.valid &&\n      !intersectSceneShadow(selected.ray, selected.maxDistance, selected.triangleIndex)) {\n    (*path).li += selected.contribution * candidateUCW;\n  }\n}\n\nfn emissiveHitMisWeight(\n  si: ptr<function, SurfaceInteraction>,\n  path: ptr<function, Path>\n) -> f32 {\n  if ((*path).fromEye || rtUniform.lightWeightTotal <= 0.0 ||\n      i32(materialsBuffer[(*si).materialIndex].matType) == UNLIT) {\n    return 1.0;\n  }\n  let samplingLuminance = dot(\n    materialsBuffer[(*si).materialIndex].emission,\n    luminance\n  );\n  let cosLight = dot((*si).faceNormal, -(*path).ray.d);\n  if (samplingLuminance <= 0.0 || cosLight <= 0.0) {\n    return 1.0;\n  }\n  let hitDistance = distance((*si).position, (*path).ray.o);\n  let lightPdf = samplingLuminance / rtUniform.lightWeightTotal *\n    hitDistance * hitDistance / max(cosLight, 1e-8);\n  return bsdfMISWeight((*path).scatteringPdf, lightPdf);\n}\n\n${hasCoatNormals ? /* wgsl */ `\n// Keep each shading frame in the geometric/view hemisphere. This correction\n// does not replace the face normal used for topology or ray offsets.\nfn coat_frame_normal(input: vec3f, face: vec3f, view: vec3f) -> vec3f {\n  let front = dot(face, view) >= 0.0;\n  let ffFace = select(-face, face, front);\n  let ffInput = select(-input, input, front);\n  if (dot(input, face) <= 0.0 || dot(ffInput, view) <= 1e-6) { return ffFace; }\n  return ffInput;\n}\n` : ''}\nfn SampleMaterial(\n  si: ptr<function, SurfaceInteraction>,\n  ma: ptr<function, OpenPbrResolvedMaterial>,\n  path: ptr<function, Path>\n) {\n${hasCoatNormals ? /* wgsl */ `\n  let originalFace = (*si).faceNormal;\n  let originalNormal = (*si).normal;\n` : ''}\n  var ndv1: f32 = -dot((*si).faceNormal, (*path).ray.d);\n  var ndv2: f32 = -dot((*si).normal, (*path).ray.d);\n  if (((*ma).transmissionWeight > 0.0 || (*ma).subsurfaceWeight > 0.0) && (*ma).thinWalled) {\n    // Always treat thin material as entering medium\n    if (ndv1 < 0.0) {\n      (*si).faceNormal = -(*si).faceNormal;\n      ndv1 = -ndv1;\n    }\n    if (ndv2 < 0.0) {\n      (*si).normal = -(*si).normal;\n      ndv2 = -ndv2;\n    }\n  }\n  // In same edge cases normal is not torwards the camera while we can still see the face.\n  // We need to choose faceNormal in this case.\n  var useFaceN: bool = ndv1 >= 0.0 && ndv2 < 0.0;\n  var ndv: f32 = select(ndv2, ndv1, useFaceN);\n  var N: vec3f = select((*si).normal, (*si).faceNormal, useFaceN);\n\n  (*ma).inside = ndv <= 0.0 && !(*ma).thinWalled;\n  // In or out\n  (*ma).relativeIor = select((*ma).specularIor, (1.0 / (*ma).specularIor), ndv > 0.0);\n  var ffnormal = select(-N, N, ndv >= 0.0);\n${hasCoatNormals ? /* wgsl */ `\n  if ((*ma).coatNormalEnabled) {\n    let view = -(*path).ray.d;\n    let geometricView = dot(originalFace, view);\n    (*ma).geometricNormal = select(-originalFace, originalFace, geometricView >= 0.0);\n    ffnormal = coat_frame_normal(originalNormal, originalFace, view);\n    (*ma).coatNormal = coat_frame_normal((*si).coatNormal, originalFace, view);\n    (*ma).inside = geometricView <= 0.0 && !(*ma).thinWalled;\n    (*ma).relativeIor = select((*ma).specularIor, 1.0 / (*ma).specularIor, geometricView > 0.0 || (*ma).thinWalled);\n  }\n` : ''}\n\n  (*path).scatteringIsDelta = false;\n  var mediumSampled = false;\n  var crossedBoundary = false;\n  let mediumType = (*si).mediumType;\n\n  var scatteringPdf: f32;\n  var scatterDir: vec3f;\n\n  if (HAS_MEDIUM) {\n    let d = distance((*si).position, (*path).ray.o);\n    let segmentOrigin = (*path).ray.o;\n    let extinction = (*si).mediumExtinction;\n    let scattering = min((*si).mediumScattering, extinction);\n    let majorant = max(max(extinction.x, extinction.y), extinction.z);\n    if (mediumType > 0 && majorant > 0.0) {\n      // Sample one RGB extinction channel and divide by the mixture PDF. This\n      // avoids high-variance majorant weights for channel-dependent SSS radii.\n      let mediumChannel = min(i32(sample1D(bounceDim(MEDIUM_CHANNEL)) * 3.0), 2);\n      let channelExtinction = extinction[mediumChannel];\n      let scatterDist = select(\n        d,\n        min(-log(max(sample1D(bounceDim(MEDIUM_DISTANCE)), 1e-7)) / channelExtinction, d),\n        channelExtinction > 0.0\n      );\n      mediumSampled = scatterDist < d;\n      let transmittance = exp(-extinction * scatterDist);\n      let density = select(\n        transmittance,\n        extinction * transmittance,\n        mediumSampled\n      );\n      let mediumPdf = max((density.x + density.y + density.z) / 3.0, 1e-8);\n      if (mediumSampled) {\n        (*path).beta *= transmittance * scattering / mediumPdf;\n        // Move from the start of the segment, not from its end surface.\n        (*path).ray.o = segmentOrigin + scatterDist * (*path).ray.d;\n        (*si).position = (*path).ray.o;\n      }\n      else {\n        (*path).beta *= transmittance / mediumPdf;\n      }\n    }\n  }\n\n  if (!mediumSampled) {\n    (*path).li += emissiveHitMisWeight(si, path) * (*ma).emission * (*path).beta;\n  }\n  if ((*ma).materialType == UNLIT) {\n    (*path).abort = true;\n    return;\n  }\n  // Surface and medium events share the light estimator. Emission is added\n  // before NEE, then the continuation direction is sampled.\n  var prepared: OpenPbrPreparedBsdf;\n  if (!mediumSampled) {\n${hasAnisotropyDirections ? /* wgsl */ `\n    (*ma).directionTangent = (*si).directionTangent;\n    (*ma).directionBitangent = (*si).directionBitangent;\n    (*ma).geometryTangent = (*si).geometryTangent;\n    (*ma).geometryBitangent = (*si).geometryBitangent;\n` : /* wgsl */ ``}\n    prepared = openpbr_prepare((*si).tangent, *ma, -(*path).ray.d, ffnormal);\n  }\n  DirectLight(si, *ma, prepared, path, ffnormal, !mediumSampled);\n  if (mediumSampled) {\n    // Pick a new direction based on the phase function.\n    scatterDir = sampling_henyey_greenstein(\n      -(*path).ray.d,\n      (*si).mediumAnisotropy,\n      sample2D(bounceDim(PHASE_DIRECTION))\n    );\n    scatteringPdf = sampling_henyey_greenstein_phase(\n      dot(scatterDir, -(*path).ray.d),\n      (*si).mediumAnisotropy\n    );\n  }\n  else {\n    // Sample BSDF for color and outgoing direction\n    var isNextRefraction: bool;\n    var sampledLobeRoughness = 1.0;\n    var sampledLobeSpecular = false;\n    var sampledLobeDiffuse = true;\n    var sampledLobeIndex = u32(OPENPBR_LOBE_DIFFUSE);\n    var sampledMarginalPdf = 0.0;\n    let matRnd = vec3f(sample2D(bounceDim(BSDF_DIRECTION)), sample1D(bounceDim(BSDF_LOBE)));\n    var fullResponse = vec3f(0.0);\n    let f = openpbr_sample_prepared(\n      prepared,\n      matRnd,\n      &scatterDir,\n      &scatteringPdf,\n      &isNextRefraction,\n      &sampledLobeRoughness,\n      &sampledLobeSpecular,\n      &sampledLobeDiffuse,\n      &sampledLobeIndex,\n      &sampledMarginalPdf,\n      &fullResponse\n    );\n    // A rejected microfacet proposal (including failed refraction), or a\n    // material with no scattering lobes, has no continuation. Keep emission\n    // and NEE already accumulated at this vertex, but never trace a default\n    // direction with the incoming throughput: that invents extra light paths.\n    if (!(scatteringPdf > 0.0) ||\n        !all(f == f) || !all(abs(f) < vec3f(3.402823e38)) ||\n        dot(scatterDir, scatterDir) < 0.5) {\n      (*path).scatteringPdf = 0.0;\n      (*path).abort = true;\n      return;\n    }\n    // Exactly index-matched solid transmission is a discrete null boundary;\n    // environment NEE has no competing density for that event.\n    (*path).scatteringIsDelta = !prepared.material.thinWalled &&\n      abs(prepared.material.relativeIor - 1.0) <= 1e-6 &&\n      prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] >= 1.0 - 1e-6;\n    (*path).beta *= f / scatteringPdf;\n\n    crossedBoundary = isNextRefraction && !(*ma).thinWalled;\n    (*path).isNextRefraction = isNextRefraction;\n    // TODO prefer the opaque surface when transmission surface and opaque surface are overlapped.\n    // Or the ray go out from transmission material will miss the opque surface.\n    (*path).ray.o = (*si).position + EPS * scatterDir;\n${hasCoatNormals ? /* wgsl */ `\n    if ((*ma).coatNormalEnabled) { (*path).ray.o = (*si).position + EPS * select(-originalFace, originalFace, dot(originalFace, scatterDir) >= 0.0); }\n` : ''}\n  }\n  (*path).scatteringPdf = scatteringPdf;\n  (*path).ray.d = scatterDir;\n  if (mediumSampled) {\n    (*path).isNextRefraction = false;\n  }\n\n  (*path).fromEye = false;\n\n  if (HAS_MEDIUM) {\n    // Reflections stay in the current medium. Enter or leave only after the\n    // BSDF actually sampled transmission through a medium boundary.\n    if (!mediumSampled && crossedBoundary && (*ma).mediumType > 0) {\n      if (ndv1 >= 0.0) {\n        (*si).mediumType = (*ma).mediumType;\n        (*si).mediumExtinction = (*ma).mediumExtinction;\n        (*si).mediumScattering = (*ma).mediumScattering;\n        (*si).mediumAnisotropy = (*ma).mediumAnisotropy;\n      }\n      else {\n        (*si).mediumType = 0;\n        (*si).mediumExtinction = vec3f(0.0);\n        (*si).mediumScattering = vec3f(0.0);\n        (*si).mediumAnisotropy = 0.0;\n      }\n    }\n  }\n}\n`;\n\n}\n\nexport default createSampleMaterialWgsl();\n"]}

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

@@ -0,0 +1,2 @@
+declare const _default: "\n\n// A one-sample binary shadow test leaves scattered fully dark pixels far\n// from the occluder at low sample counts. Averaging a few light samples per\n// primary hit costs only shadow rays and lets the mask settle much sooner.\nconst SHADOW_CATCHER_LIGHT_SAMPLES = 4u;\n\nfn sampleShadowCatcher(si: SurfaceInteraction, bounce: i32, path: ptr<function, Path>) {\n  let viewDir = -(*path).ray.d;\n\n  // The unified table also contains emissive mesh lights.\n  if (rtUniform.lightChoiceCount > 0) {\n    var shadow = 0.0;\n    for (var candidate = 0u; candidate < SHADOW_CATCHER_LIGHT_SAMPLES; candidate++) {\n      var lightSample: LightSampleRec;\n      let lightRnd = vec3f(sample2D(lightDim(candidate, 1u)), sample1D(lightDim(candidate, 0u)));\n      sampleLight(si.position, lightRnd, &lightSample, false);\n      let lightDir = lightSample.direction;\n      let cosThetaL = dot(si.normal, lightDir);\n      let orientation = dot(si.normal, viewDir) * cosThetaL;\n      if (lightSample.pdf > 0.0 && orientation >= 0.0) {\n        var ray: Ray;\n        initRay(&ray, si.position + EPS * lightDir, lightDir);\n        if (intersectSceneShadow(ray, lightSample.dist - EPS, si.triangleIndex)) {\n          shadow += 1.0;\n        }\n      }\n    }\n    // WebGPU's compose pass consumes shadow opacity directly.\n    (*path).alpha = shadow / f32(SHADOW_CATCHER_LIGHT_SAMPLES);\n  }\n  (*path).fromEye = false;\n}\n";
+export default _default;

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

@@ -0,0 +1,40 @@
+// Portions adapted from ray-tracing-renderer@0.10.15
+// (https://github.com/hoverinc/ray-tracing-renderer).
+// Copyright (c) 2019 HOVER, MIT license; see LICENSES/RayTracingRenderer-MIT.txt.
+// Estimate the direct lighting integral using multiple importance sampling
+// http://www.pbr-book.org/3ed-2018/Light_Transport_I_Surface_Reflection/Direct_Lighting.html#EstimatingtheDirectLightingIntegral
+export default /*wgsl*/ `
+
+
+
+
+const SHADOW_CATCHER_LIGHT_SAMPLES = 4u;
+
+fn sampleShadowCatcher(si: ad, bounce: i32, aa: ptr<function, Path>) {
+let oH = -(*aa).ray.d;
+
+
+if (rtUniform.lightChoiceCount > 0) {
+var shadow = 0.0;
+for (var candidate = 0u; candidate < SHADOW_CATCHER_LIGHT_SAMPLES; candidate++) {
+var lightSample: LightSampleRec;
+let kZ = vec3f(fk(qR(candidate, 1u)), dz(qR(candidate, 0u)));
+sampleLight(si.position, kZ, &lightSample, false);
+let lightDir = lightSample.direction;
+let cosThetaL = dot(si.normal, lightDir);
+let pq = dot(si.normal, oH) * cosThetaL;
+if (lightSample.pdf > 0.0 && pq >= 0.0) {
+var ray: Ray;
+iw(&ray, si.position + EPS * lightDir, lightDir);
+if (ex(ray, lightSample.dist - EPS, si.triangleIndex)) {
+shadow += 1.0;
+}
+}
+}
+
+(*aa).alpha = shadow / f32(SHADOW_CATCHER_LIGHT_SAMPLES);
+}
+(*aa).fromEye = false;
+}
+`;
+//# sourceMappingURL=sampleShadowCatcher.wgsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sampleShadowCatcher.wgsl.js","sourceRoot":"","sources":["../../../../src/renderer/wgsl/chunks/sampleShadowCatcher.wgsl.ts"],"names":[],"mappings":"AAAA,qDAAqD;AACrD,sDAAsD;AACtD,kFAAkF;AAElF,2EAA2E;AAC3E,iIAAiI;AAEjI,eAAe,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCvB,CAAC","sourcesContent":["// Portions adapted from ray-tracing-renderer@0.10.15\n// (https://github.com/hoverinc/ray-tracing-renderer).\n// Copyright (c) 2019 HOVER, MIT license; see LICENSES/RayTracingRenderer-MIT.txt.\n\n// Estimate the direct lighting integral using multiple importance sampling\n// http://www.pbr-book.org/3ed-2018/Light_Transport_I_Surface_Reflection/Direct_Lighting.html#EstimatingtheDirectLightingIntegral\n\nexport default /*wgsl*/ `\n\n// A one-sample binary shadow test leaves scattered fully dark pixels far\n// from the occluder at low sample counts. Averaging a few light samples per\n// primary hit costs only shadow rays and lets the mask settle much sooner.\nconst SHADOW_CATCHER_LIGHT_SAMPLES = 4u;\n\nfn sampleShadowCatcher(si: SurfaceInteraction, bounce: i32, path: ptr<function, Path>) {\n  let viewDir = -(*path).ray.d;\n\n  // The unified table also contains emissive mesh lights.\n  if (rtUniform.lightChoiceCount > 0) {\n    var shadow = 0.0;\n    for (var candidate = 0u; candidate < SHADOW_CATCHER_LIGHT_SAMPLES; candidate++) {\n      var lightSample: LightSampleRec;\n      let lightRnd = vec3f(sample2D(lightDim(candidate, 1u)), sample1D(lightDim(candidate, 0u)));\n      sampleLight(si.position, lightRnd, &lightSample, false);\n      let lightDir = lightSample.direction;\n      let cosThetaL = dot(si.normal, lightDir);\n      let orientation = dot(si.normal, viewDir) * cosThetaL;\n      if (lightSample.pdf > 0.0 && orientation >= 0.0) {\n        var ray: Ray;\n        initRay(&ray, si.position + EPS * lightDir, lightDir);\n        if (intersectSceneShadow(ray, lightSample.dist - EPS, si.triangleIndex)) {\n          shadow += 1.0;\n        }\n      }\n    }\n    // WebGPU's compose pass consumes shadow opacity directly.\n    (*path).alpha = shadow / f32(SHADOW_CATCHER_LIGHT_SAMPLES);\n  }\n  (*path).fromEye = false;\n}\n`;\n"]}

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

@@ -0,0 +1,2 @@
+declare const _default: "\n// The GGX distribution and spherical-cap VNDF sampler are adapted from\n// adobe/openpbr-bsdf, Copyright 2026 Adobe, Apache-2.0. Other routines are\n// project implementations of their stated analytic distributions.\n\nfn sampling_ggx_visible_normal(view: vec3f, alpha: vec2f, samplePoint: vec2f) -> vec3f {\n    let stretch = vec3f(alpha, 1.0);\n    let sphericalView = normalize(stretch * view);\n    let viewZ = min(sphericalView.z, 1.0);\n    let capSpan = 1.0 + viewZ;\n    let normalZ = (1.0 - samplePoint.y) * capSpan;\n    let oneMinusZ = samplePoint.y * capSpan;\n    let onePlusZ = normalZ + (1.0 - viewZ);\n    let radial = sqrt(max(0.0, onePlusZ * oneMinusZ));\n    let azimuth = TWOPI * samplePoint.x;\n    let sphericalNormal = vec3f(\n        sphericalView.x + radial * cos(azimuth),\n        sphericalView.y + radial * sin(azimuth),\n        normalZ\n    );\n    return normalize(stretch * sphericalNormal);\n}\n\nfn sampling_ggx_ndf(halfway: vec3f, alpha: vec2f) -> f32 {\n    let ellipsoidNormal = vec3f(\n        halfway.x / alpha.x,\n        halfway.y / alpha.y,\n        halfway.z\n    );\n    let denominator = dot(ellipsoidNormal, ellipsoidNormal);\n    return 1.0 / (\n        PI * alpha.x * alpha.y * denominator * denominator\n    );\n}\n\nfn sampling_ggx_smith_g1(direction: vec3f, alpha: vec2f) -> f32 {\n    let normalComponent = abs(direction.z);\n    if (normalComponent <= 1e-8) {\n        return 0.0;\n    }\n    let roughDirection = alpha * direction.xy;\n    let tanThetaSquared = dot(roughDirection, roughDirection)\n        / (normalComponent * normalComponent);\n    return 2.0 / (1.0 + sqrt(1.0 + tanThetaSquared));\n}\n\nfn sampling_schlick_fifth_power(cosine: f32) -> f32 {\n    let complement = clamp(1.0 - cosine, 0.0, 1.0);\n    return pow(complement, 5.0);\n}\n\nfn sampling_dielectric_fresnel(incidentCosine: f32, etaIOverEtaT: f32) -> f32 {\n    let cosineI = clamp(abs(incidentCosine), 0.0, 1.0);\n    let sineTSquared = etaIOverEtaT * etaIOverEtaT\n        * max(0.0, 1.0 - cosineI * cosineI);\n    if (sineTSquared >= 1.0) {\n        return 1.0;\n    }\n\n    let cosineT = sqrt(max(0.0, 1.0 - sineTSquared));\n    let perpendicular = (cosineI - etaIOverEtaT * cosineT)\n        / max(cosineI + etaIOverEtaT * cosineT, 1e-8);\n    let parallel = (etaIOverEtaT * cosineI - cosineT)\n        / max(etaIOverEtaT * cosineI + cosineT, 1e-8);\n    return 0.5 * (\n        perpendicular * perpendicular + parallel * parallel\n    );\n}\n\nfn sampling_concentric_disk(samplePoint: vec2f) -> vec2f {\n    let offset = 2.0 * samplePoint - vec2f(1.0);\n    if (offset.x == 0.0 && offset.y == 0.0) {\n        return vec2f(0.0);\n    }\n\n    var radius: f32;\n    var angle: f32;\n    if (abs(offset.x) > abs(offset.y)) {\n        radius = offset.x;\n        angle = 0.25 * PI * (offset.y / offset.x);\n    }\n    else {\n        radius = offset.y;\n        angle = 0.5 * PI - 0.25 * PI * (offset.x / offset.y);\n    }\n    return radius * vec2f(cos(angle), sin(angle));\n}\n\nfn sampling_cosine_hemisphere(samplePoint: vec2f) -> vec3f {\n    let diskPoint = sampling_concentric_disk(samplePoint);\n    return vec3f(\n        diskPoint,\n        sqrt(max(0.0, 1.0 - dot(diskPoint, diskPoint)))\n    );\n}\n\nfn sampling_power_heuristic(firstPdf: f32, secondPdf: f32) -> f32 {\n    let scale = max(firstPdf, secondPdf);\n    if (scale <= 0.0) {\n        return 0.0;\n    }\n    let normalized = vec2f(firstPdf, secondPdf) / scale;\n    let squared = normalized * normalized;\n    return squared.x / (squared.x + squared.y);\n}\n\nfn sampling_orthonormal_basis(\n    normal: vec3f,\n    tangent: ptr<function, vec3f>,\n    bitangent: ptr<function, vec3f>\n) {\n    let signZ = select(-1.0, 1.0, normal.z >= 0.0);\n    let factor = -1.0 / (signZ + normal.z);\n    let xy = normal.x * normal.y * factor;\n    *tangent = vec3f(\n        1.0 + signZ * normal.x * normal.x * factor,\n        signZ * xy,\n        -signZ * normal.x\n    );\n    *bitangent = vec3f(\n        xy,\n        signZ + normal.y * normal.y * factor,\n        -normal.y\n    );\n}\n\nfn sampling_spectral_rgb_filter(rgb: vec3f, wavelength: f32) -> vec3f {\n    if (wavelength == 0.0) {\n        return rgb;\n    }\n    if (wavelength > 600.0) {\n        return vec3f(rgb.r, 0.0, 0.0);\n    }\n    if (wavelength > 500.0) {\n        return vec3f(0.0, rgb.g, 0.0);\n    }\n    return vec3f(0.0, 0.0, rgb.b);\n}\n\nfn sampling_cauchy_ior(\n    wavelength: f32,\n    referenceIor: f32,\n    dispersionScale: f32,\n    abbeNumber: f32\n) -> f32 {\n    if (wavelength == 0.0 || dispersionScale <= 0.0) {\n        return referenceIor;\n    }\n\n    let FRAUNHOFER_C = 656.3;\n    let FRAUNHOFER_D = 587.6;\n    let FRAUNHOFER_F = 486.1;\n    let inverseDifference = 1.0 / (\n        1.0 / (FRAUNHOFER_F * FRAUNHOFER_F)\n        - 1.0 / (FRAUNHOFER_C * FRAUNHOFER_C)\n    );\n    let effectiveAbbe = max(abbeNumber / dispersionScale, 1e-6);\n    let cauchyB = (referenceIor - 1.0) * inverseDifference / effectiveAbbe;\n    let cauchyA = referenceIor\n        - cauchyB / (FRAUNHOFER_D * FRAUNHOFER_D);\n    return cauchyA + cauchyB / (wavelength * wavelength);\n}\n\nfn sampling_henyey_greenstein(\n    forwardDirection: vec3f,\n    anisotropy: f32,\n    samplePoint: vec2f\n) -> vec3f {\n    var cosine: f32;\n    if (abs(anisotropy) < 0.001) {\n        cosine = 1.0 - 2.0 * samplePoint.y;\n    }\n    else {\n        let ratio = (1.0 - anisotropy * anisotropy)\n            / (1.0 + anisotropy - 2.0 * anisotropy * samplePoint.y);\n        cosine = (\n            ratio * ratio - 1.0 - anisotropy * anisotropy\n        ) / (2.0 * anisotropy);\n    }\n\n    let sine = sqrt(max(0.0, 1.0 - cosine * cosine));\n    let azimuth = TWOPI * samplePoint.x;\n    var tangent: vec3f;\n    var bitangent: vec3f;\n    sampling_orthonormal_basis(forwardDirection, &tangent, &bitangent);\n    return tangent * (sine * cos(azimuth))\n        + bitangent * (sine * sin(azimuth))\n        + forwardDirection * cosine;\n}\n\nfn sampling_henyey_greenstein_phase(cosine: f32, anisotropy: f32) -> f32 {\n    let denominator = 1.0 + anisotropy * anisotropy\n        + 2.0 * anisotropy * cosine;\n    return INV4PI * (1.0 - anisotropy * anisotropy)\n        / (denominator * sqrt(denominator));\n}\n";
+export default _default;