@meimu/mutracer 0.3.0 → 0.3.1

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

@@ -1,32 +1,34 @@
 // Estimate the direct lighting integral using multiple importance sampling
 // http://www.pbr-book.org/3ed-2018/Light_Transport_I_Surface_Reflection/Direct_Lighting.html#EstimatingtheDirectLightingIntegral
 import { glsl } from '../../shader.js';
-export function createSampleMaterialGlsl(fragments = {}) {
+export function createSampleMaterialGlsl(fragments = {}, channelIndependentLight = false) {
     return glsl `
 float emissiveHitMisWeight(SurfaceInteraction si,Path path) {
 
-float ys=dot(si.faceNormal,-path.ray.d);
-if(ys<=0.0&&fetchMatData(si.materialIndex*MAT_DATA_SIZE+MAT_ROW_ALPHA).z<0.5)return 0.0;
+float Ar=dot(si.faceNormal,-path.ray.d);
+if(Ar<=0.0&&fetchMatData(si.materialIndex*MAT_DATA_SIZE+MAT_ROW_ALPHA).z<0.5)return 0.0;
 #ifdef HAS_EMISSIVE_LIGHTS
 if(!path.fromEye && emissiveWeightTotal>0.0) {
 vec3 emission=fetchMatData(si.materialIndex*MAT_DATA_SIZE+MAT_ROW_EMISSION).rgb;
 float value=dot(emission,vec3(.2126,.7152,.0722)),cosine=dot(si.faceNormal,-path.ray.d);
-if(value>0.0&&cosine>0.0){float d=distance(si.position,path.ray.o);return aF(path.scatteringPdf,value/emissiveWeightTotal*d*d/cosine);}
+if(value>0.0&&cosine>0.0){float d=distance(si.position,path.ray.o);return aG(path.scatteringPdf,value/emissiveWeightTotal*d*d/cosine);}
 }
 #endif
 return 1.0;
 }
 
-vec3 sX(SurfaceInteraction si, OpenPbrResolvedMaterial mat, OpenPbrPreparedBsdf prepared, inout Path path, vec3 ffnormal, bool isSurface) {
-float lH = 1.0;
-vec3 mZ = vec3(sample2D(bE(LIGHT_POSITION)), sample1D(bE(LIGHT_SELECT)));
+vec3 qY(SurfaceInteraction si, OpenPbrResolvedMaterial mat, OpenPbrPreparedBsdf prepared, inout Path path, vec3 ffnormal, bool isSurface) {
+float mz = 1.0;
+vec3 ob = vec3(sample2D(aX(LIGHT_POSITION)), sample1D(aX(LIGHT_SELECT)));
 
 LightSampleRec lightSample;
-sampleLight(si.position, mZ, lightSample, false);${fragments['sample0'] ?? ''}
+sampleLight(si.position, ob, lightSample, false);${fragments['sample0'] ?? ''}
+${channelIndependentLight ? /* glsl */ `  if (dispersionWavelengths == 1) {
 lightSample.emission = sampling_spectral_rgb_filter(lightSample.emission, pathChannel);
+}` : /* glsl */ `  lightSample.emission = sampling_spectral_rgb_filter(lightSample.emission, pathChannel);`}
 
 vec3 lightDir = lightSample.direction;
-vec3 qR = -path.ray.d;
+vec3 sg = -path.ray.d;
 float lightPdf = lightSample.pdf;
 
 
@@ -41,7 +43,12 @@ if (lightPdf <= 0.0 || max(max(lightSample.emission.x, lightSample.emission.y),
 return vec3(0.0);
 }
 
-float scatteringPdf = 0.0;
+${channelIndependentLight ? /* glsl */ `  
+
+if (dispersionWavelengths != 1) {
+lightSample.emission = sampling_spectral_rgb_filter(lightSample.emission, pathChannel);
+}
+` : ''}  float scatteringPdf = 0.0;
 vec3 f = vec3(0.0);
 if (isSurface) {
 if (cosThetaL <= 0.0 && mat.transmissionWeight <= 0.0 && mat.subsurfaceWeight <= 0.0) {
@@ -50,8 +57,8 @@ return vec3(0.0);
 f = openpbr_eval_prepared(prepared, lightDir, scatteringPdf);
 }
 else {
-scatteringPdf = bB(
-dot(qR, lightDir),
+scatteringPdf = ba(
+dot(sg, lightDir),
 si.mediumAnisotropy
 );
 f = vec3(scatteringPdf);
@@ -61,34 +68,34 @@ if (scatteringPdf <= 0.0 || max(max(f.x, f.y), f.z) <= 0.0) {
 return vec3(0.0);
 }
 
-Ray mY;
-vec3 eO = si.position + EPS * lightDir;
+Ray oa;
+vec3 eY = si.position + EPS * lightDir;
 if (isSurface) {
 const float shadowTerminatorCutoff = 0.1;
-float dj = dot(si.normal, lightDir);
+float dl = dot(si.normal, lightDir);
 #ifdef USE_COAT_NORMAL_FRAMES
-if (mat.coatNormalEnabled) { dj = dot(si.faceNormal, lightDir); }
+if (mat.coatNormalEnabled) { dl = dot(si.faceNormal, lightDir); }
 #endif
-vec3 geometricNormal = dj < 0.0 ? -si.faceNormal : si.faceNormal;
-dj = abs(dj);
-float hO = dot(geometricNormal, lightDir);
-float pf = dj < shadowTerminatorCutoff
+vec3 geometricNormal = dl < 0.0 ? -si.faceNormal : si.faceNormal;
+dl = abs(dl);
+float iw = dot(geometricNormal, lightDir);
+float qo = dl < shadowTerminatorCutoff
 ? clamp(
-2.0 - (hO + dj) / shadowTerminatorCutoff,
+2.0 - (iw + dl) / shadowTerminatorCutoff,
 0.0,
 1.0
 )
-: clamp(1.0 - hO / shadowTerminatorCutoff, 0.0, 1.0);
-eO += si.shadowOffset * pf;
+: clamp(1.0 - iw / shadowTerminatorCutoff, 0.0, 1.0);
+eY += si.shadowOffset * qo;
 }
-float qz=lightSample.dist-EPS;
-vec3 pO=lightDir;
+float rM=lightSample.dist-EPS;
+vec3 qS=lightDir;
 if(lightSample.sourceType==1){
 vec3 endpoint=si.position+lightDir*lightSample.dist+EPS*lightSample.normal;
-pO=normalize(endpoint-eO);qz=distance(endpoint,eO);
+qS=normalize(endpoint-eY);rM=distance(endpoint,eY);
 }
-initRay(mY, eO, pO);
-if (intersectSceneShadow(mY, qz, si.triangleIndex)) {
+initRay(oa, eY, qS);
+if (intersectSceneShadow(oa, rM, si.triangleIndex)) {
 return vec3(0.0);
 }
 
@@ -96,7 +103,7 @@ return vec3(0.0);
 
 
 if (isSurface && cosThetaL < 0.0 && lightSample.sourceType == 0) {
-vec4 background = cn(mY.o, lightDir);
+vec4 background = cq(oa.o, lightDir);
 lightSample.emission = sampling_spectral_rgb_filter(background.rgb * background.a, pathChannel);
 }
 #endif
@@ -105,45 +112,45 @@ lightSample.emission = sampling_spectral_rgb_filter(background.rgb * background.
 
 float misWeight = lightSample.isDelta
 ? 1.0
-: aF(lightPdf, scatteringPdf);
+: aG(lightPdf, scatteringPdf);
 ${fragments['sample1'] ?? ''}  return misWeight > 0.0
 ? misWeight * lightSample.emission * f / lightPdf
 : vec3(0.0);
 }
 
 #ifdef USE_COAT_NORMAL_FRAMES
-vec3 fE(vec3 ql, vec3 face, vec3 view) {
+vec3 fQ(vec3 ru, vec3 face, vec3 view) {
 bool front = dot(face, view) >= 0.0;
-vec3 wd = front ? face : -face;
-vec3 rY = front ? ql : -ql;
-if (dot(ql, face) <= 0.0 || dot(rY, view) <= 1e-6) { return wd; }
-return rY;
+vec3 yc = front ? face : -face;
+vec3 tv = front ? ru : -ru;
+if (dot(ru, face) <= 0.0 || dot(tv, view) <= 1e-6) { return yc; }
+return tv;
 }
 #endif
-void mx(inout SurfaceInteraction si, OpenPbrResolvedMaterial mat, inout Path path) {
-vec3 wh = vec3(sample2D(bE(BSDF_DIRECTION)), sample1D(bE(BSDF_LOBE)));
+void nB(inout SurfaceInteraction si, OpenPbrResolvedMaterial mat, inout Path path) {
+vec3 yh = vec3(sample2D(aX(BSDF_DIRECTION)), sample1D(aX(BSDF_LOBE)));
 #ifdef USE_COAT_NORMAL_FRAMES
-vec3 bA = si.faceNormal;
-vec3 ni = si.normal;
+vec3 bC = si.faceNormal;
+vec3 oh = si.normal;
 #endif
-float sL = -dot(si.faceNormal, path.ray.d);
-float tY = -dot(si.normal, path.ray.d);
+float uk = -dot(si.faceNormal, path.ray.d);
+float vH = -dot(si.normal, path.ray.d);
 if ((mat.transmissionWeight > 0.0 || mat.subsurfaceWeight > 0.0) && mat.thinWalled) {
 
-if (sL < 0.0) {
+if (uk < 0.0) {
 si.faceNormal = -si.faceNormal;
-sL = -sL;
+uk = -uk;
 }
-if (tY < 0.0) {
+if (vH < 0.0) {
 si.normal = -si.normal;
-tY = -tY;
+vH = -vH;
 }
 }
 
 
-bool qE = sL >= 0.0 && tY < 0.0;
-float ndv = qE ? sL : tY;
-vec3 normal = qE ? si.faceNormal : si.normal;
+bool rS = uk >= 0.0 && vH < 0.0;
+float ndv = rS ? uk : vH;
+vec3 normal = rS ? si.faceNormal : si.normal;
 
 mat.inside = ndv <= 0.0 && !mat.thinWalled;
 
@@ -152,96 +159,105 @@ vec3 ffnormal = ndv >= 0.0 ? normal : -normal;
 #ifdef USE_COAT_NORMAL_FRAMES
 if (mat.coatNormalEnabled) {
 vec3 view = -path.ray.d;
-float fZ = dot(bA, view);
-mat.geometricNormal = fZ >= 0.0 ? bA : -bA;
-ffnormal = fE(ni, bA, view);
-mat.coatNormal = fE(si.coatNormal, bA, view);
-mat.inside = fZ <= 0.0 && !mat.thinWalled;
-mat.relativeIor = (fZ > 0.0 || mat.thinWalled) ? 1.0 / mat.specularIor : mat.specularIor;
+float gr = dot(bC, view);
+mat.geometricNormal = gr >= 0.0 ? bC : -bC;
+ffnormal = fQ(oh, bC, view);
+mat.coatNormal = fQ(si.coatNormal, bC, view);
+mat.inside = gr <= 0.0 && !mat.thinWalled;
+mat.relativeIor = (gr > 0.0 || mat.thinWalled) ? 1.0 / mat.specularIor : mat.specularIor;
 }
 #endif
 
 
 float scatteringPdf;
-vec3 df;
+vec3 di;
 path.scatteringIsDelta = false;
 bool mediumSampled = false;
-bool hj = false;
+bool hE = false;
 OpenPbrPreparedBsdf prepared;
 
 #ifdef HAS_MEDIUM
 int mediumType = si.mediumType;
 float d = distance(si.position, path.ray.o);
-vec3 od = path.ray.o;
+vec3 pd = path.ray.o;
 vec3 extinction = si.mediumExtinction;
 vec3 scattering = min(si.mediumScattering, extinction);
-float tU = max(max(extinction.x, extinction.y), extinction.z);
-if (mediumType > 0 && tU > 0.0) {
+float vD = max(max(extinction.x, extinction.y), extinction.z);
+if (mediumType > 0 && vD > 0.0) {
 
 
 
 
-int nX = min(int(sample1D(bE(MEDIUM_CHANNEL)) * 3.0), 2);
-float fD = extinction[nX];
-float ij = fD > 0.0
-? min(-log(max(sample1D(bE(MEDIUM_DISTANCE)), 1e-7)) / fD, d)
+int oW = min(int(sample1D(aX(MEDIUM_CHANNEL)) * 3.0), 2);
+float fP = extinction[oW];
+float iO = fP > 0.0
+? min(-log(max(sample1D(aX(MEDIUM_DISTANCE)), 1e-7)) / fP, d)
 : d;
-mediumSampled = ij < d;
-vec3 transmittance = exp(-extinction * ij);
-vec3 oK = mediumSampled
+mediumSampled = iO < d;
+vec3 transmittance = exp(-extinction * iO);
+vec3 density = mediumSampled
 ? extinction * transmittance
 : transmittance;
 float mediumPdf = max(
-(oK.x + oK.y + oK.z) / 3.0,
+(density.x + density.y + density.z) / 3.0,
 1e-8
 );
 if (mediumSampled) {
 path.beta *= transmittance * scattering / mediumPdf;
 
-path.ray.o = od + ij * path.ray.d;
+if (all(equal(path.beta, vec3(0.0)))) { path.abort = true; return; }
+
+path.ray.o = pd + iO * path.ray.d;
 si.position = path.ray.o;
-path.li += sX(si, mat, prepared, path, ffnormal, false) * path.beta;
 
+si.triangleIndex = -1;
+si.instanceIndex = -1;
+path.li += qY(si, mat, prepared, path, ffnormal, false) * path.beta;
 
-df = fj(
+
+di = dQ(
 -path.ray.d,
 si.mediumAnisotropy,
-sample2D(bE(PHASE_DIRECTION))
+sample2D(aX(PHASE_DIRECTION))
 );
-scatteringPdf = bB(
-dot(df, -path.ray.d),
+scatteringPdf = ba(
+dot(di, -path.ray.d),
 si.mediumAnisotropy
 );
 }
 else {
 path.beta *= transmittance / mediumPdf;
+
+if (all(equal(path.beta, vec3(0.0)))) { path.abort = true; return; }
 }
 }
 #endif
 
 
 if (!mediumSampled) {
-${fragments['sample2'] ?? ''}path.li += emissiveHitMisWeight(si,path) * mat.emission * path.beta;${fragments['sample3'] ?? ''}
+
+vec3 surfaceEmission = sampling_spectral_rgb_filter(mat.emission, pathChannel);
+${fragments['sample2'] ?? ''}path.li += emissiveHitMisWeight(si,path) * surfaceEmission * path.beta;${fragments['sample3'] ?? ''}
 if (mat.materialType == UNLIT) {
 path.abort = true;
 return;
 }
-vec3 qB = vec3(0.0);
+vec3 rP = vec3(0.0);
 #ifdef USE_TANGENT
-qB = si.tangent;
+rP = si.tangent;
 #endif
 mat.directionTangent = si.directionTangent;
 mat.directionBitangent = si.directionBitangent;
 mat.geometryTangent = si.geometryTangent;
 mat.geometryBitangent = si.geometryBitangent;
-prepared = bV(qB, mat, -path.ray.d, ffnormal);
-path.li += sX(si, mat, prepared, path, ffnormal, true) * path.beta;
+prepared = bX(rP, mat, -path.ray.d, ffnormal);
+path.li += qY(si, mat, prepared, path, ffnormal, true) * path.beta;
 ${fragments['sample4'] ?? ''}    
 bool isNextRefraction;
-vec3 f = dl(
+vec3 f = dr(
 prepared,
-wh,
-df,
+yh,
+di,
 scatteringPdf,
 isNextRefraction
 );
@@ -253,25 +269,27 @@ prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] >= 1.0 - 1e-6;
 
 
 if (!(scatteringPdf > 0.0) || any(isnan(f)) || any(isinf(f)) ||
-dot(df, df) < 0.5) {
+dot(di, di) < 0.5) {
 path.scatteringPdf = 0.0;
 path.abort = true;
 return;
 }
 ${fragments['sample5'] ?? ''}    path.beta *= f / scatteringPdf;
-hj = !mat.thinWalled &&
+
+if (all(equal(path.beta, vec3(0.0)))) { path.abort = true; return; }
+hE = !mat.thinWalled &&
 isNextRefraction;
 path.isNextRefraction = isNextRefraction;
 
 
-path.ray.o = si.position + EPS * df;
+path.ray.o = si.position + EPS * di;
 #ifdef USE_COAT_NORMAL_FRAMES
-if (mat.coatNormalEnabled) { path.ray.o = si.position + EPS * (dot(bA, df) >= 0.0 ? bA : -bA); }
+if (mat.coatNormalEnabled) { path.ray.o = si.position + EPS * (dot(bC, di) >= 0.0 ? bC : -bC); }
 #endif
 }
 
 path.scatteringPdf = scatteringPdf;
-initRay(path.ray, path.ray.o, df);
+initRay(path.ray, path.ray.o, di);
 if (mediumSampled) {${fragments['sample6'] ?? ''}
 path.isNextRefraction = false;
 }
@@ -280,11 +298,12 @@ path.fromEye = false;
 #ifdef HAS_MEDIUM
 
 
-if (!mediumSampled && hj && mat.mediumType > 0) {
-if (sL >= 0.0) {
+if (!mediumSampled && hE && mat.mediumType > 0) {
+if (uk >= 0.0) {
 si.mediumType = mat.mediumType;
 si.mediumExtinction = mat.mediumExtinction;
 si.mediumScattering = mat.mediumScattering;
+path.scatteringMediumEntered = path.scatteringMediumEntered || any(greaterThan(mat.mediumScattering, vec3(0.0)));
 si.mediumAnisotropy = mat.mediumAnisotropy;
 }
 else {

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,MAAM,UAAU,wBAAwB,CAAC,YAA8C,EAAE;IAAI,OAAO,IAAI,CAAA;;;;;;;;;;;;;;;;;;;;mDAoB7C,SAAS,CAAC,SAAS,CAAC,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoFnF,SAAS,CAAC,SAAS,CAAC,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmHtB,SAAS,CAAC,SAAS,CAAC,IAAI,EAAE,uEAAuE,SAAS,CAAC,SAAS,CAAC,IAAI,EAAE;;;;;;;;;;;;;;;EAe/H,SAAS,CAAC,SAAS,CAAC,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;EAsB1B,SAAS,CAAC,SAAS,CAAC,IAAI,EAAE;;;;;;;;;;;;;;sBAcJ,SAAS,CAAC,SAAS,CAAC,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;CAwBjD,CAAC;AACF,CAAC;AACD,eAAe,wBAAwB,EAAE,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 function createSampleMaterialGlsl(fragments: Readonly<Record<string, string>> = {}) { return glsl`\nfloat emissiveHitMisWeight(SurfaceInteraction si,Path path) {\n  // Secondary intersections remain two-sided, but one-sided emission does not.\n  float facing=dot(si.faceNormal,-path.ray.d);\n  if(facing<=0.0&&fetchMatData(si.materialIndex*MAT_DATA_SIZE+MAT_ROW_ALPHA).z<0.5)return 0.0;\n#ifdef HAS_EMISSIVE_LIGHTS\n  if(!path.fromEye && emissiveWeightTotal>0.0) {\n    vec3 emission=fetchMatData(si.materialIndex*MAT_DATA_SIZE+MAT_ROW_EMISSION).rgb;\n    float value=dot(emission,vec3(.2126,.7152,.0722)),cosine=dot(si.faceNormal,-path.ray.d);\n    if(value>0.0&&cosine>0.0){float d=distance(si.position,path.ray.o);return sampling_power_heuristic(path.scatteringPdf,value/emissiveWeightTotal*d*d/cosine);}\n  }\n#endif\n  return 1.0;\n}\n\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);${fragments['sample0'] ?? ''}\n  lightSample.emission = sampling_spectral_rgb_filter(lightSample.emission, pathChannel);\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  float shadowDistance=lightSample.dist-EPS;\n  vec3 shadowDirection=lightDir;\n  if(lightSample.sourceType==1){\n    vec3 endpoint=si.position+lightDir*lightSample.dist+EPS*lightSample.normal;\n    shadowDirection=normalize(endpoint-shadowOrigin);shadowDistance=distance(endpoint,shadowOrigin);\n  }\n  initRay(lightRay, shadowOrigin, shadowDirection);\n  if (intersectSceneShadow(lightRay, shadowDistance, 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 && lightSample.sourceType == 0) {\n    vec4 background = sampleBackgroundFromRay(lightRay.o, lightDir);\n    lightSample.emission = sampling_spectral_rgb_filter(background.rgb * background.a, pathChannel);\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${fragments['sample1'] ?? ''}  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    ${fragments['sample2'] ?? ''}path.li += emissiveHitMisWeight(si,path) * mat.emission * path.beta;${fragments['sample3'] ?? ''}\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${fragments['sample4'] ?? ''}    // 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${fragments['sample5'] ?? ''}    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) {${fragments['sample6'] ?? ''}\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}\nexport default createSampleMaterialGlsl();\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,MAAM,UAAU,wBAAwB,CAAC,YAA8C,EAAE,EAAE,uBAAuB,GAAG,KAAK;IAAI,OAAO,IAAI,CAAA;;;;;;;;;;;;;;;;;;;;mDAoB9E,SAAS,CAAC,SAAS,CAAC,IAAI,EAAE;EACnF,uBAAuB,CAAC,CAAC,CAAC,UAAU,CAAC;;EAEnC,CAAC,CAAC,CAAC,UAAU,CAAC,2FAA2F;;;;;;;;;;;;;;;;;;EAkB3G,uBAAuB,CAAC,CAAC,CAAC,UAAU,CAAC;;;;;CAKtC,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiEJ,SAAS,CAAC,SAAS,CAAC,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4HtB,SAAS,CAAC,SAAS,CAAC,IAAI,EAAE,0EAA0E,SAAS,CAAC,SAAS,CAAC,IAAI,EAAE;;;;;;;;;;;;;;;EAelI,SAAS,CAAC,SAAS,CAAC,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;EAsB1B,SAAS,CAAC,SAAS,CAAC,IAAI,EAAE;;;;;;;;;;;;;;;;sBAgBJ,SAAS,CAAC,SAAS,CAAC,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;CAyBjD,CAAC;AACF,CAAC;AACD,eAAe,wBAAwB,EAAE,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 function createSampleMaterialGlsl(fragments: Readonly<Record<string, string>> = {}, channelIndependentLight = false) { return glsl`\nfloat emissiveHitMisWeight(SurfaceInteraction si,Path path) {\n  // Secondary intersections remain two-sided, but one-sided emission does not.\n  float facing=dot(si.faceNormal,-path.ray.d);\n  if(facing<=0.0&&fetchMatData(si.materialIndex*MAT_DATA_SIZE+MAT_ROW_ALPHA).z<0.5)return 0.0;\n#ifdef HAS_EMISSIVE_LIGHTS\n  if(!path.fromEye && emissiveWeightTotal>0.0) {\n    vec3 emission=fetchMatData(si.materialIndex*MAT_DATA_SIZE+MAT_ROW_EMISSION).rgb;\n    float value=dot(emission,vec3(.2126,.7152,.0722)),cosine=dot(si.faceNormal,-path.ray.d);\n    if(value>0.0&&cosine>0.0){float d=distance(si.position,path.ray.o);return sampling_power_heuristic(path.scatteringPdf,value/emissiveWeightTotal*d*d/cosine);}\n  }\n#endif\n  return 1.0;\n}\n\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);${fragments['sample0'] ?? ''}\n${channelIndependentLight ? /* glsl */ `  if (dispersionWavelengths == 1) {\n    lightSample.emission = sampling_spectral_rgb_filter(lightSample.emission, pathChannel);\n  }` : /* glsl */ `  lightSample.emission = sampling_spectral_rgb_filter(lightSample.emission, pathChannel);`}\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${channelIndependentLight ? /* glsl */ `  // Test the full emission before filtering, so black spectral components\n  // still consume the same visibility walk and random stream.\n  if (dispersionWavelengths != 1) {\n    lightSample.emission = sampling_spectral_rgb_filter(lightSample.emission, pathChannel);\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  float shadowDistance=lightSample.dist-EPS;\n  vec3 shadowDirection=lightDir;\n  if(lightSample.sourceType==1){\n    vec3 endpoint=si.position+lightDir*lightSample.dist+EPS*lightSample.normal;\n    shadowDirection=normalize(endpoint-shadowOrigin);shadowDistance=distance(endpoint,shadowOrigin);\n  }\n  initRay(lightRay, shadowOrigin, shadowDirection);\n  if (intersectSceneShadow(lightRay, shadowDistance, 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 && lightSample.sourceType == 0) {\n    vec4 background = sampleBackgroundFromRay(lightRay.o, lightDir);\n    lightSample.emission = sampling_spectral_rgb_filter(background.rgb * background.a, pathChannel);\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${fragments['sample1'] ?? ''}  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      // Zero throughput cannot contribute at subsequent vertices or light connections.\n      if (all(equal(path.beta, vec3(0.0)))) { path.abort = true; return; }\n      // Move from the start of the segment, not from its end surface.\n      path.ray.o = segmentOrigin + scatterDist * path.ray.d;\n      si.position = path.ray.o;\n      // A volume vertex has no originating surface to skip on continuation or shadow rays.\n      si.triangleIndex = -1;\n      si.instanceIndex = -1;\n      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      // Zero throughput cannot contribute at subsequent vertices or light connections.\n      if (all(equal(path.beta, vec3(0.0)))) { path.abort = true; return; }\n    }\n  }\n#endif\n\n  // Direct lighting\n  if (!mediumSampled) {\n    // Match NEE and background radiance when RGB wavelength passes are added.\n    vec3 surfaceEmission = sampling_spectral_rgb_filter(mat.emission, pathChannel);\n    ${fragments['sample2'] ?? ''}path.li += emissiveHitMisWeight(si,path) * surfaceEmission * path.beta;${fragments['sample3'] ?? ''}\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${fragments['sample4'] ?? ''}    // 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${fragments['sample5'] ?? ''}    path.beta *= f / scatteringPdf;\n    // Zero throughput cannot contribute at subsequent vertices or light connections.\n    if (all(equal(path.beta, vec3(0.0)))) { path.abort = true; return; }\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) {${fragments['sample6'] ?? ''}\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      path.scatteringMediumEntered = path.scatteringMediumEntered || any(greaterThan(mat.mediumScattering, vec3(0.0)));\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}\nexport default createSampleMaterialGlsl();\n"]}

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

@@ -12,34 +12,34 @@ export default glsl `
 
 const uint SHADOW_CATCHER_LIGHT_SAMPLES = 4u;
 
-uint kJ(uint candidate, uint slot) {
-return candidate == 0u ? bE(slot) : bE(9u + (candidate - 1u) * 3u + slot);
+uint lA(uint candidate, uint slot) {
+return candidate == 0u ? aX(slot) : aX(9u + (candidate - 1u) * 3u + slot);
 }
 
 
 
 vec2 sampleShadowCatcher(SurfaceInteraction si, int bounce, inout Path path) {
-vec3 qR = -path.ray.d;
+vec3 sg = -path.ray.d;
 vec2 counts = vec2(0.0);
 
 #if defined(NUM_LIGHTS) || defined(USE_ENVMAP)
 for (uint candidate = 0u; candidate < SHADOW_CATCHER_LIGHT_SAMPLES; candidate++) {
 LightSampleRec lightSample;
-vec3 mZ = vec3(
-sample2D(kJ(candidate, LIGHT_POSITION)),
-sample1D(kJ(candidate, LIGHT_SELECT))
+vec3 ob = vec3(
+sample2D(lA(candidate, LIGHT_POSITION)),
+sample1D(lA(candidate, LIGHT_SELECT))
 );
-sampleLight(si.position, mZ, lightSample, false);
+sampleLight(si.position, ob, lightSample, false);
 
 vec3 lightDir = lightSample.direction;
 float cosThetaL = dot(si.normal, lightDir);
-float qt = dot(si.normal, qR) * cosThetaL;
-if (lightSample.pdf > 0.0 && qt >= 0.0) {
+float rG = dot(si.normal, sg) * cosThetaL;
+if (lightSample.pdf > 0.0 && rG >= 0.0) {
 if (dot(lightSample.emission, luminance) * abs(cosThetaL) > 0.0) {
 Ray ray;
 initRay(ray, si.position + EPS * lightDir, lightDir);
-bool lH = intersectSceneShadow(ray, lightSample.dist - EPS, si.triangleIndex);
-counts += vec2(lH ? 1.0 : 0.0, 1.0);
+bool mz = intersectSceneShadow(ray, lightSample.dist - EPS, si.triangleIndex);
+counts += vec2(mz ? 1.0 : 0.0, 1.0);
 }
 }
 }