@meimu/mutracer 0.1.5 → 0.3.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"causticLight.compute.js","sourceRoot":"","sources":["../../../src/renderer/wgsl/causticLight.compute.ts"],"names":[],"mappings":"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","sourcesContent":["import {PHOTON_GRID_SIZE, photonPackingWgsl} from './photonMap.compute.js';\nimport {SPECTRUM_PHOTON_DISTRIBUTION, SPECTRUM_WAVELENGTH_RANGE, spectrumWgsl} from '../spectrum.js';\nimport background from './chunks/background.wgsl.js';\nimport atomic from './chunks/causticAtomic.wgsl.js';\nimport adjoint from './chunks/causticAdjoint.wgsl.js';\nimport common from './chunks/common.wgsl.js';\nimport core from './chunks/rayTraceCore.wgsl.js';\nimport {createMaterialBufferWgsl} from './chunks/materialBuffer.wgsl.js';\nimport intersect from './chunks/intersect.wgsl.js';\nimport rand from './chunks/rand.wgsl.js';\nimport random from './chunks/random.wgsl.js';\nimport env from './chunks/envMap.wgsl.js';\nimport sampling from './chunks/sampling.wgsl.js';\nimport {createOpenPbrBsdfWgsl} from './chunks/openPbrBsdf.wgsl.js';\nimport light from './chunks/sampleLight.wgsl.js';\nimport uv from './chunks/uvProjection.wgsl.js';\nimport {causticPartitionWGSL} from './chunks/caustics.wgsl.js';\nimport {wgpuShaderPreamble} from '../wgpuShaderSource.js';\nimport {WGPU_SCENE_FEATURE_BITS} from '../WGPUSceneFeatures.js';\n\nexport const CAUSTIC_UNIFORM_BYTES = 112;\nexport const causticUnitRandomWgsl = /* wgsl */ `\n  fn causticUnitRandom(value:f32)->f32 {\n    return clamp((value-EPS)/(1.0-2.0*EPS),0.0,0.99999994);\n  }\n`;\n\n// Preserve the dormant R1 uniform slot and shader spelling for source parity.\n// Production packs zero; only an explicitly registered research adapter sets it.\nexport function causticLightCompute(\n  constants: Record<string, boolean | number>,\n  blasLayoutMask: number,\n  hasDisplacement: boolean,\n  mode: 'lightTracing' | 'photonMapping' = 'lightTracing',\n  sceneIntersections = '',\n  fullEmissionRandom = true\n) {\n  const frames = !!constants.USE_ANISOTROPY_DIRECTIONS || !!constants.USE_COAT_NORMAL_FRAMES,\n    coat = !!constants.USE_COAT_NORMAL_FRAMES;\n  return (\n    wgpuShaderPreamble(constants, true) +\n    /* wgsl */ `\n${Object.keys(WGPU_SCENE_FEATURE_BITS)\n  .map((name) => `const ${name} = ${!!constants[name]};`)\n  .join('\\n')}\n${common}\n${core({hasAnisotropyDirections: frames, hasCoatNormals: coat, caustics: true})}\n${uv}\n${createMaterialBufferWgsl({hasAnisotropyDirections: frames, hasCoatNormals: coat, caustics: true})}\n${intersect({\n  hasDisplacement,\n  blasLayoutMask,\n  hasAnisotropyDirections: frames,\n  hasCoatNormals: coat,\n  sceneIntersections\n})}\n${rand}\n${random}\n${env}\n${sampling}\n${spectrumWgsl}\n${createOpenPbrBsdfWgsl(frames, coat)}\n${light}\n${background.replace(\n  /\\b(?:USE_BACKGROUND|USE_BACKGROUND_MAP|USE_GROUNDED_BACKGROUND)\\b/g,\n  (name) =>\n    `((rtUniform.backgroundFlags & ${\n      {USE_BACKGROUND: 1, USE_BACKGROUND_MAP: 2, USE_GROUNDED_BACKGROUND: 4}[name]\n    }) != 0)`\n)}\n${causticPartitionWGSL(false, false)}\n${adjoint}\n  struct CausticLightUniform {\n    casterSphere: vec4f,\n    viewProjection: mat4x4f,\n    photonCount: u32,\n    batch: u32,\n    mnee: u32,\n    cameraScale: f32,\n    casterCount: u32,\n    choiceCount: u32,\n    orthographic: u32,\n    experiments: u32,\n  }\n  @group(3) @binding(0) var<uniform> caustic: CausticLightUniform;\n${\n  mode === 'lightTracing'\n    ? '@group(3) @binding(1) var<storage,read_write> splats: array<atomic<u32>>;'\n    : `${photonPackingWgsl}\n  @group(3)@binding(1)var photons:texture_storage_2d<rgba32uint,write>;\n  @group(3)@binding(3)var photonDirections:texture_storage_2d<r32uint,write>;\n  fn photonStore(i:u32,value:vec4u) {\n    let width=textureDimensions(photons).x;\n    textureStore(photons,vec2i(vec2u(i%width,i/width)),value);\n  }\n  fn photonStoreDirections(i:u32,value:u32) {\n    let buckets=min(${PHOTON_GRID_SIZE}u,1u<<(32u-countLeadingZeros(max(256u,caustic.photonCount*2u)-1u)));\n    let index=8u+buckets*4u+caustic.photonCount*2u+i;\n    let width=textureDimensions(photonDirections).x;\n    textureStore(photonDirections,vec2i(vec2u(index%width,index/width)),vec4u(value));\n  }\n`\n}\n  @group(3) @binding(2) var causticDistribution:texture_2d<f32>;\n  // Geometric emission PDFs assume the full disk/cone/area support. The generic\n  // BSDF sampler contracts randoms by EPS; undo that contraction for these warps.\n${causticUnitRandomWgsl}\nfn causticEmission1D(dim:u32)->f32{return ${\n      fullEmissionRandom ? 'causticUnitRandom(sample1D(dim))' : 'sample1D(dim)'\n    }\n  ;\n}\nfn causticEmission2D(dim:u32)->vec2f {\n  let value=sample2D(dim);\n  return\n${fullEmissionRandom ? 'vec2f(causticUnitRandom(value.x),causticUnitRandom(value.y))' : 'value'}\n  ;\n}\nfn causticLoad(i:u32)->vec4f {\n  let width=textureDimensions(causticDistribution).x;\n  return textureLoad(causticDistribution,vec2i(vec2u(i%width,i/width)),0);\n}\nfn causticSphere(i:u32)->vec4f {\n  return causticLoad(i);\n}\n// Photon emission samples a source surface, independently of any receiver.\n// A NEE sample viewed from the aggregate caster center can reject an emitter\n// which still illuminates another caster, or sample only part of a sphere.\nvar<private> causticEmissionOrigin:vec3f;\nvar<private> causticEmissionAreaPdf:f32;\nfn causticAreaLight(origin:vec3f,position:vec3f,normal:vec3f,emission:vec3f,area:f32,pmf:f32,result:ptr<function,LightSampleRec>) {\n  causticEmissionOrigin=position;\n  causticEmissionAreaPdf=pmf/max(area,1e-20);\n  let offset=position-origin;\n  (*result).dist=length(offset);\n  (*result).direction=offset/max((*result).dist,1e-20);\n  (*result).normal=normal;\n  (*result).emission=emission;\n  (*result).pdf=pmf;\n}\nfn causticSampleLight(origin:vec3f,rnd:vec3f,result:ptr<function,LightSampleRec>) {\n  causticEmissionAreaPdf=0.0;\n  (*result).pdf=0.0;\n  (*result).sourceType=0u;\n  (*result).isDelta=false;\n  if(caustic.choiceCount==0u) {\n    return;\n  }\n  let scaled=rnd.z*f32(caustic.choiceCount);\n  let column=min(u32(scaled),caustic.choiceCount-1u);\n  let entry=causticLoad(caustic.casterCount+column*2u);\n  let selected=select(bitcast<u32>(entry.y),column,fract(scaled)<entry.x);\n  let choice=bitcast<vec4u>(causticLoad(caustic.casterCount+selected*2u));\n  let pmf=causticLoad(caustic.casterCount+selected*2u+1u).x;\n  (*result).sourceIndex=choice.w;\n  if(choice.z==1u) {\n    (*result).sourceType=0u;\n    sampleEnvLight(rnd.xy,result);\n    (*result).pdf*=pmf;\n  }\n  else if(choice.z==2u) {\n    (*result).sourceType=2u;\n    var light=analyticLights[choice.w];\n    let kind=i32(light.litType);\n    if(kind==RECT_LIGHT) {\n      let position=light.position+light.u*(rnd.x-.5)+light.v*(rnd.y-.5);\n      causticAreaLight(origin,position,normalize(cross(light.u,light.v)),light.emission,light.area,pmf,result);\n      (*result).isDelta=light.radiusOrSpread<=.001;\n      light_apply_rect_texture(light,position,light.position-.5*(light.u+light.v),result);\n    }\n    else if((kind==SPHERE_LIGHT||kind==SPOT_LIGHT)&&light.radiusOrSpread>0.0) {\n      let z=1.0-2.0*rnd.x;\n      let radial=sqrt(max(0.0,1.0-z*z));\n      let normal=vec3f(radial*cos(TWOPI*rnd.y),radial*sin(TWOPI*rnd.y),z);\n      causticAreaLight(origin,light.position+light.radiusOrSpread*normal,normal,light.emission,light.area,pmf,result);\n    }\n    else {\n      light.selectionPmf=1.0;\n      sampleAnalyticLight(light,origin,rnd.xy,result);\n      (*result).pdf*=pmf;\n    }\n  }\n  else {\n    (*result).sourceType=1u;\n    let triangle=getEmissiveTriangle(i32(choice.w));\n    let u=sqrt(rnd.x);\n    let bary=vec3f(1.0-u,u*(1.0-rnd.y),u*rnd.y);\n    let position=bary.x*triangle.p0+bary.y*triangle.p1+bary.z*triangle.p2;\n    let normal=normalize(cross(triangle.p1-triangle.p0,triangle.p2-triangle.p0));\n    let uv=bary.x*triangle.uv0+bary.y*triangle.uv1+bary.z*triangle.uv2;\n    let uv1=bary.x*triangle.secondaryUv0+bary.y*triangle.secondaryUv1+bary.z*triangle.secondaryUv2;\n    causticAreaLight(origin,position,normal,getMaterialEmission(i32(triangle.materialIndex),uv,uv1),triangle.area,pmf,result);\n  }\n  (*result).selectionPmf=pmf;\n}\nfn causticCosMax(s:vec4f,origin:vec3f)->f32 {\n  let distanceSquared=dot(s.xyz-origin,s.xyz-origin);\n  return select(-1.0,sqrt(max(0.0,1.0-s.w*s.w/distanceSquared)),distanceSquared>s.w*s.w);\n}\n// A positive floor retains paths from offscreen or occluded casters. The\n// complete weighted mixture PDF below, including overlaps, compensates selection.\nfn causticTargetWeight(s:vec4f)->f32 {\n  if((caustic.experiments&2u)==0u) { return 1.0; }\n  let clip=caustic.viewProjection*vec4f(s.xyz,1.0);\n  let m=caustic.viewProjection;\n  let extent=s.w*max(length(vec3f(m[0].x,m[1].x,m[2].x)),length(vec3f(m[0].y,m[1].y,m[2].y)));\n  if(clip.w<=0.0||abs(clip.x)>clip.w+extent||abs(clip.y)>clip.w+extent) { return .05; }\n  return .05+min(1.0,extent*extent/max(clip.w*clip.w,1e-20));\n}\nfn causticDirection(origin:vec3f,rnd:vec3f,pdf:ptr<function,f32>,targetRadius:ptr<function,f32>)->vec3f {\n  var total=0.0;\n  for(var i=0u;i<caustic.casterCount;i++) {\n    total+=(1.0-causticCosMax(causticSphere(i),origin))*causticTargetWeight(causticSphere(i));\n  }\n  var choice=rnd.z*total;\n  var selected=causticSphere(0u);\n  for(var i=0u;i<caustic.casterCount;i++) {\n    let sphere=causticSphere(i);\n    selected=sphere;\n    choice-=(1.0-causticCosMax(sphere,origin))*causticTargetWeight(sphere);\n    if(choice<=0.0) {\n      break;\n    }\n  }\n  *targetRadius=selected.w;\n  let offset=selected.xyz-origin;\n  let axis=normalize(select(vec3f(0.0,0.0,1.0),offset,dot(offset,offset)>1e-20));\n  let cosine=mix(1.0,causticCosMax(selected,origin),rnd.x);\n  let sine=sqrt(max(0.0,1.0-cosine*cosine));\n  var t:vec3f;\n  var b:vec3f;\n  sampling_orthonormal_basis(axis,&t,&b);\n  let direction=axis*cosine+(t*cos(TWOPI*rnd.y)+b*sin(TWOPI*rnd.y))*sine;\n  // Evaluate the entire mixture, since intersecting bounding cones overlap.\n  var overlaps=0.0;\n  for(var i=0u;i<caustic.casterCount;i++) {\n    let sphere=causticSphere(i);\n    let c=causticCosMax(sphere,origin);\n    if(c<0.0||dot(normalize(sphere.xyz-origin),direction)>=c) {\n      overlaps+=causticTargetWeight(sphere);\n    }\n  }\n  *pdf=overlaps/max(TWOPI*total,1e-20);\n  return direction;\n}\n${\n  mode === 'lightTracing'\n    ? /* wgsl */ `${atomic}\n  fn causticCameraConnect(si: SurfaceInteraction, material: OpenPbrResolvedMaterial, incoming: Ray, flux: vec3f, extinction: vec3f) {\n    let eye=cameraUniform.viewInv[3].xyz;\n    let forward=-normalize(cameraUniform.viewInv[2].xyz);\n    let lensSample=causticEmission2D(causticDim(68u));\n    let radius=cameraUniform.apertureRadius*sqrt(lensSample.x);\n    var lens=eye+radius*(cos(TWOPI*lensSample.y)*cameraUniform.viewInv[0].xyz+sin(TWOPI*lensSample.y)*cameraUniform.viewInv[1].xyz);\n    if(caustic.orthographic!=0u) {\n      lens=si.position-forward*dot(si.position-eye,forward);\n    }\n    let toEye=lens-si.position;\n    let distanceSquared=dot(toEye,toEye);\n    let direction=normalize(toEye);\n    let focalPoint=lens+(si.position-lens)*cameraUniform.focusDistance/max(dot(si.position-lens,forward),1e-12);\n    let projected=select(focalPoint,si.position,caustic.orthographic!=0u);\n    let clip=caustic.viewProjection*vec4f(projected,1.0);\n    if(clip.w<=0.0||dot(si.position-eye,forward)<=0.0) {\n      return;\n    }\n    let film=clip.xy/clip.w*0.5+0.5;\n    if(any(film<vec2f(0.0))||any(film>=vec2f(1.0))) {\n      return;\n    }\n    var shadow:Ray;\n    initRay(&shadow,si.position+EPS*direction,direction);\n    if(intersectSceneShadow(shadow,sqrt(distanceSquared)-2.0*EPS,si.triangleIndex,si.instanceIndex)) {\n      return;\n    }\n    var m=material;\n    let normal=select(-si.normal,si.normal,dot(si.normal,-incoming.d)>=0.0);\n    m.inside=dot(si.faceNormal,-incoming.d)<0.0;\n    m.relativeIor=select(1.0/m.specularIor,m.specularIor,m.inside);\n${\n  frames\n    ? /* wgsl */ `  m.directionTangent=si.directionTangent;m.directionBitangent=si.directionBitangent;m.geometryTangent=si.geometryTangent;m.geometryBitangent=si.geometryBitangent;`\n    : ''\n}\n${\n  coat\n    ? /* wgsl */ `  m.coatNormal=normal;m.geometricNormal=select(-si.faceNormal,si.faceNormal,dot(si.faceNormal,-incoming.d)>=0.0);`\n    : ''\n}\n  let prepared=openpbr_prepare(si.tangent,m,-incoming.d,normal);\n  var pdf:f32;\n  let response=openpbr_eval_prepared(prepared,direction,&pdf);\n  let cameraCosine=dot(-direction,-normalize(cameraUniform.viewInv[2].xyz));\n  if(cameraCosine<=0.0) {\n    return;\n  }\n  let importance=caustic.cameraScale*rtUniform.outputSize.x*rtUniform.outputSize.y /\n  select(max(distanceSquared*cameraCosine*cameraCosine*cameraCosine,1e-12),1.0,caustic.orthographic!=0u);\n  let transmittance=exp(-extinction*sqrt(distanceSquared));\n  let value=flux*transmittance*response*causticAdjoint(-incoming.d,direction,normal,si.faceNormal)*importance/f32(caustic.photonCount);\n  let pixel=vec2u(film*rtUniform.outputSize);\n  let index=(pixel.x+pixel.y*u32(rtUniform.outputSize.x))*3u;\n  causticAtomicAdd(index,value.x);\n  causticAtomicAdd(index+1u,value.y);\n  causticAtomicAdd(index+2u,value.z);\n}\n`\n    : ''\n}\n  @compute @workgroup_size(64)\n  fn main(@builtin(global_invocation_id) id:vec3u) {\n    let photonIndex=id.x+id.y*4194240u;\n    if(photonIndex>=caustic.photonCount) {\n      return;\n    }\n${mode === 'photonMapping' ? 'photonStore(photonIndex,vec4u(0u));' : ''}\n  samplingPixel=vec2u(photonIndex%u32(rtUniform.outputSize.x),photonIndex/u32(rtUniform.outputSize.x));\n  pixelSampleIndex=caustic.batch;\n  samplingBounce=0u;\n  hashedCounter=0u;\n  rng_initialize(samplingPixel,i32(sampleSeed(caustic.batch,rtUniform.sequenceSeed)));\n  var wavelength=0.0;\n  var wavelengthPdf=1.0;\n  if(SPECTRAL) {\n    wavelength=spectrumSample(${SPECTRUM_PHOTON_DISTRIBUTION}u,causticEmission1D(causticDim(69u)),&wavelengthPdf);\n  }\n  var ls:LightSampleRec;\n  causticSampleLight(caustic.casterSphere.xyz,vec3f(causticEmission2D(causticDim(60u)),causticEmission1D(causticDim(61u))),&ls);\n  if(ls.pdf<=0.0) {\n    return;\n  }\n  var infinite=ls.sourceType==0u;\n  if(ls.sourceType==2u) {\n    infinite=i32(analyticLights[ls.sourceIndex].litType)==DIRECTIONAL_LIGHT;\n  }\n  var origin=caustic.casterSphere.xyz+ls.direction*ls.dist;\n  if(causticEmissionAreaPdf>0.0) { origin=causticEmissionOrigin; }\n  var direction:vec3f;\n  var flux:vec3f;\n  var targetRadius=caustic.casterSphere.w;\n  if(infinite) {\n    direction=-ls.direction;\n    // Mixture of projected caster disks. Every overlap contributes to the PDF.\n    var area=0.0;\n    for(var i=0u;i<caustic.casterCount;i++) {\n      let s=causticSphere(i);\n      area+=s.w*s.w*causticTargetWeight(s);\n    }\n    var choice=causticEmission1D(causticDim(63u))*area;\n    var sphere=causticSphere(0u);\n    for(var i=0u;i<caustic.casterCount;i++) {\n      sphere=causticSphere(i);\n      choice-=sphere.w*sphere.w*causticTargetWeight(sphere);\n      if(choice<=0.0) {\n        break;\n      }\n    }\n    targetRadius=sphere.w;\n    var t:vec3f;\n    var b:vec3f;\n    sampling_orthonormal_basis(direction,&t,&b);\n    let rnd=causticEmission2D(causticDim(62u));\n    origin=sphere.xyz-direction*dot(sphere.xyz-caustic.casterSphere.xyz,direction)-direction*caustic.casterSphere.w;\n    origin+=sphere.w*sqrt(rnd.x)*(t*cos(TWOPI*rnd.y)+b*sin(TWOPI*rnd.y));\n    var overlaps=0.0;\n    for(var i=0u;i<caustic.casterCount;i++) {\n      let s=causticSphere(i);\n      let offset=origin-s.xyz;\n      let projected=offset-direction*dot(offset,direction);\n      if(dot(projected,projected)<=s.w*s.w) {\n        overlaps+=causticTargetWeight(s);\n      }\n    }\n    let diskPdf=overlaps/max(PI*area,1e-20);\n    flux=ls.emission/(ls.pdf*diskPdf);\n  }\n  else if(ls.sourceType==2u&&i32(analyticLights[ls.sourceIndex].litType)==RECT_LIGHT&&ls.isDelta) {\n    // A zero-spread rectangle is a collimated beam, matching PT's delta source.\n    direction=ls.normal;\n    flux=ls.emission/causticEmissionAreaPdf;\n  }\n  else {\n    var areaPdf=ls.pdf*abs(dot(ls.normal,-ls.direction))/max(ls.dist*ls.dist,1e-20);\n    if(causticEmissionAreaPdf>0.0) { areaPdf=causticEmissionAreaPdf; }\n    if(ls.isDelta) {\n      areaPdf=ls.selectionPmf;\n    }\n    if(areaPdf<=0.0) {\n      return;\n    }\n    var directionPdf:f32;\n    direction=causticDirection(origin,vec3f(causticEmission2D(causticDim(62u)),causticEmission1D(causticDim(63u))),&directionPdf,&targetRadius);\n    var emission=ls.emission;\n    var emissionCosine=max(0.0,dot(ls.normal,direction));\n    if(ls.sourceType==2u) {\n      let source=analyticLights[ls.sourceIndex];\n      emission=source.emission;\n      if(i32(source.litType)==SPOT_LIGHT) {\n        emission*=evaluateSpotEmissionMultiplier(source,direction);\n      }\n      if(ls.isDelta) {\n        emissionCosine=1.0;\n      }\n      if(i32(source.litType)==RECT_LIGHT&&emissionCosine<cos(0.5*PI*source.radiusOrSpread)) {\n        return;\n      }\n      if(i32(source.litType)==RECT_LIGHT) {\n        var textured:LightSampleRec;\n        textured.emission=emission;\n        light_apply_rect_texture(source,origin,source.position-0.5*(source.u+source.v),&textured);\n        emission=textured.emission;\n      }\n    }\n    flux=emission*emissionCosine/(areaPdf*directionPdf);\n  }\n  if(SPECTRAL) {\n    flux*=spectrumRgb(wavelength)/(wavelengthPdf*${SPECTRUM_WAVELENGTH_RANGE}.0);\n  }\n  var ray:Ray;\n  initRay(&ray,origin+EPS*direction,direction);\n  var chain=0u;\n  var singleT=false;\n  var extinction=vec3f(0.0);\n  var scattering=vec3f(0.0);\n  var si:SurfaceInteraction;\n  for(var depth=0;\n${mode === 'photonMapping' ? 'depth<=max(rtUniform.bounces,0)' : 'depth<20'}\n  ;\n  depth++) {\n    samplingBounce=u32(depth);\n    si.triangleIndex=-1;\n    intersectScene(ray,&si,0,true,depth>0);\n    if(!si.hit) {\n      return;\n    }\n    var m:OpenPbrResolvedMaterial;\n    getMaterial(&m,si.materialIndex,si.uv,si.uv1,si.instanceIndex,si.vertexColor);\n    if(m.alpha<1.0&&causticEmission1D(causticDim(79u))>=m.alpha) {\n      initRay(&ray,si.position+EPS*ray.d,ray.d);\n      continue;\n    }\n    if(m.materialType==SHADOW_CATCHER) {\n      return;\n    }\n    let segment=distance(ray.o,si.position);\n    let channel=min(u32(sample1D(bounceDim(MEDIUM_CHANNEL))*3.0),2u);\n    if(extinction[channel]>0.0&&any(scattering>vec3f(0.0))) {\n      let sampled=-log(max(sample1D(bounceDim(MEDIUM_DISTANCE)),1e-7))/extinction[channel];\n      // A volume event belongs to PT's R3. Surface-reaching photons use the\n      // same RGB survival mixture as PT, retaining absorption and scattering.\n      if(sampled<segment) {\n        return;\n      }\n    }\n    let transmittance=exp(-extinction*segment);\n    let survival=(transmittance.x+transmittance.y+transmittance.z)/3.0;\n    flux*=transmittance/select(1.0,max(survival,1e-20),any(scattering>vec3f(0.0)));\n    if(SPECTRAL) {\n      m.specularIor=sampling_cauchy_ior(spectrumIorWavelength(wavelength),m.specularIor,m.transmissionDispersionScale,m.dispersionAbbeNumber);\n    }\n    if(!isCausticSpecular(m)) {\n      let mneeSource=ls.sourceType!=0u;\n      let r1=mneeSource&&chain==1u&&singleT&&m.baseWeight*(1.0-m.baseMetalness)*(1.0-m.transmissionWeight)>0.0&&m.subsurfaceWeight==0.0;\n      if(chain>0u\n${mode === 'lightTracing' ? '&&!(caustic.mnee!=0u&&r1)' : ''}){${\n      mode === 'lightTracing'\n        ? 'causticCameraConnect(si,m,ray,flux,extinction);'\n        : /* wgsl */ `\n  let position=bitcast<vec3u>(si.position);\n  photonStore(photonIndex,vec4u(position,photonEncodeFlux(flux)));\n  if((caustic.experiments&1u)!=0u) {\n    var maximum=1e-8;\n    for(var i=0u;i<caustic.casterCount;i++) { maximum=max(maximum,causticSphere(i).w); }\n    let buckets=min(${PHOTON_GRID_SIZE}u,1u<<(32u-countLeadingZeros(max(256u,caustic.photonCount*2u)-1u)));\n    let index=8u+buckets*4u+caustic.photonCount*3u+photonIndex;\n    let width=textureDimensions(photonDirections).x;\n    textureStore(photonDirections,vec2i(vec2u(index%width,index/width)),vec4u(bitcast<u32>(targetRadius/maximum)));\n  }\n  let incoming=vec2u(round(photonEncodeOct(-ray.d)*255.0));\n  let normal=vec2u(round(photonEncodeOct(si.faceNormal)*vec2f(255.0,127.0)));\n  photonStoreDirections(photonIndex,normal.x|(normal.y<<8u)|(select(0u,1u,r1)<<15u)|(incoming.x<<16u)|(incoming.y<<24u));\n`\n    }\n}\nreturn;\n}\nlet view=-ray.d;\nlet normal=select(-si.normal,si.normal,dot(si.normal,view)>=0.0);\nm.inside=dot(si.faceNormal,view)<0.0;\nm.relativeIor=select(1.0/m.specularIor,m.specularIor,m.inside);\n${\n  frames\n    ? /* wgsl */ `    m.directionTangent=si.directionTangent;m.directionBitangent=si.directionBitangent;m.geometryTangent=si.geometryTangent;m.geometryBitangent=si.geometryBitangent;`\n    : ''\n}\n${\n  coat\n    ? /* wgsl */ `    m.coatNormal=normal;m.geometricNormal=select(-si.faceNormal,si.faceNormal,dot(si.faceNormal,view)>=0.0);`\n    : ''\n}\n  let prepared=openpbr_prepare(si.tangent,m,view,normal);\n  var next:vec3f;\n  var pdf:f32;\n  var transmission:bool;\n  var roughness:f32;\n  var specular:bool;\n  var diffuse:bool;\n  var lobe:u32;\n  var marginal:f32;\n  var full:vec3f;\n  let response=openpbr_sample_prepared(prepared,vec3f(sample2D(bounceDim(BSDF_DIRECTION)),sample1D(bounceDim(BSDF_LOBE))),&next,&pdf,&transmission,&roughness,&specular,&diffuse,&lobe,&marginal,&full);\n  if(!(pdf>0.0)) {\n    return;\n  }\n  if(chain==0u&&ls.sourceType==0u&&transmission) {\n    var reverse:Ray;\n    initRay(&reverse,si.position,-ray.d);\n    let bg=sampleSceneBackground(reverse);\n    flux*=bg.rgb*bg.a/max(ls.emission,vec3f(1e-20));\n  }\n  flux*=response/pdf*causticAdjoint(view,next,normal,si.faceNormal);\n  // The shared BSDF is a radiance sampler. Cancel its eta_i/eta_t squared\n  // factor for adjoint (light-to-camera) propagation.\n  if(transmission&&!m.thinWalled) {\n    flux/=m.relativeIor*m.relativeIor;\n  }\n  // Match PT: a clear solid interface does not replace the active medium.\n  if(transmission&&!m.thinWalled&&m.mediumType>0) {\n    extinction=select(m.mediumExtinction,vec3f(0.0),m.inside);\n    scattering=select(m.mediumScattering,vec3f(0.0),m.inside);\n  }\n  chain++;\n  singleT=chain==1u&&((isCausticT(m)&&transmission)||(isCausticR(m)&&!transmission));\n  initRay(&ray,si.position+EPS*next,next);\n}\n}\n`\n  );\n}\n\nexport const causticAccumulateCompute = /* wgsl */ `\n  @group(0) @binding(0) var<storage,read_write> splats:array<atomic<u32>>;\n  @group(0) @binding(1) var<storage,read_write> accumulation:array<vec4f>;\n  @compute @workgroup_size(64)\n  fn main(@builtin(global_invocation_id) id:vec3u, @builtin(num_workgroups) groups:vec3u) {\n    // Large images exceed one dispatch row; preserve the linear pixel order.\n    let pixel=id.x+id.y*groups.x*64u;\n    if(pixel>=arrayLength(&accumulation)) {\n      return;\n    }\n    let i=pixel*3u;\n    accumulation[pixel]+=vec4f(vec3f(bitcast<f32>(atomicLoad(&splats[i])),bitcast<f32>(atomicLoad(&splats[i+1u])),bitcast<f32>(atomicLoad(&splats[i+2u]))),1.0);\n  }\n`;\n\n/** Native buffer resolve has the same independent batch normalization as web. */\nexport const causticBufferCompositeCompute = /* wgsl */ `\n  @group(0)@binding(0)var<storage,read>pt:array<vec4f>;\n  @group(0)@binding(1)var<storage,read>caustics:array<vec4f>;\n  @group(0)@binding(2)var<storage,read>normal:array<vec4f>;\n  @group(0)@binding(3)var<storage,read_write>output:array<vec4f>;\n  @compute @workgroup_size(64)fn main(@builtin(global_invocation_id)id:vec3u,@builtin(num_workgroups)groups:vec3u) {\n    // Large images exceed one dispatch row; preserve the linear pixel order.\n    let pixel=id.x+id.y*groups.x*64u;\n    if(pixel>=arrayLength(&output)) {\n      return;\n    }\n    let c=caustics[pixel];\n    let p=pt[pixel];\n    output[pixel]=vec4f(p.rgb+c.rgb/max(c.a,1.0)*normal[pixel].a,p.a);\n  }\n`;\n"]}

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

@@ -0,0 +1,2 @@
+declare const _default: "fn 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 d = groundedBackgroundDirection(ray.o, ray.d);\n    let t = rtUniform.backgroundMapTransform;\n    let backgroundDirection = vec3f(t.x * d.x - t.y * d.z, d.y, t.y * d.x + t.x * d.z);\n    let rotation = rtUniform.backgroundMapRotation;\n    let mapDirection = transpose(mat3x3f(rotation[0].xyz, rotation[1].xyz, rotation[2].xyz)) * backgroundDirection;\n    let backgroundSample = textureLinear(backgroundMap, cartesianToEquirect(mapDirection));\n    bg = vec4f(backgroundSample.rgb * t.z, backgroundSample.a);\n  }\n  else if (USE_BACKGROUND) {\n    bg = rtUniform.backgroundColor;\n  }\n  else if (USE_ENVMAP) {\n    bg = textureLinear(envMap, environmentUv(ray.d));\n  }\n  return bg;\n}\n\n";
+export default _default;

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

@@ -0,0 +1,102 @@
+export default /* wgsl */ `fn di(point: vec3f, height: f32, radius: f32) -> f32 {
+let fQ = length(point);
+if (fQ < 0.00001) {
+return -radius;
+}
+
+let iG = radius * point.y / fQ;
+let iq = -1.5 * height;
+var eq: f32;
+if (iG >= 0.0) {
+eq = radius;
+}
+else if (iG < iq) {
+eq = -height * fQ / point.y;
+}
+else {
+let cv = 1.0
+- iG * iG / (3.0 * iq * iq);
+eq = radius * cv;
+}
+return fQ - eq;
+}
+
+fn eM(origin: vec3f, direction: vec3f) -> vec3f {
+if (!USE_GROUNDED_BACKGROUND) {
+return direction;
+}
+let params = rtUniform.groundedBackgroundParams;
+let bS = normalize(direction);
+let center = vec3f(
+rtUniform.groundedBackgroundCenter.x,
+params.z + params.x,
+rtUniform.groundedBackgroundCenter.y
+);
+let bs = origin - center;
+let eE = dot(bs, bS);
+let bj = eE * eE
+- dot(bs, bs) + params.y * params.y;
+if (
+bj <= 0.0
+|| di(bs, params.x, params.y) > 0.0
+) {
+return direction;
+}
+
+var cw = -eE + sqrt(bj);
+if (cw <= 0.0) {
+return direction;
+}
+
+let oA = bs + bS * cw;
+if (oA.y >= 0.0) {
+return normalize(oA);
+}
+
+if (bS.y < -0.00001 && params.y > 1.5 * params.x) {
+let hP = (-params.x - bs.y) / bS.y;
+let ot = bs + bS * hP;
+let oT = (2.0 / 3.0)
+* sqrt(params.y * params.y - 2.25 * params.x * params.x);
+if (hP > 0.0 && length(ot.xz) <= oT) {
+return normalize(ot);
+}
+}
+
+var cI = 0.0;
+for (var i = 0; i < 14; i++) {
+let fd = (cI + cw) * 0.5;
+let qq = bs + bS * fd;
+if (di(qq, params.x, params.y) > 0.0) {
+cw = fd;
+}
+else {
+cI = fd;
+}
+}
+let hit = bs + bS * ((cI + cw) * 0.5);
+return normalize(hit);
+}
+
+fn ft(ray: Ray) -> vec4f {
+var bg = vec4f(0.0);
+if (USE_BACKGROUND_MAP) {
+let d = eM(ray.o, ray.d);
+let t = rtUniform.backgroundMapTransform;
+let qS = vec3f(t.x * d.x - t.y * d.z, d.y, t.y * d.x + t.x * d.z);
+let rotation = rtUniform.backgroundMapRotation;
+let gU = transpose(mat3x3f(rotation[0].xyz, rotation[1].xyz, rotation[2].xyz)) * qS;
+let aW = textureLinear(backgroundMap, eF(gU));
+bg = vec4f(aW.rgb * t.z, aW.a);
+}
+else if (USE_BACKGROUND) {
+bg = rtUniform.backgroundColor;
+}
+else if (USE_ENVMAP) {
+bg = textureLinear(envMap, cT(ray.d));
+}
+return bg;
+}
+
+`;
+//# sourceMappingURL=background.wgsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"background.wgsl.js","sourceRoot":"","sources":["../../../../src/renderer/wgsl/chunks/background.wgsl.ts"],"names":[],"mappings":"AAAA,eAAe,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoGzB,CAAC","sourcesContent":["export default /* wgsl */ `fn 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 d = groundedBackgroundDirection(ray.o, ray.d);\n    let t = rtUniform.backgroundMapTransform;\n    let backgroundDirection = vec3f(t.x * d.x - t.y * d.z, d.y, t.y * d.x + t.x * d.z);\n    let rotation = rtUniform.backgroundMapRotation;\n    let mapDirection = transpose(mat3x3f(rotation[0].xyz, rotation[1].xyz, rotation[2].xyz)) * backgroundDirection;\n    let backgroundSample = textureLinear(backgroundMap, cartesianToEquirect(mapDirection));\n    bg = vec4f(backgroundSample.rgb * t.z, backgroundSample.a);\n  }\n  else if (USE_BACKGROUND) {\n    bg = rtUniform.backgroundColor;\n  }\n  else if (USE_ENVMAP) {\n    bg = textureLinear(envMap, environmentUv(ray.d));\n  }\n  return bg;\n}\n\n`;\n"]}

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

@@ -0,0 +1,2 @@
+declare const _default: "\nfn causticAdjoint(view:vec3f,outgoing:vec3f,shading:vec3f,geometric:vec3f)->f32 {\n  let numerator=abs(dot(view,shading)*dot(outgoing,geometric));\n  let denominator=abs(dot(view,geometric)*dot(outgoing,shading));\n  if(denominator==0.0){return 0.0;}\n  return numerator/denominator;\n}\n";
+export default _default;

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

@@ -0,0 +1,12 @@
+// Veach's adjoint shading-normal ratio. Directions point away from the vertex;
+// view is toward the preceding light vertex, outgoing toward the camera.
+// Reference: Veach 1997, thesis section 5.3 (mathematical formula, no copied code).
+export default /* wgsl */ `
+fn causticAdjoint(view:vec3f,vJ:vec3f,shading:vec3f,geometric:vec3f)->f32 {
+let iF=abs(dot(view,shading)*dot(vJ,geometric));
+let ah=abs(dot(view,geometric)*dot(vJ,shading));
+if(ah==0.0){return 0.0;}
+return iF/ah;
+}
+`;
+//# sourceMappingURL=causticAdjoint.wgsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"causticAdjoint.wgsl.js","sourceRoot":"","sources":["../../../../src/renderer/wgsl/chunks/causticAdjoint.wgsl.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,yEAAyE;AACzE,oFAAoF;AACpF,eAAe,UAAU,CAAC;;;;;;;CAOzB,CAAC","sourcesContent":["// Veach's adjoint shading-normal ratio. Directions point away from the vertex;\n// view is toward the preceding light vertex, outgoing toward the camera.\n// Reference: Veach 1997, thesis section 5.3 (mathematical formula, no copied code).\nexport default /* wgsl */ `\nfn causticAdjoint(view:vec3f,outgoing:vec3f,shading:vec3f,geometric:vec3f)->f32 {\n  let numerator=abs(dot(view,shading)*dot(outgoing,geometric));\n  let denominator=abs(dot(view,geometric)*dot(outgoing,shading));\n  if(denominator==0.0){return 0.0;}\n  return numerator/denominator;\n}\n`;\n"]}

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

@@ -0,0 +1,2 @@
+declare const _default: "\nfn causticAtomicAdd(index:u32,value:f32) {\n  if(!(value>0.0)||!(value<3.402823e38)){return;}\n  var previous=atomicLoad(&splats[index]);\n  loop {\n    let sum=bitcast<f32>(previous)+value;\n    let replacement=bitcast<u32>(sum);\n    let result=atomicCompareExchangeWeak(&splats[index],previous,replacement);\n    if(result.exchanged){break;}\n    previous=result.old_value;\n  }\n}\n";
+export default _default;

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

@@ -0,0 +1,16 @@
+// Float32 addition implemented with u32 compare/exchange works on baseline
+// WebGPU, without a fixed radiance quantum or the Q16.16 saturation ceiling.
+export default /* wgsl */ `
+fn kM(index:u32,value:f32) {
+if(!(value>0.0)||!(value<3.402823e38)){return;}
+var previous=atomicLoad(&splats[index]);
+loop {
+let sum=bitcast<f32>(previous)+value;
+let vN=bitcast<u32>(sum);
+let result=atomicCompareExchangeWeak(&splats[index],previous,vN);
+if(result.exchanged){break;}
+previous=result.old_value;
+}
+}
+`;
+//# sourceMappingURL=causticAtomic.wgsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"causticAtomic.wgsl.js","sourceRoot":"","sources":["../../../../src/renderer/wgsl/chunks/causticAtomic.wgsl.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAC3E,6EAA6E;AAC7E,eAAe,UAAU,CAAC;;;;;;;;;;;;CAYzB,CAAC","sourcesContent":["// Float32 addition implemented with u32 compare/exchange works on baseline\n// WebGPU, without a fixed radiance quantum or the Q16.16 saturation ceiling.\nexport default /* wgsl */ `\nfn causticAtomicAdd(index:u32,value:f32) {\n  if(!(value>0.0)||!(value<3.402823e38)){return;}\n  var previous=atomicLoad(&splats[index]);\n  loop {\n    let sum=bitcast<f32>(previous)+value;\n    let replacement=bitcast<u32>(sum);\n    let result=atomicCompareExchangeWeak(&splats[index],previous,replacement);\n    if(result.exchanged){break;}\n    previous=result.old_value;\n  }\n}\n`;\n"]}

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

@@ -0,0 +1 @@
+export declare function causticPartitionWGSL(mnee: boolean, lightTracing: boolean, photonMapping?: boolean, mneeMaxDepth?: number, hot?: boolean, photonMaxDepth?: number): string;

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

@@ -0,0 +1,62 @@
+// Smooth classification is independent of the sampled lobe. The single-vertex
+// marker records either an eligible delta transmission or a smooth reflection.
+export function causticPartitionWGSL(mnee, lightTracing, photonMapping = false, mneeMaxDepth = 20, hot = false, photonMaxDepth = 20) {
+    return /* wgsl */ `
+fn causticDim(slot:u32)->u32{return 1048576u+samplingBounce*4096u+slot;}
+fn isCausticSpecular(m: OpenPbrResolvedMaterial) -> bool {
+return m.baseWeight * (1.0 - m.baseMetalness) * (1.0 - m.transmissionWeight) <= 1e-6 &&
+m.subsurfaceWeight <= 0.0 && m.fuzzWeight <= 0.0 && m.coatWeight <= 0.0 && m.causticRoughness <= 0.1;
+}
+fn isCausticT(m: OpenPbrResolvedMaterial) -> bool {
+return isCausticSpecular(m) && m.transmissionWeight == 1.0 && m.causticRoughness == 0.0 && !m.thinWalled && !m.causticNormalMapped && m.alpha>=1.0;
+}
+fn isCausticR(m:OpenPbrResolvedMaterial)->bool{
+return isCausticSpecular(m)&&m.causticRoughness==0.0&&!m.causticNormalMapped&&m.alpha>=1.0;
+}
+fn causticHitOwned(path: Path, xd: bool, vl: bool) -> bool {
+let r1 = ${mnee} && xd && path.causticMneeReceiver && path.causticK == 1u && path.causticSingleT;
+let r2 = ${lightTracing} && vl && path.causticK > 0u && path.causticReceiverPrimary;
+let r3=${photonMapping}&&path.causticPhotonReceiver&&path.causticK>0u;
+return path.causticHasReceiver && (r1 || r2 || r3);
+}
+
+var<private> causticHot:array<vec3f,15>;
+fn causticHotRecord(path:Path,emission:vec3f,kind:u32){
+if(!${hot}){return;}
+let value=max(max(path.beta.x*emission.x,path.beta.y*emission.y),path.beta.z*emission.z);
+if(value<=100.0){return;}
+causticHot[9][kind]+=1.0;
+causticHot[0]+=vec3f(1.0,f32(samplingBounce),f32(path.causticK));
+causticHot[1]+=vec3f(select(0.0,1.0,path.causticHasReceiver),select(0.0,1.0,path.causticSingleT),select(0.0,1.0,path.causticReceiverPrimary));
+causticHot[2]+=vec3f(select(0.0,1.0,path.causticMneeReceiver),select(0.0,1.0,path.causticPhotonReceiver),value);
+if(samplingBounce>=3u&&samplingBounce<=8u){causticHot[samplingBounce]+=vec3f(1.0,f32(path.causticK),value);}
+}
+fn causticEstimateRecord(value:vec3f,kind:u32){
+if(!${hot}){return;}
+let peak=max(max(value.x,value.y),value.z);if(peak>100.0){causticHot[10u+kind]+=vec3f(1.0,f32(samplingBounce),peak);}
+}
+fn causticEmitterRecord(si:SurfaceInteraction,path:Path,weight:f32,emission:vec3f){
+if(!${hot}){return;}
+let value=path.beta*weight*emission;if(max(max(value.x,value.y),value.z)<=100.0){return;}
+let material=materialsBuffer[si.materialIndex];
+causticHot[12]+=vec3f(1.0+dot(si.faceNormal,-path.ray.d),select(0.0,1.0,path.fromEye),material.doubleSided);
+causticHot[13]+=vec3f(weight,material.matType,rtUniform.lightWeightTotal);
+causticHot[14]+=vec3f(path.scatteringPdf,dot(material.emission,luminance),max(max(path.beta.x,path.beta.y),path.beta.z));
+}
+fn causticAdvance(path: ptr<function, Path>, m: OpenPbrResolvedMaterial, transmission: bool, surface: bool) {
+if (surface && isCausticSpecular(m)) {
+(*path).causticK++;
+(*path).causticSingleT = (*path).causticK == 1u && ((isCausticT(m) && transmission)||(isCausticR(m)&&!transmission));
+} else {
+(*path).causticK = 0u;
+(*path).causticSingleT = false;
+(*path).causticPhotonReceiver=surface&&samplingBounce<=${photonMaxDepth}u&&m.materialType!=SHADOW_CATCHER;
+(*path).causticHasReceiver = m.materialType != SHADOW_CATCHER;
+(*path).causticMneeReceiver = surface && samplingBounce<=${mneeMaxDepth}u &&
+m.baseWeight*(1.0-m.baseMetalness)*(1.0-m.transmissionWeight)>0.0 && m.subsurfaceWeight==0.0;
+(*path).causticReceiverPrimary = (*path).fromEye && surface;
+}
+}
+`;
+}
+//# sourceMappingURL=caustics.wgsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"caustics.wgsl.js","sourceRoot":"","sources":["../../../../src/renderer/wgsl/chunks/caustics.wgsl.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,+EAA+E;AAC/E,MAAM,UAAU,oBAAoB,CAAC,IAAa,EAAE,YAAqB,EAAC,aAAa,GAAC,KAAK,EAAC,YAAY,GAAC,EAAE,EAAC,GAAG,GAAC,KAAK,EAAC,cAAc,GAAC,EAAE;IACvI,OAAO,UAAU,CAAC;;;;;;;;;;;;;WAaP,IAAI;WACJ,YAAY;SACd,aAAa;;;;;;MAMjB,GAAG;;;;;;;;;;MAUH,GAAG;;;;MAIH,GAAG;;;;;;;;;;;;;;yDAcmD,cAAc;;2DAEZ,YAAY;;;;;CAK1E,CAAC;AACF,CAAC","sourcesContent":["// Smooth classification is independent of the sampled lobe. The single-vertex\n// marker records either an eligible delta transmission or a smooth reflection.\nexport function causticPartitionWGSL(mnee: boolean, lightTracing: boolean,photonMapping=false,mneeMaxDepth=20,hot=false,photonMaxDepth=20) {\n  return /* wgsl */ `\nfn causticDim(slot:u32)->u32{return 1048576u+samplingBounce*4096u+slot;}\nfn isCausticSpecular(m: OpenPbrResolvedMaterial) -> bool {\n  return m.baseWeight * (1.0 - m.baseMetalness) * (1.0 - m.transmissionWeight) <= 1e-6 &&\n    m.subsurfaceWeight <= 0.0 && m.fuzzWeight <= 0.0 && m.coatWeight <= 0.0 && m.causticRoughness <= 0.1;\n}\nfn isCausticT(m: OpenPbrResolvedMaterial) -> bool {\n  return isCausticSpecular(m) && m.transmissionWeight == 1.0 && m.causticRoughness == 0.0 && !m.thinWalled && !m.causticNormalMapped && m.alpha>=1.0;\n}\nfn isCausticR(m:OpenPbrResolvedMaterial)->bool{\n return isCausticSpecular(m)&&m.causticRoughness==0.0&&!m.causticNormalMapped&&m.alpha>=1.0;\n}\nfn causticHitOwned(path: Path, mneeLight: bool, tracingLight: bool) -> bool {\n  let r1 = ${mnee} && mneeLight && path.causticMneeReceiver && path.causticK == 1u && path.causticSingleT;\n  let r2 = ${lightTracing} && tracingLight && path.causticK > 0u && path.causticReceiverPrimary;\n  let r3=${photonMapping}&&path.causticPhotonReceiver&&path.causticK>0u;\n  return path.causticHasReceiver && (r1 || r2 || r3);\n}\n// Private evidence images count only unsuppressed PT contributions above 100 after MIS.\nvar<private> causticHot:array<vec3f,15>;\nfn causticHotRecord(path:Path,emission:vec3f,kind:u32){\n if(!${hot}){return;}\n let value=max(max(path.beta.x*emission.x,path.beta.y*emission.y),path.beta.z*emission.z);\n if(value<=100.0){return;}\n causticHot[9][kind]+=1.0;\n causticHot[0]+=vec3f(1.0,f32(samplingBounce),f32(path.causticK));\n causticHot[1]+=vec3f(select(0.0,1.0,path.causticHasReceiver),select(0.0,1.0,path.causticSingleT),select(0.0,1.0,path.causticReceiverPrimary));\n causticHot[2]+=vec3f(select(0.0,1.0,path.causticMneeReceiver),select(0.0,1.0,path.causticPhotonReceiver),value);\n if(samplingBounce>=3u&&samplingBounce<=8u){causticHot[samplingBounce]+=vec3f(1.0,f32(path.causticK),value);}\n}\nfn causticEstimateRecord(value:vec3f,kind:u32){\n if(!${hot}){return;}\n let peak=max(max(value.x,value.y),value.z);if(peak>100.0){causticHot[10u+kind]+=vec3f(1.0,f32(samplingBounce),peak);}\n}\nfn causticEmitterRecord(si:SurfaceInteraction,path:Path,weight:f32,emission:vec3f){\n if(!${hot}){return;}\n let value=path.beta*weight*emission;if(max(max(value.x,value.y),value.z)<=100.0){return;}\n let material=materialsBuffer[si.materialIndex];\n causticHot[12]+=vec3f(1.0+dot(si.faceNormal,-path.ray.d),select(0.0,1.0,path.fromEye),material.doubleSided);\n causticHot[13]+=vec3f(weight,material.matType,rtUniform.lightWeightTotal);\n causticHot[14]+=vec3f(path.scatteringPdf,dot(material.emission,luminance),max(max(path.beta.x,path.beta.y),path.beta.z));\n}\nfn causticAdvance(path: ptr<function, Path>, m: OpenPbrResolvedMaterial, transmission: bool, surface: bool) {\n  if (surface && isCausticSpecular(m)) {\n    (*path).causticK++;\n    (*path).causticSingleT = (*path).causticK == 1u && ((isCausticT(m) && transmission)||(isCausticR(m)&&!transmission));\n  } else {\n    (*path).causticK = 0u;\n    (*path).causticSingleT = false;\n    (*path).causticPhotonReceiver=surface&&samplingBounce<=${photonMaxDepth}u&&m.materialType!=SHADOW_CATCHER;\n    (*path).causticHasReceiver = m.materialType != SHADOW_CATCHER;\n    (*path).causticMneeReceiver = surface && samplingBounce<=${mneeMaxDepth}u &&\n      m.baseWeight*(1.0-m.baseMetalness)*(1.0-m.transmissionWeight)>0.0 && m.subsurfaceWeight==0.0;\n    (*path).causticReceiverPrimary = (*path).fromEye && surface;\n  }\n}\n`;\n}\n"]}

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

@@ -11,12 +11,12 @@ const ROUGHNESS_MIN = 0.001;
 
 
 
-fn rQ(position: vec3f, geometricNormal: vec3f, direction: vec3f) -> vec3f {
+fn sO(position: vec3f, geometricNormal: vec3f, direction: vec3f) -> vec3f {
 let normal = select(-geometricNormal, geometricNormal, dot(geometricNormal, direction) >= 0.0);
-let qk = vec3i(256.0 * normal);
+let rb = vec3i(256.0 * normal);
 let bits = bitcast<vec3i>(position);
-let vO = bitcast<vec3f>(bits + select(qk, -qk, position < vec3f(0.0)));
-return select(vO, position + normal / 65536.0, abs(position) < vec3f(1.0 / 32.0));
+let ye = bitcast<vec3f>(bits + select(rb, -rb, position < vec3f(0.0)));
+return select(ye, position + normal / 65536.0, abs(position) < vec3f(1.0 / 32.0));
 }
 
 `;

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

@@ -1,2 +1,2 @@
-declare const _default: "\n\nfn textureLinear(tex: texture_2d<f32>, _uv: vec2f) -> vec4f {\n  // #ifdef OES_texture_float_linear\n  //   return texture(map, uv);\n  // #else\n  let size = vec2f(textureDimensions(tex, 0));\n\n  let uv2f = _uv * size - vec2f(0.5);\n  let uvFloor = floor(uv2f);\n  let f = fract(uv2f);\n  let uv2i = vec2i(uvFloor);\n  let maximum = vec2i(size) - vec2i(1);\n\n  // TODO use textureGather\n  let s1 = textureLoad(tex, clamp(uv2i + vec2i(0, 0), vec2i(0), maximum), 0);\n  let s2 = textureLoad(tex, clamp(uv2i + vec2i(1, 0), vec2i(0), maximum), 0);\n  let s3 = textureLoad(tex, clamp(uv2i + vec2i(0, 1), vec2i(0), maximum), 0);\n  let s4 = textureLoad(tex, clamp(uv2i + vec2i(1, 1), vec2i(0), maximum), 0);\n\n  return mix(mix(s1, s2, f.x), mix(s3, s4, f.x), f.y);\n  // #endif\n}\n\nfn cartesianToEquirect(pointOnSphere: vec3f) -> vec2f {\n  var phi = atan2(-pointOnSphere.z, -pointOnSphere.x);\n  if (phi < 0.0) {\n    phi += TWOPI;\n  }\n  let theta = acos(clamp(pointOnSphere.y, -1.0, 1.0));\n  return vec2f(phi * 0.5 * INVPI, theta * INVPI);\n}\n\nfn environmentOrientation() -> mat3x3f {\n  return mat3x3f(rtUniform.environmentRotation[0].xyz, rtUniform.environmentRotation[1].xyz, rtUniform.environmentRotation[2].xyz);\n}\n\nfn environmentUv(worldDirection: vec3f) -> vec2f {\n  return cartesianToEquirect(transpose(environmentOrientation()) * worldDirection);\n}\n\nfn getEnvmapV(u: f32, vOffset: ptr<function, i32>, pdf: ptr<function, vec2f>) -> f32 {\n  let size = vec2i(textureDimensions(envMap, 0));\n\n  var left = 0;\n  var right = size.y + 1; // cdf length is the length of the env map + 1\n  while (left < right) {\n    let mid = (left + right) >> 1;\n    let s = textureLoad(envMapDistribution, vec2i(0, mid), 0).x;\n    if (s <= u) {\n      left = mid + 1;\n    } else {\n      right = mid;\n    }\n  }\n  *vOffset = left - 1;\n\n  // x channel is cumulative distribution of env map luminance\n  // y channel is partial probability density of env map luminance\n  let s0 = textureLoad(envMapDistribution, vec2i(0, *vOffset), 0).xy;\n  let s1 = textureLoad(envMapDistribution, vec2i(0, *vOffset + 1), 0).xy;\n\n  (*pdf).y = s0.y;\n\n  return (f32(*vOffset) +  (u - s0.x) / (s1.x - s0.x)) / f32(size.y);\n}\n\nfn getEnvmapU(u: f32, vOffset: i32, pdf: ptr<function, vec2f>) -> f32 {\n  let size = vec2i(textureDimensions(envMap, 0));\n\n  var left = 0;\n  var right = size.x + 1; // cdf length is the length of the env map + 1\n  while (left < right) {\n    let mid = (left + right) >> 1;\n    let s = textureLoad(envMapDistribution, vec2i(1 + mid, vOffset), 0).x;\n    if (s <= u) {\n      left = mid + 1;\n    } else {\n      right = mid;\n    }\n  }\n  let uOffset = left - 1;\n\n  // x channel is cumulative distribution of env map luminance\n  // y channel is partial probability density of env map luminance\n  let s0 = textureLoad(envMapDistribution, vec2i(1 + uOffset, vOffset), 0).xy;\n  let s1 = textureLoad(envMapDistribution, vec2i(1 + uOffset + 1, vOffset), 0).xy;\n\n  (*pdf).x = s0.y;\n\n  return (f32(uOffset) + (u - s0.x) / (s1.x - s0.x)) / f32(size.x);\n}\n\n// Perform two binary searches to find light direction.\nfn sampleEnvmap(random: vec2f, uv: ptr<function, vec2f>, pdf: ptr<function, f32>) -> vec3f {\n  var partialPdf: vec2f;\n  var vOffset: i32;\n\n  (*uv).y = getEnvmapV(random.x, &vOffset, &partialPdf);\n  (*uv).x = getEnvmapU(random.y, vOffset, &partialPdf);\n\n  let phi = (*uv).x * TWOPI;\n  let theta = (*uv).y * PI;\n  let cosTheta = cos(theta);\n  let sinTheta = sin(theta);\n  let cosPhi = cos(phi);\n  let sinPhi = sin(phi);\n\n  let dir = vec3f(-sinTheta * cosPhi, cosTheta, -sinTheta * sinPhi);\n\n  *pdf = partialPdf.x * partialPdf.y * INVPI2 / (2.0 * sinTheta);\n\n  return environmentOrientation() * dir;\n}\n\nfn envMapPdf(_uv: vec2f) -> f32 {\n  let size = vec2f(textureDimensions(envMap, 0));\n\n  let sinTheta = sin(_uv.y * PI);\n\n  let _uv2 = vec2i(_uv * size);\n\n  let partialX = textureLoad(envMapDistribution, vec2i(1 + _uv2.x, _uv2.y), 0).y;\n  let partialY = textureLoad(envMapDistribution, vec2i(0, _uv2.y), 0).y;\n\n  return partialX * partialY * INVPI2 / (2.0 * sinTheta);\n}\n\n\n";
+declare const _default: "\n\nfn textureLinear(tex: texture_2d<f32>, _uv: vec2f) -> vec4f {\n  // #ifdef OES_texture_float_linear\n  //   return texture(map, uv);\n  // #else\n  let size = vec2f(textureDimensions(tex, 0));\n\n  let uv2f = _uv * size - vec2f(0.5);\n  let uvFloor = floor(uv2f);\n  let f = fract(uv2f);\n  let uv2i = vec2i(uvFloor);\n  let maximum = vec2i(size) - vec2i(1);\n\n  // TODO use textureGather\n  let s1 = textureLoad(tex, clamp(uv2i + vec2i(0, 0), vec2i(0), maximum), 0);\n  let s2 = textureLoad(tex, clamp(uv2i + vec2i(1, 0), vec2i(0), maximum), 0);\n  let s3 = textureLoad(tex, clamp(uv2i + vec2i(0, 1), vec2i(0), maximum), 0);\n  let s4 = textureLoad(tex, clamp(uv2i + vec2i(1, 1), vec2i(0), maximum), 0);\n\n  return mix(mix(s1, s2, f.x), mix(s3, s4, f.x), f.y);\n  // #endif\n}\n\nfn cartesianToEquirect(pointOnSphere: vec3f) -> vec2f {\n  var phi = atan2(-pointOnSphere.z, -pointOnSphere.x);\n  if (phi < 0.0) {\n    phi += TWOPI;\n  }\n  let theta = acos(clamp(pointOnSphere.y, -1.0, 1.0));\n  return vec2f(phi * 0.5 * INVPI, theta * INVPI);\n}\n\nfn environmentOrientation() -> mat3x3f {\n  return mat3x3f(rtUniform.environmentRotation[0].xyz, rtUniform.environmentRotation[1].xyz, rtUniform.environmentRotation[2].xyz);\n}\n\nfn environmentUv(worldDirection: vec3f) -> vec2f {\n  return cartesianToEquirect(transpose(environmentOrientation()) * worldDirection);\n}\n\nfn getEnvmapV(u: f32, vOffset: ptr<function, i32>, pdf: ptr<function, vec2f>) -> f32 {\n  let size = vec2i(textureDimensions(envMap, 0));\n\n  var left = 0;\n  var right = size.y + 1; // cdf length is the length of the env map + 1\n  while (left < right) {\n    let mid = (left + right) >> 1;\n    let s = textureLoad(envMapDistribution, vec2i(0, mid), 0).x;\n    if (s <= u) {\n      left = mid + 1;\n    } else {\n      right = mid;\n    }\n  }\n  *vOffset = left - 1;\n\n  // x channel is cumulative distribution of env map luminance\n  // y channel is partial probability density of env map luminance\n  let s0 = textureLoad(envMapDistribution, vec2i(0, *vOffset), 0).xy;\n  let s1 = textureLoad(envMapDistribution, vec2i(0, *vOffset + 1), 0).xy;\n\n  (*pdf).y = s0.y;\n\n  return (f32(*vOffset) +  (u - s0.x) / (s1.x - s0.x)) / f32(size.y);\n}\n\nfn getEnvmapU(u: f32, vOffset: i32, pdf: ptr<function, vec2f>) -> f32 {\n  let size = vec2i(textureDimensions(envMap, 0));\n\n  var left = 0;\n  var right = size.x + 1; // cdf length is the length of the env map + 1\n  while (left < right) {\n    let mid = (left + right) >> 1;\n    let s = textureLoad(envMapDistribution, vec2i(1 + mid, vOffset), 0).x;\n    if (s <= u) {\n      left = mid + 1;\n    } else {\n      right = mid;\n    }\n  }\n  let uOffset = left - 1;\n\n  // x channel is cumulative distribution of env map luminance\n  // y channel is partial probability density of env map luminance\n  let s0 = textureLoad(envMapDistribution, vec2i(1 + uOffset, vOffset), 0).xy;\n  let s1 = textureLoad(envMapDistribution, vec2i(1 + uOffset + 1, vOffset), 0).xy;\n\n  (*pdf).x = s0.y;\n\n  return (f32(uOffset) + (u - s0.x) / (s1.x - s0.x)) / f32(size.x);\n}\n\n// The lat-long Jacobian is undefined at either pole. In f32, sin(PI) can\n// also be negative, which makes MIS amplify a BSDF hit instead of weighting it.\nfn envMapSolidAnglePdf(partialPdf: vec2f, v: f32) -> f32 {\n  if (!(v > 0.0 && v < 1.0)) { return 0.0; }\n  let sinTheta = sin(min(v, 1.0 - v) * PI);\n  return partialPdf.x * partialPdf.y * INVPI2 / (2.0 * sinTheta);\n}\n\n// Perform two binary searches to find light direction.\nfn sampleEnvmap(random: vec2f, uv: ptr<function, vec2f>, pdf: ptr<function, f32>) -> vec3f {\n  var partialPdf: vec2f;\n  var vOffset: i32;\n\n  (*uv).y = getEnvmapV(random.x, &vOffset, &partialPdf);\n  (*uv).x = getEnvmapU(random.y, vOffset, &partialPdf);\n\n  let phi = (*uv).x * TWOPI;\n  let theta = (*uv).y * PI;\n  let cosTheta = cos(theta);\n  let sinTheta = sin(theta);\n  let cosPhi = cos(phi);\n  let sinPhi = sin(phi);\n\n  let dir = vec3f(-sinTheta * cosPhi, cosTheta, -sinTheta * sinPhi);\n\n  *pdf = envMapSolidAnglePdf(partialPdf, (*uv).y);\n\n  return environmentOrientation() * dir;\n}\n\nfn envMapPdf(_uv: vec2f) -> f32 {\n  let size = vec2f(textureDimensions(envMap, 0));\n\n  let _uv2 = clamp(vec2i(_uv * size), vec2i(0), vec2i(size) - vec2i(1));\n\n  let partialX = textureLoad(envMapDistribution, vec2i(1 + _uv2.x, _uv2.y), 0).y;\n  let partialY = textureLoad(envMapDistribution, vec2i(0, _uv2.y), 0).y;\n\n  return envMapSolidAnglePdf(vec2f(partialX, partialY), _uv.y);\n}\n\n\n";
 export default _default;

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

@@ -11,23 +11,23 @@ fn textureLinear(tex: texture_2d<f32>, _uv: vec2f) -> vec4f {
 
 let size = vec2f(textureDimensions(tex, 0));
 
-let wN = _uv * size - vec2f(0.5);
-let vT = floor(wN);
-let f = fract(wN);
-let vS = vec2i(vT);
+let uv2f = _uv * size - vec2f(0.5);
+let yj = floor(uv2f);
+let f = fract(uv2f);
+let yi = vec2i(yj);
 let maximum = vec2i(size) - vec2i(1);
 
 
-let s1 = textureLoad(tex, clamp(vS + vec2i(0, 0), vec2i(0), maximum), 0);
-let s2 = textureLoad(tex, clamp(vS + vec2i(1, 0), vec2i(0), maximum), 0);
-let s3 = textureLoad(tex, clamp(vS + vec2i(0, 1), vec2i(0), maximum), 0);
-let s4 = textureLoad(tex, clamp(vS + vec2i(1, 1), vec2i(0), maximum), 0);
+let s1 = textureLoad(tex, clamp(yi + vec2i(0, 0), vec2i(0), maximum), 0);
+let s2 = textureLoad(tex, clamp(yi + vec2i(1, 0), vec2i(0), maximum), 0);
+let s3 = textureLoad(tex, clamp(yi + vec2i(0, 1), vec2i(0), maximum), 0);
+let s4 = textureLoad(tex, clamp(yi + vec2i(1, 1), vec2i(0), maximum), 0);
 
 return mix(mix(s1, s2, f.x), mix(s3, s4, f.x), f.y);
 
 }
 
-fn eL(gh: vec3f) -> vec2f {
+fn eF(gh: vec3f) -> vec2f {
 var phi = atan2(-gh.z, -gh.x);
 if (phi < 0.0) {
 phi += TWOPI;
@@ -36,15 +36,15 @@ let theta = acos(clamp(gh.y, -1.0, 1.0));
 return vec2f(phi * 0.5 * INVPI, theta * INVPI);
 }
 
-fn jN() -> mat3x3f {
+fn jS() -> mat3x3f {
 return mat3x3f(rtUniform.environmentRotation[0].xyz, rtUniform.environmentRotation[1].xyz, rtUniform.environmentRotation[2].xyz);
 }
 
-fn cY(mP: vec3f) -> vec2f {
-return eL(transpose(jN()) * mP);
+fn cT(nD: vec3f) -> vec2f {
+return eF(transpose(jS()) * nD);
 }
 
-fn qB(u: f32, vOffset: ptr<function, i32>, pdf: ptr<function, vec2f>) -> f32 {
+fn rv(u: f32, vOffset: ptr<function, i32>, pdf: ptr<function, vec2f>) -> f32 {
 let size = vec2i(textureDimensions(envMap, 0));
 
 var left = 0;
@@ -70,7 +70,7 @@ let s1 = textureLoad(envMapDistribution, vec2i(0, *vOffset + 1), 0).xy;
 return (f32(*vOffset) +  (u - s0.x) / (s1.x - s0.x)) / f32(size.y);
 }
 
-fn qA(u: f32, vOffset: i32, pdf: ptr<function, vec2f>) -> f32 {
+fn ru(u: f32, vOffset: i32, pdf: ptr<function, vec2f>) -> f32 {
 let size = vec2i(textureDimensions(envMap, 0));
 
 var left = 0;
@@ -84,51 +84,57 @@ left = mid + 1;
 right = mid;
 }
 }
-let oR = left - 1;
+let pw = left - 1;
 
 
 
-let s0 = textureLoad(envMapDistribution, vec2i(1 + oR, vOffset), 0).xy;
-let s1 = textureLoad(envMapDistribution, vec2i(1 + oR + 1, vOffset), 0).xy;
+let s0 = textureLoad(envMapDistribution, vec2i(1 + pw, vOffset), 0).xy;
+let s1 = textureLoad(envMapDistribution, vec2i(1 + pw + 1, vOffset), 0).xy;
 
 (*pdf).x = s0.y;
 
-return (f32(oR) + (u - s0.x) / (s1.x - s0.x)) / f32(size.x);
+return (f32(pw) + (u - s0.x) / (s1.x - s0.x)) / f32(size.x);
 }
 
 
-fn oL(random: vec2f, uv: ptr<function, vec2f>, pdf: ptr<function, f32>) -> vec3f {
-var he: vec2f;
+
+fn envMapSolidAnglePdf(partialPdf: vec2f, v: f32) -> f32 {
+if (!(v > 0.0 && v < 1.0)) { return 0.0; }
+let sinTheta = sin(min(v, 1.0 - v) * PI);
+return partialPdf.x * partialPdf.y * INVPI2 / (2.0 * sinTheta);
+}
+
+
+fn pn(random: vec2f, uv: ptr<function, vec2f>, pdf: ptr<function, f32>) -> vec3f {
+var partialPdf: vec2f;
 var vOffset: i32;
 
-(*uv).y = qB(random.x, &vOffset, &he);
-(*uv).x = qA(random.y, vOffset, &he);
+(*uv).y = rv(random.x, &vOffset, &partialPdf);
+(*uv).x = ru(random.y, vOffset, &partialPdf);
 
 let phi = (*uv).x * TWOPI;
 let theta = (*uv).y * PI;
-let cc = cos(theta);
+let ct = cos(theta);
 let sinTheta = sin(theta);
-let ul = cos(phi);
-let uw = sin(phi);
+let vZ = cos(phi);
+let wr = sin(phi);
 
-let dir = vec3f(-sinTheta * ul, cc, -sinTheta * uw);
+let dir = vec3f(-sinTheta * vZ, ct, -sinTheta * wr);
 
-*pdf = he.x * he.y * INVPI2 / (2.0 * sinTheta);
+*pdf = envMapSolidAnglePdf(partialPdf, (*uv).y);
 
-return jN() * dir;
+return jS() * dir;
 }
 
-fn iB(_uv: vec2f) -> f32 {
+fn envMapPdf(_uv: vec2f) -> f32 {
 let size = vec2f(textureDimensions(envMap, 0));
 
-let sinTheta = sin(_uv.y * PI);
-
-let vX = vec2i(_uv * size);
+let yn = clamp(vec2i(_uv * size), vec2i(0), vec2i(size) - vec2i(1));
 
-let sL = textureLoad(envMapDistribution, vec2i(1 + vX.x, vX.y), 0).y;
-let sM = textureLoad(envMapDistribution, vec2i(0, vX.y), 0).y;
+let ue = textureLoad(envMapDistribution, vec2i(1 + yn.x, yn.y), 0).y;
+let uf = textureLoad(envMapDistribution, vec2i(0, yn.y), 0).y;
 
-return sL * sM * INVPI2 / (2.0 * sinTheta);
+return envMapSolidAnglePdf(vec2f(ue, uf), _uv.y);
 }
 
 

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

@@ -1 +1 @@
-{"version":3,"file":"envMap.wgsl.js","sourceRoot":"","sources":["../../../../src/renderer/wgsl/chunks/envMap.wgsl.ts"],"names":[],"mappings":"AAAA,qDAAqD;AACrD,sDAAsD;AACtD,kFAAkF;AAElF,sFAAsF;AACtF,uHAAuH;AAEvH,eAAe,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiIzB,CAAC","sourcesContent":["// Portions adapted from ray-tracing-renderer@0.10.15\n// (https://github.com/hoverinc/ray-tracing-renderer).\n// Copyright (c) 2019 HOVER, MIT license; see LICENSES/RayTracingRenderer-MIT.txt.\n\n// Sample the environment map using a cumulative distribution function as described in\n// http://www.pbr-book.org/3ed-2018/Light_Transport_I_Surface_Reflection/Sampling_Light_Sources.html#InfiniteAreaLights\n\nexport default /* wgsl */ `\n\nfn textureLinear(tex: texture_2d<f32>, _uv: vec2f) -> vec4f {\n  // #ifdef OES_texture_float_linear\n  //   return texture(map, uv);\n  // #else\n  let size = vec2f(textureDimensions(tex, 0));\n\n  let uv2f = _uv * size - vec2f(0.5);\n  let uvFloor = floor(uv2f);\n  let f = fract(uv2f);\n  let uv2i = vec2i(uvFloor);\n  let maximum = vec2i(size) - vec2i(1);\n\n  // TODO use textureGather\n  let s1 = textureLoad(tex, clamp(uv2i + vec2i(0, 0), vec2i(0), maximum), 0);\n  let s2 = textureLoad(tex, clamp(uv2i + vec2i(1, 0), vec2i(0), maximum), 0);\n  let s3 = textureLoad(tex, clamp(uv2i + vec2i(0, 1), vec2i(0), maximum), 0);\n  let s4 = textureLoad(tex, clamp(uv2i + vec2i(1, 1), vec2i(0), maximum), 0);\n\n  return mix(mix(s1, s2, f.x), mix(s3, s4, f.x), f.y);\n  // #endif\n}\n\nfn cartesianToEquirect(pointOnSphere: vec3f) -> vec2f {\n  var phi = atan2(-pointOnSphere.z, -pointOnSphere.x);\n  if (phi < 0.0) {\n    phi += TWOPI;\n  }\n  let theta = acos(clamp(pointOnSphere.y, -1.0, 1.0));\n  return vec2f(phi * 0.5 * INVPI, theta * INVPI);\n}\n\nfn environmentOrientation() -> mat3x3f {\n  return mat3x3f(rtUniform.environmentRotation[0].xyz, rtUniform.environmentRotation[1].xyz, rtUniform.environmentRotation[2].xyz);\n}\n\nfn environmentUv(worldDirection: vec3f) -> vec2f {\n  return cartesianToEquirect(transpose(environmentOrientation()) * worldDirection);\n}\n\nfn getEnvmapV(u: f32, vOffset: ptr<function, i32>, pdf: ptr<function, vec2f>) -> f32 {\n  let size = vec2i(textureDimensions(envMap, 0));\n\n  var left = 0;\n  var right = size.y + 1; // cdf length is the length of the env map + 1\n  while (left < right) {\n    let mid = (left + right) >> 1;\n    let s = textureLoad(envMapDistribution, vec2i(0, mid), 0).x;\n    if (s <= u) {\n      left = mid + 1;\n    } else {\n      right = mid;\n    }\n  }\n  *vOffset = left - 1;\n\n  // x channel is cumulative distribution of env map luminance\n  // y channel is partial probability density of env map luminance\n  let s0 = textureLoad(envMapDistribution, vec2i(0, *vOffset), 0).xy;\n  let s1 = textureLoad(envMapDistribution, vec2i(0, *vOffset + 1), 0).xy;\n\n  (*pdf).y = s0.y;\n\n  return (f32(*vOffset) +  (u - s0.x) / (s1.x - s0.x)) / f32(size.y);\n}\n\nfn getEnvmapU(u: f32, vOffset: i32, pdf: ptr<function, vec2f>) -> f32 {\n  let size = vec2i(textureDimensions(envMap, 0));\n\n  var left = 0;\n  var right = size.x + 1; // cdf length is the length of the env map + 1\n  while (left < right) {\n    let mid = (left + right) >> 1;\n    let s = textureLoad(envMapDistribution, vec2i(1 + mid, vOffset), 0).x;\n    if (s <= u) {\n      left = mid + 1;\n    } else {\n      right = mid;\n    }\n  }\n  let uOffset = left - 1;\n\n  // x channel is cumulative distribution of env map luminance\n  // y channel is partial probability density of env map luminance\n  let s0 = textureLoad(envMapDistribution, vec2i(1 + uOffset, vOffset), 0).xy;\n  let s1 = textureLoad(envMapDistribution, vec2i(1 + uOffset + 1, vOffset), 0).xy;\n\n  (*pdf).x = s0.y;\n\n  return (f32(uOffset) + (u - s0.x) / (s1.x - s0.x)) / f32(size.x);\n}\n\n// Perform two binary searches to find light direction.\nfn sampleEnvmap(random: vec2f, uv: ptr<function, vec2f>, pdf: ptr<function, f32>) -> vec3f {\n  var partialPdf: vec2f;\n  var vOffset: i32;\n\n  (*uv).y = getEnvmapV(random.x, &vOffset, &partialPdf);\n  (*uv).x = getEnvmapU(random.y, vOffset, &partialPdf);\n\n  let phi = (*uv).x * TWOPI;\n  let theta = (*uv).y * PI;\n  let cosTheta = cos(theta);\n  let sinTheta = sin(theta);\n  let cosPhi = cos(phi);\n  let sinPhi = sin(phi);\n\n  let dir = vec3f(-sinTheta * cosPhi, cosTheta, -sinTheta * sinPhi);\n\n  *pdf = partialPdf.x * partialPdf.y * INVPI2 / (2.0 * sinTheta);\n\n  return environmentOrientation() * dir;\n}\n\nfn envMapPdf(_uv: vec2f) -> f32 {\n  let size = vec2f(textureDimensions(envMap, 0));\n\n  let sinTheta = sin(_uv.y * PI);\n\n  let _uv2 = vec2i(_uv * size);\n\n  let partialX = textureLoad(envMapDistribution, vec2i(1 + _uv2.x, _uv2.y), 0).y;\n  let partialY = textureLoad(envMapDistribution, vec2i(0, _uv2.y), 0).y;\n\n  return partialX * partialY * INVPI2 / (2.0 * sinTheta);\n}\n\n\n`;\n"]}
+{"version":3,"file":"envMap.wgsl.js","sourceRoot":"","sources":["../../../../src/renderer/wgsl/chunks/envMap.wgsl.ts"],"names":[],"mappings":"AAAA,qDAAqD;AACrD,sDAAsD;AACtD,kFAAkF;AAElF,sFAAsF;AACtF,uHAAuH;AAEvH,eAAe,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuIzB,CAAC","sourcesContent":["// Portions adapted from ray-tracing-renderer@0.10.15\n// (https://github.com/hoverinc/ray-tracing-renderer).\n// Copyright (c) 2019 HOVER, MIT license; see LICENSES/RayTracingRenderer-MIT.txt.\n\n// Sample the environment map using a cumulative distribution function as described in\n// http://www.pbr-book.org/3ed-2018/Light_Transport_I_Surface_Reflection/Sampling_Light_Sources.html#InfiniteAreaLights\n\nexport default /* wgsl */ `\n\nfn textureLinear(tex: texture_2d<f32>, _uv: vec2f) -> vec4f {\n  // #ifdef OES_texture_float_linear\n  //   return texture(map, uv);\n  // #else\n  let size = vec2f(textureDimensions(tex, 0));\n\n  let uv2f = _uv * size - vec2f(0.5);\n  let uvFloor = floor(uv2f);\n  let f = fract(uv2f);\n  let uv2i = vec2i(uvFloor);\n  let maximum = vec2i(size) - vec2i(1);\n\n  // TODO use textureGather\n  let s1 = textureLoad(tex, clamp(uv2i + vec2i(0, 0), vec2i(0), maximum), 0);\n  let s2 = textureLoad(tex, clamp(uv2i + vec2i(1, 0), vec2i(0), maximum), 0);\n  let s3 = textureLoad(tex, clamp(uv2i + vec2i(0, 1), vec2i(0), maximum), 0);\n  let s4 = textureLoad(tex, clamp(uv2i + vec2i(1, 1), vec2i(0), maximum), 0);\n\n  return mix(mix(s1, s2, f.x), mix(s3, s4, f.x), f.y);\n  // #endif\n}\n\nfn cartesianToEquirect(pointOnSphere: vec3f) -> vec2f {\n  var phi = atan2(-pointOnSphere.z, -pointOnSphere.x);\n  if (phi < 0.0) {\n    phi += TWOPI;\n  }\n  let theta = acos(clamp(pointOnSphere.y, -1.0, 1.0));\n  return vec2f(phi * 0.5 * INVPI, theta * INVPI);\n}\n\nfn environmentOrientation() -> mat3x3f {\n  return mat3x3f(rtUniform.environmentRotation[0].xyz, rtUniform.environmentRotation[1].xyz, rtUniform.environmentRotation[2].xyz);\n}\n\nfn environmentUv(worldDirection: vec3f) -> vec2f {\n  return cartesianToEquirect(transpose(environmentOrientation()) * worldDirection);\n}\n\nfn getEnvmapV(u: f32, vOffset: ptr<function, i32>, pdf: ptr<function, vec2f>) -> f32 {\n  let size = vec2i(textureDimensions(envMap, 0));\n\n  var left = 0;\n  var right = size.y + 1; // cdf length is the length of the env map + 1\n  while (left < right) {\n    let mid = (left + right) >> 1;\n    let s = textureLoad(envMapDistribution, vec2i(0, mid), 0).x;\n    if (s <= u) {\n      left = mid + 1;\n    } else {\n      right = mid;\n    }\n  }\n  *vOffset = left - 1;\n\n  // x channel is cumulative distribution of env map luminance\n  // y channel is partial probability density of env map luminance\n  let s0 = textureLoad(envMapDistribution, vec2i(0, *vOffset), 0).xy;\n  let s1 = textureLoad(envMapDistribution, vec2i(0, *vOffset + 1), 0).xy;\n\n  (*pdf).y = s0.y;\n\n  return (f32(*vOffset) +  (u - s0.x) / (s1.x - s0.x)) / f32(size.y);\n}\n\nfn getEnvmapU(u: f32, vOffset: i32, pdf: ptr<function, vec2f>) -> f32 {\n  let size = vec2i(textureDimensions(envMap, 0));\n\n  var left = 0;\n  var right = size.x + 1; // cdf length is the length of the env map + 1\n  while (left < right) {\n    let mid = (left + right) >> 1;\n    let s = textureLoad(envMapDistribution, vec2i(1 + mid, vOffset), 0).x;\n    if (s <= u) {\n      left = mid + 1;\n    } else {\n      right = mid;\n    }\n  }\n  let uOffset = left - 1;\n\n  // x channel is cumulative distribution of env map luminance\n  // y channel is partial probability density of env map luminance\n  let s0 = textureLoad(envMapDistribution, vec2i(1 + uOffset, vOffset), 0).xy;\n  let s1 = textureLoad(envMapDistribution, vec2i(1 + uOffset + 1, vOffset), 0).xy;\n\n  (*pdf).x = s0.y;\n\n  return (f32(uOffset) + (u - s0.x) / (s1.x - s0.x)) / f32(size.x);\n}\n\n// The lat-long Jacobian is undefined at either pole. In f32, sin(PI) can\n// also be negative, which makes MIS amplify a BSDF hit instead of weighting it.\nfn envMapSolidAnglePdf(partialPdf: vec2f, v: f32) -> f32 {\n  if (!(v > 0.0 && v < 1.0)) { return 0.0; }\n  let sinTheta = sin(min(v, 1.0 - v) * PI);\n  return partialPdf.x * partialPdf.y * INVPI2 / (2.0 * sinTheta);\n}\n\n// Perform two binary searches to find light direction.\nfn sampleEnvmap(random: vec2f, uv: ptr<function, vec2f>, pdf: ptr<function, f32>) -> vec3f {\n  var partialPdf: vec2f;\n  var vOffset: i32;\n\n  (*uv).y = getEnvmapV(random.x, &vOffset, &partialPdf);\n  (*uv).x = getEnvmapU(random.y, vOffset, &partialPdf);\n\n  let phi = (*uv).x * TWOPI;\n  let theta = (*uv).y * PI;\n  let cosTheta = cos(theta);\n  let sinTheta = sin(theta);\n  let cosPhi = cos(phi);\n  let sinPhi = sin(phi);\n\n  let dir = vec3f(-sinTheta * cosPhi, cosTheta, -sinTheta * sinPhi);\n\n  *pdf = envMapSolidAnglePdf(partialPdf, (*uv).y);\n\n  return environmentOrientation() * dir;\n}\n\nfn envMapPdf(_uv: vec2f) -> f32 {\n  let size = vec2f(textureDimensions(envMap, 0));\n\n  let _uv2 = clamp(vec2i(_uv * size), vec2i(0), vec2i(size) - vec2i(1));\n\n  let partialX = textureLoad(envMapDistribution, vec2i(1 + _uv2.x, _uv2.y), 0).y;\n  let partialY = textureLoad(envMapDistribution, vec2i(0, _uv2.y), 0).y;\n\n  return envMapSolidAnglePdf(vec2f(partialX, partialY), _uv.y);\n}\n\n\n`;\n"]}

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

@@ -1,6 +1,18 @@
-export default function getIntersectCode({ hasDisplacement, hasAnisotropyDirections, hasCoatNormals, blasLayoutMask }: {
+export declare function createSceneHitQueryWgsl(hasAnisotropyDirections?: boolean): string;
+export declare function createSceneIntersectionsWgsl({ hasDisplacement, hasAnisotropyDirections, hasCoatNormals, blasLayoutMask, closestName, shadowName, bevelName, closestHitHook }: {
     hasDisplacement: boolean;
     hasAnisotropyDirections?: boolean;
     hasCoatNormals?: boolean;
     blasLayoutMask?: number;
+    closestName?: string;
+    shadowName?: string;
+    bevelName?: string;
+    closestHitHook?: string;
+}): string;
+export default function getIntersectCode({ hasDisplacement, hasAnisotropyDirections, hasCoatNormals, blasLayoutMask, sceneIntersections }: {
+    hasDisplacement: boolean;
+    hasAnisotropyDirections?: boolean;
+    hasCoatNormals?: boolean;
+    blasLayoutMask?: number;
+    sceneIntersections?: string;
 }): string;