@meimu/mutracer 0.1.2 → 0.1.3

package/lib/renderer/wgsl/rayTrace.compute.js.map

@@ -1 +1 @@
-{"version":3,"file":"rayTrace.compute.js","sourceRoot":"","sources":["../../../src/renderer/wgsl/rayTrace.compute.ts"],"names":[],"mappings":"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","sourcesContent":["import { MAX_PATH_EVENTS } from '../pathLimits.js';\nimport shadowCatcherAccumulationWGSL from './chunks/shadowCatcherAccumulation.wgsl.js';\nimport depthQueryWGSL from './depthQuery.wgsl.js';\n// 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\nimport commonWgsl from './chunks/common.wgsl.js';\nimport { WGPU_SCENE_FEATURE_BITS } from '../WGPUSceneFeatures.js';\nimport rayTraceCoreWgsl from './chunks/rayTraceCore.wgsl.js';\nimport { createMaterialBufferWgsl } from './chunks/materialBuffer.wgsl.js';\nimport createIntersectionWgsl from './chunks/intersect.wgsl.js';\nimport randomWgsl from './chunks/random.wgsl.js';\nimport randWgsl from './chunks/rand.wgsl.js';\nimport { createSampleMaterialWgsl } from './chunks/sampleMaterial.wgsl.js';\nimport sampleLightWgsl from './chunks/sampleLight.wgsl.js';\nimport { createOpenPbrBsdfWgsl } from './chunks/openPbrBsdf.wgsl.js';\nimport samplingWgsl from './chunks/sampling.wgsl.js';\nimport sampleShadowCatcherWgsl from './chunks/sampleShadowCatcher.wgsl.js';\nimport envMapWgsl from './chunks/envMap.wgsl.js';\nimport uvProjectionWgsl from './chunks/uvProjection.wgsl.js';\nexport const WORKGROUP_SIZE = 8;\n\nexport interface RayTraceShaderOptions {\n  hasDisplacement: boolean;\n  /** Include direction frames only when used, preserving the legacy shader arithmetic otherwise. */\n  hasAnisotropyDirections?: boolean;\n  /** Include independent coat normals only when a material uses that slot. */\n  hasCoatNormals?: boolean;\n  /** Split glTF BLEND primary hits deterministically instead of stochastically. */\n  hasAlpha?: boolean;\n  /** Any scene material uses alpha mask or blend. */\n  hasSceneAlpha?: boolean;\n  /** Bit mask of the BLAS layouts present in the scene (bvh2, bvh4, bvh-gpu, cwbvh). */\n  blasLayoutMask?: number;\n}\n\n/** Generates the WebGPU megakernel path tracing compute shader. */\nexport default function rayTraceCompute({\n  hasDisplacement,\n  hasAnisotropyDirections = false,\n  hasCoatNormals = false,\n  hasAlpha = true,\n  hasSceneAlpha = true,\n  blasLayoutMask = 1\n}: RayTraceShaderOptions) {\n  hasAnisotropyDirections ||= hasCoatNormals;\n  const deterministicPrimaryAlpha = hasAlpha;\n  const source = /* wgsl */ `\n\n${commonWgsl}\n\n${rayTraceCoreWgsl({ hasSceneAlpha, hasAnisotropyDirections, hasCoatNormals })}\n\n${uvProjectionWgsl}\n\n${createMaterialBufferWgsl({ hasSceneAlpha, hasAnisotropyDirections, hasCoatNormals })}\n\n${createIntersectionWgsl({ hasDisplacement, blasLayoutMask, hasAnisotropyDirections, hasCoatNormals })}\n${randWgsl}\n${randomWgsl}\n${envMapWgsl}\n\n${samplingWgsl}\n${createOpenPbrBsdfWgsl(hasAnisotropyDirections, hasCoatNormals)}\n${sampleLightWgsl}\n\n// Index of the path vertex currently being shaded.\nvar<private> bounceIndex: u32 = 0u;\n\n// Number of light candidates resampled for each NEE estimate. Interactive\n// preview caps the budget at two.\nfn neeCandidateCount() -> u32 {\n  return u32(max(rtUniform.directLightCandidates, 1));\n}\n\n// Hash-based random number used to select among light candidates. It is\n// independent of the path sample stream so the candidate count does not\n// change the dimensions consumed by later bounces.\nfn lightCandidateRandom(salt: u32) -> f32 {\n  // Reservoir replacement needs the full [0, 1) interval: sample1D's EPS\n  // remapping makes small positive replacement probabilities unreachable.\n  // Preserve the legacy sequential RNG draw in the random sampling mode so\n  // subsequent path samples retain their stream; selection uses the hash.\n  if (SAMPLING_PATTERN == 2) { _ = rand(); }\n  let pixelID = samplingPixel.x + samplingPixel.y * u32(rtUniform.outputSize.x);\n  let key = sampleSeed(sampleSeed(pixelID, pixelSampleIndex), rtUniform.sequenceSeed);\n  let dimension = sampleSeed(samplingBounce, salt) ^ 0xa511e9b3u;\n  return f32(sampleHash(key ^ dimension) >> 8u) * (1.0 / 16777216.0);\n}\n\n// MIS weight of a light-sampled contribution. With several resampled\n// candidates the NEE technique is drawn neeCandidateCount() times.\nfn neeMISWeight(lightPdf: f32, scatteringPdf: f32) -> f32 {\n  let candidateCount = neeCandidateCount();\n  if (candidateCount <= 1u) {\n    return sampling_power_heuristic(lightPdf, scatteringPdf);\n  }\n  let weightedLightPdf = f32(candidateCount) * lightPdf;\n  return weightedLightPdf /\n    max(weightedLightPdf + scatteringPdf, 1e-20);\n}\n\n// MIS weight of a BSDF-sampled ray that hits a light.\nfn bsdfMISWeight(scatteringPdf: f32, lightPdf: f32) -> f32 {\n  let candidateCount = neeCandidateCount();\n  if (candidateCount <= 1u) {\n    return sampling_power_heuristic(scatteringPdf, lightPdf);\n  }\n  let weightedLightPdf = f32(candidateCount) * lightPdf;\n  return scatteringPdf /\n    max(scatteringPdf + weightedLightPdf, 1e-20);\n}\n\n${createSampleMaterialWgsl(hasAnisotropyDirections, hasCoatNormals)}\n${sampleShadowCatcherWgsl}\n\n// Output\n@group(3) @binding(0) var<storage, read_write> outColor: array<vec4f>;\n@group(3) @binding(1) var<storage, read_write> outNormal: array<vec4f>;\n@group(3) @binding(2) var<storage, read_write> outAlbedo: array<vec4f>;\n\n${shadowCatcherAccumulationWGSL}\n@group(3) @binding(3) var<storage, read_write> outShadowCatcher: array<ShadowCatcherAccumulation>;\n\n\nfn accumulateNormalOrVariance(\n  pixelIndex: u32,\n  radiance: vec3f,\n  normal: vec3f\n) {\n  if (rtUniform.varianceMoments != 0) {\n    let value = dot(radiance, luminance);\n    outNormal[pixelIndex] += vec4f(value * value, 0.0, 0.0, 1.0);\n  }\n  else {\n    outNormal[pixelIndex] += vec4f(normal, 1.0);\n  }\n}\n\n// Moments of the per-sample value the built-in denoiser compares, used to\n// estimate the variance of each pixel's mean.\nfn accumulateDenoiseMoments(pixelIndex: u32, value: f32) {\n  outShadowCatcher[pixelIndex].moments += vec4f(value, value * value, 0.0, 0.0);\n}\n\n\nstruct RayTraceAuxiliary {\n  // Denoising guides and auxiliary pixel classification.\n  albedo: vec3f,\n  isShadowCatcher: bool,\n  normal: vec3f,\n  isBlank: bool,\n}\n\nfn groundedSurfaceDistance(point: vec3f, height: f32, radius: f32) -> f32 {\n  let pointLength = length(point);\n  if (pointLength < 0.00001) {\n    return -radius;\n  }\n\n  let originalY = radius * point.y / pointLength;\n  let transitionY = -1.5 * height;\n  var surfaceRadius: f32;\n  if (originalY >= 0.0) {\n    surfaceRadius = radius;\n  }\n  else if (originalY < transitionY) {\n    surfaceRadius = -height * pointLength / point.y;\n  }\n  else {\n    let factor = 1.0\n      - originalY * originalY / (3.0 * transitionY * transitionY);\n    surfaceRadius = radius * factor;\n  }\n  return pointLength - surfaceRadius;\n}\n\nfn groundedBackgroundDirection(origin: vec3f, direction: vec3f) -> vec3f {\n  if (!USE_GROUNDED_BACKGROUND) {\n    return direction;\n  }\n  let params = rtUniform.groundedBackgroundParams;\n  let rayDirection = normalize(direction);\n  let center = vec3f(\n    rtUniform.groundedBackgroundCenter.x,\n    params.z + params.x,\n    rtUniform.groundedBackgroundCenter.y\n  );\n  let localOrigin = origin - center;\n  let projectedOrigin = dot(localOrigin, rayDirection);\n  let discriminant = projectedOrigin * projectedOrigin\n    - dot(localOrigin, localOrigin) + params.y * params.y;\n  if (\n    discriminant <= 0.0\n    || groundedSurfaceDistance(localOrigin, params.x, params.y) > 0.0\n  ) {\n    return direction;\n  }\n\n  var farDistance = -projectedOrigin + sqrt(discriminant);\n  if (farDistance <= 0.0) {\n    return direction;\n  }\n\n  let sphereHit = localOrigin + rayDirection * farDistance;\n  if (sphereHit.y >= 0.0) {\n    return normalize(sphereHit);\n  }\n\n  if (rayDirection.y < -0.00001 && params.y > 1.5 * params.x) {\n    let groundDistance = (-params.x - localOrigin.y) / rayDirection.y;\n    let groundHit = localOrigin + rayDirection * groundDistance;\n    let groundRadius = (2.0 / 3.0)\n      * sqrt(params.y * params.y - 2.25 * params.x * params.x);\n    if (groundDistance > 0.0 && length(groundHit.xz) <= groundRadius) {\n      return normalize(groundHit);\n    }\n  }\n\n  var nearDistance = 0.0;\n  for (var i = 0; i < 14; i++) {\n    let middleDistance = (nearDistance + farDistance) * 0.5;\n    let middlePoint = localOrigin + rayDirection * middleDistance;\n    if (groundedSurfaceDistance(middlePoint, params.x, params.y) > 0.0) {\n      farDistance = middleDistance;\n    }\n    else {\n      nearDistance = middleDistance;\n    }\n  }\n  let hit = localOrigin + rayDirection * ((nearDistance + farDistance) * 0.5);\n  return normalize(hit);\n}\n\nfn sampleSceneBackground(ray: Ray) -> vec4f {\n  var bg = vec4f(0.0);\n  if (USE_BACKGROUND_MAP) {\n    let backgroundDirection = groundedBackgroundDirection(ray.o, ray.d);\n    bg = textureLinear(backgroundMap, cartesianToEquirect(backgroundDirection));\n  }\n  else if (USE_BACKGROUND) {\n    bg = rtUniform.backgroundColor;\n  }\n  else if (USE_ENVMAP) {\n    bg = textureLinear(envMap, cartesianToEquirect(ray.d));\n  }\n  return bg;\n}\n\nfn sampleSpectralSceneBackground(ray: Ray, wavelength: f32) -> vec4f {\n  let bg = sampleSceneBackground(ray);\n  if (SPECTRAL) {\n    return vec4f(sampling_spectral_rgb_filter(bg.rgb, wavelength), bg.a);\n  }\n  return bg;\n}\n\nfn bounce(uv: vec2f, path: ptr<function, Path>, depth: ptr<function, i32>, si: ptr<function, SurfaceInteraction>, ma: ptr<function, OpenPbrResolvedMaterial>, outAux: ptr<function, RayTraceAuxiliary>) {\n  samplingBounce = u32(max(*depth, 0));\n  let matType = (*ma).materialType;\n  let isShadowCatcher = matType == SHADOW_CATCHER;\n  if (isShadowCatcher) {\n    if ((*path).fromEye) {\n      (*si).hit = false;\n    }\n    else {\n      // The catcher only contributes to the separate shadow mask. Secondary\n      // rays must see the environment behind it instead of its default white\n      // material, otherwise it appears in reflections.\n      if (USE_ENVMAP) {\n        if ((*path).isNextRefraction) {\n          // A camera-visible transmitted ray can hit the invisible catcher\n          // before the grounded skybox. Preserve the displayed projection.\n          let bg = sampleSpectralSceneBackground(\n            (*path).ray,\n            (*si).wavelength\n          );\n          let backgroundMisWeight = select(bsdfMISWeight((*path).scatteringPdf,\n            envMapPdf(cartesianToEquirect((*path).ray.d)) * rtUniform.envLightPmf),\n            1.0, (*path).scatteringIsDelta);\n          (*path).li += backgroundMisWeight * (*path).beta * bg.rgb * bg.a;\n          (*path).alpha = max((*path).alpha, bg.a);\n        }\n        else {\n          let envUv = cartesianToEquirect((*path).ray.d);\n          var emission = textureLinear(envMap, envUv).rgb;\n          if (SPECTRAL) {\n            emission = sampling_spectral_rgb_filter(emission, (*si).wavelength);\n          }\n          (*path).li += (*path).beta * emission *\n            bsdfMISWeight((*path).scatteringPdf, envMapPdf(envUv));\n        }\n      }\n      else {\n        let bg = sampleSpectralSceneBackground(\n          (*path).ray,\n          (*si).wavelength\n        );\n        (*path).li += (*path).beta * bg.rgb * bg.a;\n      }\n      (*path).abort = true;\n      return;\n    }\n  }\n  if (!(*si).hit) {\n    // The spectral integrator traces red, green, and blue paths separately.\n    // Split background radiance by wavelength as well so the three paths\n    // reconstruct the skybox instead of adding three full RGB copies.\n    let bg = sampleSpectralSceneBackground(\n      (*path).ray,\n      (*si).wavelength\n    );\n    if ((*path).fromEye) {\n      // Sample from background if first ray not hit anything.\n      (*path).li = (*path).beta * bg.rgb * bg.a;\n      (*path).alpha = bg.a;\n      // Only treat as blank pixels when the background is transparent\n      (*outAux).isBlank = bg.a < 0.001 ||\n        (USE_BACKGROUND && !USE_BACKGROUND_MAP);\n    }\n    else {\n      let cam = initCameraRay(uv);\n      let towardsCam = dot(cam.d, (*path).ray.d) > 0.0;\n      if (rtUniform.transmissiveOutputAlphaMin < 1.0) {\n        if (towardsCam) {\n          (*path).alpha = max((*path).alpha, bg.a);\n        } else {\n          (*path).alpha = 1.0;\n        }\n      }\n      if (!USE_ENVMAP) {\n        // A display background is not an illumination environment, but a\n        // visible secondary ray (e.g. through glass) still resolves it.\n        if (towardsCam) {\n          // This is a terminal BSDF-hit contribution, not a replacement for\n          // NEE accumulated at earlier vertices on the same path.\n          (*path).li += (*path).beta *\n            bsdfMISWeight((*path).scatteringPdf, 1.0) * bg.rgb;\n        }\n      }\n    }\n    (*path).abort = true;\n    return;\n  }\n\n  var sampleIgnored = false;\n  if ((matType == STANDARD || matType == UNLIT)) {\n    let alpha = clamp((*ma).alpha, 0.0, 1.0);\n    \n    if (alpha < 1.0) {\n      // Alpha is stochastic coverage. Keep accepted surface radiance at full\n      // weight instead of multiplying it by alpha a second time.\n      if (alpha <= 0.0 || hashedSample(3u) > alpha) {\n        sampleIgnored = true;\n      }\n    }\n    if (!sampleIgnored && rtUniform.transmissiveOutputAlphaMin < 1.0) {\n      // A selected stochastic coverage sample is fully covered. Ignored\n      // samples leave output alpha untouched and continue to the back layer.\n      let outputAlpha = max(1.0 - (*ma).transmissionWeight, 1.0 - pow(1.0 - rtUniform.transmissiveOutputAlphaMin, f32(*depth)));\n      (*path).alpha = max(outputAlpha, (*path).alpha);\n    }\n    if (!sampleIgnored) {\n      bounceIndex = u32(max(*depth, 0));\n      SampleMaterial(si, ma, path);\n    }\n    else {\n      // Alpha-null traversal does not consume the receiver event. The first\n      // accepted surface behind it is still the receiver for NEE/AOVs.\n      (*path).ray.o = (*si).position + (*path).ray.d * EPS;\n    }\n  }\n\n  if (!(*si).albedoSampled && !sampleIgnored) {\n    // Select denoising guides.\n    if ((matType == STANDARD || matType == UNLIT)) {\n      if (!((*ma).transmissionWeight > 0.5 ||\n        ((*ma).specularRoughness <= 0.02 && (*ma).baseMetalness > 0.98))) {\n        (*outAux).albedo = (*ma).baseColor;\n        (*outAux).normal = select(\n          (*si).normal,\n          -(*si).normal,\n          dot(\n            (*si).normal,\n            (*si).position - cameraUniform.viewInv[3].xyz\n          ) > 0.0\n        );\n        (*si).albedoSampled = true;\n      }\n      // TODO pick albedo and normal on the surface if ray is too deep and can't hit any rough or opaque surfaces.\n      if (*depth > 4) {\n        (*si).albedoSampled = true;\n      }\n    }\n  }\n\n  // Russian roulette with throughput compensation.\n  if (USE_RR) {\n    if (*depth >= RR_MAX && !sampleIgnored) {\n      let rouletteBeta = (*path).beta;\n      // Max-component survival (pbrt-v4) avoids over-amplifying saturated paths.\n      let maxComponent = max(max(rouletteBeta.x, rouletteBeta.y), rouletteBeta.z);\n      let q: f32 = max(0.0, 1.0 - maxComponent);\n      if (sample1D(bounceDim(RUSSIAN_ROULETTE)) < q) {\n        // TODO we force use alpha 1.0 here.\n        // To avoid the glass pixels is transparent even if it's on an opaque object.\n        (*path).alpha = 1.0;\n        (*path).abort = true;\n      }\n      else {\n        (*path).beta /= 1.0 - q;\n      }\n    }\n  }\n  if ((*path).abort) {\n    return;\n  }\n\n  intersectScene((*path).ray, si, *depth, true, (*path).isNextRefraction);\n  getMaterial(ma, (*si).materialIndex, (*si).uv, (*si).uv1, (*si).instanceIndex);\n\n  if (SPECTRAL) {\n    // Is glass\n    if ((*ma).transmissionWeight > 0.001) {\n      (*ma).specularIor = sampling_cauchy_ior(\n        (*si).wavelength,\n        (*ma).specularIor,\n        (*ma).transmissionDispersionScale,\n        (*ma).dispersionAbbeNumber\n      );\n    }\n  }\n\n  if (sampleIgnored) {\n    return;\n  }\n\n  // Use light if hit the light\n  var lightSample: LightSampleRec;\n  let isAlphaOccluded = hashedSample(3u) < (*ma).alpha;\n  for (var i = 0; i < rtUniform.lightsCount; i++) {\n    // Fetch light Data\n    let light: Light = analyticLights[i];\n    let d = intersectLight((*path).ray, light, &lightSample);\n    lightSample.pdf *= light.selectionPmf;\n    let occluded = (*si).hit && d > distance((*si).position, (*path).ray.o);\n    if (d != INF && !(occluded && isAlphaOccluded)) {\n      let misWeight = bsdfMISWeight((*path).scatteringPdf, lightSample.pdf);\n      if (SPECTRAL) {\n        lightSample.emission = sampling_spectral_rgb_filter(lightSample.emission, (*si).wavelength);\n      }\n      (*path).li += misWeight * (*path).beta * lightSample.emission;\n      (*path).alpha = 1.0;\n      (*path).abort = true;\n    }\n  }\n\n  if (USE_ENVMAP) {\n    if (!((*si).hit && isAlphaOccluded)) {\n      if ((*path).isNextRefraction) {\n        // Camera-visible transmission follows the displayed background,\n        // including grounded projection. Other rays use the raw environment\n        // map as the physically sampled lighting source.\n        let bg = sampleSpectralSceneBackground(\n          (*path).ray,\n          (*si).wavelength\n        );\n        let backgroundMisWeight = select(bsdfMISWeight((*path).scatteringPdf,\n            envMapPdf(cartesianToEquirect((*path).ray.d)) * rtUniform.envLightPmf),\n            1.0, (*path).scatteringIsDelta);\n          (*path).li += backgroundMisWeight * (*path).beta * bg.rgb * bg.a;\n        (*path).alpha = max((*path).alpha, bg.a);\n        (*path).abort = true;\n        return;\n      }\n      let _uv = cartesianToEquirect((*path).ray.d);\n      var emission = textureLinear(envMap, _uv).rgb;\n      let misWeight = bsdfMISWeight(\n        (*path).scatteringPdf,\n        envMapPdf(_uv) * rtUniform.envLightPmf\n      );\n      if (SPECTRAL) {\n        emission = sampling_spectral_rgb_filter(emission, (*si).wavelength);\n      }\n      // TODO force the min alpha to be 1 when showing envmap as background\n      if (!USE_BACKGROUND) {\n        (*path).alpha = 1.0;\n      }\n      (*path).li += (*path).beta * emission * misWeight;\n      (*path).abort = true;\n    }\n  }\n\n  *depth = *depth + 1;\n}\n\nfn initCameraRay(coord: vec2f) -> Ray {\n  let origin = cameraUniform.viewProjectionInv * vec4f(coord * 2.0 - 1.0, -1.0, 1.0);\n  let center = cameraUniform.viewProjectionInv * vec4f(coord * 2.0 - 1.0, 1.0, 1.0);\n  var cam: Ray;\n  initRay(&cam, origin.xyz / origin.w, normalize(center.xyz * origin.w - origin.xyz * center.w));\n\n  return cam;\n}\n\n\nfn bevelCubicSample(radius: f32, xi: f32) -> vec2f {\n  var x = 0.25;\n  for (var iteration = 0; iteration < 10; iteration++) {\n    let x2 = x * x;\n    let x3 = x2 * x;\n    let oneMinusX = 1.0 - x;\n    let value = 10.0 * x2 - 20.0 * x3 + 15.0 * x2 * x2 -\n      4.0 * x2 * x3 - xi;\n    let derivative = 20.0 * x * oneMinusX * oneMinusX * oneMinusX;\n    if (abs(value) < 1e-6 || derivative == 0.0) { break; }\n    x = clamp(x - value / derivative, 0.0, 1.0);\n  }\n  let diskRadius = x * radius;\n  return vec2f(diskRadius, sqrt(max(radius * radius - diskRadius * diskRadius, 0.0)));\n}\n\nfn bevelCubicPdf(radius: f32, distanceToSource: f32) -> f32 {\n  if (distanceToSource >= radius) { return 0.0; }\n  let falloff = radius - distanceToSource;\n  return falloff * falloff * falloff;\n}\n\n// Shader bevel. Usage: docs/materials.md (Renderer extensions)\nfn getBevelNormal(source: SurfaceInteraction, radius: f32) -> vec3f {\n  var geometricNormal = source.faceNormal;\n  if (dot(geometricNormal, source.vertexNormal) < 0.0) {\n    geometricNormal = -geometricNormal;\n  }\n  var tangent: vec3f;\n  var bitangent: vec3f;\n  sampling_orthonormal_basis(geometricNormal, &tangent, &bitangent);\n  var normalSum = vec3f(0.0);\n\n  for (var sampleIndex = 0; sampleIndex < BEVEL_SAMPLES; sampleIndex++) {\n    let bevelRnd = sample2D(CAMERA_BEVEL_BASE + u32(sampleIndex));\n    var axisSample = bevelRnd.x;\n    let radialSample = bevelRnd.y;\n    var diskNormal = geometricNormal;\n    var diskTangent = tangent;\n    var diskBitangent = bitangent;\n    var pickPdfNormal = 0.5;\n    var pickPdfTangent = 0.25;\n    var pickPdfBitangent = 0.25;\n    if (axisSample < 0.5) {\n      axisSample *= 2.0;\n    }\n    else if (axisSample < 0.75) {\n      let swapAxis = diskNormal;\n      diskNormal = diskTangent;\n      diskTangent = swapAxis;\n      pickPdfNormal = 0.25;\n      pickPdfTangent = 0.5;\n      axisSample = (axisSample - 0.5) * 4.0;\n    }\n    else {\n      let swapAxis = diskNormal;\n      diskNormal = diskBitangent;\n      diskBitangent = swapAxis;\n      pickPdfNormal = 0.25;\n      pickPdfBitangent = 0.5;\n      axisSample = (axisSample - 0.75) * 4.0;\n    }\n\n    let diskSample = bevelCubicSample(radius, radialSample);\n    let phi = TWOPI * axisSample;\n    let diskOffset = diskSample.x *\n      (cos(phi) * diskTangent + sin(phi) * diskBitangent);\n    var ray: Ray;\n    initRay(\n      &ray,\n      source.position + diskNormal * diskSample.y + diskOffset,\n      -diskNormal\n    );\n    var hit: SurfaceInteraction;\n    intersectSceneBevel(\n      ray,\n      &hit,\n      source.instanceIndex,\n      max(2.0 * diskSample.y, EPS)\n    );\n    if (!hit.hit) { continue; }\n\n    let pdfNormal = pickPdfNormal * abs(dot(diskNormal, hit.faceNormal));\n    let pdfTangent = pickPdfTangent * abs(dot(diskTangent, hit.faceNormal));\n    let pdfBitangent = pickPdfBitangent * abs(dot(diskBitangent, hit.faceNormal));\n    var weight = pdfNormal / max(\n      pdfNormal * pdfNormal + pdfTangent * pdfTangent +\n        pdfBitangent * pdfBitangent,\n      1e-8\n    );\n    weight *= bevelCubicPdf(radius, distance(hit.position, source.position)) /\n      max(bevelCubicPdf(radius, diskSample.x), 1e-8);\n    normalSum += weight * hit.vertexNormal;\n  }\n\n  if (dot(normalSum, normalSum) <= 1e-12) { return source.normal; }\n  let bevelVertexNormal = normalize(normalSum);\n  let result = source.normal + bevelVertexNormal - source.vertexNormal;\n  if (dot(result, result) > 1e-12) { return normalize(result); }\n  return source.normal;\n}\n\nfn integrateOnePathSample(uv: vec2f, si: ptr<function, SurfaceInteraction>, ray: Ray, ma: ptr<function, OpenPbrResolvedMaterial>, outAux: ptr<function, RayTraceAuxiliary>) -> vec4f {\n  var path: Path;\n  path.ray = ray;\n  path.li = vec3f(0.0);\n  path.alpha = select(1.0, 0.0, rtUniform.transmissiveOutputAlphaMin < 1.0);\n  path.beta = vec3f(1.0);\n  path.fromEye = true;\n  path.scatteringPdf = 0.0;\n  path.scatteringIsDelta = false;\n  path.isNextRefraction = false;\n  path.abort = false;\n\n  let isNotTransparent = (*ma).transmissionWeight < 0.001 && (*ma).subsurfaceWeight < 0.001 && (*ma).alpha > 0.99;\n  let bounceLimit = max(rtUniform.bounces, 0);\n  var depth = 0;\n  // Transparent paths may take up to three times the configured bounces.\n  for (var idx: i32 = 0; idx < min(bounceLimit * 3, ${MAX_PATH_EVENTS}); idx = idx + 1) {\n    if (isNotTransparent && idx > bounceLimit) {\n      path.abort = true;\n    }\n    if (path.abort) {\n      break;\n    }\n    bounce(uv, &path, &depth, si, ma, outAux);\n  }\n\n  return vec4f(path.li, path.alpha);\n}\n\nfn integrateOnePath(uv: vec2f, si: ptr<function, SurfaceInteraction>, ray: Ray, ma: ptr<function, OpenPbrResolvedMaterial>, outAux: ptr<function, RayTraceAuxiliary>) -> vec4f {\n  ${deterministicPrimaryAlpha ? /* wgsl */ `let coverage = clamp((*ma).alpha, 0.0, 1.0);\n  if (!(*si).hit || ((*ma).materialType != STANDARD && (*ma).materialType != UNLIT) || coverage >= 1.0) {\n    return integrateOnePathSample(uv, si, ray, ma, outAux);\n  }\n\n  // glTF BLEND is source-over opacity, not a physical glass boundary. Split\n  // the primary ray so reflected radiance is attenuated by alpha every sample\n  // while the complementary branch continues straight to the scene behind it.\n  // Secondary alpha hits remain stochastic to avoid exponential path growth.\n  var backRay = ray;\n  backRay.o = (*si).position + ray.d * (EPS * 0.02);\n  var backSi = *si;\n  backSi.albedoSampled = false;\n  intersectScene(backRay, &backSi, 0, false, false);\n  var backMa: OpenPbrResolvedMaterial;\n  getMaterial(&backMa, backSi.materialIndex, backSi.uv, backSi.uv1, backSi.instanceIndex);\n  var backAux = *outAux;\n  if (backSi.hit && backMa.materialType == STANDARD) {\n    backAux.albedo = select(\n      backMa.baseColor,\n      vec3f(1.0),\n      backMa.transmissionWeight > 0.5\n    );\n    backAux.normal = select(\n      backSi.normal,\n      -backSi.normal,\n      dot(\n        backSi.normal,\n        backSi.position - cameraUniform.viewInv[3].xyz\n      ) > 0.0\n    );\n    backSi.albedoSampled = backMa.transmissionWeight > 0.5;\n  }\n  let back = integrateOnePathSample(\n    uv, &backSi, backRay, &backMa, &backAux\n  );\n  if (coverage <= 0.0) {\n    *outAux = backAux;\n    return back;\n  }\n\n  var frontSi = *si;\n  var frontMa = *ma;\n  frontMa.alpha = 1.0;\n  var frontAux = *outAux;\n  let front = integrateOnePathSample(\n    uv, &frontSi, ray, &frontMa, &frontAux\n  );\n  (*outAux).albedo = mix(backAux.albedo, frontAux.albedo, coverage);\n  let blendedNormal = mix(backAux.normal, frontAux.normal, coverage);\n  (*outAux).normal = select(\n    vec3f(0.0),\n    normalize(blendedNormal),\n    dot(blendedNormal, blendedNormal) > 1e-12\n  );\n  (*outAux).isBlank = backAux.isBlank && frontAux.isBlank;\n  (*outAux).isShadowCatcher = backAux.isShadowCatcher && frontAux.isShadowCatcher;\n  return mix(back, front, coverage);` : /* wgsl */ `return integrateOnePathSample(uv, si, ray, ma, outAux);`}\n}\n\n// Path tracing integrator as described in\n// http://www.pbr-book.org/3ed-2018/Light_Transport_I_Surface_Reflection/Path_Tracing.html#\nfn integrator(uv: vec2f, ray: Ray, outAux: ptr<function, RayTraceAuxiliary>) -> vec4f {\n  var si: SurfaceInteraction;\n  var ma: OpenPbrResolvedMaterial;\n  si.albedoSampled = false;\n  si.mediumType = 0;\n  si.mediumExtinction = vec3f(0.0);\n  si.mediumScattering = vec3f(0.0);\n  si.mediumAnisotropy = 0.0;\n  si.barycentrics = vec2f(0.0);\n\n  // TODO not put tMax in ray. So we don't need to use pointer of ray here.\n  intersectScene(ray, &si, 0, false, false);\n  getMaterial(&ma, si.materialIndex, si.uv, si.uv1, si.instanceIndex);\n\n  if (ma.materialType == SHADOW_CATCHER) {\n    (*outAux).isShadowCatcher = true;\n    // The composed denoising input includes this receiver's shadow. Supply\n    // neutral reflectance and its shading normal, independent of visibility.\n    (*outAux).albedo = vec3f(1.0);\n    (*outAux).normal = select(si.normal, -si.normal, dot(si.normal, ray.d) > 0.0);\n    var path: Path;\n    path.ray = ray;\n    path.fromEye = true;\n    sampleShadowCatcher(si, 0, &path);\n    // RGB stores primary catcher coverage independently from the stochastic\n    // visibility in alpha. Composition uses this raw coverage to clip any\n    // shadow-mask denoising bleed at model silhouettes.\n    return vec4f(vec3f(1.0), path.alpha);\n  }\n  else {\n    if (HAS_BEVEL && rtUniform.bevel != 0) {\n      if (ma.bevel > 0.0) {\n        si.normal = getBevelNormal(si, ma.bevel);\n      }\n    }\n\n    // Store a clean first-hit fallback. Glass retains this stable guide;\n    // other delta paths may replace it at their first non-delta hit.\n    if (si.hit && (ma.materialType == STANDARD || ma.materialType == UNLIT)) {\n      (*outAux).albedo = select(ma.baseColor, vec3f(1.0), ma.transmissionWeight > 0.5);\n      (*outAux).normal = select(\n        si.normal,\n        -si.normal,\n        dot(si.normal, si.position - cameraUniform.viewInv[3].xyz) > 0.0\n      );\n\n      // Do not replace a glass guide with a randomly selected downstream\n      // refraction/reflection hit; OIDN auxiliary features must stay clean.\n      si.albedoSampled = ma.transmissionWeight > 0.5;\n    }\n\n    (*outAux).isShadowCatcher = false;\n\n    if (SPECTRAL) {\n      // Keep one source-level integrateOnePath call for both interactive\n      // preview and offline RGB splitting. A runtime loop bound prevents the\n      // WGSL compiler from cloning the full path graph three times while the\n      // uniform still selects the exact existing preview/offline behavior.\n      let rgbWaveLengths = array<f32, 3>(650.0, 510.0, 475.0);\n      var colAccum = vec3f(0.0);\n      var alpha = 0.0;\n      var accumulatedGuideAlbedo = vec3f(0.0);\n      var accumulatedGuideNormal = vec3f(0.0);\n      var allBlank = true;\n      var si2 = si;\n      var ma2 = ma;\n      let wavelengthRngState = s0;\n      let wavelengthHashedCounter = hashedCounter;\n      let singleWavelength = rtUniform.dispersionWavelengths == 1;\n      let dispersivePrimary = si.hit &&\n        ma.transmissionWeight > 0.001 &&\n        ma.transmissionDispersionScale > 0.001;\n      let wavelengthCount = select(3, 1, singleWavelength);\n      var heroWavelengthIndex = 0;\n      if (singleWavelength && dispersivePrimary) {\n        // Stochastic hero wavelength: one RGB channel per pixel keeps the\n        // preview spectral at one-third of the full three-path cost.\n        heroWavelengthIndex = min(i32(floor(sample1D(CAMERA_WAVELENGTH) * 3.0)), 2);\n      }\n      for (var i = 0; i < wavelengthCount; i++) {\n        // Common random numbers keep Monte Carlo error correlated between\n        // RGB wavelengths. This removes much of the colored variance that\n        // otherwise turns into dirty chromatic patches after OIDN.\n        if (!singleWavelength) {\n          s0 = wavelengthRngState;\n          hashedCounter = wavelengthHashedCounter;\n          samplingBounce = 0u;\n        }\n        si.wavelength = 0.0;\n        if (!singleWavelength || dispersivePrimary) {\n          si.wavelength = rgbWaveLengths[select(i, heroWavelengthIndex, singleWavelength)];\n          ma.specularIor = sampling_cauchy_ior(\n            si.wavelength,\n            ma.specularIor,\n            ma.transmissionDispersionScale,\n            ma.dispersionAbbeNumber\n          );\n        }\n        var wavelengthAux: RayTraceAuxiliary;\n        if (singleWavelength) {\n          wavelengthAux = *outAux;\n        } else {\n          wavelengthAux.albedo = (*outAux).albedo;\n          wavelengthAux.normal = (*outAux).normal;\n          wavelengthAux.isBlank = false;\n          wavelengthAux.isShadowCatcher = false;\n        }\n        let res = integrateOnePath(uv, &si, ray, &ma, &wavelengthAux);\n        if (singleWavelength) {\n          *outAux = wavelengthAux;\n          let scale = select(1.0, 3.0, dispersivePrimary);\n          return vec4f(res.rgb * scale, res.a);\n        }\n        colAccum += res.rgb;\n        alpha = max(alpha, res.a);\n        accumulatedGuideAlbedo += wavelengthAux.albedo;\n        accumulatedGuideNormal += wavelengthAux.normal;\n        allBlank = allBlank && wavelengthAux.isBlank;\n        si = si2;\n        ma = ma2;\n      }\n      (*outAux).albedo = accumulatedGuideAlbedo / 3.0;\n      (*outAux).normal = accumulatedGuideNormal / 3.0;\n      (*outAux).isBlank = allBlank;\n      return vec4f(colAccum, alpha);\n    }\n    else {\n      return integrateOnePath(uv, &si, ray, &ma, outAux);\n    }\n  }\n}\n\nfn sampleCircle(ip: vec2f) -> vec2f {\n  let p = 2.0 * ip - 1.0;\n  let greater = abs(p.x) > abs(p.y);\n  let r = select(p.y, p.x, greater);\n  let theta = select(PI * (0.5 - 0.25 * p.x / p.y), 0.25 * PI * p.y / p.x, greater);\n  return r * vec2f(cos(theta), sin(theta));\n}\n\n\n@compute @workgroup_size(${WORKGROUP_SIZE}, ${WORKGROUP_SIZE}, 1)\nfn main(@builtin(global_invocation_id) globalId: vec3u) {\n  let outputSize = rtUniform.outputSize;\n  let scaleOffset = rtUniform.scaleOffset;\n  var jitter = rtUniform.jitter;\n  // TODO if outputSize is not multiple of 8?\n  let coord = globalId.xy * vec2u(scaleOffset.xy) + vec2u(scaleOffset.zw);\n  if (coord.x >= u32(outputSize.x) || coord.y >= u32(outputSize.y)) {\n    return;\n  }\n  let idx = coord.x + coord.y * u32(outputSize.x);\n\n  if (\n    rtUniform.adaptiveSampling != 0 &&\n    outNormal[idx].a >= textureLoad(\n      adaptiveSampleTargets,\n      vec2i(coord),\n      0\n    ).r\n  ) {\n    return;\n  }\n\n  // Match WebGL's rasterized v_Texcoord, whose sample is at the center of\n  // each pixel. Keeping the same origin is material relevant: a half-pixel\n  // shift moves a narrow metal highlight across several pixels.\n  let uv = (vec2<f32>(f32(coord.x), f32(coord.y)) + vec2f(0.5)) / outputSize;\n\n  samplingPixel = coord;\n  pixelSampleIndex = u32(outNormal[idx].a) + rtUniform.sampleSequenceOffset;\n  samplingBounce = 0u; hashedCounter = 0u;\n  if (SAMPLING_PATTERN == 0 || SAMPLING_PATTERN == 1) {\n    jitter = (sample2D(CAMERA_PIXEL) - 0.5) / outputSize;\n  }\n  rng_initialize(coord, i32(pixelSampleIndex ^ sampleHash(rtUniform.sequenceSeed)));\n  var cam = initCameraRay(uv + jitter);\n\n  if (cameraUniform.apertureRadius > 0.0) {\n    // Thin lens: the focus plane is perpendicular to the view direction.\n    let eye = cameraUniform.viewInv[3].xyz;\n    let forward = -normalize(cameraUniform.viewInv[2].xyz);\n    let focusPoint = eye + cam.d * (cameraUniform.focusDistance / dot(cam.d, forward));\n    let lensPoint = cameraUniform.apertureRadius * sampleCircle(sample2D(CAMERA_LENS));\n    let origin = (cameraUniform.viewInv * vec4f(lensPoint, 0.0, 1.0)).xyz;\n    let dir = normalize(focusPoint - origin);\n    initRay(&cam, origin, dir);\n  }\n\n  var outAux: RayTraceAuxiliary;\n  outAux.albedo = vec3f(0.0);\n  outAux.normal = vec3f(0.0);\n  outAux.isBlank = false;\n  outAux.isShadowCatcher = false;\n  var liAndAlpha = integrator(uv + jitter, cam, &outAux);\n\n  // Clamp at Integration Level to reduce fireflies.\n  // TODO Path level configuration?\n  if (rtUniform.clamping > 0.0) {\n    let clamping = rtUniform.clamping;\n    liAndAlpha = vec4(clamp(liAndAlpha.rgb, -vec3f(clamping), vec3f(clamping)), liAndAlpha.a);\n  }\n  if (!(liAndAlpha.x < INF && liAndAlpha.x > -EPS)) {\n    liAndAlpha = vec4f(0.0, 0.0, 0.0, 1.0);\n  }\n\n  if (outAux.isShadowCatcher) {\n    // The catcher is invisible, so the main color at this pixel must still\n    // contain whatever the camera ray would have seen behind it.\n    let backgroundSample = sampleSceneBackground(cam);\n    let backgroundHit = select(0.0, 1.0, backgroundSample.a >= 0.01);\n    let backgroundPremultiplied = vec4f(backgroundSample.rgb * backgroundSample.a, backgroundSample.a);\n    // Keep the background contribution separate from geometry at silhouettes.\n    // mask: catcher coverage, background alpha, background hits, shadow opacity.\n    outShadowCatcher[idx].mask += vec4f(1.0, backgroundSample.a, backgroundHit, liAndAlpha.a);\n    outShadowCatcher[idx].background += backgroundPremultiplied;\n    outColor[idx] += backgroundPremultiplied;\n    outAlbedo[idx] += vec4f(outAux.albedo, backgroundHit);\n    accumulateNormalOrVariance(idx, backgroundSample.rgb, outAux.normal);\n    // The composed catcher is the background darkened by the shadow. Over a\n    // transparent background the shadow is only its opacity.\n    let visibility = 1.0 - liAndAlpha.a;\n    accumulateDenoiseMoments(idx, visibility * select(\n      1.0, dot(backgroundSample.rgb, luminance), backgroundSample.a >= 0.01\n    ));\n  }\n  else {\n    outColor[idx] += liAndAlpha;\n    outAlbedo[idx] += vec4f(outAux.albedo, select(1.0, 0.0, outAux.isBlank));\n    accumulateNormalOrVariance(idx, liAndAlpha.rgb, outAux.normal);\n    accumulateDenoiseMoments(idx, dot(liAndAlpha.rgb, luminance));\n  }\n}\n`;\n  // The query entry point shares the exact BVH and material implementation.\n  // It has no effect on the beauty entry point or its bindings.\n  // Gate optional material layers on scene-level feature flags so drivers can\n  // skip the unused BSDF lobes.\n  let specializedSource = source + depthQueryWGSL;\n  const backgroundBits: Record<string, number> = {\n    USE_BACKGROUND: 1,\n    USE_BACKGROUND_MAP: 2,\n    USE_GROUNDED_BACKGROUND: 4\n  };\n  specializedSource = specializedSource.replace(\n    /\\b(?:USE_BACKGROUND|USE_BACKGROUND_MAP|USE_GROUNDED_BACKGROUND)\\b/g,\n    (name) => `((rtUniform.backgroundFlags & ${backgroundBits[name]}) != 0)`\n  );\n  specializedSource = specializedSource.replace(\n    new RegExp(`\\\\b(?:${Object.keys(WGPU_SCENE_FEATURE_BITS).join('|')})\\\\b`, 'g'),\n    name => `((rtUniform.sceneFeatureFlags & ${WGPU_SCENE_FEATURE_BITS[name]}u) != 0u)`\n  );\n  return specializedSource;\n}\n"]}
+{"version":3,"file":"rayTrace.compute.js","sourceRoot":"","sources":["../../../src/renderer/wgsl/rayTrace.compute.ts"],"names":[],"mappings":"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","sourcesContent":["import { MAX_PATH_EVENTS } from '../pathLimits.js';\nimport shadowCatcherAccumulationWGSL from './chunks/shadowCatcherAccumulation.wgsl.js';\nimport depthQueryWGSL from './depthQuery.wgsl.js';\n// 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\nimport commonWgsl from './chunks/common.wgsl.js';\nimport { WGPU_SCENE_FEATURE_BITS } from '../WGPUSceneFeatures.js';\nimport rayTraceCoreWgsl from './chunks/rayTraceCore.wgsl.js';\nimport { createMaterialBufferWgsl } from './chunks/materialBuffer.wgsl.js';\nimport createIntersectionWgsl from './chunks/intersect.wgsl.js';\nimport randomWgsl from './chunks/random.wgsl.js';\nimport randWgsl from './chunks/rand.wgsl.js';\nimport { createSampleMaterialWgsl } from './chunks/sampleMaterial.wgsl.js';\nimport sampleLightWgsl from './chunks/sampleLight.wgsl.js';\nimport { createOpenPbrBsdfWgsl } from './chunks/openPbrBsdf.wgsl.js';\nimport samplingWgsl from './chunks/sampling.wgsl.js';\nimport sampleShadowCatcherWgsl from './chunks/sampleShadowCatcher.wgsl.js';\nimport envMapWgsl from './chunks/envMap.wgsl.js';\nimport uvProjectionWgsl from './chunks/uvProjection.wgsl.js';\nexport const WORKGROUP_SIZE = 8;\n\nexport interface RayTraceShaderOptions {\n  hasDisplacement: boolean;\n  /** Include direction frames only when used, preserving the legacy shader arithmetic otherwise. */\n  hasAnisotropyDirections?: boolean;\n  /** Include independent coat normals only when a material uses that slot. */\n  hasCoatNormals?: boolean;\n  /** Split glTF BLEND primary hits deterministically instead of stochastically. */\n  hasAlpha?: boolean;\n  /** Any scene material uses alpha mask or blend. */\n  hasSceneAlpha?: boolean;\n  /** Bit mask of the BLAS layouts present in the scene (bvh2, bvh4, bvh-gpu, cwbvh). */\n  blasLayoutMask?: number;\n}\n\n/** Generates the WebGPU megakernel path tracing compute shader. */\nexport default function rayTraceCompute({\n  hasDisplacement,\n  hasAnisotropyDirections = false,\n  hasCoatNormals = false,\n  hasAlpha = true,\n  hasSceneAlpha = true,\n  blasLayoutMask = 1\n}: RayTraceShaderOptions) {\n  hasAnisotropyDirections ||= hasCoatNormals;\n  const deterministicPrimaryAlpha = hasAlpha;\n  const source = /* wgsl */ `\n\n${commonWgsl}\n\n${rayTraceCoreWgsl({ hasSceneAlpha, hasAnisotropyDirections, hasCoatNormals })}\n\n${uvProjectionWgsl}\n\n${createMaterialBufferWgsl({ hasSceneAlpha, hasAnisotropyDirections, hasCoatNormals })}\n\n${createIntersectionWgsl({ hasDisplacement, blasLayoutMask, hasAnisotropyDirections, hasCoatNormals })}\n${randWgsl}\n${randomWgsl}\n${envMapWgsl}\n\n${samplingWgsl}\n${createOpenPbrBsdfWgsl(hasAnisotropyDirections, hasCoatNormals)}\n${sampleLightWgsl}\n\n// Index of the path vertex currently being shaded.\nvar<private> bounceIndex: u32 = 0u;\n\n// Number of light candidates resampled for each NEE estimate. Interactive\n// preview caps the budget at two.\nfn neeCandidateCount() -> u32 {\n  return u32(max(rtUniform.directLightCandidates, 1));\n}\n\n// Hash-based random number used to select among light candidates. It is\n// independent of the path sample stream so the candidate count does not\n// change the dimensions consumed by later bounces.\nfn lightCandidateRandom(salt: u32) -> f32 {\n  // Reservoir replacement needs the full [0, 1) interval: sample1D's EPS\n  // remapping makes small positive replacement probabilities unreachable.\n  // Preserve the legacy sequential RNG draw in the random sampling mode so\n  // subsequent path samples retain their stream; selection uses the hash.\n  if (SAMPLING_PATTERN == 2) { _ = rand(); }\n  let pixelID = samplingPixel.x + samplingPixel.y * u32(rtUniform.outputSize.x);\n  let key = sampleSeed(sampleSeed(pixelID, pixelSampleIndex), rtUniform.sequenceSeed);\n  let dimension = sampleSeed(samplingBounce, salt) ^ 0xa511e9b3u;\n  return f32(sampleHash(key ^ dimension) >> 8u) * (1.0 / 16777216.0);\n}\n\n// MIS weight of a light-sampled contribution. With several resampled\n// candidates the NEE technique is drawn neeCandidateCount() times.\nfn neeMISWeight(lightPdf: f32, scatteringPdf: f32) -> f32 {\n  let candidateCount = neeCandidateCount();\n  if (candidateCount <= 1u) {\n    return sampling_power_heuristic(lightPdf, scatteringPdf);\n  }\n  let weightedLightPdf = f32(candidateCount) * lightPdf;\n  return weightedLightPdf /\n    max(weightedLightPdf + scatteringPdf, 1e-20);\n}\n\n// MIS weight of a BSDF-sampled ray that hits a light.\nfn bsdfMISWeight(scatteringPdf: f32, lightPdf: f32) -> f32 {\n  let candidateCount = neeCandidateCount();\n  if (candidateCount <= 1u) {\n    return sampling_power_heuristic(scatteringPdf, lightPdf);\n  }\n  let weightedLightPdf = f32(candidateCount) * lightPdf;\n  return scatteringPdf /\n    max(scatteringPdf + weightedLightPdf, 1e-20);\n}\n\n${createSampleMaterialWgsl(hasAnisotropyDirections, hasCoatNormals)}\n${sampleShadowCatcherWgsl}\n\n// Output\n@group(3) @binding(0) var<storage, read_write> outColor: array<vec4f>;\n@group(3) @binding(1) var<storage, read_write> outNormal: array<vec4f>;\n@group(3) @binding(2) var<storage, read_write> outAlbedo: array<vec4f>;\n\n${shadowCatcherAccumulationWGSL}\n@group(3) @binding(3) var<storage, read_write> outShadowCatcher: array<ShadowCatcherAccumulation>;\n\n\nfn accumulateNormalOrVariance(\n  pixelIndex: u32,\n  radiance: vec3f,\n  normal: vec3f\n) {\n  if (rtUniform.varianceMoments != 0) {\n    let value = dot(radiance, luminance);\n    outNormal[pixelIndex] += vec4f(value * value, 0.0, 0.0, 1.0);\n  }\n  else {\n    outNormal[pixelIndex] += vec4f(normal, 1.0);\n  }\n}\n\n// Moments of the per-sample value the built-in denoiser compares, used to\n// estimate the variance of each pixel's mean.\nfn accumulateDenoiseMoments(pixelIndex: u32, value: f32) {\n  outShadowCatcher[pixelIndex].moments += vec4f(value, value * value, 0.0, 0.0);\n}\n\n\nstruct RayTraceAuxiliary {\n  // Denoising guides and auxiliary pixel classification.\n  albedo: vec3f,\n  isShadowCatcher: bool,\n  normal: vec3f,\n  isBlank: bool,\n}\n\nfn groundedSurfaceDistance(point: vec3f, height: f32, radius: f32) -> f32 {\n  let pointLength = length(point);\n  if (pointLength < 0.00001) {\n    return -radius;\n  }\n\n  let originalY = radius * point.y / pointLength;\n  let transitionY = -1.5 * height;\n  var surfaceRadius: f32;\n  if (originalY >= 0.0) {\n    surfaceRadius = radius;\n  }\n  else if (originalY < transitionY) {\n    surfaceRadius = -height * pointLength / point.y;\n  }\n  else {\n    let factor = 1.0\n      - originalY * originalY / (3.0 * transitionY * transitionY);\n    surfaceRadius = radius * factor;\n  }\n  return pointLength - surfaceRadius;\n}\n\nfn groundedBackgroundDirection(origin: vec3f, direction: vec3f) -> vec3f {\n  if (!USE_GROUNDED_BACKGROUND) {\n    return direction;\n  }\n  let params = rtUniform.groundedBackgroundParams;\n  let rayDirection = normalize(direction);\n  let center = vec3f(\n    rtUniform.groundedBackgroundCenter.x,\n    params.z + params.x,\n    rtUniform.groundedBackgroundCenter.y\n  );\n  let localOrigin = origin - center;\n  let projectedOrigin = dot(localOrigin, rayDirection);\n  let discriminant = projectedOrigin * projectedOrigin\n    - dot(localOrigin, localOrigin) + params.y * params.y;\n  if (\n    discriminant <= 0.0\n    || groundedSurfaceDistance(localOrigin, params.x, params.y) > 0.0\n  ) {\n    return direction;\n  }\n\n  var farDistance = -projectedOrigin + sqrt(discriminant);\n  if (farDistance <= 0.0) {\n    return direction;\n  }\n\n  let sphereHit = localOrigin + rayDirection * farDistance;\n  if (sphereHit.y >= 0.0) {\n    return normalize(sphereHit);\n  }\n\n  if (rayDirection.y < -0.00001 && params.y > 1.5 * params.x) {\n    let groundDistance = (-params.x - localOrigin.y) / rayDirection.y;\n    let groundHit = localOrigin + rayDirection * groundDistance;\n    let groundRadius = (2.0 / 3.0)\n      * sqrt(params.y * params.y - 2.25 * params.x * params.x);\n    if (groundDistance > 0.0 && length(groundHit.xz) <= groundRadius) {\n      return normalize(groundHit);\n    }\n  }\n\n  var nearDistance = 0.0;\n  for (var i = 0; i < 14; i++) {\n    let middleDistance = (nearDistance + farDistance) * 0.5;\n    let middlePoint = localOrigin + rayDirection * middleDistance;\n    if (groundedSurfaceDistance(middlePoint, params.x, params.y) > 0.0) {\n      farDistance = middleDistance;\n    }\n    else {\n      nearDistance = middleDistance;\n    }\n  }\n  let hit = localOrigin + rayDirection * ((nearDistance + farDistance) * 0.5);\n  return normalize(hit);\n}\n\nfn sampleSceneBackground(ray: Ray) -> vec4f {\n  var bg = vec4f(0.0);\n  if (USE_BACKGROUND_MAP) {\n    let backgroundDirection = groundedBackgroundDirection(ray.o, ray.d);\n    bg = textureLinear(backgroundMap, cartesianToEquirect(backgroundDirection));\n  }\n  else if (USE_BACKGROUND) {\n    bg = rtUniform.backgroundColor;\n  }\n  else if (USE_ENVMAP) {\n    bg = textureLinear(envMap, cartesianToEquirect(ray.d));\n  }\n  return bg;\n}\n\nfn sampleSpectralSceneBackground(ray: Ray, wavelength: f32) -> vec4f {\n  let bg = sampleSceneBackground(ray);\n  if (SPECTRAL) {\n    return vec4f(sampling_spectral_rgb_filter(bg.rgb, wavelength), bg.a);\n  }\n  return bg;\n}\n\nfn bounce(uv: vec2f, path: ptr<function, Path>, depth: ptr<function, i32>, si: ptr<function, SurfaceInteraction>, ma: ptr<function, OpenPbrResolvedMaterial>, outAux: ptr<function, RayTraceAuxiliary>) {\n  samplingBounce = u32(max(*depth, 0));\n  let matType = (*ma).materialType;\n  let isShadowCatcher = matType == SHADOW_CATCHER;\n  if (isShadowCatcher) {\n    if ((*path).fromEye) {\n      (*si).hit = false;\n    }\n    else {\n      // The catcher only contributes to the separate shadow mask. Secondary\n      // rays must see the environment behind it instead of its default white\n      // material, otherwise it appears in reflections.\n      if (USE_ENVMAP) {\n        if ((*path).isNextRefraction) {\n          // A camera-visible transmitted ray can hit the invisible catcher\n          // before the grounded skybox. Preserve the displayed projection.\n          let bg = sampleSpectralSceneBackground(\n            (*path).ray,\n            (*si).wavelength\n          );\n          let backgroundMisWeight = select(bsdfMISWeight((*path).scatteringPdf,\n            envMapPdf(cartesianToEquirect((*path).ray.d)) * rtUniform.envLightPmf),\n            1.0, (*path).scatteringIsDelta);\n          (*path).li += backgroundMisWeight * (*path).beta * bg.rgb * bg.a;\n          (*path).alpha = max((*path).alpha, bg.a);\n        }\n        else {\n          let envUv = cartesianToEquirect((*path).ray.d);\n          var emission = textureLinear(envMap, envUv).rgb;\n          if (SPECTRAL) {\n            emission = sampling_spectral_rgb_filter(emission, (*si).wavelength);\n          }\n          (*path).li += (*path).beta * emission *\n            bsdfMISWeight((*path).scatteringPdf, envMapPdf(envUv));\n        }\n      }\n      else {\n        let bg = sampleSpectralSceneBackground(\n          (*path).ray,\n          (*si).wavelength\n        );\n        (*path).li += (*path).beta * bg.rgb * bg.a;\n      }\n      (*path).abort = true;\n      return;\n    }\n  }\n  if (!(*si).hit) {\n    // The spectral integrator traces red, green, and blue paths separately.\n    // Split background radiance by wavelength as well so the three paths\n    // reconstruct the skybox instead of adding three full RGB copies.\n    let bg = sampleSpectralSceneBackground(\n      (*path).ray,\n      (*si).wavelength\n    );\n    if ((*path).fromEye) {\n      // Sample from background if first ray not hit anything.\n      (*path).li = (*path).beta * bg.rgb * bg.a;\n      (*path).alpha = bg.a;\n      // Only treat as blank pixels when the background is transparent\n      (*outAux).isBlank = bg.a < 0.001 ||\n        (USE_BACKGROUND && !USE_BACKGROUND_MAP);\n    }\n    else {\n      let cam = initCameraRay(uv);\n      let towardsCam = dot(cam.d, (*path).ray.d) > 0.0;\n      if (rtUniform.transmissiveOutputAlphaMin < 1.0) {\n        if (towardsCam) {\n          (*path).alpha = max((*path).alpha, bg.a);\n        } else {\n          (*path).alpha = 1.0;\n        }\n      }\n      if (!USE_ENVMAP) {\n        // A display background is not an illumination environment, but a\n        // visible secondary ray (e.g. through glass) still resolves it.\n        if (towardsCam) {\n          // This is a terminal BSDF-hit contribution, not a replacement for\n          // NEE accumulated at earlier vertices on the same path.\n          (*path).li += (*path).beta *\n            bsdfMISWeight((*path).scatteringPdf, 1.0) * bg.rgb;\n        }\n      }\n    }\n    (*path).abort = true;\n    return;\n  }\n\n  var sampleIgnored = false;\n  if ((matType == STANDARD || matType == UNLIT)) {\n    let alpha = clamp((*ma).alpha, 0.0, 1.0);\n    \n    if (alpha < 1.0) {\n      // Alpha is stochastic coverage. Keep accepted surface radiance at full\n      // weight instead of multiplying it by alpha a second time.\n      if (alpha <= 0.0 || hashedSample(3u) > alpha) {\n        sampleIgnored = true;\n      }\n    }\n    if (!sampleIgnored && rtUniform.transmissiveOutputAlphaMin < 1.0) {\n      // A selected stochastic coverage sample is fully covered. Ignored\n      // samples leave output alpha untouched and continue to the back layer.\n      let outputAlpha = max(1.0 - (*ma).transmissionWeight, 1.0 - pow(1.0 - rtUniform.transmissiveOutputAlphaMin, f32(*depth)));\n      (*path).alpha = max(outputAlpha, (*path).alpha);\n    }\n    if (!sampleIgnored) {\n      bounceIndex = u32(max(*depth, 0));\n      SampleMaterial(si, ma, path);\n    }\n    else {\n      // Alpha-null traversal does not consume the receiver event. The first\n      // accepted surface behind it is still the receiver for NEE/AOVs.\n      (*path).ray.o = (*si).position + (*path).ray.d * EPS;\n    }\n  }\n\n  if (!(*si).albedoSampled && !sampleIgnored) {\n    // Select denoising guides.\n    if ((matType == STANDARD || matType == UNLIT)) {\n      if (!((*ma).transmissionWeight > 0.5 ||\n        ((*ma).specularRoughness <= 0.02 && (*ma).baseMetalness > 0.98))) {\n        (*outAux).albedo = (*ma).baseColor;\n        (*outAux).normal = select(\n          (*si).normal,\n          -(*si).normal,\n          dot(\n            (*si).normal,\n            (*si).position - cameraUniform.viewInv[3].xyz\n          ) > 0.0\n        );\n        (*si).albedoSampled = true;\n      }\n      // TODO pick albedo and normal on the surface if ray is too deep and can't hit any rough or opaque surfaces.\n      if (*depth > 4) {\n        (*si).albedoSampled = true;\n      }\n    }\n  }\n\n  // Russian roulette with throughput compensation.\n  if (USE_RR) {\n    if (*depth >= RR_MAX && !sampleIgnored) {\n      let rouletteBeta = (*path).beta;\n      // Max-component survival (pbrt-v4) avoids over-amplifying saturated paths.\n      let maxComponent = max(max(rouletteBeta.x, rouletteBeta.y), rouletteBeta.z);\n      let q: f32 = max(0.0, 1.0 - maxComponent);\n      if (sample1D(bounceDim(RUSSIAN_ROULETTE)) < q) {\n        // TODO we force use alpha 1.0 here.\n        // To avoid the glass pixels is transparent even if it's on an opaque object.\n        (*path).alpha = 1.0;\n        (*path).abort = true;\n      }\n      else {\n        (*path).beta /= 1.0 - q;\n      }\n    }\n  }\n  if ((*path).abort) {\n    return;\n  }\n\n  intersectScene((*path).ray, si, *depth, true, (*path).isNextRefraction);\n  getMaterial(ma, (*si).materialIndex, (*si).uv, (*si).uv1, (*si).instanceIndex);\n\n  if (SPECTRAL) {\n    // Is glass\n    if ((*ma).transmissionWeight > 0.001) {\n      (*ma).specularIor = sampling_cauchy_ior(\n        (*si).wavelength,\n        (*ma).specularIor,\n        (*ma).transmissionDispersionScale,\n        (*ma).dispersionAbbeNumber\n      );\n    }\n  }\n\n  if (sampleIgnored) {\n    return;\n  }\n\n  // Use light if hit the light\n  var lightSample: LightSampleRec;\n  let isAlphaOccluded = hashedSample(3u) < (*ma).alpha;\n  for (var i = 0; i < rtUniform.lightsCount; i++) {\n    // Fetch light Data\n    let light: Light = analyticLights[i];\n    let d = intersectLight((*path).ray, light, &lightSample);\n    lightSample.pdf *= light.selectionPmf;\n    let occluded = (*si).hit && d > distance((*si).position, (*path).ray.o);\n    if (d != INF && !(occluded && isAlphaOccluded)) {\n      let misWeight = bsdfMISWeight((*path).scatteringPdf, lightSample.pdf);\n      if (SPECTRAL) {\n        lightSample.emission = sampling_spectral_rgb_filter(lightSample.emission, (*si).wavelength);\n      }\n      (*path).li += misWeight * (*path).beta * lightSample.emission;\n      (*path).alpha = 1.0;\n      (*path).abort = true;\n    }\n  }\n\n  if (USE_ENVMAP) {\n    if (!((*si).hit && isAlphaOccluded)) {\n      if ((*path).isNextRefraction) {\n        // Camera-visible transmission follows the displayed background,\n        // including grounded projection. Other rays use the raw environment\n        // map as the physically sampled lighting source.\n        let bg = sampleSpectralSceneBackground(\n          (*path).ray,\n          (*si).wavelength\n        );\n        let backgroundMisWeight = select(bsdfMISWeight((*path).scatteringPdf,\n            envMapPdf(cartesianToEquirect((*path).ray.d)) * rtUniform.envLightPmf),\n            1.0, (*path).scatteringIsDelta);\n          (*path).li += backgroundMisWeight * (*path).beta * bg.rgb * bg.a;\n        (*path).alpha = max((*path).alpha, bg.a);\n        (*path).abort = true;\n        return;\n      }\n      let _uv = cartesianToEquirect((*path).ray.d);\n      var emission = textureLinear(envMap, _uv).rgb;\n      let misWeight = bsdfMISWeight(\n        (*path).scatteringPdf,\n        envMapPdf(_uv) * rtUniform.envLightPmf\n      );\n      if (SPECTRAL) {\n        emission = sampling_spectral_rgb_filter(emission, (*si).wavelength);\n      }\n      // TODO force the min alpha to be 1 when showing envmap as background\n      if (!USE_BACKGROUND) {\n        (*path).alpha = 1.0;\n      }\n      (*path).li += (*path).beta * emission * misWeight;\n      (*path).abort = true;\n    }\n  }\n\n  *depth = *depth + 1;\n}\n\nfn initCameraRay(coord: vec2f) -> Ray {\n  let origin = cameraUniform.viewProjectionInv * vec4f(coord * 2.0 - 1.0, -1.0, 1.0);\n  let center = cameraUniform.viewProjectionInv * vec4f(coord * 2.0 - 1.0, 1.0, 1.0);\n  var cam: Ray;\n  initRay(&cam, origin.xyz / origin.w, normalize(center.xyz * origin.w - origin.xyz * center.w));\n\n  return cam;\n}\n\n\nfn bevelCubicSample(radius: f32, xi: f32) -> vec2f {\n  var x = 0.25;\n  for (var iteration = 0; iteration < 10; iteration++) {\n    let x2 = x * x;\n    let x3 = x2 * x;\n    let oneMinusX = 1.0 - x;\n    let value = 10.0 * x2 - 20.0 * x3 + 15.0 * x2 * x2 -\n      4.0 * x2 * x3 - xi;\n    let derivative = 20.0 * x * oneMinusX * oneMinusX * oneMinusX;\n    if (abs(value) < 1e-6 || derivative == 0.0) { break; }\n    x = clamp(x - value / derivative, 0.0, 1.0);\n  }\n  let diskRadius = x * radius;\n  return vec2f(diskRadius, sqrt(max(radius * radius - diskRadius * diskRadius, 0.0)));\n}\n\nfn bevelCubicPdf(radius: f32, distanceToSource: f32) -> f32 {\n  if (distanceToSource >= radius) { return 0.0; }\n  let falloff = radius - distanceToSource;\n  return falloff * falloff * falloff;\n}\n\n// Shader bevel. Usage: docs/materials.md (Renderer extensions)\nfn getBevelNormal(source: SurfaceInteraction, radius: f32) -> vec3f {\n  var geometricNormal = source.faceNormal;\n  if (dot(geometricNormal, source.vertexNormal) < 0.0) {\n    geometricNormal = -geometricNormal;\n  }\n  var tangent: vec3f;\n  var bitangent: vec3f;\n  sampling_orthonormal_basis(geometricNormal, &tangent, &bitangent);\n  var normalSum = vec3f(0.0);\n\n  for (var sampleIndex = 0; sampleIndex < BEVEL_SAMPLES; sampleIndex++) {\n    let bevelRnd = sample2D(CAMERA_BEVEL_BASE + u32(sampleIndex));\n    var axisSample = bevelRnd.x;\n    let radialSample = bevelRnd.y;\n    var diskNormal = geometricNormal;\n    var diskTangent = tangent;\n    var diskBitangent = bitangent;\n    var pickPdfNormal = 0.5;\n    var pickPdfTangent = 0.25;\n    var pickPdfBitangent = 0.25;\n    if (axisSample < 0.5) {\n      axisSample *= 2.0;\n    }\n    else if (axisSample < 0.75) {\n      let swapAxis = diskNormal;\n      diskNormal = diskTangent;\n      diskTangent = swapAxis;\n      pickPdfNormal = 0.25;\n      pickPdfTangent = 0.5;\n      axisSample = (axisSample - 0.5) * 4.0;\n    }\n    else {\n      let swapAxis = diskNormal;\n      diskNormal = diskBitangent;\n      diskBitangent = swapAxis;\n      pickPdfNormal = 0.25;\n      pickPdfBitangent = 0.5;\n      axisSample = (axisSample - 0.75) * 4.0;\n    }\n\n    let diskSample = bevelCubicSample(radius, radialSample);\n    let phi = TWOPI * axisSample;\n    let diskOffset = diskSample.x *\n      (cos(phi) * diskTangent + sin(phi) * diskBitangent);\n    var ray: Ray;\n    initRay(\n      &ray,\n      source.position + diskNormal * diskSample.y + diskOffset,\n      -diskNormal\n    );\n    var hit: SurfaceInteraction;\n    intersectSceneBevel(\n      ray,\n      &hit,\n      source.instanceIndex,\n      max(2.0 * diskSample.y, EPS)\n    );\n    if (!hit.hit) { continue; }\n\n    let pdfNormal = pickPdfNormal * abs(dot(diskNormal, hit.faceNormal));\n    let pdfTangent = pickPdfTangent * abs(dot(diskTangent, hit.faceNormal));\n    let pdfBitangent = pickPdfBitangent * abs(dot(diskBitangent, hit.faceNormal));\n    var weight = pdfNormal / max(\n      pdfNormal * pdfNormal + pdfTangent * pdfTangent +\n        pdfBitangent * pdfBitangent,\n      1e-8\n    );\n    weight *= bevelCubicPdf(radius, distance(hit.position, source.position)) /\n      max(bevelCubicPdf(radius, diskSample.x), 1e-8);\n    normalSum += weight * hit.vertexNormal;\n  }\n\n  if (dot(normalSum, normalSum) <= 1e-12) { return source.normal; }\n  let bevelVertexNormal = normalize(normalSum);\n  let result = source.normal + bevelVertexNormal - source.vertexNormal;\n  if (dot(result, result) > 1e-12) { return normalize(result); }\n  return source.normal;\n}\n\nfn integrateOnePathSample(uv: vec2f, si: ptr<function, SurfaceInteraction>, ray: Ray, ma: ptr<function, OpenPbrResolvedMaterial>, outAux: ptr<function, RayTraceAuxiliary>) -> vec4f {\n  var path: Path;\n  path.ray = ray;\n  path.li = vec3f(0.0);\n  path.alpha = select(1.0, 0.0, rtUniform.transmissiveOutputAlphaMin < 1.0);\n  path.beta = vec3f(1.0);\n  path.fromEye = true;\n  path.scatteringPdf = 0.0;\n  path.scatteringIsDelta = false;\n  path.isNextRefraction = false;\n  path.abort = false;\n\n  let isNotTransparent = (*ma).transmissionWeight < 0.001 && (*ma).subsurfaceWeight < 0.001 && (*ma).alpha > 0.99;\n  let bounceLimit = max(rtUniform.bounces, 0);\n  var depth = 0;\n  // Transparent paths may take up to three times the configured bounces.\n  for (var idx: i32 = 0; idx < min(bounceLimit * 3, ${MAX_PATH_EVENTS}); idx = idx + 1) {\n    if (isNotTransparent && idx > bounceLimit) {\n      path.abort = true;\n    }\n    if (path.abort) {\n      break;\n    }\n    bounce(uv, &path, &depth, si, ma, outAux);\n  }\n\n  return vec4f(path.li, path.alpha);\n}\n\nfn integrateOnePath(uv: vec2f, si: ptr<function, SurfaceInteraction>, ray: Ray, ma: ptr<function, OpenPbrResolvedMaterial>, outAux: ptr<function, RayTraceAuxiliary>) -> vec4f {\n  ${deterministicPrimaryAlpha ? /* wgsl */ `let coverage = clamp((*ma).alpha, 0.0, 1.0);\n  if (!(*si).hit || ((*ma).materialType != STANDARD && (*ma).materialType != UNLIT) || coverage >= 1.0) {\n    return integrateOnePathSample(uv, si, ray, ma, outAux);\n  }\n\n  // glTF BLEND is source-over opacity, not a physical glass boundary. Split\n  // the primary ray so reflected radiance is attenuated by alpha every sample\n  // while the complementary branch continues straight to the scene behind it.\n  // Secondary alpha hits remain stochastic to avoid exponential path growth.\n  var backRay = ray;\n  backRay.o = (*si).position + ray.d * (EPS * 0.02);\n  var backSi = *si;\n  backSi.albedoSampled = false;\n  intersectScene(backRay, &backSi, 0, false, false);\n  var backMa: OpenPbrResolvedMaterial;\n  getMaterial(&backMa, backSi.materialIndex, backSi.uv, backSi.uv1, backSi.instanceIndex);\n  var backAux = *outAux;\n  if (backSi.hit && backMa.materialType == STANDARD) {\n    backAux.albedo = select(\n      backMa.baseColor,\n      vec3f(1.0),\n      backMa.transmissionWeight > 0.5\n    );\n    backAux.normal = select(\n      backSi.normal,\n      -backSi.normal,\n      dot(\n        backSi.normal,\n        backSi.position - cameraUniform.viewInv[3].xyz\n      ) > 0.0\n    );\n    backSi.albedoSampled = backMa.transmissionWeight > 0.5;\n  }\n  let back = integrateOnePathSample(\n    uv, &backSi, backRay, &backMa, &backAux\n  );\n  if (coverage <= 0.0) {\n    *outAux = backAux;\n    return back;\n  }\n\n  var frontSi = *si;\n  var frontMa = *ma;\n  frontMa.alpha = 1.0;\n  var frontAux = *outAux;\n  let front = integrateOnePathSample(\n    uv, &frontSi, ray, &frontMa, &frontAux\n  );\n  (*outAux).albedo = mix(backAux.albedo, frontAux.albedo, coverage);\n  let blendedNormal = mix(backAux.normal, frontAux.normal, coverage);\n  (*outAux).normal = select(\n    vec3f(0.0),\n    normalize(blendedNormal),\n    dot(blendedNormal, blendedNormal) > 1e-12\n  );\n  (*outAux).isBlank = backAux.isBlank && frontAux.isBlank;\n  (*outAux).isShadowCatcher = backAux.isShadowCatcher && frontAux.isShadowCatcher;\n  return mix(back, front, coverage);` : /* wgsl */ `return integrateOnePathSample(uv, si, ray, ma, outAux);`}\n}\n\n// Path tracing integrator as described in\n// http://www.pbr-book.org/3ed-2018/Light_Transport_I_Surface_Reflection/Path_Tracing.html#\nfn integrator(uv: vec2f, ray: Ray, outAux: ptr<function, RayTraceAuxiliary>) -> vec4f {\n  var si: SurfaceInteraction;\n  var ma: OpenPbrResolvedMaterial;\n  si.albedoSampled = false;\n  si.mediumType = 0;\n  si.mediumExtinction = vec3f(0.0);\n  si.mediumScattering = vec3f(0.0);\n  si.mediumAnisotropy = 0.0;\n  si.barycentrics = vec2f(0.0);\n\n  // TODO not put tMax in ray. So we don't need to use pointer of ray here.\n  intersectScene(ray, &si, 0, false, false);\n  getMaterial(&ma, si.materialIndex, si.uv, si.uv1, si.instanceIndex);\n\n  if (si.hit && ma.materialType == SHADOW_CATCHER) {\n    (*outAux).isShadowCatcher = true;\n    // The composed denoising input includes this receiver's shadow. Supply\n    // neutral reflectance and its shading normal, independent of visibility.\n    (*outAux).albedo = vec3f(1.0);\n    (*outAux).normal = select(si.normal, -si.normal, dot(si.normal, ray.d) > 0.0);\n    var path: Path;\n    path.ray = ray;\n    path.fromEye = true;\n    sampleShadowCatcher(si, 0, &path);\n    // RGB stores primary catcher coverage independently from the stochastic\n    // visibility in alpha. Composition uses this raw coverage to clip any\n    // shadow-mask denoising bleed at model silhouettes.\n    return vec4f(vec3f(1.0), path.alpha);\n  }\n  else {\n    if (HAS_BEVEL && rtUniform.bevel != 0) {\n      if (ma.bevel > 0.0) {\n        si.normal = getBevelNormal(si, ma.bevel);\n      }\n    }\n\n    // Store a clean first-hit fallback. Glass retains this stable guide;\n    // other delta paths may replace it at their first non-delta hit.\n    if (si.hit && (ma.materialType == STANDARD || ma.materialType == UNLIT)) {\n      (*outAux).albedo = select(ma.baseColor, vec3f(1.0), ma.transmissionWeight > 0.5);\n      (*outAux).normal = select(\n        si.normal,\n        -si.normal,\n        dot(si.normal, si.position - cameraUniform.viewInv[3].xyz) > 0.0\n      );\n\n      // Do not replace a glass guide with a randomly selected downstream\n      // refraction/reflection hit; OIDN auxiliary features must stay clean.\n      si.albedoSampled = ma.transmissionWeight > 0.5;\n    }\n\n    (*outAux).isShadowCatcher = false;\n\n    if (SPECTRAL) {\n      // Keep one source-level integrateOnePath call for both interactive\n      // preview and offline RGB splitting. A runtime loop bound prevents the\n      // WGSL compiler from cloning the full path graph three times while the\n      // uniform still selects the exact existing preview/offline behavior.\n      let rgbWaveLengths = array<f32, 3>(650.0, 510.0, 475.0);\n      var colAccum = vec3f(0.0);\n      var alpha = 0.0;\n      var accumulatedGuideAlbedo = vec3f(0.0);\n      var accumulatedGuideNormal = vec3f(0.0);\n      var allBlank = true;\n      var si2 = si;\n      var ma2 = ma;\n      let wavelengthRngState = s0;\n      let wavelengthHashedCounter = hashedCounter;\n      let singleWavelength = rtUniform.dispersionWavelengths == 1;\n      let dispersivePrimary = si.hit &&\n        ma.transmissionWeight > 0.001 &&\n        ma.transmissionDispersionScale > 0.001;\n      let wavelengthCount = select(3, 1, singleWavelength);\n      var heroWavelengthIndex = 0;\n      if (singleWavelength && dispersivePrimary) {\n        // Stochastic hero wavelength: one RGB channel per pixel keeps the\n        // preview spectral at one-third of the full three-path cost.\n        heroWavelengthIndex = min(i32(floor(sample1D(CAMERA_WAVELENGTH) * 3.0)), 2);\n      }\n      for (var i = 0; i < wavelengthCount; i++) {\n        // Common random numbers keep Monte Carlo error correlated between\n        // RGB wavelengths. This removes much of the colored variance that\n        // otherwise turns into dirty chromatic patches after OIDN.\n        if (!singleWavelength) {\n          s0 = wavelengthRngState;\n          hashedCounter = wavelengthHashedCounter;\n          samplingBounce = 0u;\n        }\n        si.wavelength = 0.0;\n        if (!singleWavelength || dispersivePrimary) {\n          si.wavelength = rgbWaveLengths[select(i, heroWavelengthIndex, singleWavelength)];\n          ma.specularIor = sampling_cauchy_ior(\n            si.wavelength,\n            ma.specularIor,\n            ma.transmissionDispersionScale,\n            ma.dispersionAbbeNumber\n          );\n        }\n        var wavelengthAux: RayTraceAuxiliary;\n        if (singleWavelength) {\n          wavelengthAux = *outAux;\n        } else {\n          wavelengthAux.albedo = (*outAux).albedo;\n          wavelengthAux.normal = (*outAux).normal;\n          wavelengthAux.isBlank = false;\n          wavelengthAux.isShadowCatcher = false;\n        }\n        let res = integrateOnePath(uv, &si, ray, &ma, &wavelengthAux);\n        if (singleWavelength) {\n          *outAux = wavelengthAux;\n          let scale = select(1.0, 3.0, dispersivePrimary);\n          return vec4f(res.rgb * scale, res.a);\n        }\n        colAccum += res.rgb;\n        alpha = max(alpha, res.a);\n        accumulatedGuideAlbedo += wavelengthAux.albedo;\n        accumulatedGuideNormal += wavelengthAux.normal;\n        allBlank = allBlank && wavelengthAux.isBlank;\n        si = si2;\n        ma = ma2;\n      }\n      (*outAux).albedo = accumulatedGuideAlbedo / 3.0;\n      (*outAux).normal = accumulatedGuideNormal / 3.0;\n      (*outAux).isBlank = allBlank;\n      return vec4f(colAccum, alpha);\n    }\n    else {\n      return integrateOnePath(uv, &si, ray, &ma, outAux);\n    }\n  }\n}\n\nfn sampleCircle(ip: vec2f) -> vec2f {\n  let p = 2.0 * ip - 1.0;\n  let greater = abs(p.x) > abs(p.y);\n  let r = select(p.y, p.x, greater);\n  let theta = select(PI * (0.5 - 0.25 * p.x / p.y), 0.25 * PI * p.y / p.x, greater);\n  return r * vec2f(cos(theta), sin(theta));\n}\n\n\n@compute @workgroup_size(${WORKGROUP_SIZE}, ${WORKGROUP_SIZE}, 1)\nfn main(@builtin(global_invocation_id) globalId: vec3u) {\n  let outputSize = rtUniform.outputSize;\n  let scaleOffset = rtUniform.scaleOffset;\n  var jitter = rtUniform.jitter;\n  // TODO if outputSize is not multiple of 8?\n  let coord = globalId.xy * vec2u(scaleOffset.xy) + vec2u(scaleOffset.zw);\n  if (coord.x >= u32(outputSize.x) || coord.y >= u32(outputSize.y)) {\n    return;\n  }\n  let idx = coord.x + coord.y * u32(outputSize.x);\n\n  if (\n    rtUniform.adaptiveSampling != 0 &&\n    outNormal[idx].a >= textureLoad(\n      adaptiveSampleTargets,\n      vec2i(coord),\n      0\n    ).r\n  ) {\n    return;\n  }\n\n  // Match WebGL's rasterized v_Texcoord, whose sample is at the center of\n  // each pixel. Keeping the same origin is material relevant: a half-pixel\n  // shift moves a narrow metal highlight across several pixels.\n  let uv = (vec2<f32>(f32(coord.x), f32(coord.y)) + vec2f(0.5)) / outputSize;\n\n  samplingPixel = coord;\n  pixelSampleIndex = u32(outNormal[idx].a) + rtUniform.sampleSequenceOffset;\n  samplingBounce = 0u; hashedCounter = 0u;\n  if (SAMPLING_PATTERN == 0 || SAMPLING_PATTERN == 1) {\n    jitter = (sample2D(CAMERA_PIXEL) - 0.5) / outputSize;\n  }\n  rng_initialize(coord, i32(pixelSampleIndex ^ sampleHash(rtUniform.sequenceSeed)));\n  var cam = initCameraRay(uv + jitter);\n\n  if (cameraUniform.apertureRadius > 0.0) {\n    // Thin lens: the focus plane is perpendicular to the view direction.\n    let eye = cameraUniform.viewInv[3].xyz;\n    let forward = -normalize(cameraUniform.viewInv[2].xyz);\n    let focusPoint = eye + cam.d * (cameraUniform.focusDistance / dot(cam.d, forward));\n    let lensPoint = cameraUniform.apertureRadius * sampleCircle(sample2D(CAMERA_LENS));\n    let origin = (cameraUniform.viewInv * vec4f(lensPoint, 0.0, 1.0)).xyz;\n    let dir = normalize(focusPoint - origin);\n    initRay(&cam, origin, dir);\n  }\n\n  var outAux: RayTraceAuxiliary;\n  outAux.albedo = vec3f(0.0);\n  outAux.normal = vec3f(0.0);\n  outAux.isBlank = false;\n  outAux.isShadowCatcher = false;\n  var liAndAlpha = integrator(uv + jitter, cam, &outAux);\n\n  // Clamp at Integration Level to reduce fireflies.\n  // TODO Path level configuration?\n  if (rtUniform.clamping > 0.0) {\n    let clamping = rtUniform.clamping;\n    liAndAlpha = vec4(clamp(liAndAlpha.rgb, -vec3f(clamping), vec3f(clamping)), liAndAlpha.a);\n  }\n  if (!(liAndAlpha.x < INF && liAndAlpha.x > -EPS)) {\n    liAndAlpha = vec4f(0.0, 0.0, 0.0, 1.0);\n  }\n\n  if (outAux.isShadowCatcher) {\n    // The catcher is invisible, so the main color at this pixel must still\n    // contain whatever the camera ray would have seen behind it.\n    let backgroundSample = sampleSceneBackground(cam);\n    let backgroundHit = select(0.0, 1.0, backgroundSample.a >= 0.01);\n    let backgroundPremultiplied = vec4f(backgroundSample.rgb * backgroundSample.a, backgroundSample.a);\n    // Keep the background contribution separate from geometry at silhouettes.\n    // mask: catcher coverage, background alpha, background hits, shadow opacity.\n    outShadowCatcher[idx].mask += vec4f(1.0, backgroundSample.a, backgroundHit, liAndAlpha.a);\n    outShadowCatcher[idx].background += backgroundPremultiplied;\n    outColor[idx] += backgroundPremultiplied;\n    outAlbedo[idx] += vec4f(outAux.albedo, backgroundHit);\n    accumulateNormalOrVariance(idx, backgroundSample.rgb, outAux.normal);\n    // The composed catcher is the background darkened by the shadow. Over a\n    // transparent background the shadow is only its opacity.\n    let visibility = 1.0 - liAndAlpha.a;\n    accumulateDenoiseMoments(idx, visibility * select(\n      1.0, dot(backgroundSample.rgb, luminance), backgroundSample.a >= 0.01\n    ));\n  }\n  else {\n    if (HAS_SHADOW_CATCHER && outAux.isBlank && USE_BACKGROUND && !USE_BACKGROUND_MAP && rtUniform.backgroundColor.a >= 0.99999) {\n      // A primary miss sees the same opaque display backdrop as a catcher\n      // hit, but must never receive its shadow. Keep that radiance and alpha\n      // out of the geometry layer before hit-count normalization/tone mapping.\n      // Red/blue still count only actual catcher hits; green counts all\n      // background alpha removed from the foreground during normalization.\n      outShadowCatcher[idx].background += liAndAlpha;\n      outShadowCatcher[idx].mask.g += liAndAlpha.a;\n    }\n    outColor[idx] += liAndAlpha;\n    outAlbedo[idx] += vec4f(outAux.albedo, select(1.0, 0.0, outAux.isBlank));\n    accumulateNormalOrVariance(idx, liAndAlpha.rgb, outAux.normal);\n    accumulateDenoiseMoments(idx, dot(liAndAlpha.rgb, luminance));\n  }\n}\n`;\n  // The query entry point shares the exact BVH and material implementation.\n  // It has no effect on the beauty entry point or its bindings.\n  // Gate optional material layers on scene-level feature flags so drivers can\n  // skip the unused BSDF lobes.\n  let specializedSource = source + depthQueryWGSL;\n  const backgroundBits: Record<string, number> = {\n    USE_BACKGROUND: 1,\n    USE_BACKGROUND_MAP: 2,\n    USE_GROUNDED_BACKGROUND: 4\n  };\n  specializedSource = specializedSource.replace(\n    /\\b(?:USE_BACKGROUND|USE_BACKGROUND_MAP|USE_GROUNDED_BACKGROUND)\\b/g,\n    (name) => `((rtUniform.backgroundFlags & ${backgroundBits[name]}) != 0)`\n  );\n  specializedSource = specializedSource.replace(\n    new RegExp(`\\\\b(?:${Object.keys(WGPU_SCENE_FEATURE_BITS).join('|')})\\\\b`, 'g'),\n    name => `((rtUniform.sceneFeatureFlags & ${WGPU_SCENE_FEATURE_BITS[name]}u) != 0u)`\n  );\n  return specializedSource;\n}\n"]}

package/lib/version.d.ts

@@ -1,2 +1,2 @@
 /** Library version. Kept in sync with package.json by a unit test. */
-export declare const VERSION = "0.1.2";
+export declare const VERSION = "0.1.3";

package/lib/version.js

@@ -1,3 +1,3 @@
 /** Library version. Kept in sync with package.json by a unit test. */
-export const VERSION = '0.1.2';
+export const VERSION = '0.1.3';
 //# sourceMappingURL=version.js.map

package/lib/version.js.map

@@ -1 +1 @@
-{"version":3,"file":"version.js","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AAAA,sEAAsE;AACtE,MAAM,CAAC,MAAM,OAAO,GAAG,OAAO,CAAC","sourcesContent":["/** Library version. Kept in sync with package.json by a unit test. */\nexport const VERSION = '0.1.2';\n"]}
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AAAA,sEAAsE;AACtE,MAAM,CAAC,MAAM,OAAO,GAAG,OAAO,CAAC","sourcesContent":["/** Library version. Kept in sync with package.json by a unit test. */\nexport const VERSION = '0.1.3';\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meimu/mutracer",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "MuTracer: a physically based WebGPU path tracer with WebGL 2 fallback, OpenPBR materials, TinyBVH and OIDN denoising.",
   "keywords": [
     "path tracing",
@@ -89,10 +89,9 @@
     "check:material-comparison": "node scripts/generate-material-comparison.mjs --check"
   },
   "dependencies": {
+    "@webgpu/types": "^0.1.40",
     "gl-matrix": "^3.4.4",
-    "oidn-web": "^0.5.0",
-    "webgpu-utils": "^1.9.3",
-    "@webgpu/types": "^0.1.40"
+    "oidn-web": "^0.5.0"
   },
   "peerDependencies": {
     "@types/three": ">=0.150.0",
@@ -112,6 +111,7 @@
     "@types/react-dom": "^18.3.7",
     "@types/three": "^0.185.4",
     "@vitejs/plugin-react": "^4.7.0",
+    "fflate": "^0.8.3",
     "lucide-react": "^1.54.0",
     "react": "^18.3.1",
     "react-aria-components": "^1.22.0",
@@ -120,6 +120,7 @@
     "typescript": "^5.8.2",
     "vite": "^4.1.2",
     "vitest": "^1.6.1",
+    "webgpu-utils": "^1.11.0",
     "wrangler": "^4.54.0",
     "zustand": "^5.0.15"
   }