@meimu/mutracer 0.1.4 → 0.2.0

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

@@ -2,41 +2,41 @@
 // http://www.pbr-book.org/3ed-2018/Light_Transport_I_Surface_Reflection/Direct_Lighting.html#EstimatingtheDirectLightingIntegral
 import { glsl } from '../../shader.js';
 export default glsl `
-vec3 mU(ad si, J mat, ag prepared, inout Path aa, vec3 ffnormal, bool gE) {
-float mD = 1.0;
-vec3 ln = vec3(fo(cw(LIGHT_POSITION)), dz(cw(LIGHT_SELECT)));
+vec3 ta(SurfaceInteraction si, OpenPbrResolvedMaterial mat, ag prepared, inout Path aa, vec3 ffnormal, bool eM) {
+float lY = 1.0;
+vec3 lV = vec3(dZ(cE(LIGHT_POSITION)), dp(cE(LIGHT_SELECT)));
 
 LightSampleRec lightSample;
-sampleLight(si.position, ln, lightSample, false);
-lightSample.emission = ai(lightSample.emission, bf);
+sampleLight(si.position, lV, lightSample, false);
+lightSample.emission = aj(lightSample.emission, bp);
 
 vec3 lightDir = lightSample.direction;
-vec3 oT = -aa.ray.d;
-float fg = lightSample.pdf;
+vec3 qY = -aa.ray.d;
+float fA = lightSample.pdf;
 
 
 
 
 float cosThetaL = dot(ffnormal, lightDir);
-#ifdef NUM_COAT_NORMAL_MAPS
-if (gE && mat.coatNormalEnabled) { cosThetaL = dot(mat.geometricNormal, lightDir); }
+#ifdef USE_COAT_NORMAL_FRAMES
+if (eM && mat.coatNormalEnabled) { cosThetaL = dot(mat.geometricNormal, lightDir); }
 #endif
 
-if (fg <= 0.0 || max(max(lightSample.emission.x, lightSample.emission.y), lightSample.emission.z) <= 0.0) {
+if (fA <= 0.0 || max(max(lightSample.emission.x, lightSample.emission.y), lightSample.emission.z) <= 0.0) {
 return vec3(0.0);
 }
 
 float scatteringPdf = 0.0;
 vec3 f = vec3(0.0);
-if (gE) {
+if (eM) {
 if (cosThetaL <= 0.0 && mat.transmissionWeight <= 0.0 && mat.subsurfaceWeight <= 0.0) {
 return vec3(0.0);
 }
-f = bI(prepared, lightDir, scatteringPdf);
+f = bO(prepared, lightDir, scatteringPdf);
 }
 else {
-scatteringPdf = bD(
-dot(oT, lightDir),
+scatteringPdf = bL(
+dot(qY, lightDir),
 si.mediumAnisotropy
 );
 f = vec3(scatteringPdf);
@@ -46,181 +46,181 @@ if (scatteringPdf <= 0.0 || max(max(f.x, f.y), f.z) <= 0.0) {
 return vec3(0.0);
 }
 
-Ray mA;
-vec3 hi = si.position + EPS * lightDir;
-if (gE) {
-const float bZ = 0.1;
-float dr = dot(si.normal, lightDir);
-#ifdef NUM_COAT_NORMAL_MAPS
-if (mat.coatNormalEnabled) { dr = dot(si.faceNormal, lightDir); }
+Ray ns;
+vec3 hw = si.position + EPS * lightDir;
+if (eM) {
+const float ch = 0.1;
+float dL = dot(si.normal, lightDir);
+#ifdef USE_COAT_NORMAL_FRAMES
+if (mat.coatNormalEnabled) { dL = dot(si.faceNormal, lightDir); }
 #endif
-vec3 geometricNormal = dr < 0.0 ? -si.faceNormal : si.faceNormal;
-dr = abs(dr);
-float hS = dot(geometricNormal, lightDir);
-float oC = dr < bZ
+vec3 geometricNormal = dL < 0.0 ? -si.faceNormal : si.faceNormal;
+dL = abs(dL);
+float iq = dot(geometricNormal, lightDir);
+float pq = dL < ch
 ? clamp(
-2.0 - (hS + dr) / bZ,
+2.0 - (iq + dL) / ch,
 0.0,
 1.0
 )
-: clamp(1.0 - hS / bZ, 0.0, 1.0);
-hi += si.shadowOffset * oC;
+: clamp(1.0 - iq / ch, 0.0, 1.0);
+hw += si.shadowOffset * pq;
 }
-iC(mA, hi, lightDir);
-if (ex(mA, lightSample.dist - EPS, si.triangleIndex)) {
+gC(ns, hw, lightDir);
+if (intersectSceneShadow(ns, lightSample.dist - EPS, si.triangleIndex)) {
 return vec3(0.0);
 }
 
 #ifdef USE_ENVMAP
 
 
-if (gE && cosThetaL < 0.0 && ln.z < envLightSelectionPmf) {
-vec4 background = cx(mA.o, lightDir);
-lightSample.emission = ai(background.rgb * background.a, bf);
+if (eM && cosThetaL < 0.0 && lV.z < envLightSelectionPmf) {
+vec4 background = cG(ns.o, lightDir);
+lightSample.emission = aj(background.rgb * background.a, bp);
 }
 #endif
 
 
 
-float fa = lightSample.isDelta
+float fl = lightSample.isDelta
 ? 1.0
-: aG(fg, scatteringPdf);
-return fa > 0.0
-? fa * lightSample.emission * f / fg
+: aK(fA, scatteringPdf);
+return fl > 0.0
+? fl * lightSample.emission * f / fA
 : vec3(0.0);
 }
 
-#ifdef NUM_COAT_NORMAL_MAPS
-vec3 fE(vec3 pG, vec3 tq, vec3 view) {
-bool qY = dot(tq, view) >= 0.0;
-vec3 uo = qY ? tq : -tq;
-vec3 qX = qY ? pG : -pG;
-if (dot(pG, tq) <= 0.0 || dot(qX, view) <= 1e-6) { return uo; }
-return qX;
+#ifdef USE_COAT_NORMAL_FRAMES
+vec3 fT(vec3 qt, vec3 face, vec3 view) {
+bool front = dot(face, view) >= 0.0;
+vec3 vP = front ? face : -face;
+vec3 sc = front ? qt : -qt;
+if (dot(qt, face) <= 0.0 || dot(sc, view) <= 1e-6) { return vP; }
+return sc;
 }
 #endif
-void mc(inout ad si, J mat, inout Path aa) {
-vec3 ur = vec3(fo(cw(BSDF_DIRECTION)), dz(cw(BSDF_LOBE)));
-#ifdef NUM_COAT_NORMAL_MAPS
-vec3 bC = si.faceNormal;
-vec3 mF = si.normal;
+void mL(inout SurfaceInteraction si, OpenPbrResolvedMaterial mat, inout Path aa) {
+vec3 vR = vec3(dZ(cE(BSDF_DIRECTION)), dp(cE(BSDF_LOBE)));
+#ifdef USE_COAT_NORMAL_FRAMES
+vec3 bK = si.faceNormal;
+vec3 nB = si.normal;
 #endif
-float rN = -dot(si.faceNormal, aa.ray.d);
-float sG = -dot(si.normal, aa.ray.d);
+float sO = -dot(si.faceNormal, aa.ray.d);
+float tV = -dot(si.normal, aa.ray.d);
 if ((mat.transmissionWeight > 0.0 || mat.subsurfaceWeight > 0.0) && mat.thinWalled) {
 
-if (rN < 0.0) {
+if (sO < 0.0) {
 si.faceNormal = -si.faceNormal;
-rN = -rN;
+sO = -sO;
 }
-if (sG < 0.0) {
+if (tV < 0.0) {
 si.normal = -si.normal;
-sG = -sG;
+tV = -tV;
 }
 }
 
 
-bool pU = rN >= 0.0 && sG < 0.0;
-float ndv = pU ? rN : sG;
-vec3 normal = pU ? si.faceNormal : si.normal;
+bool qM = sO >= 0.0 && tV < 0.0;
+float ndv = qM ? sO : tV;
+vec3 normal = qM ? si.faceNormal : si.normal;
 
 mat.inside = ndv <= 0.0 && !mat.thinWalled;
 
 mat.relativeIor = ndv > 0.0 ? (1.0 / mat.specularIor) : mat.specularIor;
 vec3 ffnormal = ndv >= 0.0 ? normal : -normal;
-#ifdef NUM_COAT_NORMAL_MAPS
+#ifdef USE_COAT_NORMAL_FRAMES
 if (mat.coatNormalEnabled) {
 vec3 view = -aa.ray.d;
-float ga = dot(bC, view);
-mat.geometricNormal = ga >= 0.0 ? bC : -bC;
-ffnormal = fE(mF, bC, view);
-mat.coatNormal = fE(si.coatNormal, bC, view);
-mat.inside = ga <= 0.0 && !mat.thinWalled;
-mat.relativeIor = (ga > 0.0 || mat.thinWalled) ? 1.0 / mat.specularIor : mat.specularIor;
+float gp = dot(bK, view);
+mat.geometricNormal = gp >= 0.0 ? bK : -bK;
+ffnormal = fT(nB, bK, view);
+mat.coatNormal = fT(si.coatNormal, bK, view);
+mat.inside = gp <= 0.0 && !mat.thinWalled;
+mat.relativeIor = (gp > 0.0 || mat.thinWalled) ? 1.0 / mat.specularIor : mat.specularIor;
 }
 #endif
 
 
 float scatteringPdf;
-vec3 cG;
+vec3 dH;
 aa.scatteringIsDelta = false;
-bool bl = false;
-bool hn = false;
+bool bs = false;
+bool hC = false;
 ag prepared;
 
 #ifdef HAS_MEDIUM
 int mediumType = si.mediumType;
 float d = distance(si.position, aa.ray.o);
-vec3 nv = aa.ray.o;
+vec3 os = aa.ray.o;
 vec3 extinction = si.mediumExtinction;
 vec3 scattering = min(si.mediumScattering, extinction);
-float sC = max(max(extinction.x, extinction.y), extinction.z);
-if (mediumType > 0 && sC > 0.0) {
+float tR = max(max(extinction.x, extinction.y), extinction.z);
+if (mediumType > 0 && tR > 0.0) {
 
 
 
 
-int nk = min(int(dz(cw(MEDIUM_CHANNEL)) * 3.0), 2);
-float fD = extinction[nk];
-float ih = fD > 0.0
-? min(-log(max(dz(cw(MEDIUM_DISTANCE)), 1e-7)) / fD, d)
+int oi = min(int(dp(cE(MEDIUM_CHANNEL)) * 3.0), 2);
+float fS = extinction[oi];
+float iH = fS > 0.0
+? min(-log(max(dp(cE(MEDIUM_DISTANCE)), 1e-7)) / fS, d)
 : d;
-bl = ih < d;
-vec3 ew = exp(-extinction * ih);
-vec3 oa = bl
-? extinction * ew
-: ew;
-float nL = max(
-(oa.x + oa.y + oa.z) / 3.0,
+bs = iH < d;
+vec3 transmittance = exp(-extinction * iH);
+vec3 oU = bs
+? extinction * transmittance
+: transmittance;
+float oE = max(
+(oU.x + oU.y + oU.z) / 3.0,
 1e-8
 );
-if (bl) {
-aa.beta *= ew * scattering / nL;
+if (bs) {
+aa.beta *= transmittance * scattering / oE;
 
-aa.ray.o = nv + ih * aa.ray.d;
+aa.ray.o = os + iH * aa.ray.d;
 si.position = aa.ray.o;
-aa.li += mU(si, mat, prepared, aa, ffnormal, false) * aa.beta;
+aa.li += ta(si, mat, prepared, aa, ffnormal, false) * aa.beta;
 
 
-cG = fp(
+dH = fH(
 -aa.ray.d,
 si.mediumAnisotropy,
-fo(cw(PHASE_DIRECTION))
+dZ(cE(PHASE_DIRECTION))
 );
-scatteringPdf = bD(
-dot(cG, -aa.ray.d),
+scatteringPdf = bL(
+dot(dH, -aa.ray.d),
 si.mediumAnisotropy
 );
 }
 else {
-aa.beta *= ew / nL;
+aa.beta *= transmittance / oE;
 }
 }
 #endif
 
 
-if (!bl) {
+if (!bs) {
 aa.li += mat.emission * aa.beta;
 if (mat.materialType == UNLIT) {
 aa.abort = true;
 return;
 }
-vec3 pS = vec3(0.0);
+vec3 qJ = vec3(0.0);
 #ifdef USE_TANGENT
-pS = si.tangent;
+qJ = si.tangent;
 #endif
 mat.directionTangent = si.directionTangent;
 mat.directionBitangent = si.directionBitangent;
 mat.geometryTangent = si.geometryTangent;
 mat.geometryBitangent = si.geometryBitangent;
-prepared = eH(pS, mat, -aa.ray.d, ffnormal);
-aa.li += mU(si, mat, prepared, aa, ffnormal, true) * aa.beta;
+prepared = ds(qJ, mat, -aa.ray.d, ffnormal);
+aa.li += ta(si, mat, prepared, aa, ffnormal, true) * aa.beta;
 
 bool isNextRefraction;
-vec3 f = dv(
+vec3 f = eN(
 prepared,
-ur,
-cG,
+vR,
+dH,
 scatteringPdf,
 isNextRefraction
 );
@@ -232,26 +232,26 @@ prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] >= 1.0 - 1e-6;
 
 
 if (!(scatteringPdf > 0.0) || any(isnan(f)) || any(isinf(f)) ||
-dot(cG, cG) < 0.5) {
+dot(dH, dH) < 0.5) {
 aa.scatteringPdf = 0.0;
 aa.abort = true;
 return;
 }
 aa.beta *= f / scatteringPdf;
-hn = !mat.thinWalled &&
+hC = !mat.thinWalled &&
 isNextRefraction;
 aa.isNextRefraction = isNextRefraction;
 
 
-aa.ray.o = si.position + EPS * cG;
-#ifdef NUM_COAT_NORMAL_MAPS
-if (mat.coatNormalEnabled) { aa.ray.o = si.position + EPS * (dot(bC, cG) >= 0.0 ? bC : -bC); }
+aa.ray.o = si.position + EPS * dH;
+#ifdef USE_COAT_NORMAL_FRAMES
+if (mat.coatNormalEnabled) { aa.ray.o = si.position + EPS * (dot(bK, dH) >= 0.0 ? bK : -bK); }
 #endif
 }
 
 aa.scatteringPdf = scatteringPdf;
-iC(aa.ray, aa.ray.o, cG);
-if (bl) {
+gC(aa.ray, aa.ray.o, dH);
+if (bs) {
 aa.isNextRefraction = false;
 }
 aa.fromEye = false;
@@ -259,8 +259,8 @@ aa.fromEye = false;
 #ifdef HAS_MEDIUM
 
 
-if (!bl && hn && mat.mediumType > 0) {
-if (rN >= 0.0) {
+if (!bs && hC && mat.mediumType > 0) {
+if (sO >= 0.0) {
 si.mediumType = mat.mediumType;
 si.mediumExtinction = mat.mediumExtinction;
 si.mediumScattering = mat.mediumScattering;

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

@@ -1 +1 @@
-{"version":3,"file":"sampleMaterial.glsl.js","sourceRoot":"","sources":["../../../../src/renderer/glsl/chunks/sampleMaterial.glsl.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAC3E,iIAAiI;AAEjI,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACvC,eAAe,IAAI,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkRlB,CAAC","sourcesContent":["// Estimate the direct lighting integral using multiple importance sampling\n// http://www.pbr-book.org/3ed-2018/Light_Transport_I_Surface_Reflection/Direct_Lighting.html#EstimatingtheDirectLightingIntegral\n\nimport { glsl } from '../../shader.js';\nexport default glsl`\nvec3 DirectLight(SurfaceInteraction si, OpenPbrResolvedMaterial mat, OpenPbrPreparedBsdf prepared, inout Path path, vec3 ffnormal, bool isSurface) {\n  float occluded = 1.0;\n  vec3 lightRnd = vec3(sample2D(bounceDim(LIGHT_POSITION)), sample1D(bounceDim(LIGHT_SELECT)));\n\n  LightSampleRec lightSample;\n  sampleLight(si.position, lightRnd, lightSample, false);\n  lightSample.emission = sampling_spectral_rgb_filter(lightSample.emission, pathWavelength);\n\n  vec3 lightDir = lightSample.direction;\n  vec3 viewDir = -path.ray.d;\n  float lightPdf = lightSample.pdf;\n  // Opaque surfaces are rendered two-sided by the core renderer. Use the\n  // face-forward shading normal here as well, otherwise the early-out rejects\n  // every direct-light sample seen from the back of a triangle (for example\n  // the inside of an imported room wall).\n  float cosThetaL = dot(ffnormal, lightDir);\n#ifdef NUM_COAT_NORMAL_MAPS\n  if (isSurface && mat.coatNormalEnabled) { cosThetaL = dot(mat.geometricNormal, lightDir); }\n#endif\n\n  if (lightPdf <= 0.0 || max(max(lightSample.emission.x, lightSample.emission.y), lightSample.emission.z) <= 0.0) {\n    return vec3(0.0);\n  }\n\n  float scatteringPdf = 0.0;\n  vec3 f = vec3(0.0);\n  if (isSurface) {\n    if (cosThetaL <= 0.0 && mat.transmissionWeight <= 0.0 && mat.subsurfaceWeight <= 0.0) {\n      return vec3(0.0);\n    }\n    f = openpbr_eval_prepared(prepared, lightDir, scatteringPdf);\n  }\n  else {\n    scatteringPdf = sampling_henyey_greenstein_phase(\n      dot(viewDir, lightDir),\n      si.mediumAnisotropy\n    );\n    f = vec3(scatteringPdf);\n  }\n\n  if (scatteringPdf <= 0.0 || max(max(f.x, f.y), f.z) <= 0.0) {\n    return vec3(0.0);\n  }\n\n  Ray lightRay;\n  vec3 shadowOrigin = si.position + EPS * lightDir;\n  if (isSurface) {\n    const float shadowTerminatorCutoff = 0.1;\n    float normalLight = dot(si.normal, lightDir);\n#ifdef NUM_COAT_NORMAL_MAPS\n    if (mat.coatNormalEnabled) { normalLight = dot(si.faceNormal, lightDir); }\n#endif\n    vec3 geometricNormal = normalLight < 0.0 ? -si.faceNormal : si.faceNormal;\n    normalLight = abs(normalLight);\n    float geometricLight = dot(geometricNormal, lightDir);\n    float offsetAmount = normalLight < shadowTerminatorCutoff\n      ? clamp(\n          2.0 - (geometricLight + normalLight) / shadowTerminatorCutoff,\n          0.0,\n          1.0\n        )\n      : clamp(1.0 - geometricLight / shadowTerminatorCutoff, 0.0, 1.0);\n    shadowOrigin += si.shadowOffset * offsetAmount;\n  }\n  initRay(lightRay, shadowOrigin, lightDir);\n  if (intersectSceneShadow(lightRay, lightSample.dist - EPS, si.triangleIndex)) {\n    return vec3(0.0);\n  }\n\n#ifdef USE_ENVMAP\n  // Match the endpoint used by a BSDF-sampled surface transmission, including\n  // a separately displayed or grounded background and its coverage.\n  if (isSurface && cosThetaL < 0.0 && lightRnd.z < envLightSelectionPmf) {\n    vec4 background = sampleBackgroundFromRay(lightRay.o, lightDir);\n    lightSample.emission = sampling_spectral_rgb_filter(background.rgb * background.a, pathWavelength);\n  }\n#endif\n\n  // Delta lights cannot be sampled by the BSDF strategy, so their MIS weight\n  // is exactly one even when their light-selection PMF is small.\n  float misWeight = lightSample.isDelta\n    ? 1.0\n    : sampling_power_heuristic(lightPdf, scatteringPdf);\n  return misWeight > 0.0\n    ? misWeight * lightSample.emission * f / lightPdf\n    : vec3(0.0);\n}\n\n#ifdef NUM_COAT_NORMAL_MAPS\nvec3 coat_frame_normal(vec3 inputNormal, vec3 face, vec3 view) {\n  bool front = dot(face, view) >= 0.0;\n  vec3 ffFace = front ? face : -face;\n  vec3 ffInput = front ? inputNormal : -inputNormal;\n  if (dot(inputNormal, face) <= 0.0 || dot(ffInput, view) <= 1e-6) { return ffFace; }\n  return ffInput;\n}\n#endif\nvoid SampleMaterial(inout SurfaceInteraction si, OpenPbrResolvedMaterial mat, inout Path path) {\n  vec3 matRnd = vec3(sample2D(bounceDim(BSDF_DIRECTION)), sample1D(bounceDim(BSDF_LOBE)));\n#ifdef NUM_COAT_NORMAL_MAPS\n  vec3 originalFace = si.faceNormal;\n  vec3 originalNormal = si.normal;\n#endif\n  float ndv1 = -dot(si.faceNormal, path.ray.d);\n  float ndv2 = -dot(si.normal, path.ray.d);\n  if ((mat.transmissionWeight > 0.0 || mat.subsurfaceWeight > 0.0) && mat.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  bool useFaceN = ndv1 >= 0.0 && ndv2 < 0.0;\n  float ndv = useFaceN ? ndv1 : ndv2;\n  vec3 normal = useFaceN ? si.faceNormal : si.normal;\n\n  mat.inside = ndv <= 0.0 && !mat.thinWalled;\n  // In or out\n  mat.relativeIor = ndv > 0.0 ? (1.0 / mat.specularIor) : mat.specularIor;\n  vec3 ffnormal = ndv >= 0.0 ? normal : -normal;\n#ifdef NUM_COAT_NORMAL_MAPS\n  if (mat.coatNormalEnabled) {\n    vec3 view = -path.ray.d;\n    float geometricView = dot(originalFace, view);\n    mat.geometricNormal = geometricView >= 0.0 ? originalFace : -originalFace;\n    ffnormal = coat_frame_normal(originalNormal, originalFace, view);\n    mat.coatNormal = coat_frame_normal(si.coatNormal, originalFace, view);\n    mat.inside = geometricView <= 0.0 && !mat.thinWalled;\n    mat.relativeIor = (geometricView > 0.0 || mat.thinWalled) ? 1.0 / mat.specularIor : mat.specularIor;\n  }\n#endif\n\n\n  float scatteringPdf;\n  vec3 scatterDir;\n  path.scatteringIsDelta = false;\n  bool mediumSampled = false;\n  bool crossedBoundary = false;\n  OpenPbrPreparedBsdf prepared;\n\n#ifdef HAS_MEDIUM\n  int mediumType = si.mediumType;\n  float d = distance(si.position, path.ray.o);\n  vec3 segmentOrigin = path.ray.o;\n  vec3 extinction = si.mediumExtinction;\n  vec3 scattering = min(si.mediumScattering, extinction);\n  float 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    // is the homogeneous-medium estimator used by PBRT and avoids the very\n    // large exp((majorant - extinction) * distance) weights produced by\n    // majorant tracking when OpenPBR SSS radii differ strongly by channel.\n    int mediumChannel = min(int(sample1D(bounceDim(MEDIUM_CHANNEL)) * 3.0), 2);\n    float channelExtinction = extinction[mediumChannel];\n    float scatterDist = channelExtinction > 0.0\n      ? min(-log(max(sample1D(bounceDim(MEDIUM_DISTANCE)), 1e-7)) / channelExtinction, d)\n      : d;\n    mediumSampled = scatterDist < d;\n    vec3 transmittance = exp(-extinction * scatterDist);\n    vec3 density = mediumSampled\n      ? extinction * transmittance\n      : transmittance;\n    float mediumPdf = max(\n      (density.x + density.y + density.z) / 3.0,\n      1e-8\n    );\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      path.li += DirectLight(si, mat, prepared, path, ffnormal, false) * path.beta;\n\n      // Pick a new direction based on the phase function\n      scatterDir = sampling_henyey_greenstein(\n        -path.ray.d,\n        si.mediumAnisotropy,\n        sample2D(bounceDim(PHASE_DIRECTION))\n      );\n      scatteringPdf = sampling_henyey_greenstein_phase(\n        dot(scatterDir, -path.ray.d),\n        si.mediumAnisotropy\n      );\n    }\n    else {\n      path.beta *= transmittance / mediumPdf;\n    }\n  }\n#endif\n\n  // Direct lighting\n  if (!mediumSampled) {\n    path.li += mat.emission * path.beta;\n    if (mat.materialType == UNLIT) {\n      path.abort = true;\n      return;\n    }\n    vec3 surfaceTangent = vec3(0.0);\n#ifdef USE_TANGENT\n    surfaceTangent = si.tangent;\n#endif\n    mat.directionTangent = si.directionTangent;\n    mat.directionBitangent = si.directionBitangent;\n    mat.geometryTangent = si.geometryTangent;\n    mat.geometryBitangent = si.geometryBitangent;\n    prepared = openpbr_prepare(surfaceTangent, mat, -path.ray.d, ffnormal);\n    path.li += DirectLight(si, mat, prepared, path, ffnormal, true) * path.beta;\n    // Sample BSDF for color and outgoing direction\n    bool isNextRefraction;\n    vec3 f = openpbr_sample_prepared(\n      prepared,\n      matRnd,\n      scatterDir,\n      scatteringPdf,\n      isNextRefraction\n    );\n    // Null-boundary transmission is discrete and has no NEE competitor.\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    // Match WebGPU: rejected VNDF/refraction proposals have no continuation.\n    // Tracing their fallback direction with the incoming throughput invents\n    // light paths, especially after total internal reflection inside glass.\n    if (!(scatteringPdf > 0.0) || any(isnan(f)) || any(isinf(f)) ||\n        dot(scatterDir, scatterDir) < 0.5) {\n      path.scatteringPdf = 0.0;\n      path.abort = true;\n      return;\n    }\n    path.beta *= f / scatteringPdf;\n    crossedBoundary = !mat.thinWalled &&\n      isNextRefraction;\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#ifdef NUM_COAT_NORMAL_MAPS\n    if (mat.coatNormalEnabled) { path.ray.o = si.position + EPS * (dot(originalFace, scatterDir) >= 0.0 ? originalFace : -originalFace); }\n#endif\n  }\n\n  path.scatteringPdf = scatteringPdf;\n  initRay(path.ray, path.ray.o, scatterDir);\n  if (mediumSampled) {\n    path.isNextRefraction = false;\n  }\n  path.fromEye = false;\n\n#ifdef HAS_MEDIUM\n  // A reflected ray stays in its current medium. Only a sampled transmission\n  // event crosses the boundary of a medium-bearing closed mesh.\n  if (!mediumSampled && crossedBoundary && mat.mediumType > 0) {\n    if (ndv1 >= 0.0) {\n      si.mediumType = mat.mediumType;\n      si.mediumExtinction = mat.mediumExtinction;\n      si.mediumScattering = mat.mediumScattering;\n      si.mediumAnisotropy = mat.mediumAnisotropy;\n    }\n    else {\n      si.mediumType = 0;\n      si.mediumExtinction = vec3(0.0);\n      si.mediumScattering = vec3(0.0);\n      si.mediumAnisotropy = 0.0;\n    }\n  }\n#endif\n}\n`;\n"]}
+{"version":3,"file":"sampleMaterial.glsl.js","sourceRoot":"","sources":["../../../../src/renderer/glsl/chunks/sampleMaterial.glsl.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAC3E,iIAAiI;AAEjI,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACvC,eAAe,IAAI,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkRlB,CAAC","sourcesContent":["// Estimate the direct lighting integral using multiple importance sampling\n// http://www.pbr-book.org/3ed-2018/Light_Transport_I_Surface_Reflection/Direct_Lighting.html#EstimatingtheDirectLightingIntegral\n\nimport { glsl } from '../../shader.js';\nexport default glsl`\nvec3 DirectLight(SurfaceInteraction si, OpenPbrResolvedMaterial mat, OpenPbrPreparedBsdf prepared, inout Path path, vec3 ffnormal, bool isSurface) {\n  float occluded = 1.0;\n  vec3 lightRnd = vec3(sample2D(bounceDim(LIGHT_POSITION)), sample1D(bounceDim(LIGHT_SELECT)));\n\n  LightSampleRec lightSample;\n  sampleLight(si.position, lightRnd, lightSample, false);\n  lightSample.emission = sampling_spectral_rgb_filter(lightSample.emission, pathWavelength);\n\n  vec3 lightDir = lightSample.direction;\n  vec3 viewDir = -path.ray.d;\n  float lightPdf = lightSample.pdf;\n  // Opaque surfaces are rendered two-sided by the core renderer. Use the\n  // face-forward shading normal here as well, otherwise the early-out rejects\n  // every direct-light sample seen from the back of a triangle (for example\n  // the inside of an imported room wall).\n  float cosThetaL = dot(ffnormal, lightDir);\n#ifdef USE_COAT_NORMAL_FRAMES\n  if (isSurface && mat.coatNormalEnabled) { cosThetaL = dot(mat.geometricNormal, lightDir); }\n#endif\n\n  if (lightPdf <= 0.0 || max(max(lightSample.emission.x, lightSample.emission.y), lightSample.emission.z) <= 0.0) {\n    return vec3(0.0);\n  }\n\n  float scatteringPdf = 0.0;\n  vec3 f = vec3(0.0);\n  if (isSurface) {\n    if (cosThetaL <= 0.0 && mat.transmissionWeight <= 0.0 && mat.subsurfaceWeight <= 0.0) {\n      return vec3(0.0);\n    }\n    f = openpbr_eval_prepared(prepared, lightDir, scatteringPdf);\n  }\n  else {\n    scatteringPdf = sampling_henyey_greenstein_phase(\n      dot(viewDir, lightDir),\n      si.mediumAnisotropy\n    );\n    f = vec3(scatteringPdf);\n  }\n\n  if (scatteringPdf <= 0.0 || max(max(f.x, f.y), f.z) <= 0.0) {\n    return vec3(0.0);\n  }\n\n  Ray lightRay;\n  vec3 shadowOrigin = si.position + EPS * lightDir;\n  if (isSurface) {\n    const float shadowTerminatorCutoff = 0.1;\n    float normalLight = dot(si.normal, lightDir);\n#ifdef USE_COAT_NORMAL_FRAMES\n    if (mat.coatNormalEnabled) { normalLight = dot(si.faceNormal, lightDir); }\n#endif\n    vec3 geometricNormal = normalLight < 0.0 ? -si.faceNormal : si.faceNormal;\n    normalLight = abs(normalLight);\n    float geometricLight = dot(geometricNormal, lightDir);\n    float offsetAmount = normalLight < shadowTerminatorCutoff\n      ? clamp(\n          2.0 - (geometricLight + normalLight) / shadowTerminatorCutoff,\n          0.0,\n          1.0\n        )\n      : clamp(1.0 - geometricLight / shadowTerminatorCutoff, 0.0, 1.0);\n    shadowOrigin += si.shadowOffset * offsetAmount;\n  }\n  initRay(lightRay, shadowOrigin, lightDir);\n  if (intersectSceneShadow(lightRay, lightSample.dist - EPS, si.triangleIndex)) {\n    return vec3(0.0);\n  }\n\n#ifdef USE_ENVMAP\n  // Match the endpoint used by a BSDF-sampled surface transmission, including\n  // a separately displayed or grounded background and its coverage.\n  if (isSurface && cosThetaL < 0.0 && lightRnd.z < envLightSelectionPmf) {\n    vec4 background = sampleBackgroundFromRay(lightRay.o, lightDir);\n    lightSample.emission = sampling_spectral_rgb_filter(background.rgb * background.a, pathWavelength);\n  }\n#endif\n\n  // Delta lights cannot be sampled by the BSDF strategy, so their MIS weight\n  // is exactly one even when their light-selection PMF is small.\n  float misWeight = lightSample.isDelta\n    ? 1.0\n    : sampling_power_heuristic(lightPdf, scatteringPdf);\n  return misWeight > 0.0\n    ? misWeight * lightSample.emission * f / lightPdf\n    : vec3(0.0);\n}\n\n#ifdef USE_COAT_NORMAL_FRAMES\nvec3 coat_frame_normal(vec3 inputNormal, vec3 face, vec3 view) {\n  bool front = dot(face, view) >= 0.0;\n  vec3 ffFace = front ? face : -face;\n  vec3 ffInput = front ? inputNormal : -inputNormal;\n  if (dot(inputNormal, face) <= 0.0 || dot(ffInput, view) <= 1e-6) { return ffFace; }\n  return ffInput;\n}\n#endif\nvoid SampleMaterial(inout SurfaceInteraction si, OpenPbrResolvedMaterial mat, inout Path path) {\n  vec3 matRnd = vec3(sample2D(bounceDim(BSDF_DIRECTION)), sample1D(bounceDim(BSDF_LOBE)));\n#ifdef USE_COAT_NORMAL_FRAMES\n  vec3 originalFace = si.faceNormal;\n  vec3 originalNormal = si.normal;\n#endif\n  float ndv1 = -dot(si.faceNormal, path.ray.d);\n  float ndv2 = -dot(si.normal, path.ray.d);\n  if ((mat.transmissionWeight > 0.0 || mat.subsurfaceWeight > 0.0) && mat.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  bool useFaceN = ndv1 >= 0.0 && ndv2 < 0.0;\n  float ndv = useFaceN ? ndv1 : ndv2;\n  vec3 normal = useFaceN ? si.faceNormal : si.normal;\n\n  mat.inside = ndv <= 0.0 && !mat.thinWalled;\n  // In or out\n  mat.relativeIor = ndv > 0.0 ? (1.0 / mat.specularIor) : mat.specularIor;\n  vec3 ffnormal = ndv >= 0.0 ? normal : -normal;\n#ifdef USE_COAT_NORMAL_FRAMES\n  if (mat.coatNormalEnabled) {\n    vec3 view = -path.ray.d;\n    float geometricView = dot(originalFace, view);\n    mat.geometricNormal = geometricView >= 0.0 ? originalFace : -originalFace;\n    ffnormal = coat_frame_normal(originalNormal, originalFace, view);\n    mat.coatNormal = coat_frame_normal(si.coatNormal, originalFace, view);\n    mat.inside = geometricView <= 0.0 && !mat.thinWalled;\n    mat.relativeIor = (geometricView > 0.0 || mat.thinWalled) ? 1.0 / mat.specularIor : mat.specularIor;\n  }\n#endif\n\n\n  float scatteringPdf;\n  vec3 scatterDir;\n  path.scatteringIsDelta = false;\n  bool mediumSampled = false;\n  bool crossedBoundary = false;\n  OpenPbrPreparedBsdf prepared;\n\n#ifdef HAS_MEDIUM\n  int mediumType = si.mediumType;\n  float d = distance(si.position, path.ray.o);\n  vec3 segmentOrigin = path.ray.o;\n  vec3 extinction = si.mediumExtinction;\n  vec3 scattering = min(si.mediumScattering, extinction);\n  float 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    // is the homogeneous-medium estimator used by PBRT and avoids the very\n    // large exp((majorant - extinction) * distance) weights produced by\n    // majorant tracking when OpenPBR SSS radii differ strongly by channel.\n    int mediumChannel = min(int(sample1D(bounceDim(MEDIUM_CHANNEL)) * 3.0), 2);\n    float channelExtinction = extinction[mediumChannel];\n    float scatterDist = channelExtinction > 0.0\n      ? min(-log(max(sample1D(bounceDim(MEDIUM_DISTANCE)), 1e-7)) / channelExtinction, d)\n      : d;\n    mediumSampled = scatterDist < d;\n    vec3 transmittance = exp(-extinction * scatterDist);\n    vec3 density = mediumSampled\n      ? extinction * transmittance\n      : transmittance;\n    float mediumPdf = max(\n      (density.x + density.y + density.z) / 3.0,\n      1e-8\n    );\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      path.li += DirectLight(si, mat, prepared, path, ffnormal, false) * path.beta;\n\n      // Pick a new direction based on the phase function\n      scatterDir = sampling_henyey_greenstein(\n        -path.ray.d,\n        si.mediumAnisotropy,\n        sample2D(bounceDim(PHASE_DIRECTION))\n      );\n      scatteringPdf = sampling_henyey_greenstein_phase(\n        dot(scatterDir, -path.ray.d),\n        si.mediumAnisotropy\n      );\n    }\n    else {\n      path.beta *= transmittance / mediumPdf;\n    }\n  }\n#endif\n\n  // Direct lighting\n  if (!mediumSampled) {\n    path.li += mat.emission * path.beta;\n    if (mat.materialType == UNLIT) {\n      path.abort = true;\n      return;\n    }\n    vec3 surfaceTangent = vec3(0.0);\n#ifdef USE_TANGENT\n    surfaceTangent = si.tangent;\n#endif\n    mat.directionTangent = si.directionTangent;\n    mat.directionBitangent = si.directionBitangent;\n    mat.geometryTangent = si.geometryTangent;\n    mat.geometryBitangent = si.geometryBitangent;\n    prepared = openpbr_prepare(surfaceTangent, mat, -path.ray.d, ffnormal);\n    path.li += DirectLight(si, mat, prepared, path, ffnormal, true) * path.beta;\n    // Sample BSDF for color and outgoing direction\n    bool isNextRefraction;\n    vec3 f = openpbr_sample_prepared(\n      prepared,\n      matRnd,\n      scatterDir,\n      scatteringPdf,\n      isNextRefraction\n    );\n    // Null-boundary transmission is discrete and has no NEE competitor.\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    // Match WebGPU: rejected VNDF/refraction proposals have no continuation.\n    // Tracing their fallback direction with the incoming throughput invents\n    // light paths, especially after total internal reflection inside glass.\n    if (!(scatteringPdf > 0.0) || any(isnan(f)) || any(isinf(f)) ||\n        dot(scatterDir, scatterDir) < 0.5) {\n      path.scatteringPdf = 0.0;\n      path.abort = true;\n      return;\n    }\n    path.beta *= f / scatteringPdf;\n    crossedBoundary = !mat.thinWalled &&\n      isNextRefraction;\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#ifdef USE_COAT_NORMAL_FRAMES\n    if (mat.coatNormalEnabled) { path.ray.o = si.position + EPS * (dot(originalFace, scatterDir) >= 0.0 ? originalFace : -originalFace); }\n#endif\n  }\n\n  path.scatteringPdf = scatteringPdf;\n  initRay(path.ray, path.ray.o, scatterDir);\n  if (mediumSampled) {\n    path.isNextRefraction = false;\n  }\n  path.fromEye = false;\n\n#ifdef HAS_MEDIUM\n  // A reflected ray stays in its current medium. Only a sampled transmission\n  // event crosses the boundary of a medium-bearing closed mesh.\n  if (!mediumSampled && crossedBoundary && mat.mediumType > 0) {\n    if (ndv1 >= 0.0) {\n      si.mediumType = mat.mediumType;\n      si.mediumExtinction = mat.mediumExtinction;\n      si.mediumScattering = mat.mediumScattering;\n      si.mediumAnisotropy = mat.mediumAnisotropy;\n    }\n    else {\n      si.mediumType = 0;\n      si.mediumExtinction = vec3(0.0);\n      si.mediumScattering = vec3(0.0);\n      si.mediumAnisotropy = 0.0;\n    }\n  }\n#endif\n}\n`;\n"]}

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

@@ -9,40 +9,43 @@ export default glsl `
 
 
 
+
 const uint SHADOW_CATCHER_LIGHT_SAMPLES = 4u;
 
-uint ky(uint candidate, uint slot) {
-return candidate == 0u ? cw(slot) : cw(9u + (candidate - 1u) * 3u + slot);
+uint lc(uint candidate, uint slot) {
+return candidate == 0u ? cE(slot) : cE(9u + (candidate - 1u) * 3u + slot);
 }
 
-void sampleShadowCatcher(ad si, int bounce, inout Path aa) {
-vec3 oT = -aa.ray.d;
+
+
+vec2 sampleShadowCatcher(SurfaceInteraction si, int bounce, inout Path aa) {
+vec3 qY = -aa.ray.d;
+vec2 counts = vec2(0.0);
 
 #if defined(NUM_LIGHTS) || defined(USE_ENVMAP)
-float visibility = 0.0;
 for (uint candidate = 0u; candidate < SHADOW_CATCHER_LIGHT_SAMPLES; candidate++) {
 LightSampleRec lightSample;
-vec3 ln = vec3(
-fo(ky(candidate, LIGHT_POSITION)),
-dz(ky(candidate, LIGHT_SELECT))
+vec3 lV = vec3(
+dZ(lc(candidate, LIGHT_POSITION)),
+dp(lc(candidate, LIGHT_SELECT))
 );
-sampleLight(si.position, ln, lightSample, false);
+sampleLight(si.position, lV, lightSample, false);
 
 vec3 lightDir = lightSample.direction;
 float cosThetaL = dot(si.normal, lightDir);
-float pM = dot(si.normal, oT) * cosThetaL;
-bool mD = false;
-if (pM >= 0.0) {
+float qB = dot(si.normal, qY) * cosThetaL;
+if (lightSample.pdf > 0.0 && qB >= 0.0) {
+if (dot(lightSample.emission, luminance) * abs(cosThetaL) > 0.0) {
 Ray ray;
-iC(ray, si.position + EPS * lightDir, lightDir);
-mD = ex(ray, lightSample.dist - EPS, si.triangleIndex);
+gC(ray, si.position + EPS * lightDir, lightDir);
+bool lY = intersectSceneShadow(ray, lightSample.dist - EPS, si.triangleIndex);
+counts += vec2(lY ? 1.0 : 0.0, 1.0);
+}
 }
-visibility += mD ? 0.0 : 1.0;
 }
-
-aa.alpha = visibility / float(SHADOW_CATCHER_LIGHT_SAMPLES);
 #endif
 aa.fromEye = false;
+return counts;
 }
 `;
 //# sourceMappingURL=sampleShadowCatcher.glsl.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"sampleShadowCatcher.glsl.js","sourceRoot":"","sources":["../../../../src/renderer/glsl/chunks/sampleShadowCatcher.glsl.ts"],"names":[],"mappings":"AAAA,qDAAqD;AACrD,sDAAsD;AACtD,kFAAkF;AAElF,2EAA2E;AAC3E,iIAAiI;AAEjI,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAEvC,eAAe,IAAI,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwClB,CAAC","sourcesContent":["// Portions adapted from ray-tracing-renderer@0.10.15\n// (https://github.com/hoverinc/ray-tracing-renderer).\n// Copyright (c) 2019 HOVER, MIT license; see LICENSES/RayTracingRenderer-MIT.txt.\n\n// Estimate the direct lighting integral using multiple importance sampling\n// http://www.pbr-book.org/3ed-2018/Light_Transport_I_Surface_Reflection/Direct_Lighting.html#EstimatingtheDirectLightingIntegral\n\nimport { glsl } from '../../shader.js';\n\nexport default glsl`\n// A one-sample binary shadow test leaves scattered fully dark pixels far\n// from the occluder at low sample counts. Averaging a few light samples per\n// primary hit costs only shadow rays and lets the mask settle much sooner.\n// Candidate dimensions match WGSL lightDim().\nconst uint SHADOW_CATCHER_LIGHT_SAMPLES = 4u;\n\nuint shadowCatcherLightDim(uint candidate, uint slot) {\n  return candidate == 0u ? bounceDim(slot) : bounceDim(9u + (candidate - 1u) * 3u + slot);\n}\n\nvoid sampleShadowCatcher(SurfaceInteraction si, int bounce, inout Path path) {\n  vec3 viewDir = -path.ray.d;\n\n#if defined(NUM_LIGHTS) || defined(USE_ENVMAP)\n  float visibility = 0.0;\n  for (uint candidate = 0u; candidate < SHADOW_CATCHER_LIGHT_SAMPLES; candidate++) {\n    LightSampleRec lightSample;\n    vec3 lightRnd = vec3(\n      sample2D(shadowCatcherLightDim(candidate, LIGHT_POSITION)),\n      sample1D(shadowCatcherLightDim(candidate, LIGHT_SELECT))\n    );\n    sampleLight(si.position, lightRnd, lightSample, false);\n\n    vec3 lightDir = lightSample.direction;\n    float cosThetaL = dot(si.normal, lightDir);\n    float orientation = dot(si.normal, viewDir) * cosThetaL;\n    bool occluded = false;\n    if (orientation >= 0.0) {\n      Ray ray;\n      initRay(ray, si.position + EPS * lightDir, lightDir);\n      occluded = intersectSceneShadow(ray, lightSample.dist - EPS, si.triangleIndex);\n    }\n    visibility += occluded ? 0.0 : 1.0;\n  }\n  // WebGL's compose pass converts visibility to shadow opacity.\n  path.alpha = visibility / float(SHADOW_CATCHER_LIGHT_SAMPLES);\n#endif\n  path.fromEye = false;\n}\n`;\n"]}
+{"version":3,"file":"sampleShadowCatcher.glsl.js","sourceRoot":"","sources":["../../../../src/renderer/glsl/chunks/sampleShadowCatcher.glsl.ts"],"names":[],"mappings":"AAAA,qDAAqD;AACrD,sDAAsD;AACtD,kFAAkF;AAElF,2EAA2E;AAC3E,iIAAiI;AAEjI,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAEvC,eAAe,IAAI,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2ClB,CAAC","sourcesContent":["// Portions adapted from ray-tracing-renderer@0.10.15\n// (https://github.com/hoverinc/ray-tracing-renderer).\n// Copyright (c) 2019 HOVER, MIT license; see LICENSES/RayTracingRenderer-MIT.txt.\n\n// Estimate the direct lighting integral using multiple importance sampling\n// http://www.pbr-book.org/3ed-2018/Light_Transport_I_Surface_Reflection/Direct_Lighting.html#EstimatingtheDirectLightingIntegral\n\nimport { glsl } from '../../shader.js';\n\nexport default glsl`\n// A one-sample binary shadow test leaves scattered fully dark pixels far\n// from the occluder at low sample counts. Averaging a few light samples per\n// primary hit costs only shadow rays and lets the mask settle much sooner.\n// Candidate dimensions match WGSL lightDim(). sampleLight() draws only the\n// environment and analytic lights, like WGSL's shadow-catcher table.\nconst uint SHADOW_CATCHER_LIGHT_SAMPLES = 4u;\n\nuint shadowCatcherLightDim(uint candidate, uint slot) {\n  return candidate == 0u ? bounceDim(slot) : bounceDim(9u + (candidate - 1u) * 3u + slot);\n}\n\n// Returns the occluded and the total count of light samples that reach the\n// visible side of this hit; see the WGSL sampleShadowCatcher().\nvec2 sampleShadowCatcher(SurfaceInteraction si, int bounce, inout Path path) {\n  vec3 viewDir = -path.ray.d;\n  vec2 counts = vec2(0.0);\n\n#if defined(NUM_LIGHTS) || defined(USE_ENVMAP)\n  for (uint candidate = 0u; candidate < SHADOW_CATCHER_LIGHT_SAMPLES; candidate++) {\n    LightSampleRec lightSample;\n    vec3 lightRnd = vec3(\n      sample2D(shadowCatcherLightDim(candidate, LIGHT_POSITION)),\n      sample1D(shadowCatcherLightDim(candidate, LIGHT_SELECT))\n    );\n    sampleLight(si.position, lightRnd, lightSample, false);\n\n    vec3 lightDir = lightSample.direction;\n    float cosThetaL = dot(si.normal, lightDir);\n    float orientation = dot(si.normal, viewDir) * cosThetaL;\n    if (lightSample.pdf > 0.0 && orientation >= 0.0) {\n      if (dot(lightSample.emission, luminance) * abs(cosThetaL) > 0.0) {\n        Ray ray;\n        initRay(ray, si.position + EPS * lightDir, lightDir);\n        bool occluded = intersectSceneShadow(ray, lightSample.dist - EPS, si.triangleIndex);\n        counts += vec2(occluded ? 1.0 : 0.0, 1.0);\n      }\n    }\n  }\n#endif\n  path.fromEye = false;\n  return counts;\n}\n`;\n"]}