@meimu/mutracer 0.1.4 → 0.2.0

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

@@ -1 +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"]}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoChB,cAAc,CAAC,CAAC,CAAC,UAAU,CAAC;mFAC4D,CAAC,CAAC,CAAC,0CAA0C;;;;;;;;;;;;;;;;;EAiBvI,cAAc,CAAC,CAAC,CAAC,UAAU,CAAC,yEAAkF,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiIzG,cAAc,CAAC,CAAC,CAAC,8GAA8G,CAAC,CAAC,CAAC,uBAAuB;;;;;;;;;;;;;;;;;;EAkB7J,cAAc,CAAC,CAAC,CAAC,UAAU,CAAC;kFAC2D,CAAC,CAAC,CAAC,UAAU,CAAC,0CAA0C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0DrJ,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgCf,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 finishDirectLight(\n  si: ptr<function, SurfaceInteraction>,\n  ma: OpenPbrResolvedMaterial,\n  path: ptr<function, Path>,\n  ffnormal: vec3f,\n  isSurface: bool,\n  lightSample: LightSampleRec,\n  f: vec3f,\n  scatteringPdf: f32,\n  shadowWork: ptr<function, ShadowRayWork>\n) -> bool {\n  (*shadowWork).valid = false;\n  (*shadowWork).lightSelectionPmf = 0.0;\n  (*shadowWork).risTarget = 0.0;\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  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\nstruct ScatteringWork {\n  direction: vec3f,\n  response: vec3f,\n  pdf: f32,\n  transmission: bool,\n}\n\nfn sampleScattering(\n  si: ptr<function, SurfaceInteraction>,\n  ma: OpenPbrResolvedMaterial,\n  prepared: OpenPbrPreparedBsdf,\n  path: ptr<function, Path>,\n  ffnormal: vec3f,\n  isSurface: bool\n) -> ScatteringWork {\n  let candidateCount = neeCandidateCount();\n  var selected: ShadowRayWork;\n  selected.valid = false;\n  var selectedTarget = 0.0;\n  var scalarWeightSum = 0.0;\n  var result: ScatteringWork;\n  // The final iteration samples the continuation after NEE and its shadow ray.\n  // Both proposals use one BSDF evaluation call site, avoiding a second inlined\n  // optical graph. Keep all random draws and visibility queries in their\n  // original order, including the short-circuit reservoir replacement draw.\n  for (var event = 0u; event <= candidateCount; event++) {\n    let continuation = event == candidateCount;\n    var lightSample: LightSampleRec;\n    var lightDir: vec3f;\n    var scatteringPdf = 0.0;\n    var response = vec3f(0.0);\n    var discrete = false;\n    if (continuation) {\n      var candidateUCW = 1.0;\n      var valid = selected.valid;\n      if (candidateCount > 1u) {\n        valid = valid & (selectedTarget > 0.0);\n        if (valid) {\n          candidateUCW = selected.lightSelectionPmf * scalarWeightSum /\n            (f32(candidateCount) * selectedTarget);\n        }\n      }\n      if (valid && !intersectSceneShadow(selected.ray, selected.maxDistance, selected.triangleIndex)) {\n        (*path).li += selected.contribution * candidateUCW;\n      }\n      if (!isSurface) {\n        result.direction = sampling_henyey_greenstein(-(*path).ray.d,\n          (*si).mediumAnisotropy, sample2D(bounceDim(PHASE_DIRECTION)));\n        result.pdf = sampling_henyey_greenstein_phase(\n          dot(result.direction, -(*path).ray.d), (*si).mediumAnisotropy);\n        return result;\n      }\n      let matRnd = vec3f(sample2D(bounceDim(BSDF_DIRECTION)), sample1D(bounceDim(BSDF_LOBE)));\n      discrete = !prepared.material.thinWalled &\n        (abs(prepared.material.relativeIor - 1.0) <= 1e-6) &\n        (prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] >= 1.0 - 1e-6);\n      if (discrete) {\n        lightDir = openpbr_to_world(prepared.basis, -prepared.viewLocal);\n        response = openpbr_transmission_tint(prepared.material) * openpbr_coat_base_scale(prepared,\n          ${hasCoatNormals ? 'select(-prepared.viewLocal.z, dot(prepared.coatBasis.normal, lightDir), prepared.material.coatNormalEnabled)' : '-prepared.viewLocal.z'});\n        scatteringPdf = 1.0;\n        result.transmission = true;\n      } else {\n        var roughness = 1.0; var specular = false; var diffuse = true;\n        var lobe = u32(OPENPBR_LOBE_DIFFUSE);\n        // Use locals rather than member pointers for Naga's SPIR-V writer.\n        var transmission = false;\n        if (!openpbr_sample_direction(prepared, matRnd, &lightDir, &transmission,\n            &roughness, &specular, &diffuse, &lobe)) { return result; }\n        result.transmission = transmission;\n      }\n    } else {\n      let lightRnd = vec3f(sample2D(lightDim(event, 1u)), sample1D(lightDim(event, 0u)));\n      sampleLightForNEECandidate((*si).position, lightRnd, event, candidateCount, &lightSample);\n      lightDir = lightSample.direction;\n      if ((lightSample.pdf <= 0.0) | (lightSample.selectionPmf <= 0.0) |\n          (max(max(lightSample.emission.x, lightSample.emission.y), lightSample.emission.z) <= 0.0)) { continue; }\n      ${hasCoatNormals ? /* wgsl */ `var cosThetaL = dot(ffnormal, lightDir);\n      if (isSurface & ma.coatNormalEnabled) { cosThetaL = dot(ma.geometricNormal, lightDir); }` : /* wgsl */ `let cosThetaL = dot(ffnormal, lightDir);`}\n      if (isSurface & (cosThetaL <= 0.0) & (ma.transmissionWeight <= 0.0) & (ma.subsurfaceWeight <= 0.0)) { continue; }\n    }\n    if (!discrete) {\n      if (isSurface) {\n        response = openpbr_eval_prepared(prepared, lightDir, &scatteringPdf);\n      } else {\n        scatteringPdf = sampling_henyey_greenstein_phase(\n          dot(-(*path).ray.d, lightDir), (*si).mediumAnisotropy);\n        response = vec3f(scatteringPdf);\n      }\n    }\n    if (continuation) {\n      result.direction = lightDir; result.response = response; result.pdf = scatteringPdf;\n      return result;\n    }\n    var candidate: ShadowRayWork;\n    let candidateValid = finishDirectLight(si, ma, path, ffnormal, isSurface,\n      lightSample, response, scatteringPdf, &candidate);\n    if (!candidateValid) { continue; }\n    if (candidateCount == 1u) {\n      selected = candidate;\n      continue;\n    }\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(event) * scalarWeightSum <= scalarWeight) {\n      selected = candidate;\n      selectedTarget = candidate.risTarget;\n    }\n  }\n  return result;\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  let scattered = sampleScattering(si, *ma, prepared, path, ffnormal, !mediumSampled);\n  scatterDir = scattered.direction;\n  scatteringPdf = scattered.pdf;\n  if (!mediumSampled) {\n    let f = scattered.response;\n    let isNextRefraction = scattered.transmission;\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

@@ -1,2 +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";
+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\n// Returns the occluded and the total count of light samples that reach the\n// visible side of this hit. The shadow opacity is the ratio of their sums over\n// all samples; samples that carry no light, such as those from below the\n// receiver, do not dilute it. Weighting by Le * cos / pdf instead is unbiased\n// but noisier, because the environment CDF dilates bright texels.\nfn sampleShadowCatcher(si: SurfaceInteraction, bounce: i32, path: ptr<function, Path>) -> vec2f {\n  let viewDir = -(*path).ray.d;\n  var counts = vec2f(0.0);\n\n  // The catcher table holds only the environment and analytic lights, as in\n  // WebGL 2: emissive meshes are scene objects, not light in the plate.\n  if (rtUniform.shadowCatcherChoiceCount > 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      sampleLightChoiceTable(\n        si.position,\n        lightRnd,\n        rtUniform.shadowCatcherChoiceOffset,\n        rtUniform.shadowCatcherChoiceCount,\n        1.0,\n        &lightSample\n      );\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        if (dot(lightSample.emission, luminance) * abs(cosThetaL) > 0.0) {\n          var ray: Ray;\n          initRay(&ray, si.position + EPS * lightDir, lightDir);\n          let occluded = intersectSceneShadow(ray, lightSample.dist - EPS, si.triangleIndex);\n          counts += vec2f(select(0.0, 1.0, occluded), 1.0);\n        }\n      }\n    }\n  }\n  (*path).fromEye = false;\n  return counts;\n}\n";
 export default _default;

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

@@ -10,31 +10,44 @@ export default /*wgsl*/ `
 
 const SHADOW_CATCHER_LIGHT_SAMPLES = 4u;
 
-fn sampleShadowCatcher(si: ad, bounce: i32, aa: ptr<function, Path>) {
-let oT = -(*aa).ray.d;
 
 
-if (rtUniform.lightChoiceCount > 0) {
-var shadow = 0.0;
+
+
+
+fn sampleShadowCatcher(si: SurfaceInteraction, bounce: i32, aa: ptr<function, Path>) -> vec2f {
+let qY = -(*aa).ray.d;
+var counts = vec2f(0.0);
+
+
+
+if (rtUniform.shadowCatcherChoiceCount > 0) {
 for (var candidate = 0u; candidate < SHADOW_CATCHER_LIGHT_SAMPLES; candidate++) {
 var lightSample: LightSampleRec;
-let ln = vec3f(fo(rd(candidate, 1u)), dz(rd(candidate, 0u)));
-sampleLight(si.position, ln, &lightSample, false);
+let lV = vec3f(dZ(sl(candidate, 1u)), dp(sl(candidate, 0u)));
+hv(
+si.position,
+lV,
+rtUniform.shadowCatcherChoiceOffset,
+rtUniform.shadowCatcherChoiceCount,
+1.0,
+&lightSample
+);
 let lightDir = lightSample.direction;
 let cosThetaL = dot(si.normal, lightDir);
-let pM = dot(si.normal, oT) * cosThetaL;
-if (lightSample.pdf > 0.0 && pM >= 0.0) {
+let qB = dot(si.normal, qY) * cosThetaL;
+if (lightSample.pdf > 0.0 && qB >= 0.0) {
+if (dot(lightSample.emission, luminance) * abs(cosThetaL) > 0.0) {
 var ray: Ray;
-iC(&ray, si.position + EPS * lightDir, lightDir);
-if (ex(ray, lightSample.dist - EPS, si.triangleIndex)) {
-shadow += 1.0;
+gC(&ray, si.position + EPS * lightDir, lightDir);
+let lY = intersectSceneShadow(ray, lightSample.dist - EPS, si.triangleIndex);
+counts += vec2f(select(0.0, 1.0, lY), 1.0);
 }
 }
 }
-
-(*aa).alpha = shadow / f32(SHADOW_CATCHER_LIGHT_SAMPLES);
 }
 (*aa).fromEye = false;
+return counts;
 }
 `;
 //# sourceMappingURL=sampleShadowCatcher.wgsl.js.map

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

@@ -1 +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"]}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8CvB,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\n// Returns the occluded and the total count of light samples that reach the\n// visible side of this hit. The shadow opacity is the ratio of their sums over\n// all samples; samples that carry no light, such as those from below the\n// receiver, do not dilute it. Weighting by Le * cos / pdf instead is unbiased\n// but noisier, because the environment CDF dilates bright texels.\nfn sampleShadowCatcher(si: SurfaceInteraction, bounce: i32, path: ptr<function, Path>) -> vec2f {\n  let viewDir = -(*path).ray.d;\n  var counts = vec2f(0.0);\n\n  // The catcher table holds only the environment and analytic lights, as in\n  // WebGL 2: emissive meshes are scene objects, not light in the plate.\n  if (rtUniform.shadowCatcherChoiceCount > 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      sampleLightChoiceTable(\n        si.position,\n        lightRnd,\n        rtUniform.shadowCatcherChoiceOffset,\n        rtUniform.shadowCatcherChoiceCount,\n        1.0,\n        &lightSample\n      );\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        if (dot(lightSample.emission, luminance) * abs(cosThetaL) > 0.0) {\n          var ray: Ray;\n          initRay(&ray, si.position + EPS * lightDir, lightDir);\n          let occluded = intersectSceneShadow(ray, lightSample.dist - EPS, si.triangleIndex);\n          counts += vec2f(select(0.0, 1.0, occluded), 1.0);\n        }\n      }\n    }\n  }\n  (*path).fromEye = false;\n  return counts;\n}\n`;\n"]}

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

@@ -3,71 +3,71 @@ export default /*wgsl*/ `
 
 
 
-fn aQ(view: vec3f, alpha: vec2f, samplePoint: vec2f) -> vec3f {
-let rm = vec3f(alpha, 1.0);
-let gj = normalize(rm * view);
-let uh = min(gj.z, 1.0);
-let qQ = 1.0 + uh;
-let rh = (1.0 - samplePoint.y) * qQ;
-let rR = samplePoint.y * qQ;
-let sI = rh + (1.0 - uh);
-let fl = sqrt(max(0.0, sI * rR));
-let br = TWOPI * samplePoint.x;
-let lJ = vec3f(
-gj.x + fl * cos(br),
-gj.y + fl * sin(br),
-rh
+fn aD(view: vec3f, alpha: vec2f, samplePoint: vec2f) -> vec3f {
+let sv = vec3f(alpha, 1.0);
+let cr = normalize(sv * view);
+let qP = min(cr.z, 1.0);
+let kh = 1.0 + qP;
+let kC = (1.0 - samplePoint.y) * kh;
+let sU = samplePoint.y * kh;
+let tY = kC + (1.0 - qP);
+let ex = sqrt(max(0.0, tY * sU));
+let azimuth = TWOPI * samplePoint.x;
+let mr = vec3f(
+cr.x + ex * cos(azimuth),
+cr.y + ex * sin(azimuth),
+kC
 );
-return normalize(rm * lJ);
+return normalize(sv * mr);
 }
 
-fn gK(oq: vec3f, alpha: vec2f) -> f32 {
-let hr = vec3f(
-oq.x / alpha.x,
-oq.y / alpha.y,
-oq.z
+fn cW(pf: vec3f, alpha: vec2f) -> f32 {
+let hF = vec3f(
+pf.x / alpha.x,
+pf.y / alpha.y,
+pf.z
 );
-let ap = dot(hr, hr);
+let aq = dot(hF, hF);
 return 1.0 / (
-PI * alpha.x * alpha.y * ap * ap
+PI * alpha.x * alpha.y * aq * aq
 );
 }
 
-fn bk(direction: vec3f, alpha: vec2f) -> f32 {
-let eF = abs(direction.z);
-if (eF <= 1e-8) {
+fn aF(direction: vec3f, alpha: vec2f) -> f32 {
+let eQ = abs(direction.z);
+if (eQ <= 1e-8) {
 return 0.0;
 }
-let ic = alpha * direction.xy;
-let lK = dot(ic, ic)
-/ (eF * eF);
-return 2.0 / (1.0 + sqrt(1.0 + lK));
+let iE = alpha * direction.xy;
+let mt = dot(iE, iE)
+/ (eQ * eQ);
+return 2.0 / (1.0 + sqrt(1.0 + mt));
 }
 
-fn aE(au: f32) -> f32 {
-let di = clamp(1.0 - au, 0.0, 1.0);
-return pow(di, 5.0);
+fn aI(cosine: f32) -> f32 {
+let dw = clamp(1.0 - cosine, 0.0, 1.0);
+return pow(dw, 5.0);
 }
 
-fn cu(L: f32, cJ: f32) -> f32 {
-let iA = clamp(abs(L), 0.0, 1.0);
-let kl = cJ * cJ
-* max(0.0, 1.0 - iA * iA);
-if (kl >= 1.0) {
+fn cC(J: f32, cR: f32) -> f32 {
+let iS = clamp(abs(J), 0.0, 1.0);
+let kQ = cR * cR
+* max(0.0, 1.0 - iS * iS);
+if (kQ >= 1.0) {
 return 1.0;
 }
 
-let lU = sqrt(max(0.0, 1.0 - kl));
-let ba = (iA - cJ * lU)
-/ max(iA + cJ * lU, 1e-8);
-let pN = (cJ * iA - lU)
-/ max(cJ * iA + lU, 1e-8);
+let mD = sqrt(max(0.0, 1.0 - kQ));
+let bk = (iS - cR * mD)
+/ max(iS + cR * mD, 1e-8);
+let qC = (cR * iS - mD)
+/ max(cR * iS + mD, 1e-8);
 return 0.5 * (
-ba * ba + pN * pN
+bk * bk + qC * qC
 );
 }
 
-fn gh(samplePoint: vec2f) -> vec2f {
+fn gy(samplePoint: vec2f) -> vec2f {
 let offset = 2.0 * samplePoint - vec2f(1.0);
 if (offset.x == 0.0 && offset.y == 0.0) {
 return vec2f(0.0);
@@ -86,45 +86,45 @@ angle = 0.5 * PI - 0.25 * PI * (offset.x / offset.y);
 return radius * vec2f(cos(angle), sin(angle));
 }
 
-fn bi(samplePoint: vec2f) -> vec3f {
-let kF = gh(samplePoint);
+fn aO(samplePoint: vec2f) -> vec3f {
+let lk = gy(samplePoint);
 return vec3f(
-kF,
-sqrt(max(0.0, 1.0 - dot(kF, kF)))
+lk,
+sqrt(max(0.0, 1.0 - dot(lk, lk)))
 );
 }
 
-fn aG(pr: f32, nO: f32) -> f32 {
-let scale = max(pr, nO);
+fn aK(qo: f32, oJ: f32) -> f32 {
+let scale = max(qo, oJ);
 if (scale <= 0.0) {
 return 0.0;
 }
-let normalized = vec2f(pr, nO) / scale;
-let oP = normalized * normalized;
-return oP.x / (oP.x + oP.y);
+let normalized = vec2f(qo, oJ) / scale;
+let pL = normalized * normalized;
+return pL.x / (pL.x + pL.y);
 }
 
-fn aL(
+fn aP(
 normal: vec3f,
 tangent: ptr<function, vec3f>,
 bitangent: ptr<function, vec3f>
 ) {
-let ik = select(-1.0, 1.0, normal.z >= 0.0);
-let dW = -1.0 / (ik + normal.z);
-let xy = normal.x * normal.y * dW;
+let iI = select(-1.0, 1.0, normal.z >= 0.0);
+let cL = -1.0 / (iI + normal.z);
+let xy = normal.x * normal.y * cL;
 *tangent = vec3f(
-1.0 + ik * normal.x * normal.x * dW,
-ik * xy,
--ik * normal.x
+1.0 + iI * normal.x * normal.x * cL,
+iI * xy,
+-iI * normal.x
 );
 *bitangent = vec3f(
 xy,
-ik + normal.y * normal.y * dW,
+iI + normal.y * normal.y * cL,
 -normal.y
 );
 }
 
-fn ai(rgb: vec3f, wavelength: f32) -> vec3f {
+fn aj(rgb: vec3f, wavelength: f32) -> vec3f {
 if (wavelength == 0.0) {
 return rgb;
 }
@@ -137,62 +137,62 @@ return vec3f(0.0, rgb.g, 0.0);
 return vec3f(0.0, 0.0, rgb.b);
 }
 
-fn eN(
+fn ee(
 wavelength: f32,
-hg: f32,
-hp: f32,
-qs: f32
+hu: f32,
+hD: f32,
+rt: f32
 ) -> f32 {
-if (wavelength == 0.0 || hp <= 0.0) {
-return hg;
+if (wavelength == 0.0 || hD <= 0.0) {
+return hu;
 }
 
 let FRAUNHOFER_C = 656.3;
 let FRAUNHOFER_D = 587.6;
 let FRAUNHOFER_F = 486.1;
-let jR = 1.0 / (
+let kv = 1.0 / (
 1.0 / (FRAUNHOFER_F * FRAUNHOFER_F)
 - 1.0 / (FRAUNHOFER_C * FRAUNHOFER_C)
 );
-let nh = max(qs / hp, 1e-6);
-let qR = (hg - 1.0) * jR / nh;
-let tl = hg
-- qR / (FRAUNHOFER_D * FRAUNHOFER_D);
-return tl + qR / (wavelength * wavelength);
+let oe = max(rt / hD, 1e-6);
+let rV = (hu - 1.0) * kv / oe;
+let uK = hu
+- rV / (FRAUNHOFER_D * FRAUNHOFER_D);
+return uK + rV / (wavelength * wavelength);
 }
 
-fn fp(
-gy: vec3f,
+fn fH(
+gO: vec3f,
 anisotropy: f32,
 samplePoint: vec2f
 ) -> vec3f {
-var au: f32;
+var cosine: f32;
 if (abs(anisotropy) < 0.001) {
-au = 1.0 - 2.0 * samplePoint.y;
+cosine = 1.0 - 2.0 * samplePoint.y;
 }
 else {
-let ja = (1.0 - anisotropy * anisotropy)
+let ju = (1.0 - anisotropy * anisotropy)
 / (1.0 + anisotropy - 2.0 * anisotropy * samplePoint.y);
-au = (
-ja * ja - 1.0 - anisotropy * anisotropy
+cosine = (
+ju * ju - 1.0 - anisotropy * anisotropy
 ) / (2.0 * anisotropy);
 }
 
-let ud = sqrt(max(0.0, 1.0 - au * au));
-let br = TWOPI * samplePoint.x;
+let vF = sqrt(max(0.0, 1.0 - cosine * cosine));
+let azimuth = TWOPI * samplePoint.x;
 var tangent: vec3f;
 var bitangent: vec3f;
-aL(gy, &tangent, &bitangent);
-return tangent * (ud * cos(br))
-+ bitangent * (ud * sin(br))
-+ gy * au;
+aP(gO, &tangent, &bitangent);
+return tangent * (vF * cos(azimuth))
++ bitangent * (vF * sin(azimuth))
++ gO * cosine;
 }
 
-fn bD(au: f32, anisotropy: f32) -> f32 {
-let ap = 1.0 + anisotropy * anisotropy
-+ 2.0 * anisotropy * au;
+fn bL(cosine: f32, anisotropy: f32) -> f32 {
+let aq = 1.0 + anisotropy * anisotropy
++ 2.0 * anisotropy * cosine;
 return INV4PI * (1.0 - anisotropy * anisotropy)
-/ (ap * sqrt(ap));
+/ (aq * sqrt(aq));
 }
 `;
 //# sourceMappingURL=sampling.wgsl.js.map

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

@@ -4,5 +4,5 @@
  * luminance moments for the built-in denoiser's variance estimate.
  */
 export declare const SHADOW_CATCHER_ACCUMULATION_BYTES = 48;
-declare const _default: "\nstruct ShadowCatcherAccumulation {\n  // Catcher coverage, separated background alpha, catcher background hits, shadow opacity.\n  mask: vec4f,\n  background: vec4f,\n  // Sum of the denoising guide value and of its square (x, y).\n  moments: vec4f,\n}\n";
+declare const _default: "\nstruct ShadowCatcherAccumulation {\n  // Catcher coverage, separated background alpha, catcher background hits.\n  mask: vec4f,\n  background: vec4f,\n  // Sum of the denoising guide value and of its square (x, y), and of the\n  // catcher's occluded and total light sample counts (z, w).\n  moments: vec4f,\n}\n";
 export default _default;

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

@@ -10,6 +10,7 @@ struct ShadowCatcherAccumulation {
 mask: vec4f,
 background: vec4f,
 
+
 moments: vec4f,
 }
 `;

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

@@ -1 +1 @@
-{"version":3,"file":"shadowCatcherAccumulation.wgsl.js","sourceRoot":"","sources":["../../../../src/renderer/wgsl/chunks/shadowCatcherAccumulation.wgsl.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,CAAC,MAAM,iCAAiC,GAAG,EAAE,CAAC;AAEpD,eAAe,UAAU,CAAC;;;;;;;;CAQzB,CAAC","sourcesContent":["/**\n * Per-pixel auxiliary accumulation: the shadow-catcher mask, its premultiplied\n * primary background contribution (including opaque flat primary misses), and\n * luminance moments for the built-in denoiser's variance estimate.\n */\nexport const SHADOW_CATCHER_ACCUMULATION_BYTES = 48;\n\nexport default /* wgsl */ `\nstruct ShadowCatcherAccumulation {\n  // Catcher coverage, separated background alpha, catcher background hits, shadow opacity.\n  mask: vec4f,\n  background: vec4f,\n  // Sum of the denoising guide value and of its square (x, y).\n  moments: vec4f,\n}\n`;\n"]}
+{"version":3,"file":"shadowCatcherAccumulation.wgsl.js","sourceRoot":"","sources":["../../../../src/renderer/wgsl/chunks/shadowCatcherAccumulation.wgsl.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,CAAC,MAAM,iCAAiC,GAAG,EAAE,CAAC;AAEpD,eAAe,UAAU,CAAC;;;;;;;;;CASzB,CAAC","sourcesContent":["/**\n * Per-pixel auxiliary accumulation: the shadow-catcher mask, its premultiplied\n * primary background contribution (including opaque flat primary misses), and\n * luminance moments for the built-in denoiser's variance estimate.\n */\nexport const SHADOW_CATCHER_ACCUMULATION_BYTES = 48;\n\nexport default /* wgsl */ `\nstruct ShadowCatcherAccumulation {\n  // Catcher coverage, separated background alpha, catcher background hits.\n  mask: vec4f,\n  background: vec4f,\n  // Sum of the denoising guide value and of its square (x, y), and of the\n  // catcher's occluded and total light sample counts (z, w).\n  moments: vec4f,\n}\n`;\n"]}