@meimu/mutracer 0.3.0 → 0.3.1

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,EAAE,QAAQ,GAAG,KAAK,EAAE,oBAAoB,GAAG,EAAE,EAAC,aAAa,GAAC,KAAK;IAC9J,OAAO,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCA8BqB,QAAQ,CAAC,CAAC,CAAC,UAAU,CAAC;;;;;EAK3D,CAAC,CAAC,CAAC,EAAE;;;;;;EAML,cAAc,CAAC,CAAC,CAAC,UAAU,CAAC;0FAC4D,CAAC,CAAC,CAAC,0CAA0C;;;;;;;;;;;;;;;;;EAiBvI,cAAc,CAAC,CAAC,CAAC,UAAU,CAAC,yEAAkF,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiHnH,QAAQ,CAAA,CAAC,CAAA;;;CAGV,CAAA,CAAC,CAAA,EAAE;;;;;;;;;;;;;;;;EAgBQ,cAAc,CAAC,CAAC,CAAC,8GAA8G,CAAC,CAAC,CAAC,uBAAuB;;;;;;;;;;;;;;;;;;EAkB7J,cAAc,CAAC,CAAC,CAAC,UAAU,CAAC;yFAC2D,CAAC,CAAC,CAAC,UAAU,CAAC,0CAA0C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAuC3I,QAAQ,CAAC,CAAC,CAAC,UAAU,CAAC;wDACwB,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;EAsB7D,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+CJ,QAAQ,CAAA,CAAC,CAAA;;4CAEiD,CAAA,CAAC,CAAA,mFAAmF;;;;;;;;;;EAU9I,uBAAuB,CAAC,CAAC,CAAC,UAAU,CAAC;;;;;CAKtC,CAAC,CAAC,CAAC,UAAU,CAAC,EAAE;;;EAGf,oBAAoB,GAAG,aAAa,CAAA,CAAC,CAAA,UAAU,CAAC;CACjD,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;EAsBJ,QAAQ,CAAC,CAAC,CAAC,UAAU,CAAC;CACvB,CAAC,CAAC,CAAC,EAAE;;;;;;;EAOJ,cAAc,CAAC,CAAC,CAAC,UAAU,CAAC;;CAE7B,CAAC,CAAC,CAAC,EAAE;;;;sBAIkB,QAAQ,CAAC,CAAC,CAAC,UAAU,CAAC;yCACD,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;CAyBjD,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, caustics = false, researchContribution = '',photonMapping=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;${caustics ? /* wgsl */ `\n  if(isSurface&&isCausticSpecular(ma)){\n    var connection=*path;\n    causticAdvance(&connection,ma,dot(ffnormal,lightDir)<0.0,true);\n    if(causticHitOwned(connection,lightSample.sourceType!=0u,true)){return false;}\n  }` : ''}\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).spectralChannel);\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, (*si).instanceIndex)) {\n${caustics?`        var connection=*path;\n        if(isSurface&&isCausticSpecular(ma)){causticAdvance(&connection,ma,dot(ffnormal,selected.ray.d)<0.0,true);}\n        connection.beta=vec3f(1.0);causticHotRecord(connection,selected.contribution*candidateUCW,0u);\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 {${caustics ? /* wgsl */ `\n  if (causticHitOwned(*path, true, true)) { return 0.0; }` : ''}\n  // Secondary traversal accepts back faces for transmission; a one-sided\n  // emitter still radiates only into its front hemisphere.\n  let cosLight = dot((*si).faceNormal, -(*path).ray.d);\n  if (cosLight <= 0.0 && materialsBuffer[(*si).materialIndex].doubleSided < 0.5) { return 0.0; }\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  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${caustics?`    let emissionWeight=emissiveHitMisWeight(si,path);\n    causticHotRecord(*path,emissionWeight*(*ma).emission,1u);causticEmitterRecord(*si,*path,emissionWeight,(*ma).emission);\n    (*path).li+=emissionWeight*(*ma).emission*(*path).beta;`:'    (*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${researchContribution}${photonMapping?/* wgsl */ `  if(!mediumSampled){let value=(*path).beta*photonContribution(*si,prepared,(*path).fromEye,!(*path).causticHasReceiver);causticEstimateRecord(value,1u);(*path).li+=value;}\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${caustics ? /* wgsl */ `    causticAdvance(path, *ma, isNextRefraction, true);\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) {${caustics ? /* wgsl */ `\n    causticAdvance(path, *ma, false, false);` : ''}\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,EAAE,QAAQ,GAAG,KAAK,EAAE,oBAAoB,GAAG,EAAE,EAAC,aAAa,GAAC,KAAK,EAAE,qBAAqB,GAAC,KAAK;IAC3L,OAAO,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCA8BqB,QAAQ,CAAC,CAAC,CAAC,UAAU,CAAC;;;;;EAK3D,CAAC,CAAC,CAAC,EAAE;;;;;;EAML,cAAc,CAAC,CAAC,CAAC,UAAU,CAAC;0FAC4D,CAAC,CAAC,CAAC,0CAA0C;;;;;;;;;;;;;;;;;EAiBvI,cAAc,CAAC,CAAC,CAAC,UAAU,CAAC,yEAAkF,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA0CrG,qBAAqB,CAAC,CAAC,CAAC,0CAA0C,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;+CAcd,qBAAqB,CAAC,CAAC,CAAC,uFAAuF,CAAC,CAAC,CAAC,WAAW;;;;;;sCAMhI,qBAAqB,CAAC,CAAC,CAAC,UAAU,CAAC;;;;;;EAMnG,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmDT,QAAQ,CAAA,CAAC,CAAA;;;CAGV,CAAA,CAAC,CAAA,EAAE;;;;;;;;;;;;;;;;EAgBQ,cAAc,CAAC,CAAC,CAAC,8GAA8G,CAAC,CAAC,CAAC,uBAAuB;;;;;;;;;;;;;;;;;;EAkB7J,cAAc,CAAC,CAAC,CAAC,UAAU,CAAC;yFAC2D,CAAC,CAAC,CAAC,UAAU,CAAC,0CAA0C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAuC3I,QAAQ,CAAC,CAAC,CAAC,UAAU,CAAC;wDACwB,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;EAsB7D,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4DJ,QAAQ,CAAA,CAAC,CAAA;;6CAEkD,CAAA,CAAC,CAAA,oFAAoF;;;;;;;;;;EAUhJ,uBAAuB,CAAC,CAAC,CAAC,UAAU,CAAC;;;;;CAKtC,CAAC,CAAC,CAAC,UAAU,CAAC,EAAE;;;EAGf,oBAAoB,GAAG,aAAa,CAAA,CAAC,CAAA,UAAU,CAAC;CACjD,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;EAsBJ,QAAQ,CAAC,CAAC,CAAC,UAAU,CAAC;CACvB,CAAC,CAAC,CAAC,EAAE;;;;;;;;;EASJ,cAAc,CAAC,CAAC,CAAC,UAAU,CAAC;;CAE7B,CAAC,CAAC,CAAC,EAAE;;;;sBAIkB,QAAQ,CAAC,CAAC,CAAC,UAAU,CAAC;yCACD,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BjD,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, caustics = false, researchContribution = '',photonMapping=false, channelIndependentRis=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;${caustics ? /* wgsl */ `\n  if(isSurface&&isCausticSpecular(ma)){\n    var connection=*path;\n    causticAdvance(&connection,ma,dot(ffnormal,lightDir)<0.0,true);\n    if(causticHitOwned(connection,lightSample.sourceType!=0u,true)){return false;}\n  }` : ''}\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${channelIndependentRis ? ' && rtUniform.dispersionWavelengths == 1' : ''}) {\n    Li = sampling_spectral_rgb_filter(Li, (*si).spectralChannel);\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)), ${channelIndependentRis ? 'select(luminance, vec3f(1.0 / 3.0), SPECTRAL && rtUniform.dispersionWavelengths != 1)' : 'luminance'}),\n      0.0\n    );\n    (*shadowWork).ray = lightRay;\n    (*shadowWork).maxDistance = visibilityDistance;\n    (*shadowWork).triangleIndex = (*si).triangleIndex;\n    (*shadowWork).contribution = misWeight * unweightedContribution;${channelIndependentRis ? /* wgsl */ `\n    // Give each RGB component equal target weight for all three wavelengths.\n    // Single-wavelength preview keeps its original luminance target. Filtering\n    // only the estimator preserves the common reservoir and UCW normalization.\n    if (SPECTRAL && rtUniform.dispersionWavelengths != 1) {\n      (*shadowWork).contribution = sampling_spectral_rgb_filter((*shadowWork).contribution, (*si).spectralChannel);\n    }` : ''}\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, (*si).instanceIndex)) {\n${caustics?`        var connection=*path;\n        if(isSurface&&isCausticSpecular(ma)){causticAdvance(&connection,ma,dot(ffnormal,selected.ray.d)<0.0,true);}\n        connection.beta=vec3f(1.0);causticHotRecord(connection,selected.contribution*candidateUCW,0u);\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 {${caustics ? /* wgsl */ `\n  if (causticHitOwned(*path, true, true)) { return 0.0; }` : ''}\n  // Secondary traversal accepts back faces for transmission; a one-sided\n  // emitter still radiates only into its front hemisphere.\n  let cosLight = dot((*si).faceNormal, -(*path).ray.d);\n  if (cosLight <= 0.0 && materialsBuffer[(*si).materialIndex].doubleSided < 0.5) { return 0.0; }\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  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        // Zero throughput cannot contribute at subsequent vertices or light connections.\n        if (all((*path).beta == vec3f(0.0))) { (*path).abort = true; return; }\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        // A volume vertex has no originating surface to skip on continuation or shadow rays.\n        (*si).triangleIndex = -1;\n        (*si).instanceIndex = -1;\n      }\n      else {\n        (*path).beta *= transmittance / mediumPdf;\n        // Zero throughput cannot contribute at subsequent vertices or light connections.\n        if (all((*path).beta == vec3f(0.0))) { (*path).abort = true; return; }\n      }\n    }\n  }\n\n  if (!mediumSampled) {\n    // Each spectral path carries one channel, including directly hit emitters.\n    // Keep the full material emission in the light-selection/MIS density.\n    var surfaceEmission = (*ma).emission;\n    if (SPECTRAL) {\n      surfaceEmission = sampling_spectral_rgb_filter(surfaceEmission, (*si).spectralChannel);\n    }\n${caustics?`    let emissionWeight=emissiveHitMisWeight(si,path);\n    causticHotRecord(*path,emissionWeight*surfaceEmission,1u);causticEmitterRecord(*si,*path,emissionWeight,surfaceEmission);\n    (*path).li+=emissionWeight*surfaceEmission*(*path).beta;`:'    (*path).li += emissiveHitMisWeight(si, path) * surfaceEmission * (*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${researchContribution}${photonMapping?/* wgsl */ `  if(!mediumSampled){let value=(*path).beta*photonContribution(*si,prepared,(*path).fromEye,!(*path).causticHasReceiver);causticEstimateRecord(value,1u);(*path).li+=value;}\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${caustics ? /* wgsl */ `    causticAdvance(path, *ma, isNextRefraction, true);\n` : ''}    (*path).beta *= f / scatteringPdf;\n    // Zero throughput cannot contribute at subsequent vertices or light connections.\n    if (all((*path).beta == vec3f(0.0))) { (*path).abort = true; return; }\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) {${caustics ? /* wgsl */ `\n    causticAdvance(path, *ma, false, false);` : ''}\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        (*path).scatteringMediumEntered = (*path).scatteringMediumEntered || any((*ma).mediumScattering > vec3f(0.0));\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.js

@@ -16,7 +16,7 @@ const SHADOW_CATCHER_LIGHT_SAMPLES = 4u;
 
 
 fn sampleShadowCatcher(si: SurfaceInteraction, bounce: i32, path: ptr<function, Path>) -> vec2f {
-let qR = -(*path).ray.d;
+let sg = -(*path).ray.d;
 var counts = vec2f(0.0);
 
 
@@ -24,10 +24,10 @@ var counts = vec2f(0.0);
 if (rtUniform.shadowCatcherChoiceCount > 0) {
 for (var candidate = 0u; candidate < SHADOW_CATCHER_LIGHT_SAMPLES; candidate++) {
 var lightSample: LightSampleRec;
-let mZ = vec3f(sample2D(sf(candidate, 1u)), sample1D(sf(candidate, 0u)));
-hb(
+let ob = vec3f(sample2D(tF(candidate, 1u)), sample1D(tF(candidate, 0u)));
+hz(
 si.position,
-mZ,
+ob,
 rtUniform.shadowCatcherChoiceOffset,
 rtUniform.shadowCatcherChoiceCount,
 1.0,
@@ -35,13 +35,13 @@ rtUniform.shadowCatcherChoiceCount,
 );
 let lightDir = lightSample.direction;
 let cosThetaL = dot(si.normal, lightDir);
-let qt = dot(si.normal, qR) * cosThetaL;
-if (lightSample.pdf > 0.0 && qt >= 0.0) {
+let rG = dot(si.normal, sg) * cosThetaL;
+if (lightSample.pdf > 0.0 && rG >= 0.0) {
 if (dot(lightSample.emission, luminance) * abs(cosThetaL) > 0.0) {
 var ray: Ray;
 initRay(&ray, si.position + EPS * lightDir, lightDir);
-let lH = intersectSceneShadow(ray, lightSample.dist - EPS, si.triangleIndex,si.instanceIndex);
-counts += vec2f(select(0.0, 1.0, lH), 1.0);
+let mz = intersectSceneShadow(ray, lightSample.dist - EPS, si.triangleIndex,si.instanceIndex);
+counts += vec2f(select(0.0, 1.0, mz), 1.0);
 }
 }
 }

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

@@ -4,70 +4,70 @@ export default /*wgsl*/ `
 
 
 fn aA(view: vec3f, alpha: vec2f, samplePoint: vec2f) -> vec3f {
-let sn = vec3f(alpha, 1.0);
-let ce = normalize(sn * view);
-let qG = min(ce.z, 1.0);
-let jN = 1.0 + qG;
-let kf = (1.0 - samplePoint.y) * jN;
-let sR = samplePoint.y * jN;
-let ub = kf + (1.0 - qG);
-let dr = sqrt(max(0.0, ub * sR));
+let qD = vec3f(alpha, 1.0);
+let cf = normalize(qD * view);
+let rU = min(cf.z, 1.0);
+let ku = 1.0 + rU;
+let kM = (1.0 - samplePoint.y) * ku;
+let ur = samplePoint.y * ku;
+let vK = kM + (1.0 - rU);
+let dw = sqrt(max(0.0, vK * ur));
 let azimuth = TWOPI * samplePoint.x;
-let lX = vec3f(
-ce.x + dr * cos(azimuth),
-ce.y + dr * sin(azimuth),
-kf
+let mR = vec3f(
+cf.x + dw * cos(azimuth),
+cf.y + dw * sin(azimuth),
+kM
 );
-return normalize(sn * lX);
+return normalize(qD * mR);
 }
 
-fn sampling_ggx_ndf(oU: vec3f, alpha: vec2f) -> f32 {
-let hl = vec3f(
-oU.x / alpha.x,
-oU.y / alpha.y,
-oU.z
+fn sampling_ggx_ndf(qc: vec3f, alpha: vec2f) -> f32 {
+let hG = vec3f(
+qc.x / alpha.x,
+qc.y / alpha.y,
+qc.z
 );
-let ah = dot(hl, hl);
+let ah = dot(hG, hG);
 return 1.0 / (
 PI * alpha.x * alpha.y * ah * ah
 );
 }
 
 fn aD(direction: vec3f, alpha: vec2f) -> f32 {
-let eB = abs(direction.z);
-if (eB <= 1e-8) {
+let eK = abs(direction.z);
+if (eK <= 1e-8) {
 return 0.0;
 }
-let hZ = alpha * direction.xy;
-let lY = dot(hZ, hZ)
-/ (eB * eB);
-return 2.0 / (1.0 + sqrt(1.0 + lY));
+let iK = alpha * direction.xy;
+let mS = dot(iK, iK)
+/ (eK * eK);
+return 2.0 / (1.0 + sqrt(1.0 + mS));
 }
 
-fn aH(cosine: f32) -> f32 {
-let cY = clamp(1.0 - cosine, 0.0, 1.0);
-return pow(cY, 5.0);
+fn aI(cosine: f32) -> f32 {
+let da = clamp(1.0 - cosine, 0.0, 1.0);
+return pow(da, 5.0);
 }
 
-fn sampling_dielectric_fresnel(J: f32, cE: f32) -> f32 {
-let iB = clamp(abs(J), 0.0, 1.0);
-let kv = cE * cE
-* max(0.0, 1.0 - iB * iB);
-if (kv >= 1.0) {
+fn sampling_dielectric_fresnel(J: f32, cH: f32) -> f32 {
+let ja = clamp(abs(J), 0.0, 1.0);
+let ld = cH * cH
+* max(0.0, 1.0 - ja * ja);
+if (ld >= 1.0) {
 return 1.0;
 }
 
-let ml = sqrt(max(0.0, 1.0 - kv));
-let bd = (iB - cE * ml)
-/ max(iB + cE * ml, 1e-8);
-let qu = (cE * iB - ml)
-/ max(cE * iB + ml, 1e-8);
+let nh = sqrt(max(0.0, 1.0 - ld));
+let bf = (ja - cH * nh)
+/ max(ja + cH * nh, 1e-8);
+let rH = (cH * ja - nh)
+/ max(cH * ja + nh, 1e-8);
 return 0.5 * (
-bd * bd + qu * qu
+bf * bf + rH * rH
 );
 }
 
-fn gi(samplePoint: vec2f) -> vec2f {
+fn gA(samplePoint: vec2f) -> vec2f {
 let offset = 2.0 * samplePoint - vec2f(1.0);
 if (offset.x == 0.0 && offset.y == 0.0) {
 return vec2f(0.0);
@@ -87,21 +87,21 @@ return radius * vec2f(cos(angle), sin(angle));
 }
 
 fn aM(samplePoint: vec2f) -> vec3f {
-let kS = gi(samplePoint);
+let lL = gA(samplePoint);
 return vec3f(
-kS,
-sqrt(max(0.0, 1.0 - dot(kS, kS)))
+lL,
+sqrt(max(0.0, 1.0 - dot(lL, lL)))
 );
 }
 
-fn aF(firstPdf: f32, secondPdf: f32) -> f32 {
+fn aG(firstPdf: f32, secondPdf: f32) -> f32 {
 let scale = max(firstPdf, secondPdf);
 if (scale <= 0.0) {
 return 0.0;
 }
 let normalized = vec2f(firstPdf, secondPdf) / scale;
-let pq = normalized * normalized;
-return pq.x / (pq.x + pq.y);
+let qC = normalized * normalized;
+return qC.x / (qC.x + qC.y);
 }
 
 fn sampling_orthonormal_basis(
@@ -109,17 +109,17 @@ normal: vec3f,
 tangent: ptr<function, vec3f>,
 bitangent: ptr<function, vec3f>
 ) {
-let ik = select(-1.0, 1.0, normal.z >= 0.0);
-let cv = -1.0 / (ik + normal.z);
-let xy = normal.x * normal.y * cv;
+let iP = select(-1.0, 1.0, normal.z >= 0.0);
+let cA = -1.0 / (iP + normal.z);
+let xy = normal.x * normal.y * cA;
 *tangent = vec3f(
-1.0 + ik * normal.x * normal.x * cv,
-ik * xy,
--ik * normal.x
+1.0 + iP * normal.x * normal.x * cA,
+iP * xy,
+-iP * normal.x
 );
 *bitangent = vec3f(
 xy,
-ik + normal.y * normal.y * cv,
+iP + normal.y * normal.y * cA,
 -normal.y
 );
 }
@@ -135,30 +135,30 @@ return filtered;
 
 fn sampling_cauchy_ior(
 wavelength: f32,
-ha: f32,
-hk: f32,
-rm: f32
+hy: f32,
+hF: f32,
+sD: f32
 ) -> f32 {
-if (wavelength == 0.0 || hk <= 0.0) {
-return ha;
+if (wavelength == 0.0 || hF <= 0.0) {
+return hy;
 }
 
 let FRAUNHOFER_C = 656.3;
 let FRAUNHOFER_D = 587.6;
 let FRAUNHOFER_F = 486.1;
-let jX = 1.0 / (
+let kD = 1.0 / (
 1.0 / (FRAUNHOFER_F * FRAUNHOFER_F)
 - 1.0 / (FRAUNHOFER_C * FRAUNHOFER_C)
 );
-let nU = max(rm / hk, 1e-6);
-let rR = (ha - 1.0) * jX / nU;
-let uO = ha
-- rR / (FRAUNHOFER_D * FRAUNHOFER_D);
-return uO + rR / (wavelength * wavelength);
+let oT = max(sD / hF, 1e-6);
+let tj = (hy - 1.0) * kD / oT;
+let wx = hy
+- tj / (FRAUNHOFER_D * FRAUNHOFER_D);
+return wx + tj / (wavelength * wavelength);
 }
 
-fn fj(
-gw: vec3f,
+fn dQ(
+gQ: vec3f,
 anisotropy: f32,
 samplePoint: vec2f
 ) -> vec3f {
@@ -167,24 +167,24 @@ if (abs(anisotropy) < 0.001) {
 cosine = 1.0 - 2.0 * samplePoint.y;
 }
 else {
-let iZ = (1.0 - anisotropy * anisotropy)
+let fw = (1.0 - anisotropy * anisotropy)
 / (1.0 + anisotropy - 2.0 * anisotropy * samplePoint.y);
 cosine = (
-iZ * iZ - 1.0 - anisotropy * anisotropy
+fw * fw - 1.0 - anisotropy * anisotropy
 ) / (2.0 * anisotropy);
 }
 
-let uC = sqrt(max(0.0, 1.0 - cosine * cosine));
+let wk = sqrt(max(0.0, 1.0 - cosine * cosine));
 let azimuth = TWOPI * samplePoint.x;
 var tangent: vec3f;
 var bitangent: vec3f;
-sampling_orthonormal_basis(gw, &tangent, &bitangent);
-return tangent * (uC * cos(azimuth))
-+ bitangent * (uC * sin(azimuth))
-+ gw * cosine;
+sampling_orthonormal_basis(gQ, &tangent, &bitangent);
+return tangent * (wk * cos(azimuth))
++ bitangent * (wk * sin(azimuth))
++ gQ * cosine;
 }
 
-fn bB(cosine: f32, anisotropy: f32) -> f32 {
+fn ba(cosine: f32, anisotropy: f32) -> f32 {
 let ah = 1.0 + anisotropy * anisotropy
 + 2.0 * anisotropy * cosine;
 return INV4PI * (1.0 - anisotropy * anisotropy)

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

@@ -16,41 +16,41 @@ const BOUNCE_STRIDE = 64u;
 
 
 
-var<private> aI: vec2u;
+var<private> aJ: vec2u;
 var<private> aC: u32;
 var<private> samplingBounce: u32 = 0u;
-var<private> ca: u32 = 0u;
-fn cB(kC: u32) -> u32 {
-var x = kC;
+var<private> hashedCounter: u32 = 0u;
+fn cD(lm: u32) -> u32 {
+var x = lm;
 x ^= x >> 16u; x *= 0x7feb352du;
 x ^= x >> 15u; x *= 0x846ca68bu;
 return x ^ (x >> 16u);
 }
 fn ak(a: u32, b: u32) -> u32 {
-return cB(a ^ cB(b + 0x9e3779b9u));
+return cD(a ^ cD(b + 0x9e3779b9u));
 }
-fn iD(kC: u32, seed: u32) -> u32 {
-var x = kC + seed;
+fn jc(lm: u32, seed: u32) -> u32 {
+var x = lm + seed;
 x ^= x * 0x6c50b47cu; x ^= x * 0xb82f1e52u;
 x ^= x * 0xc7afe638u; x ^= x * 0x8d22f6e6u;
 return x;
 }
-fn ud(x: u32, seed: u32) -> u32 {
-return reverseBits(iD(reverseBits(x), seed));
+fn vN(x: u32, seed: u32) -> u32 {
+return reverseBits(jc(reverseBits(x), seed));
 }
 
-fn sm(kC: u32) -> u32 {
-var r = reverseBits(kC);
+fn tP(lm: u32) -> u32 {
+var r = reverseBits(lm);
 ${sobolD1Steps.map(([shift, mask]) => `r ^= (r << ${shift}u) & 0x${mask.toString(16)}u;`).join("\n  ")}
 return r;
 }
-fn yf(index: u32, seed: u32) -> vec2f {
-let i = ud(index, ak(seed, 0u));
-let x = reverseBits(iD(i, ak(seed, 1u)));
-let y = ud(sm(i), ak(seed, 2u));
+fn Ac(index: u32, seed: u32) -> vec2f {
+let i = vN(index, ak(seed, 0u));
+let x = reverseBits(jc(i, ak(seed, 1u)));
+let y = vN(tP(i), ak(seed, 2u));
 return vec2f(f32(x >> 8u), f32(y >> 8u)) * (1.0 / 16777216.0);
 }
-fn uX(p: vec2u) -> u32 {
+fn wL(p: vec2u) -> u32 {
 var v = p & vec2u(255u);
 v = (v | (v << vec2u(4u))) & vec2u(0x0f0fu);
 v = (v | (v << vec2u(2u))) & vec2u(0x3333u);
@@ -58,112 +58,112 @@ v = (v | (v << vec2u(1u))) & vec2u(0x5555u);
 return v.x | (v.y << 1u);
 }
 ${zSobolPackedPermutations.map((v, i) => `const Z_PERM_${i} = ${v}u;`).join("\n")}
-fn kG(va: u32) -> u32 {
-let group = va >> 2u;
+fn lq(wO: u32) -> u32 {
+let group = wO >> 2u;
 var word = Z_PERM_5;
 ${[0, 1, 2, 3, 4].map(i => `word = select(word, Z_PERM_${i}, group == ${i}u);`).join("\n  ")}
-return (word >> ((va & 3u) * 8u)) & 255u;
+return (word >> ((wO & 3u) * 8u)) & 255u;
 }
-fn qJ(kY: u32, dim: u32, logSPP: u32) -> u32 {
+fn rX(lS: u32, dim: u32, logSPP: u32) -> u32 {
 let odd = logSPP & 1u;
-let wb = 8u + ((logSPP + 1u) >> 1u);
+let xX = 8u + ((logSPP + 1u) >> 1u);
 var result = 0u;
-for (var digit = i32(wb) - 1; digit >= i32(odd); digit--) {
+for (var digit = i32(xX) - 1; digit >= i32(odd); digit--) {
 let shift = 2u*u32(digit) - odd;
 
-var tN = 0u;
-if (shift < 30u) { tN = kY >> (shift + 2u); }
-let va = (cB(tN ^ (0x55555555u * dim)) >> 24u) % 24u;
-let d = (kY >> shift) & 3u;
-result |= ((kG(va) >> (2u*d)) & 3u) << shift;
+var vs = 0u;
+if (shift < 30u) { vs = lS >> (shift + 2u); }
+let wO = (cD(vs ^ (0x55555555u * dim)) >> 24u) % 24u;
+let d = (lS >> shift) & 3u;
+result |= ((lq(wO) >> (2u*d)) & 3u) << shift;
 }
 if (odd != 0u) {
-result |= (kY & 1u) ^ (cB((kY >> 1u) ^ (0x55555555u * dim)) & 1u);
+result |= (lS & 1u) ^ (cD((lS >> 1u) ^ (0x55555555u * dim)) & 1u);
 }
 return result;
 }
 
 
 
-fn bE(slot: u32) -> u32 {
+fn aX(slot: u32) -> u32 {
 return CAMERA_BEVEL_BASE + u32(BEVEL_SAMPLES) + samplingBounce * BOUNCE_STRIDE + slot;
 }
-fn sf(candidate: u32, slot: u32) -> u32 {
+fn tF(candidate: u32, slot: u32) -> u32 {
 if (candidate == 0u) {
-if (slot == 2u) { return bE(8u); }
-return bE(slot);
+if (slot == 2u) { return aX(8u); }
+return aX(slot);
 }
-return bE(9u + (candidate - 1u) * 3u + slot);
+return aX(9u + (candidate - 1u) * 3u + slot);
 }
 
 
-var<private> hg: vec4u;
-var<private> hh: u32;
-var<private> fA: bool = false;
-var<private> cX: bool = false;
-var<private> dD: u32;
-var<private> gt: u32;
-var<private> eJ: vec2f;
-fn dm(dim: u32) {
+var<private> hC: vec4u;
+var<private> hD: u32;
+var<private> fM: bool = false;
+var<private> cZ: bool = false;
+var<private> dF: u32;
+var<private> gM: u32;
+var<private> eT: vec2f;
+fn ds(dim: u32) {
 
-let kl = aI.x + aI.y * u32(rtUniform.outputSize.x);
-let key = vec4u(dim, aC, kl, rtUniform.sequenceSeed);
-if (fA && all(hg == key) && hh == rtUniform.zSobolLogSPP) { return; }
-hg = key; hh = rtUniform.zSobolLogSPP;
-fA = true; cX = false;
-var seed = ak(ak(kl, dim), rtUniform.sequenceSeed);
+let kT = aJ.x + aJ.y * u32(rtUniform.outputSize.x);
+let key = vec4u(dim, aC, kT, rtUniform.sequenceSeed);
+if (fM && all(hC == key) && hD == rtUniform.zSobolLogSPP) { return; }
+hC = key; hD = rtUniform.zSobolLogSPP;
+fM = true; cZ = false;
+var seed = ak(ak(kT, dim), rtUniform.sequenceSeed);
 var index = aC;
 if (SAMPLING_PATTERN == 1) {
 var logSPP = rtUniform.zSobolLogSPP;
 if (index == 0u) { logSPP = 0u; }
 else { index -= 1u; }
 
-var jd = index >> logSPP;
+var jH = index >> logSPP;
 let mask = (1u << logSPP) - 1u;
-let kY = (uX(aI) << logSPP) | (index & mask);
-index = qJ(kY, dim, logSPP);
-let tile = aI >> vec2u(8u);
+let lS = (wL(aJ) << logSPP) | (index & mask);
+index = rX(lS, dim, logSPP);
+let tile = aJ >> vec2u(8u);
 seed = ak(ak(dim, rtUniform.sequenceSeed), ak(tile.x, tile.y));
 
-if (aC != 0u) { jd += 1u; }
-seed = ak(seed, jd);
+if (aC != 0u) { jH += 1u; }
+seed = ak(seed, jH);
 }
-dD = ud(index, ak(seed, 0u));
-gt = seed;
-let x = reverseBits(iD(dD, ak(seed, 1u)));
-eJ.x = f32(x >> 8u) * (1.0 / 16777216.0);
+dF = vN(index, ak(seed, 0u));
+gM = seed;
+let x = reverseBits(jc(dF, ak(seed, 1u)));
+eT.x = f32(x >> 8u) * (1.0 / 16777216.0);
 }
-fn le(dim: u32) -> vec2f {
-dm(dim);
-if (!cX) {
-let y = ud(sm(dD), ak(gt, 2u));
-eJ.y = f32(y >> 8u) * (1.0 / 16777216.0);
-cX = true;
+fn lZ(dim: u32) -> vec2f {
+ds(dim);
+if (!cZ) {
+let y = vN(tP(dF), ak(gM, 2u));
+eT.y = f32(y >> 8u) * (1.0 / 16777216.0);
+cZ = true;
 }
-return EPS + (1.0 - 2.0*EPS) * eJ;
+return EPS + (1.0 - 2.0*EPS) * eT;
 }
 fn sample1D(dim: u32) -> f32 {
 if (SAMPLING_PATTERN == 2) { return EPS + (1.0 - 2.0*EPS)*rand(); }
-dm(dim);
-return EPS + (1.0 - 2.0*EPS) * eJ.x;
+ds(dim);
+return EPS + (1.0 - 2.0*EPS) * eT.x;
 }
 fn sample2D(dim: u32) -> vec2f {
 if (SAMPLING_PATTERN == 2) {
 let x = sample1D(dim); let y = sample1D(dim);
 return vec2f(x,y);
 }
-return le(dim);
+return lZ(dim);
 }
 
-fn ek(slot: u32) -> f32 {
-let dim = ak(ak(samplingBounce, slot), ca) | 0x80000000u;
-ca += 1u;
+fn cm(slot: u32) -> f32 {
+let dim = ak(ak(samplingBounce, slot), hashedCounter) | 0x80000000u;
+hashedCounter += 1u;
 if (SAMPLING_PATTERN == 2) { return EPS + (1.0 - 2.0*EPS)*rand(); }
 
-let kl = aI.x + aI.y * u32(rtUniform.outputSize.x);
-let seed = ak(ak(kl, dim), rtUniform.sequenceSeed);
-let i = ud(aC, ak(seed, 0u));
-let x = reverseBits(iD(i, ak(seed, 1u)));
+let kT = aJ.x + aJ.y * u32(rtUniform.outputSize.x);
+let seed = ak(ak(kT, dim), rtUniform.sequenceSeed);
+let i = vN(aC, ak(seed, 0u));
+let x = reverseBits(jc(i, ak(seed, 1u)));
 return EPS + (1.0 - 2.0*EPS) * (f32(x >> 8u) * (1.0 / 16777216.0));
 }
 `;

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

@@ -0,0 +1,6 @@
+export declare function spectralPrefixWgsl(shareSecondary?: boolean): string;
+export type PrefixBindings = Record<string, [type: string, expression: string]>;
+export declare const prefixRandomBindings: PrefixBindings;
+export declare function prefixCheckpoint(name: string, bindings: PrefixBindings): string;
+export declare function prefixSave(name: string, bindings: PrefixBindings): string;
+export declare function prefixRestore(name: string, bindings: PrefixBindings): string;