@meimu/mutracer 0.1.0 → 0.1.2

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

@@ -58,9 +58,9 @@ fu lm;
 top = 0;
 stack[0] = ivec2(0, -1);
 
-int wd = 0;
-while(top >= 0 && wd < 5000) {
-wd++;
+int wf = 0;
+while(top >= 0 && wf < 5000) {
+wf++;
 ivec2 node = stack[top--];
 
 int cf = node.y;
@@ -117,7 +117,7 @@ uintBitsToFloat(uint(rs + 127) << 23u)
 uint childBase = floatBitsToUint(fC.x);
 uint oE = floatBitsToUint(fC.y);
 uint internalMask = header >> 24u;
-uint uf = (d.x < 0.0 ? 4u : 0u) |
+uint ug = (d.x < 0.0 ? 4u : 0u) |
 (d.y < 0.0 ? 2u : 0u) |
 (d.z < 0.0 ? 1u : 0u);
 uint gA[12] = uint[12](
@@ -130,7 +130,7 @@ floatBitsToUint(mJ.z), floatBitsToUint(mJ.w)
 );
 
 for (int order = 7; order >= 0; order--) {
-uint slot = uint(order) ^ uf;
+uint slot = uint(order) ^ ug;
 uint sn = slot >= 4u
 ? floatBitsToUint(fC.w)
 : floatBitsToUint(fC.z);
@@ -148,9 +148,9 @@ float((gA[6u + kJ] >> lL) & 0xffu),
 float((gA[8u + kJ] >> lL) & 0xffu),
 float((gA[10u + kJ] >> lL) & 0xffu)
 );
-vec3 uI = jr.xyz + tq * hG;
-vec3 uH = jr.xyz + tp * hG;
-if (cM(o, d, uI, uH, tMax) <= 0.0) continue;
+vec3 uK = jr.xyz + tq * hG;
+vec3 uJ = jr.xyz + tp * hG;
+if (cM(o, d, uK, uJ, tMax) <= 0.0) continue;
 uint ju = meta & 0x1fu;
 if (ju >= 24u) {
 uint mY = internalMask & ((1u << slot) - 1u);
@@ -162,29 +162,29 @@ eS + int(sL * 5u), cf
 else {
 uint triangleCount = qG(meta >> 5u);
 uint rF = oE + ju;
-uint uS = 0x80000000u |
+uint uU = 0x80000000u |
 (triangleCount << 23u) |
 (rF & 0x007fffffu);
-stack[++top] = ivec2(int(uS), cf);
+stack[++top] = ivec2(int(uU), cf);
 }
 }
 }
 }
 else if (gL == 2) {
 int i = node.x + bo;
-vec4 uK = dp(i);
-vec4 uL = dp(i + 1);
-vec4 uM = dp(i + 2);
-vec4 uN = dp(i + 3);
-bh = int(floatBitsToUint(uM.w));
+vec4 uM = dp(i);
+vec4 uN = dp(i + 1);
+vec4 uO = dp(i + 2);
+vec4 uP = dp(i + 3);
+bh = int(floatBitsToUint(uO.w));
 if (bh > 0) {
-primitiveOffset = bo + eS + int(floatBitsToUint(uN.w));
+primitiveOffset = bo + eS + int(floatBitsToUint(uP.w));
 }
 else {
-int left = eS + int(floatBitsToUint(uK.w) * 4u);
-int right = eS + int(floatBitsToUint(uL.w) * 4u);
-float d0 = cM(o, d, uK.xyz, uL.xyz, tMax);
-float d1 = cM(o, d, uM.xyz, uN.xyz, tMax);
+int left = eS + int(floatBitsToUint(uM.w) * 4u);
+int right = eS + int(floatBitsToUint(uN.w) * 4u);
+float d0 = cM(o, d, uM.xyz, uN.xyz, tMax);
+float d1 = cM(o, d, uO.xyz, uP.xyz, tMax);
 if (d0 > d1) {
 if (d0 > 0.0) stack[++top] = ivec2(left, cf);
 if (d1 > 0.0) stack[++top] = ivec2(right, cf);
@@ -203,12 +203,12 @@ primitiveOffset = bo + eS + int(hT & 0x007fffffu);
 }
 else {
 int i = node.x + bo;
-vec4 tV = dp(i);
+vec4 tW = dp(i);
 vec4 ra = dp(i + 1);
 vec4 rb = dp(i + 2);
 vec4 rc = dp(i + 3);
-vec3 nodeMin = tV.xyz;
-vec3 ec = vec3(tV.w, ra.x, ra.y);
+vec3 nodeMin = tW.xyz;
+vec3 ec = vec3(tW.w, ra.x, ra.y);
 uint lS[4] = uint[4](
 floatBitsToUint(ra.z), floatBitsToUint(ra.w),
 floatBitsToUint(rb.x), floatBitsToUint(rb.y)
@@ -451,8 +451,8 @@ d = ht(light.radius, light.position, r);
 lightSample.isDelta = false;
 }
 if (d != INF) {
-vec3 uQ = r.o + d * r.d;
-float mo = bL(light, normalize(r.o - uQ));
+vec3 uS = r.o + d * r.d;
+float mo = bL(light, normalize(r.o - uS));
 if (mo <= 0.0) return INF;
 float aj = distance(r.o, light.position);
 float cosThetaMax = aj <= light.radius
@@ -835,19 +835,19 @@ return vec3(0.0);
 
 
 
-float cM(vec3 o, vec3 d, vec3 vw, vec3 vu, float tMax) {
+float cM(vec3 o, vec3 d, vec3 vx, vec3 vw, float tMax) {
 #ifdef DEPTH_QUERY_MODE
 vec3 gv = eX(d);
-vec3 uD = (vw - o) * gv;
-vec3 uE = (vu - o) * gv;
+vec3 uF = (vx - o) * gv;
+vec3 uG = (vw - o) * gv;
 vec3 bJ = eV(gv, o);
 #else
-vec3 uD = (vw - o) / d;
-vec3 uE = (vu - o) / d;
+vec3 uF = (vx - o) / d;
+vec3 uG = (vw - o) / d;
 vec3 bJ = vec3(0.0);
 #endif
-vec3 my = min(uD, uE) - bJ;
-vec3 rH = max(uD, uE) + bJ;
+vec3 my = min(uF, uG) - bJ;
+vec3 rH = max(uF, uG) + bJ;
 float t0 = max(my.x, max(my.y, my.z));
 float t1 = min(rH.x, min(rH.y, rH.z));
 

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

@@ -51,7 +51,7 @@ return alpha >= alphaCutoff ? 1.0 : 0.0;
 return alpha;
 }
 
-float vO(int idx) {
+float vP(int idx) {
 return fetchMatData(idx * MAT_DATA_SIZE + MAT_ROW_COLOR).w;
 }
 
@@ -135,8 +135,8 @@ vec4 nh = fetchMatData(i + MAT_ROW_ALPHA_FILM);
 vec4 lF = fetchMatData(i + MAT_ROW_BASE_CONTROLS);
 vec4 oM = fetchMatData(i + MAT_ROW_SPECULAR_FUZZ);
 vec4 subsurface = fetchMatData(i + MAT_ROW_SUBSURFACE);
-vec4 wc = fetchMatData(i + MAT_ROW_FUZZ);
-vec4 vx = fetchMatData(i + MAT_ROW_COAT);
+vec4 wd = fetchMatData(i + MAT_ROW_FUZZ);
+vec4 vy = fetchMatData(i + MAT_ROW_COAT);
 vec4 lG = fetchMatData(i + MAT_ROW_COAT_CONTROLS);
 vec4 mK = fetchMatData(i + MAT_ROW_FILM_DISPERSION);
 vec4 ng = fetchMatData(i + MAT_ROW_STANDALONE_MAPS);
@@ -173,10 +173,10 @@ mat.specularColor = max(oM.rgb, vec3(0.0));
 mat.fuzzWeight = clamp(oM.w, 0.0, 1.0);
 mat.subsurfaceColor = max(subsurface.rgb, vec3(0.0));
 mat.transmissionColor = max(fetchMatData(i + MAT_ROW_TRANSMISSION_COLOR).rgb, vec3(0.0));
-mat.fuzzColor = max(wc.rgb, vec3(0.0));
-mat.fuzzRoughness = clamp(wc.w, 0.0, 1.0);
-mat.coatColor = max(vx.rgb, vec3(0.0));
-mat.coatWeight = clamp(vx.w, 0.0, 1.0);
+mat.fuzzColor = max(wd.rgb, vec3(0.0));
+mat.fuzzRoughness = clamp(wd.w, 0.0, 1.0);
+mat.coatColor = max(vy.rgb, vec3(0.0));
+mat.coatWeight = clamp(vy.w, 0.0, 1.0);
 mat.coatRoughness = clamp(lG.x, ROUGHNESS_MIN, 1.0);
 mat.coatAnisotropy = clamp(lG.y, 0.0, 1.0);
 mat.coatIor = max(lG.z, 1.0);
@@ -253,10 +253,10 @@ mat.emission *= decodeMapColor(emissiveMapIndex, emissive);
 #ifdef NUM_COAT_WEIGHT_MAPS
 int hN = int(fetchMatData(i + MAT_ROW_LAYER_MAPS).x);
 if (hN >= 0 && mat.materialType == 0) {
-float qk = clamp(vx.w, 0.0, 1.0) * sampleMap(
+float qk = clamp(vy.w, 0.0, 1.0) * sampleMap(
 hN, getMapUvSet(hN, uv, uv1)
 ).r;
-mat.emission *= mix(vec3(1.0), sqrt(max(vx.rgb, vec3(0.0))), qk);
+mat.emission *= mix(vec3(1.0), sqrt(max(vy.rgb, vec3(0.0))), qk);
 }
 #endif
 

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

@@ -122,18 +122,18 @@ float cp = bA - float(dP);
 float cy = aG - float(aM);
 float ku = bt - float(cI);
 
-float uk = F(cI, dP * 32 + aM);
-float ul = F(eO, dP * 32 + aM);
-float um = F(cI, dP * 32 + cn);
-float un = F(eO, dP * 32 + cn);
-float uo = F(cI, hB * 32 + aM);
-float uq = F(eO, hB * 32 + aM);
-float ur = F(cI, hB * 32 + cn);
-float us = F(eO, hB * 32 + cn);
-float v00 = mix(uk, uo, cp);
-float v01 = mix(ul, uq, cp);
-float v10 = mix(um, ur, cp);
-float v11 = mix(un, us, cp);
+float ul = F(cI, dP * 32 + aM);
+float um = F(eO, dP * 32 + aM);
+float un = F(cI, dP * 32 + cn);
+float uo = F(eO, dP * 32 + cn);
+float uq = F(cI, hB * 32 + aM);
+float ur = F(eO, hB * 32 + aM);
+float us = F(cI, hB * 32 + cn);
+float ut = F(eO, hB * 32 + cn);
+float v00 = mix(ul, uq, cp);
+float v01 = mix(um, ur, cp);
+float v10 = mix(un, us, cp);
+float v11 = mix(uo, ut, cp);
 return mix(
 mix(v00, v10, cy),
 mix(v01, v11, cy),
@@ -181,18 +181,18 @@ float cp = bA - float(dP);
 float cy = aG - float(aM);
 float ku = bt - float(cI);
 
-float uk = F(cI, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dP * 32 + aM);
-float ul = F(eO, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dP * 32 + aM);
-float um = F(cI, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dP * 32 + cn);
-float un = F(eO, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dP * 32 + cn);
-float uo = F(cI, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hB * 32 + aM);
-float uq = F(eO, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hB * 32 + aM);
-float ur = F(cI, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hB * 32 + cn);
-float us = F(eO, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hB * 32 + cn);
-float v00 = mix(uk, uo, cp);
-float v01 = mix(ul, uq, cp);
-float v10 = mix(um, ur, cp);
-float v11 = mix(un, us, cp);
+float ul = F(cI, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dP * 32 + aM);
+float um = F(eO, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dP * 32 + aM);
+float un = F(cI, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dP * 32 + cn);
+float uo = F(eO, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dP * 32 + cn);
+float uq = F(cI, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hB * 32 + aM);
+float ur = F(eO, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hB * 32 + aM);
+float us = F(cI, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hB * 32 + cn);
+float ut = F(eO, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hB * 32 + cn);
+float v00 = mix(ul, uq, cp);
+float v01 = mix(um, ur, cp);
+float v10 = mix(un, us, cp);
+float v11 = mix(uo, ut, cp);
 return mix(
 mix(v00, v10, cy),
 mix(v01, v11, cy),
@@ -906,17 +906,17 @@ J material = prepared.material;
 float dielectric = 1.0 - material.baseMetalness;
 float opaque = dielectric * (1.0 - material.transmissionWeight) * (1.0 - material.subsurfaceWeight);
 float sss = dielectric * (1.0 - material.transmissionWeight) * material.subsurfaceWeight;
-float tT = dielectric * material.transmissionWeight;
+float tU = dielectric * material.transmissionWeight;
 float fL = bM(prepared.specularEtaTOverEtaI);
 float kI = bM(1.0 / prepared.transmissionReflectionIor);
-float pw = clamp(opaque * fL + (sss + tT) * kI + material.baseMetalness, 0.0, 1.0);
+float pw = clamp(opaque * fL + (sss + tU) * kI + material.baseMetalness, 0.0, 1.0);
 float ji = mix(1.0, material.specularRoughness, pw);
 float ks = bM(material.coatIor);
 float kr = 1.0 - (1.0 - ks) / (material.coatIor * material.coatIor);
 float k = mix(ks, kr, ji);
 vec3 eb = material.baseMetalness * material.specularWeight * bP(material.baseWeight * material.baseColor, material.specularColor)
 + opaque * mix(material.baseWeight * material.baseColor, vec3(1.0), fL)
-+ sss * material.subsurfaceColor + vec3(tT);
++ sss * material.subsurfaceColor + vec3(tU);
 vec3 qH = vec3(1.0 - k) / max(vec3(1.0) - eb * k, vec3(1e-6));
 return mix(vec3(1.0), qH, material.coatWeight * material.coatDarkening);
 }
@@ -1545,7 +1545,7 @@ normal
 return bI(prepared, lightDirection, pdf);
 }
 
-float vJ(
+float vK(
 vec3 tangent,
 J material,
 vec3 bF,
@@ -1662,8 +1662,8 @@ else if (bm < cdf[OPENPBR_LOBE_TRANSMISSION]) {
 isTransmissionEvent = true;
 
 
-float ue = (bm - cdf[OPENPBR_LOBE_SPECULAR]) / max(prepared.probabilities[OPENPBR_LOBE_TRANSMISSION], 1e-12);
-if (prepared.dielectricMsProbability > 0.0 && ue < prepared.dielectricMsProbability) {
+float uf = (bm - cdf[OPENPBR_LOBE_SPECULAR]) / max(prepared.probabilities[OPENPBR_LOBE_TRANSMISSION], 1e-12);
+if (prepared.dielectricMsProbability > 0.0 && uf < prepared.dielectricMsProbability) {
 float iU = prepared.dielectricMsReflectionRatio;
 bool lM = cx < iU;
 float z;

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

@@ -11,7 +11,7 @@ s0 = uvec4(p, uint(frame), uint(p.x) + uint(p.y));
 }
 
 
-void vg(inout uvec4 v) {
+void vj(inout uvec4 v) {
 v = v * 1664525u + 1013904223u;
 v.x += v.y*v.w; v.y += v.z*v.x; v.z += v.x*v.y; v.w += v.y*v.z;
 v = v ^ (v>>16u);
@@ -19,7 +19,7 @@ v.x += v.y*v.w; v.y += v.z*v.x; v.z += v.x*v.y; v.w += v.y*v.z;
 }
 
 float rand() {
-vg(s0); return float(s0.x)/float(0xffffffffu);
+vj(s0); return float(s0.x)/float(0xffffffffu);
 }
 
 `;

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

@@ -23,7 +23,7 @@ export default createShaderMixin({
     main: glsl `
 
 const vec3 luminance = vec3(0.2126, 0.7152, 0.0722);
-const int vo = 8;
+const int vp = 8;
 
 #define RAY_MAX_DISTANCE 9999.0
 
@@ -276,10 +276,10 @@ float tD = light.v.y > 1e-6
 ? smoothstep(light.v.x, light.v.x + light.v.y, cc)
 : step(light.v.x, cc);
 if (tD <= 0.0 || light.textureIndex < 0) return tD;
-vec3 tW = light.iesReference;
-vec3 vn = cross(axis, tW);
+vec3 tX = light.iesReference;
+vec3 vo = cross(axis, tX);
 float vertical = acos(clamp(cc, -1.0, 1.0));
-float horizontal = atan(dot(dJ, vn), dot(dJ, tW));
+float horizontal = atan(dot(dJ, vo), dot(dJ, tX));
 return tD * kF(light.textureIndex, vec2(vertical / PI, horizontal / TWOPI + 0.5));
 }
 `

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

@@ -60,9 +60,9 @@ result.pdf = 1.0 / max(TWOPI * (1.0 - rJ), 1e-8);
 float iZ = dot(direction, nE);
 float ej = iZ * iZ
 - dot(nE, nE) + radius * radius;
-float wt = sqrt(max(0.0, ej));
-float cN = iZ - wt;
-float cB = iZ + wt;
+float wu = sqrt(max(0.0, ej));
+float cN = iZ - wu;
+float cB = iZ + wu;
 result.dist = cN > 1e-6 ? cN : cB;
 result.direction = direction;
 vec3 surfacePoint = shadingPoint + direction * result.dist;

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

@@ -93,14 +93,14 @@ return eW > 0.0
 #ifdef NUM_COAT_NORMAL_MAPS
 vec3 fB(vec3 pk, vec3 tc, vec3 view) {
 bool qL = dot(tc, view) >= 0.0;
-vec3 ub = qL ? tc : -tc;
+vec3 uc = qL ? tc : -tc;
 vec3 qK = qL ? pk : -pk;
-if (dot(pk, tc) <= 0.0 || dot(qK, view) <= 1e-6) { return ub; }
+if (dot(pk, tc) <= 0.0 || dot(qK, view) <= 1e-6) { return uc; }
 return qK;
 }
 #endif
 void lO(inout ad si, J mat, inout Path aa) {
-vec3 ud = vec3(fk(cv(BSDF_DIRECTION)), dz(cv(BSDF_LOBE)));
+vec3 ue = vec3(fk(cv(BSDF_DIRECTION)), dz(cv(BSDF_LOBE)));
 #ifdef NUM_COAT_NORMAL_MAPS
 vec3 bC = si.faceNormal;
 vec3 mr = si.normal;
@@ -219,7 +219,7 @@ aa.li += mG(si, mat, prepared, aa, ffnormal, true) * aa.beta;
 bool isNextRefraction;
 vec3 f = dv(
 prepared,
-ud,
+ue,
 cF,
 scatteringPdf,
 isNextRefraction

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

@@ -7,11 +7,11 @@ export default glsl `
 vec3 aQ(vec3 view, vec2 alpha, vec2 samplePoint) {
 vec3 qY = vec3(alpha, 1.0);
 vec3 ge = normalize(qY * view);
-float tU = min(ge.z, 1.0);
-float qD = 1.0 + tU;
+float tV = min(ge.z, 1.0);
+float qD = 1.0 + tV;
 float qT = (1.0 - samplePoint.y) * qD;
 float rE = samplePoint.y * qD;
-float st = qT + (1.0 - tU);
+float st = qT + (1.0 - tV);
 float fi = sqrt(max(0.0, st * rE));
 float br = TWOPI * samplePoint.x;
 vec3 lt = vec3(

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

@@ -52,7 +52,7 @@ uint r = reverseBits(ki);
 ${sobolD1Steps.map(([shift, mask]) => `r ^= (r << ${shift}u) & 0x${mask.toString(16)}u;`).join("\n  ")}
 return r;
 }
-vec2 vC(uint index, uint ie) {
+vec2 vD(uint index, uint ie) {
 uint i = sv(index, aq(ie, 0u));
 uint x = reverseBits(iA(i, aq(ie, 1u)));
 uint y = sv(qX(i), aq(ie, 2u));
@@ -74,9 +74,9 @@ return (word >> ((tm & 3u) * 8u)) & 255u;
 }
 uint pK(uint kB, uint dim, uint logSPP) {
 uint odd = logSPP & 1u;
-uint tZ = 8u + ((logSPP + 1u) >> 1u);
+uint ua = 8u + ((logSPP + 1u) >> 1u);
 uint result = 0u;
-for (int digit = int(tZ) - 1; digit >= int(odd); digit--) {
+for (int digit = int(ua) - 1; digit >= int(odd); digit--) {
 uint shift = 2u*uint(digit) - odd;
 
 uint sd = 0u;

package/lib/renderer/glsl/rayTrace.frag.js

@@ -32,7 +32,7 @@ return;
 // So here the code are injected separately.
 const bounceCodeOnIntelMac = glsl `
 
-for(int vH = 0; vH < BOUNCES; vH++) {{
+for(int vI = 0; vI < BOUNCES; vI++) {{
 if (aa.abort) {
 return vec4(aa.li, aa.alpha);
 }
@@ -40,10 +40,10 @@ bounce(aa, depth, si, mat, outAux);
 }}
 `;
 const bounceCodeOnOther = glsl `
-bool uR = !si.isTransparency;
+bool uT = !si.isTransparency;
 int qB = min(BOUNCES, bounceLimit);
 for(int idx = 0; idx < min(BOUNCES * 3, ${MAX_PATH_EVENTS}); idx++) {
-if (uR && idx > qB) {
+if (uT && idx > qB) {
 aa.abort = true;
 }
 if (aa.abort) {
@@ -120,6 +120,10 @@ ${intelMac ? doubleTransmissionCheckCode : ''}
 bool isShadowCatcher = mat.materialType == SHADOW_CATCHER;
 if (isShadowCatcher) {
 if (aa.fromEye) {
+
+
+outAux.albedo = vec3(1.0);
+outAux.normal = dot(si.normal, aa.ray.d) > 0.0 ? -si.normal : si.normal;
 si.hit = false;
 outAux.isShadowCatcher = true;
 }

package/lib/renderer/glsl/rayTrace.frag.js.map

@@ -1 +1 @@
-{"version":3,"file":"rayTrace.frag.js","sourceRoot":"","sources":["../../../src/renderer/glsl/rayTrace.frag.ts"],"names":[],"mappings":"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","sourcesContent":["import { MAX_PATH_EVENTS } from '../pathLimits.js';\nimport cameraRayGlsl from './chunks/cameraRay.glsl.js';\n// Portions adapted from ray-tracing-renderer@0.10.15\n// (https://github.com/hoverinc/ray-tracing-renderer).\n// Copyright (c) 2019 HOVER, MIT license; see LICENSES/RayTracingRenderer-MIT.txt.\n\nimport commonGlsl from './chunks/common.glsl.js';\nimport rayTraceCore from './chunks/rayTraceCore.glsl.js';\nimport textureLinear from './chunks/textureLinear.glsl.js';\nimport materialBufferGlsl from './chunks/materialBuffer.glsl.js';\nimport intersect from './chunks/intersect.glsl.js';\nimport randGlsl from './chunks/rand.glsl.js';\nimport random from './chunks/random.glsl.js';\nimport envMap from './chunks/envMap.glsl.js';\nimport sampleMaterialGlsl from './chunks/sampleMaterial.glsl.js';\nimport sampleLightGlsl from './chunks/sampleLight.glsl.js';\nimport { FragmentShader, glsl, Shader } from '../shader.js';\nimport openPbrBsdfGlsl from './chunks/openPbrBsdf.glsl.js';\nimport samplingGlsl from './chunks/sampling.glsl.js';\nimport { isIntelMac } from '../util.js';\nimport uvProjectionGlsl from './chunks/uvProjection.glsl.js';\n\nconst doubleTransmissionCheckCode = glsl`\n#if defined(HAS_TRANSMISSION) || defined(HAS_ALPHA)\n  if (!si.isTransparency && BOUNCES < 16 && depth * 2 > BOUNCES) {\n    path.abort = true;\n    return;\n  }\n#endif\n`;\n\n// bounce fix on intel mac\n// The intel mac only have one bounce if the loop is not unrolled\n// But windows will have extremely slow shader compilation if the loop is unrolled\n// So here the code are injected separately.\nconst bounceCodeOnIntelMac = glsl`\n// Mark loop can be unrolled\nfor(int _idx_ = 0; _idx_ < BOUNCES; _idx_++) {{\n  if (path.abort) {\n    return vec4(path.li, path.alpha);\n  }\n  bounce(path, depth, si, mat, outAux);\n}}\n`;\nconst bounceCodeOnOther = glsl`\nbool isOpaque = !si.isTransparency;\nint activeBounceLimit = min(BOUNCES, bounceLimit);\nfor(int idx = 0; idx < min(BOUNCES * 3, ${MAX_PATH_EVENTS}); idx++) {\n  if (isOpaque && idx > activeBounceLimit) {\n    path.abort = true;\n  }\n  if (path.abort) {\n    return vec4(path.li, path.alpha);\n  }\n  bounce(path, depth, si, mat, outAux);\n}\n`;\n\nexport default function createRayTraceFragmentShader() {\n  const intelMac = isIntelMac();\n  return new FragmentShader({\n  name: 'rayTraceFrag',\n  outputs: ['color', 'albedo', 'normal', 'moments'],\n  defines: {\n    BOUNCES: 2\n  },\n  uniforms: {\n    cameraApertureRadius: Shader.uniform('float', 0),\n    cameraFocusDistance: Shader.uniform('float', 10),\n\n    viewProjectionInv: Shader.uniform('mat4'),\n    viewInv: Shader.uniform('mat4'),\n    transmissiveOutputAlphaMin: Shader.uniform('float'),\n    openPbrEnergyLut: Shader.uniform('sampler2D'),\n\n    viewportSize: Shader.uniform('vec2'),\n\n    wavelength: Shader.uniform('float', 0),\n    bevelEnabled: Shader.uniform('bool', true),\n    dispersionWavelengths: Shader.uniform('int', 3),\n    bounceLimit: Shader.uniform('int', 8)\n  },\n  includes: [rayTraceCore, materialBufferGlsl, intersect, random, envMap],\n  main: glsl`\n${commonGlsl}\n\n${randGlsl}\n${random.main}\n\n${textureLinear}\n\n${rayTraceCore.main}\n\n${uvProjectionGlsl}\n\n${materialBufferGlsl.main}\n${intersect.main}\n${envMap.main}\n\n${samplingGlsl}\n${openPbrBsdfGlsl}\n\nfloat heroWavelength;\nfloat pathWavelength;\n\n${sampleLightGlsl}\n${sampleMaterialGlsl}\n\n${cameraRayGlsl}\nstruct RayTraceAuxiliary {\n  // Denoising guides and auxiliary pixel classification.\n  vec3 albedo;\n  vec3 normal;\n  bool isBlank;\n  // The primary ray hit a shadow catcher, whose sample the catcher pass owns.\n  bool isShadowCatcher;\n};\n\nvoid bounce(inout Path path, inout int depth, inout SurfaceInteraction si, inout OpenPbrResolvedMaterial mat, inout RayTraceAuxiliary outAux) {\n  samplingBounce = uint(max(depth, 0));\n  // The bounce will be doubled on the transmission material.\n  // For other materials. We will quite early\n  // TODO It is only used on Mac with AMD card. If I enabled it on windows.\n  // It will cause shader compilation too slow.\n${intelMac ? doubleTransmissionCheckCode : ''}\n\n  bool isShadowCatcher = mat.materialType == SHADOW_CATCHER;\n  if (isShadowCatcher) {\n    if (path.fromEye) {\n      si.hit = false;\n      outAux.isShadowCatcher = true;\n    }\n    else {\n      // The catcher belongs only to the shadow-mask pass. Keep its default\n      // white material out of glossy and transmission reflections.\n#ifdef USE_ENVMAP\n      if (path.isNextRefraction) {\n        // The invisible catcher can sit between a transmitted camera ray and\n        // the grounded skybox. Use the displayed background here instead of\n        // terminating early with the raw lighting environment.\n        vec4 bg = sampleBackgroundFromRay(path.ray.o, path.ray.d);\n        bg.rgb = sampling_spectral_rgb_filter(bg.rgb, pathWavelength);\n        float backgroundMisWeight = path.scatteringIsDelta ? 1.0\n          : sampling_power_heuristic(path.scatteringPdf,\n              envMapPdf(cartesianToEquirect(path.ray.d)) * envLightSelectionPmf);\n        path.li += backgroundMisWeight * path.beta * bg.rgb * bg.a;\n        path.alpha = max(path.alpha, bg.a);\n      }\n      else {\n        vec2 envUv = cartesianToEquirect(path.ray.d);\n        vec3 emission = textureLinear(envMap, envUv).rgb;\n        emission = sampling_spectral_rgb_filter(emission, pathWavelength);\n        path.li += path.beta * emission *\n          sampling_power_heuristic(\n            path.scatteringPdf,\n            envMapPdf(envUv) * envLightSelectionPmf\n          );\n      }\n#else\n      vec4 bg = sampleBackgroundFromRay(path.ray.o, path.ray.d);\n      bg.rgb = sampling_spectral_rgb_filter(bg.rgb, pathWavelength);\n      path.li += path.beta * bg.rgb * bg.a;\n#endif\n      path.abort = true;\n      return;\n    }\n  }\n\n  if (!si.hit) {\n    // Sample from background if first ray not hit anything.\n    vec4 bg = sampleBackgroundFromRay(path.ray.o, path.ray.d);\n    // Dispersion renders one additive pass per RGB wavelength. Background\n    // radiance has to be split in the same way as lights and emissive\n    // surfaces, otherwise the full skybox is accumulated three times.\n    bg.rgb = sampling_spectral_rgb_filter(bg.rgb, pathWavelength);\n    if (path.fromEye) {\n      path.li = bg.rgb * bg.a;\n      path.alpha = bg.a;\n      // Only treat as blank pixels when the background is transparent\n      outAux.isBlank = bg.a < 0.01;\n    }\n    else {\n      Ray cam = initCameraRay(v_Texcoord + pixelJitter());\n      bool towardsCam = dot(cam.d, path.ray.d) > 0.0;\n      if (transmissiveOutputAlphaMin < 1.0) {\n        if (towardsCam) {\n          path.alpha = max(path.alpha, bg.a);\n        } else {\n          path.alpha = 1.0;\n        }\n      }\n#if !defined(USE_ENVMAP)\n      // TODO treat background as a light source\n      if (towardsCam) {\n        path.li = path.beta * sampling_power_heuristic(path.scatteringPdf, 1.0) * bg.rgb;\n      }\n#endif\n    }\n    path.abort = true;\n    return;\n  }\n\n  bool sampleIgnored = false;\n  if ((mat.materialType == STANDARD || mat.materialType == UNLIT)) {\n    if (transmissiveOutputAlphaMin < 1.0) {\n      // TODO increase the alpha when there are more bounces.\n      float alpha = max(1.0 - mat.transmissionWeight, 1.0 - pow(1.0 - transmissiveOutputAlphaMin, float(depth)));\n      path.alpha = max(alpha, path.alpha);\n    }\n    float alpha = mat.alpha;\n    if (alpha < 1.0) {\n      // Alpha is sampled as stochastic coverage. An accepted surface branch\n      // must use full radiance weight; multiplying by alpha again is biased.\n      path.alpha = max(path.alpha, alpha);\n      if (hashedSample(3u) > alpha) {\n        sampleIgnored = true;\n      }\n    }\n    if (!sampleIgnored) {\n      SampleMaterial(si, mat, path);\n    }\n    else {\n      path.ray.o = si.position + path.ray.d * EPS;\n    }\n  }\n\n  if (!si.albedoSampled && !sampleIgnored) {\n    // Select denoising guides.\n    if ((mat.materialType == STANDARD || mat.materialType == UNLIT) &&\n      !(mat.transmissionWeight > 0.5 ||\n        (mat.specularRoughness <= 0.02 && mat.baseMetalness > 0.98))) {\n      // Alpha-blended decals can be skipped stochastically. In that case keep\n      // looking for the first useful rough-surface guide behind the decal,\n      // even though it is reached after depth zero.\n      outAux.albedo = mat.baseColor;\n      outAux.normal = dot(si.normal, si.position - vec3(viewInv[3])) > 0.0\n        ? -si.normal\n        : si.normal;\n      si.albedoSampled = true;\n    }\n    if (depth > 4) {\n      si.albedoSampled = true;\n    }\n  }\n\n\n  // Russian Roulette sampling\n#ifdef USE_RR\n  if (depth >= RR_MAX && !sampleIgnored) {\n    // Max-component survival (pbrt-v4) avoids over-amplifying saturated paths.\n    float maxComponent = max(max(path.beta.x, path.beta.y), path.beta.z);\n    float q = max(0.0, 1.0 - maxComponent);\n    if (sample1D(bounceDim(RUSSIAN_ROULETTE)) < q) {\n      // TODO we force use alpha 1.0 here.\n      // To avoid the glass pixels is transparent even if it's on an opaque object.\n      path.alpha = 1.0;\n      path.abort = true;\n    }\n    else {\n      path.beta /= 1.0 - q;\n    }\n  }\n#endif\n\n  if (path.abort) {\n    return;\n  }\n\n  // Next ray hit\n  intersectScene(path.ray, si, true);\n  getMaterial(mat, si.materialIndex, si.uv, si.uv1, si.instanceIndex);\n  si.isTransparency = mat.transmissionWeight > 0.001 || mat.subsurfaceWeight > 0.001 || mat.alpha < 0.999;\n\n  // Dynamic preview only becomes spectral when the primary visible surface\n  // actually disperses transmitted light. Direct background and ordinary\n  // opaque materials stay full RGB and therefore remain noise-free.\n  if (dispersionWavelengths == 1 && si.hit && mat.transmissionWeight > 0.001 && mat.transmissionDispersionScale > 0.001) {\n    pathWavelength = heroWavelength;\n  }\n  if (mat.transmissionWeight > 0.001 && pathWavelength > 0.0) {\n    mat.specularIor = sampling_cauchy_ior(\n      pathWavelength,\n      mat.specularIor,\n      mat.transmissionDispersionScale,\n      mat.dispersionAbbeNumber\n    );\n  }\n\n  if (sampleIgnored) {\n    return;\n  }\n\n  bool isAlphaOccluded = hashedSample(3u) < mat.alpha;\n#ifdef NUM_LIGHTS\n  // Use light if hit the light\n  LightSampleRec lightSample;\n  for (int i = 0; i < NUM_LIGHTS; i++) {\n    // Fetch light Data\n    Light light = fetchLight(i);\n    float d = intersectLight(path.ray, light, lightSample);\n    bool occluded = si.hit && d > distance(si.position, path.ray.o);\n    if (d != INF && !(occluded && isAlphaOccluded)) {\n      lightSample.pdf *= light.selectionPmf;\n      float misWeight = sampling_power_heuristic(path.scatteringPdf, lightSample.pdf);\n      lightSample.emission = sampling_spectral_rgb_filter(lightSample.emission, pathWavelength);\n      path.li += misWeight * path.beta * lightSample.emission;\n      // TODO set alpha to 1.0 will cause some sharp edges\n      path.alpha = 1.0;\n      path.abort = true;\n    }\n  }\n#endif\n\n#ifdef USE_ENVMAP\n  if (!(si.hit && isAlphaOccluded)) {\n    if (path.isNextRefraction) {\n      // Camera-visible transmission must use the displayed background. The\n      // raw environment remains the lighting source for non-transmission rays.\n      vec4 bg = sampleBackgroundFromRay(path.ray.o, path.ray.d);\n      bg.rgb = sampling_spectral_rgb_filter(bg.rgb, pathWavelength);\n      float backgroundMisWeight = path.scatteringIsDelta ? 1.0\n          : sampling_power_heuristic(path.scatteringPdf,\n              envMapPdf(cartesianToEquirect(path.ray.d)) * envLightSelectionPmf);\n        path.li += backgroundMisWeight * path.beta * bg.rgb * bg.a;\n      path.alpha = max(path.alpha, bg.a);\n      path.abort = true;\n      return;\n    }\n    vec2 uv = cartesianToEquirect(path.ray.d);\n    vec3 emission = textureLinear(envMap, uv).rgb;\n    float misWeight = sampling_power_heuristic(\n      path.scatteringPdf,\n      envMapPdf(uv) * envLightSelectionPmf\n    );\n    emission = sampling_spectral_rgb_filter(emission, pathWavelength);\n    path.li += path.beta * emission * misWeight;\n\n  // TODO force the min alpha to be 1 when showing envmap as background\n  #if !defined(USE_BACKGROUND)\n    path.alpha = 1.0;\n  #endif\n    path.abort = true;\n    return;\n  }\n#endif\n\n  depth++;\n}\n\n\nvec2 bevelCubicSample(float radius, float xi) {\n  float x = 0.25;\n  for (int iteration = 0; iteration < 10; iteration++) {\n    float x2 = x * x;\n    float x3 = x2 * x;\n    float oneMinusX = 1.0 - x;\n    float value = 10.0 * x2 - 20.0 * x3 + 15.0 * x2 * x2 -\n      4.0 * x2 * x3 - xi;\n    float derivative = 20.0 * x * oneMinusX * oneMinusX * oneMinusX;\n    if (abs(value) < 1e-6 || derivative == 0.0) break;\n    x = clamp(x - value / derivative, 0.0, 1.0);\n  }\n  float diskRadius = x * radius;\n  return vec2(\n    diskRadius,\n    sqrt(max(radius * radius - diskRadius * diskRadius, 0.0))\n  );\n}\n\nfloat bevelCubicPdf(float radius, float distanceToSource) {\n  if (distanceToSource >= radius) return 0.0;\n  float falloff = radius - distanceToSource;\n  return falloff * falloff * falloff;\n}\n\n// Shader bevel. Usage: docs/materials.md (Renderer extensions)\nvec3 getBevelNormal(SurfaceInteraction source, float radius) {\n  vec3 geometricNormal = source.faceNormal;\n  if (dot(geometricNormal, source.vertexNormal) < 0.0) geometricNormal = -geometricNormal;\n  vec3 tangent;\n  vec3 bitangent;\n  sampling_orthonormal_basis(geometricNormal, tangent, bitangent);\n  vec3 normalSum = vec3(0.0);\n\n  for (int sampleIndex = 0; sampleIndex < BEVEL_SAMPLES; sampleIndex++) {\n    vec2 bevelRnd = sample2D(CAMERA_BEVEL_BASE + uint(sampleIndex));\n    float axisSample = bevelRnd.x;\n    float radialSample = bevelRnd.y;\n    vec3 diskNormal = geometricNormal;\n    vec3 diskTangent = tangent;\n    vec3 diskBitangent = bitangent;\n    float pickPdfNormal = 0.5;\n    float pickPdfTangent = 0.25;\n    float pickPdfBitangent = 0.25;\n    if (axisSample < 0.5) {\n      axisSample *= 2.0;\n    }\n    else if (axisSample < 0.75) {\n      vec3 swapAxis = diskNormal;\n      diskNormal = diskTangent;\n      diskTangent = swapAxis;\n      pickPdfNormal = 0.25;\n      pickPdfTangent = 0.5;\n      axisSample = (axisSample - 0.5) * 4.0;\n    }\n    else {\n      vec3 swapAxis = diskNormal;\n      diskNormal = diskBitangent;\n      diskBitangent = swapAxis;\n      pickPdfNormal = 0.25;\n      pickPdfBitangent = 0.5;\n      axisSample = (axisSample - 0.75) * 4.0;\n    }\n\n    vec2 diskSample = bevelCubicSample(radius, radialSample);\n    float phi = TWOPI * axisSample;\n    vec3 diskOffset = diskSample.x *\n      (cos(phi) * diskTangent + sin(phi) * diskBitangent);\n    Ray ray;\n    initRay(\n      ray,\n      source.position + diskNormal * diskSample.y + diskOffset,\n      -diskNormal\n    );\n    SurfaceInteraction hit;\n    intersectSceneBevel(\n      ray,\n      hit,\n      source.instanceIndex,\n      max(2.0 * diskSample.y, EPS)\n    );\n    if (!hit.hit) continue;\n\n    float pdfNormal = pickPdfNormal * abs(dot(diskNormal, hit.faceNormal));\n    float pdfTangent = pickPdfTangent * abs(dot(diskTangent, hit.faceNormal));\n    float pdfBitangent = pickPdfBitangent * abs(dot(diskBitangent, hit.faceNormal));\n    float weight = pdfNormal / max(\n      pdfNormal * pdfNormal + pdfTangent * pdfTangent +\n        pdfBitangent * pdfBitangent,\n      1e-8\n    );\n    weight *= bevelCubicPdf(radius, distance(hit.position, source.position)) /\n      max(bevelCubicPdf(radius, diskSample.x), 1e-8);\n    normalSum += weight * hit.vertexNormal;\n  }\n\n  if (dot(normalSum, normalSum) <= 1e-12) return source.normal;\n  vec3 bevelVertexNormal = normalize(normalSum);\n  vec3 result = source.normal + bevelVertexNormal - source.vertexNormal;\n  return dot(result, result) > 1e-12 ? normalize(result) : source.normal;\n}\n\nvec4 integrateOnePathSample(SurfaceInteraction si, Ray ray, OpenPbrResolvedMaterial mat, inout RayTraceAuxiliary outAux) {\n  Path path;\n  path.ray = ray;\n  path.li = vec3(0);\n  path.alpha = transmissiveOutputAlphaMin < 1.0 ? 0.0 : 1.0;\n  path.beta = vec3(1.0);\n  path.fromEye = true;\n  path.scatteringPdf = 0.0;\n  path.scatteringIsDelta = false;\n  path.isNextRefraction = false;\n  path.abort = false;\n  int depth = 0;\n${intelMac ? bounceCodeOnIntelMac : bounceCodeOnOther}\n  return vec4(path.li, path.alpha);\n}\n\nvec4 integrateOnePath(SurfaceInteraction si, Ray ray, OpenPbrResolvedMaterial mat, inout RayTraceAuxiliary outAux) {\n  float coverage = clamp(mat.alpha, 0.0, 1.0);\n  if (!si.hit || (mat.materialType != STANDARD && mat.materialType != UNLIT) || coverage >= 1.0) {\n    return integrateOnePathSample(si, ray, mat, outAux);\n  }\n\n  // glTF BLEND is source-over opacity, not a physical glass boundary. Split\n  // the primary ray so reflected radiance is attenuated by alpha every sample\n  // while the complementary branch continues straight to the scene behind it.\n  // Secondary alpha hits remain stochastic to avoid exponential path growth.\n  Ray backRay = ray;\n  backRay.o = si.position + ray.d * (EPS * 0.02);\n  SurfaceInteraction backSi = si;\n  backSi.albedoSampled = false;\n  intersectScene(backRay, backSi, false);\n  OpenPbrResolvedMaterial backMat;\n  getMaterial(backMat, backSi.materialIndex, backSi.uv, backSi.uv1, backSi.instanceIndex);\n  RayTraceAuxiliary backAux = outAux;\n  if (backSi.hit && (backMat.materialType == STANDARD || backMat.materialType == UNLIT)) {\n    backAux.albedo = backMat.transmissionWeight > 0.5\n      ? vec3(1.0)\n      : backMat.baseColor;\n    backAux.normal = dot(\n      backSi.normal,\n      backSi.position - vec3(viewInv[3])\n    ) > 0.0\n      ? -backSi.normal\n      : backSi.normal;\n    backSi.albedoSampled = backMat.transmissionWeight > 0.5;\n  }\n  vec4 back = integrateOnePathSample(backSi, backRay, backMat, backAux);\n  if (coverage <= 0.0) {\n    outAux = backAux;\n    return back;\n  }\n\n  SurfaceInteraction frontSi = si;\n  OpenPbrResolvedMaterial frontMat = mat;\n  frontMat.alpha = 1.0;\n  RayTraceAuxiliary frontAux = outAux;\n  vec4 front = integrateOnePathSample(frontSi, ray, frontMat, frontAux);\n  outAux.albedo = mix(backAux.albedo, frontAux.albedo, coverage);\n  vec3 blendedNormal = mix(backAux.normal, frontAux.normal, coverage);\n  outAux.normal = dot(blendedNormal, blendedNormal) > 1e-12\n    ? normalize(blendedNormal)\n    : vec3(0.0);\n  outAux.isBlank = backAux.isBlank && frontAux.isBlank;\n  return mix(back, front, coverage);\n}\n\n// Path tracing integrator as described in\n// http://www.pbr-book.org/3ed-2018/Light_Transport_I_Surface_Reflection/Path_Tracing.html#\nvec4 integrator(Ray ray, out RayTraceAuxiliary outAux) {\n\n  SurfaceInteraction si;\n  OpenPbrResolvedMaterial mat;\n\n  si.albedoSampled = false;\n#ifdef HAS_MEDIUM\n  si.mediumType = 0;\n  si.mediumExtinction = vec3(0.0);\n  si.mediumScattering = vec3(0.0);\n  si.mediumAnisotropy = 0.0;\n#endif\n\n  intersectScene(ray, si, false);\n  getMaterial(mat, si.materialIndex, si.uv, si.uv1, si.instanceIndex);\n  si.isTransparency = mat.transmissionWeight > 0.001 || mat.subsurfaceWeight > 0.001 || mat.alpha < 0.999;\n\n#ifdef HAS_BEVEL\n  if (bevelEnabled && mat.bevel > 0.0) {\n    si.normal = getBevelNormal(si, mat.bevel);\n  }\n#endif\n\n  // Keep a clean first-hit fallback for denoising. Glass retains this stable\n  // guide; other delta paths may replace it at their first non-delta hit.\n  if (si.hit && (mat.materialType == STANDARD || mat.materialType == UNLIT)) {\n    outAux.albedo = mat.transmissionWeight > 0.5 ? vec3(1.0) : mat.baseColor;\n    outAux.normal = dot(si.normal, si.position - vec3(viewInv[3])) > 0.0\n      ? -si.normal\n      : si.normal;\n    // A refracted/reflected continuation is stochastic and therefore not a\n    // clean OIDN feature. Keep the stable primary glass guide instead.\n    si.albedoSampled = mat.transmissionWeight > 0.5;\n  }\n\n  if (mat.transmissionDispersionScale > 0.001) {\n    mat.specularIor = sampling_cauchy_ior(\n      pathWavelength,\n      mat.specularIor,\n      mat.transmissionDispersionScale,\n      mat.dispersionAbbeNumber\n    );\n  }\n  return integrateOnePath(si, ray, mat, outAux);\n}\n\nvoid main() {\n\n  initRandom();\n  rng_initialize(v_Texcoord * viewportSize, int(uint(sampleCount) ^ sampleHash(uint(sequenceSeed))));\n\n\n  pathWavelength = dispersionWavelengths == 1 ? 0.0 : wavelength;\n  heroWavelength = wavelength;\n  if (dispersionWavelengths == 1 && wavelength > 0.0) {\n    float channel = floor(sample1D(CAMERA_WAVELENGTH) * 3.0);\n    heroWavelength = channel < 1.0 ? 650.0 : channel < 2.0 ? 510.0 : 475.0;\n  }\n\n  // Thin lens model with depth-of-field\n  // http://www.pbr-book.org/3ed-2018/Camera_Models/Projective_Camera_Models.html#TheThinLensModelandDepthofField\n  Ray cam = primaryCameraRay();\n\n  RayTraceAuxiliary outAux;\n  outAux.albedo = vec3(0.0);\n  outAux.normal = vec3(0.0);\n  outAux.isBlank = false;\n  outAux.isShadowCatcher = false;\n\n  vec4 liAndAlpha = integrator(cam, outAux);\n\n  // Clamp at Integration Level to reduce fireflies.\n  // TODO Path level configuration?\n#ifdef CLAMPING\n  float clamping = float(CLAMPING);\n  liAndAlpha.rgb = clamp(liAndAlpha.rgb, -clamping, clamping);\n#endif\n\n  // Each sample will be accumulated three times.\n  if (pathWavelength > 0.0) {\n    // RGB will be normalized using accumated hit in out_albedo.a\n    liAndAlpha.rgb *= 3.0;\n    if (dispersionWavelengths != 1) {\n      // Full spectral samples use three additive passes. Preview only submits\n      // one hero wavelength, so its alpha must not be divided.\n      liAndAlpha.a /= 3.0;\n    }\n  }\n  if (!(liAndAlpha.x < INF && liAndAlpha.x > -EPS)) {\n    liAndAlpha = vec4(0, 0, 0, 1);\n  }\n\n  out_color = liAndAlpha;\n  out_albedo = vec4(outAux.albedo, outAux.isBlank ? 0.0 : 1.0);\n  out_normal = vec4(outAux.normal, 1.0);\n  // Moments and count of the built-in denoiser's guide value. The catcher\n  // pass accumulates its own samples (see shadowCatcher.frag).\n  float guideValue = dot(liAndAlpha.rgb, vec3(0.2126, 0.7152, 0.0722));\n  out_moments = outAux.isShadowCatcher\n    ? vec4(0.0)\n    : vec4(guideValue, guideValue * guideValue, 1.0, 0.0);\n\n}`\n  });\n}\n"]}
+{"version":3,"file":"rayTrace.frag.js","sourceRoot":"","sources":["../../../src/renderer/glsl/rayTrace.frag.ts"],"names":[],"mappings":"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","sourcesContent":["import { MAX_PATH_EVENTS } from '../pathLimits.js';\nimport cameraRayGlsl from './chunks/cameraRay.glsl.js';\n// Portions adapted from ray-tracing-renderer@0.10.15\n// (https://github.com/hoverinc/ray-tracing-renderer).\n// Copyright (c) 2019 HOVER, MIT license; see LICENSES/RayTracingRenderer-MIT.txt.\n\nimport commonGlsl from './chunks/common.glsl.js';\nimport rayTraceCore from './chunks/rayTraceCore.glsl.js';\nimport textureLinear from './chunks/textureLinear.glsl.js';\nimport materialBufferGlsl from './chunks/materialBuffer.glsl.js';\nimport intersect from './chunks/intersect.glsl.js';\nimport randGlsl from './chunks/rand.glsl.js';\nimport random from './chunks/random.glsl.js';\nimport envMap from './chunks/envMap.glsl.js';\nimport sampleMaterialGlsl from './chunks/sampleMaterial.glsl.js';\nimport sampleLightGlsl from './chunks/sampleLight.glsl.js';\nimport { FragmentShader, glsl, Shader } from '../shader.js';\nimport openPbrBsdfGlsl from './chunks/openPbrBsdf.glsl.js';\nimport samplingGlsl from './chunks/sampling.glsl.js';\nimport { isIntelMac } from '../util.js';\nimport uvProjectionGlsl from './chunks/uvProjection.glsl.js';\n\nconst doubleTransmissionCheckCode = glsl`\n#if defined(HAS_TRANSMISSION) || defined(HAS_ALPHA)\n  if (!si.isTransparency && BOUNCES < 16 && depth * 2 > BOUNCES) {\n    path.abort = true;\n    return;\n  }\n#endif\n`;\n\n// bounce fix on intel mac\n// The intel mac only have one bounce if the loop is not unrolled\n// But windows will have extremely slow shader compilation if the loop is unrolled\n// So here the code are injected separately.\nconst bounceCodeOnIntelMac = glsl`\n// Mark loop can be unrolled\nfor(int _idx_ = 0; _idx_ < BOUNCES; _idx_++) {{\n  if (path.abort) {\n    return vec4(path.li, path.alpha);\n  }\n  bounce(path, depth, si, mat, outAux);\n}}\n`;\nconst bounceCodeOnOther = glsl`\nbool isOpaque = !si.isTransparency;\nint activeBounceLimit = min(BOUNCES, bounceLimit);\nfor(int idx = 0; idx < min(BOUNCES * 3, ${MAX_PATH_EVENTS}); idx++) {\n  if (isOpaque && idx > activeBounceLimit) {\n    path.abort = true;\n  }\n  if (path.abort) {\n    return vec4(path.li, path.alpha);\n  }\n  bounce(path, depth, si, mat, outAux);\n}\n`;\n\nexport default function createRayTraceFragmentShader() {\n  const intelMac = isIntelMac();\n  return new FragmentShader({\n  name: 'rayTraceFrag',\n  outputs: ['color', 'albedo', 'normal', 'moments'],\n  defines: {\n    BOUNCES: 2\n  },\n  uniforms: {\n    cameraApertureRadius: Shader.uniform('float', 0),\n    cameraFocusDistance: Shader.uniform('float', 10),\n\n    viewProjectionInv: Shader.uniform('mat4'),\n    viewInv: Shader.uniform('mat4'),\n    transmissiveOutputAlphaMin: Shader.uniform('float'),\n    openPbrEnergyLut: Shader.uniform('sampler2D'),\n\n    viewportSize: Shader.uniform('vec2'),\n\n    wavelength: Shader.uniform('float', 0),\n    bevelEnabled: Shader.uniform('bool', true),\n    dispersionWavelengths: Shader.uniform('int', 3),\n    bounceLimit: Shader.uniform('int', 8)\n  },\n  includes: [rayTraceCore, materialBufferGlsl, intersect, random, envMap],\n  main: glsl`\n${commonGlsl}\n\n${randGlsl}\n${random.main}\n\n${textureLinear}\n\n${rayTraceCore.main}\n\n${uvProjectionGlsl}\n\n${materialBufferGlsl.main}\n${intersect.main}\n${envMap.main}\n\n${samplingGlsl}\n${openPbrBsdfGlsl}\n\nfloat heroWavelength;\nfloat pathWavelength;\n\n${sampleLightGlsl}\n${sampleMaterialGlsl}\n\n${cameraRayGlsl}\nstruct RayTraceAuxiliary {\n  // Denoising guides and auxiliary pixel classification.\n  vec3 albedo;\n  vec3 normal;\n  bool isBlank;\n  // The primary ray hit a shadow catcher, whose sample the catcher pass owns.\n  bool isShadowCatcher;\n};\n\nvoid bounce(inout Path path, inout int depth, inout SurfaceInteraction si, inout OpenPbrResolvedMaterial mat, inout RayTraceAuxiliary outAux) {\n  samplingBounce = uint(max(depth, 0));\n  // The bounce will be doubled on the transmission material.\n  // For other materials. We will quite early\n  // TODO It is only used on Mac with AMD card. If I enabled it on windows.\n  // It will cause shader compilation too slow.\n${intelMac ? doubleTransmissionCheckCode : ''}\n\n  bool isShadowCatcher = mat.materialType == SHADOW_CATCHER;\n  if (isShadowCatcher) {\n    if (path.fromEye) {\n      // Match the composed shadow with neutral receiver guides, while keeping\n      // background coverage and radiance independent of the invisible ground.\n      outAux.albedo = vec3(1.0);\n      outAux.normal = dot(si.normal, path.ray.d) > 0.0 ? -si.normal : si.normal;\n      si.hit = false;\n      outAux.isShadowCatcher = true;\n    }\n    else {\n      // The catcher belongs only to the shadow-mask pass. Keep its default\n      // white material out of glossy and transmission reflections.\n#ifdef USE_ENVMAP\n      if (path.isNextRefraction) {\n        // The invisible catcher can sit between a transmitted camera ray and\n        // the grounded skybox. Use the displayed background here instead of\n        // terminating early with the raw lighting environment.\n        vec4 bg = sampleBackgroundFromRay(path.ray.o, path.ray.d);\n        bg.rgb = sampling_spectral_rgb_filter(bg.rgb, pathWavelength);\n        float backgroundMisWeight = path.scatteringIsDelta ? 1.0\n          : sampling_power_heuristic(path.scatteringPdf,\n              envMapPdf(cartesianToEquirect(path.ray.d)) * envLightSelectionPmf);\n        path.li += backgroundMisWeight * path.beta * bg.rgb * bg.a;\n        path.alpha = max(path.alpha, bg.a);\n      }\n      else {\n        vec2 envUv = cartesianToEquirect(path.ray.d);\n        vec3 emission = textureLinear(envMap, envUv).rgb;\n        emission = sampling_spectral_rgb_filter(emission, pathWavelength);\n        path.li += path.beta * emission *\n          sampling_power_heuristic(\n            path.scatteringPdf,\n            envMapPdf(envUv) * envLightSelectionPmf\n          );\n      }\n#else\n      vec4 bg = sampleBackgroundFromRay(path.ray.o, path.ray.d);\n      bg.rgb = sampling_spectral_rgb_filter(bg.rgb, pathWavelength);\n      path.li += path.beta * bg.rgb * bg.a;\n#endif\n      path.abort = true;\n      return;\n    }\n  }\n\n  if (!si.hit) {\n    // Sample from background if first ray not hit anything.\n    vec4 bg = sampleBackgroundFromRay(path.ray.o, path.ray.d);\n    // Dispersion renders one additive pass per RGB wavelength. Background\n    // radiance has to be split in the same way as lights and emissive\n    // surfaces, otherwise the full skybox is accumulated three times.\n    bg.rgb = sampling_spectral_rgb_filter(bg.rgb, pathWavelength);\n    if (path.fromEye) {\n      path.li = bg.rgb * bg.a;\n      path.alpha = bg.a;\n      // Only treat as blank pixels when the background is transparent\n      outAux.isBlank = bg.a < 0.01;\n    }\n    else {\n      Ray cam = initCameraRay(v_Texcoord + pixelJitter());\n      bool towardsCam = dot(cam.d, path.ray.d) > 0.0;\n      if (transmissiveOutputAlphaMin < 1.0) {\n        if (towardsCam) {\n          path.alpha = max(path.alpha, bg.a);\n        } else {\n          path.alpha = 1.0;\n        }\n      }\n#if !defined(USE_ENVMAP)\n      // TODO treat background as a light source\n      if (towardsCam) {\n        path.li = path.beta * sampling_power_heuristic(path.scatteringPdf, 1.0) * bg.rgb;\n      }\n#endif\n    }\n    path.abort = true;\n    return;\n  }\n\n  bool sampleIgnored = false;\n  if ((mat.materialType == STANDARD || mat.materialType == UNLIT)) {\n    if (transmissiveOutputAlphaMin < 1.0) {\n      // TODO increase the alpha when there are more bounces.\n      float alpha = max(1.0 - mat.transmissionWeight, 1.0 - pow(1.0 - transmissiveOutputAlphaMin, float(depth)));\n      path.alpha = max(alpha, path.alpha);\n    }\n    float alpha = mat.alpha;\n    if (alpha < 1.0) {\n      // Alpha is sampled as stochastic coverage. An accepted surface branch\n      // must use full radiance weight; multiplying by alpha again is biased.\n      path.alpha = max(path.alpha, alpha);\n      if (hashedSample(3u) > alpha) {\n        sampleIgnored = true;\n      }\n    }\n    if (!sampleIgnored) {\n      SampleMaterial(si, mat, path);\n    }\n    else {\n      path.ray.o = si.position + path.ray.d * EPS;\n    }\n  }\n\n  if (!si.albedoSampled && !sampleIgnored) {\n    // Select denoising guides.\n    if ((mat.materialType == STANDARD || mat.materialType == UNLIT) &&\n      !(mat.transmissionWeight > 0.5 ||\n        (mat.specularRoughness <= 0.02 && mat.baseMetalness > 0.98))) {\n      // Alpha-blended decals can be skipped stochastically. In that case keep\n      // looking for the first useful rough-surface guide behind the decal,\n      // even though it is reached after depth zero.\n      outAux.albedo = mat.baseColor;\n      outAux.normal = dot(si.normal, si.position - vec3(viewInv[3])) > 0.0\n        ? -si.normal\n        : si.normal;\n      si.albedoSampled = true;\n    }\n    if (depth > 4) {\n      si.albedoSampled = true;\n    }\n  }\n\n\n  // Russian Roulette sampling\n#ifdef USE_RR\n  if (depth >= RR_MAX && !sampleIgnored) {\n    // Max-component survival (pbrt-v4) avoids over-amplifying saturated paths.\n    float maxComponent = max(max(path.beta.x, path.beta.y), path.beta.z);\n    float q = max(0.0, 1.0 - maxComponent);\n    if (sample1D(bounceDim(RUSSIAN_ROULETTE)) < q) {\n      // TODO we force use alpha 1.0 here.\n      // To avoid the glass pixels is transparent even if it's on an opaque object.\n      path.alpha = 1.0;\n      path.abort = true;\n    }\n    else {\n      path.beta /= 1.0 - q;\n    }\n  }\n#endif\n\n  if (path.abort) {\n    return;\n  }\n\n  // Next ray hit\n  intersectScene(path.ray, si, true);\n  getMaterial(mat, si.materialIndex, si.uv, si.uv1, si.instanceIndex);\n  si.isTransparency = mat.transmissionWeight > 0.001 || mat.subsurfaceWeight > 0.001 || mat.alpha < 0.999;\n\n  // Dynamic preview only becomes spectral when the primary visible surface\n  // actually disperses transmitted light. Direct background and ordinary\n  // opaque materials stay full RGB and therefore remain noise-free.\n  if (dispersionWavelengths == 1 && si.hit && mat.transmissionWeight > 0.001 && mat.transmissionDispersionScale > 0.001) {\n    pathWavelength = heroWavelength;\n  }\n  if (mat.transmissionWeight > 0.001 && pathWavelength > 0.0) {\n    mat.specularIor = sampling_cauchy_ior(\n      pathWavelength,\n      mat.specularIor,\n      mat.transmissionDispersionScale,\n      mat.dispersionAbbeNumber\n    );\n  }\n\n  if (sampleIgnored) {\n    return;\n  }\n\n  bool isAlphaOccluded = hashedSample(3u) < mat.alpha;\n#ifdef NUM_LIGHTS\n  // Use light if hit the light\n  LightSampleRec lightSample;\n  for (int i = 0; i < NUM_LIGHTS; i++) {\n    // Fetch light Data\n    Light light = fetchLight(i);\n    float d = intersectLight(path.ray, light, lightSample);\n    bool occluded = si.hit && d > distance(si.position, path.ray.o);\n    if (d != INF && !(occluded && isAlphaOccluded)) {\n      lightSample.pdf *= light.selectionPmf;\n      float misWeight = sampling_power_heuristic(path.scatteringPdf, lightSample.pdf);\n      lightSample.emission = sampling_spectral_rgb_filter(lightSample.emission, pathWavelength);\n      path.li += misWeight * path.beta * lightSample.emission;\n      // TODO set alpha to 1.0 will cause some sharp edges\n      path.alpha = 1.0;\n      path.abort = true;\n    }\n  }\n#endif\n\n#ifdef USE_ENVMAP\n  if (!(si.hit && isAlphaOccluded)) {\n    if (path.isNextRefraction) {\n      // Camera-visible transmission must use the displayed background. The\n      // raw environment remains the lighting source for non-transmission rays.\n      vec4 bg = sampleBackgroundFromRay(path.ray.o, path.ray.d);\n      bg.rgb = sampling_spectral_rgb_filter(bg.rgb, pathWavelength);\n      float backgroundMisWeight = path.scatteringIsDelta ? 1.0\n          : sampling_power_heuristic(path.scatteringPdf,\n              envMapPdf(cartesianToEquirect(path.ray.d)) * envLightSelectionPmf);\n        path.li += backgroundMisWeight * path.beta * bg.rgb * bg.a;\n      path.alpha = max(path.alpha, bg.a);\n      path.abort = true;\n      return;\n    }\n    vec2 uv = cartesianToEquirect(path.ray.d);\n    vec3 emission = textureLinear(envMap, uv).rgb;\n    float misWeight = sampling_power_heuristic(\n      path.scatteringPdf,\n      envMapPdf(uv) * envLightSelectionPmf\n    );\n    emission = sampling_spectral_rgb_filter(emission, pathWavelength);\n    path.li += path.beta * emission * misWeight;\n\n  // TODO force the min alpha to be 1 when showing envmap as background\n  #if !defined(USE_BACKGROUND)\n    path.alpha = 1.0;\n  #endif\n    path.abort = true;\n    return;\n  }\n#endif\n\n  depth++;\n}\n\n\nvec2 bevelCubicSample(float radius, float xi) {\n  float x = 0.25;\n  for (int iteration = 0; iteration < 10; iteration++) {\n    float x2 = x * x;\n    float x3 = x2 * x;\n    float oneMinusX = 1.0 - x;\n    float value = 10.0 * x2 - 20.0 * x3 + 15.0 * x2 * x2 -\n      4.0 * x2 * x3 - xi;\n    float derivative = 20.0 * x * oneMinusX * oneMinusX * oneMinusX;\n    if (abs(value) < 1e-6 || derivative == 0.0) break;\n    x = clamp(x - value / derivative, 0.0, 1.0);\n  }\n  float diskRadius = x * radius;\n  return vec2(\n    diskRadius,\n    sqrt(max(radius * radius - diskRadius * diskRadius, 0.0))\n  );\n}\n\nfloat bevelCubicPdf(float radius, float distanceToSource) {\n  if (distanceToSource >= radius) return 0.0;\n  float falloff = radius - distanceToSource;\n  return falloff * falloff * falloff;\n}\n\n// Shader bevel. Usage: docs/materials.md (Renderer extensions)\nvec3 getBevelNormal(SurfaceInteraction source, float radius) {\n  vec3 geometricNormal = source.faceNormal;\n  if (dot(geometricNormal, source.vertexNormal) < 0.0) geometricNormal = -geometricNormal;\n  vec3 tangent;\n  vec3 bitangent;\n  sampling_orthonormal_basis(geometricNormal, tangent, bitangent);\n  vec3 normalSum = vec3(0.0);\n\n  for (int sampleIndex = 0; sampleIndex < BEVEL_SAMPLES; sampleIndex++) {\n    vec2 bevelRnd = sample2D(CAMERA_BEVEL_BASE + uint(sampleIndex));\n    float axisSample = bevelRnd.x;\n    float radialSample = bevelRnd.y;\n    vec3 diskNormal = geometricNormal;\n    vec3 diskTangent = tangent;\n    vec3 diskBitangent = bitangent;\n    float pickPdfNormal = 0.5;\n    float pickPdfTangent = 0.25;\n    float pickPdfBitangent = 0.25;\n    if (axisSample < 0.5) {\n      axisSample *= 2.0;\n    }\n    else if (axisSample < 0.75) {\n      vec3 swapAxis = diskNormal;\n      diskNormal = diskTangent;\n      diskTangent = swapAxis;\n      pickPdfNormal = 0.25;\n      pickPdfTangent = 0.5;\n      axisSample = (axisSample - 0.5) * 4.0;\n    }\n    else {\n      vec3 swapAxis = diskNormal;\n      diskNormal = diskBitangent;\n      diskBitangent = swapAxis;\n      pickPdfNormal = 0.25;\n      pickPdfBitangent = 0.5;\n      axisSample = (axisSample - 0.75) * 4.0;\n    }\n\n    vec2 diskSample = bevelCubicSample(radius, radialSample);\n    float phi = TWOPI * axisSample;\n    vec3 diskOffset = diskSample.x *\n      (cos(phi) * diskTangent + sin(phi) * diskBitangent);\n    Ray ray;\n    initRay(\n      ray,\n      source.position + diskNormal * diskSample.y + diskOffset,\n      -diskNormal\n    );\n    SurfaceInteraction hit;\n    intersectSceneBevel(\n      ray,\n      hit,\n      source.instanceIndex,\n      max(2.0 * diskSample.y, EPS)\n    );\n    if (!hit.hit) continue;\n\n    float pdfNormal = pickPdfNormal * abs(dot(diskNormal, hit.faceNormal));\n    float pdfTangent = pickPdfTangent * abs(dot(diskTangent, hit.faceNormal));\n    float pdfBitangent = pickPdfBitangent * abs(dot(diskBitangent, hit.faceNormal));\n    float weight = pdfNormal / max(\n      pdfNormal * pdfNormal + pdfTangent * pdfTangent +\n        pdfBitangent * pdfBitangent,\n      1e-8\n    );\n    weight *= bevelCubicPdf(radius, distance(hit.position, source.position)) /\n      max(bevelCubicPdf(radius, diskSample.x), 1e-8);\n    normalSum += weight * hit.vertexNormal;\n  }\n\n  if (dot(normalSum, normalSum) <= 1e-12) return source.normal;\n  vec3 bevelVertexNormal = normalize(normalSum);\n  vec3 result = source.normal + bevelVertexNormal - source.vertexNormal;\n  return dot(result, result) > 1e-12 ? normalize(result) : source.normal;\n}\n\nvec4 integrateOnePathSample(SurfaceInteraction si, Ray ray, OpenPbrResolvedMaterial mat, inout RayTraceAuxiliary outAux) {\n  Path path;\n  path.ray = ray;\n  path.li = vec3(0);\n  path.alpha = transmissiveOutputAlphaMin < 1.0 ? 0.0 : 1.0;\n  path.beta = vec3(1.0);\n  path.fromEye = true;\n  path.scatteringPdf = 0.0;\n  path.scatteringIsDelta = false;\n  path.isNextRefraction = false;\n  path.abort = false;\n  int depth = 0;\n${intelMac ? bounceCodeOnIntelMac : bounceCodeOnOther}\n  return vec4(path.li, path.alpha);\n}\n\nvec4 integrateOnePath(SurfaceInteraction si, Ray ray, OpenPbrResolvedMaterial mat, inout RayTraceAuxiliary outAux) {\n  float coverage = clamp(mat.alpha, 0.0, 1.0);\n  if (!si.hit || (mat.materialType != STANDARD && mat.materialType != UNLIT) || coverage >= 1.0) {\n    return integrateOnePathSample(si, ray, mat, outAux);\n  }\n\n  // glTF BLEND is source-over opacity, not a physical glass boundary. Split\n  // the primary ray so reflected radiance is attenuated by alpha every sample\n  // while the complementary branch continues straight to the scene behind it.\n  // Secondary alpha hits remain stochastic to avoid exponential path growth.\n  Ray backRay = ray;\n  backRay.o = si.position + ray.d * (EPS * 0.02);\n  SurfaceInteraction backSi = si;\n  backSi.albedoSampled = false;\n  intersectScene(backRay, backSi, false);\n  OpenPbrResolvedMaterial backMat;\n  getMaterial(backMat, backSi.materialIndex, backSi.uv, backSi.uv1, backSi.instanceIndex);\n  RayTraceAuxiliary backAux = outAux;\n  if (backSi.hit && (backMat.materialType == STANDARD || backMat.materialType == UNLIT)) {\n    backAux.albedo = backMat.transmissionWeight > 0.5\n      ? vec3(1.0)\n      : backMat.baseColor;\n    backAux.normal = dot(\n      backSi.normal,\n      backSi.position - vec3(viewInv[3])\n    ) > 0.0\n      ? -backSi.normal\n      : backSi.normal;\n    backSi.albedoSampled = backMat.transmissionWeight > 0.5;\n  }\n  vec4 back = integrateOnePathSample(backSi, backRay, backMat, backAux);\n  if (coverage <= 0.0) {\n    outAux = backAux;\n    return back;\n  }\n\n  SurfaceInteraction frontSi = si;\n  OpenPbrResolvedMaterial frontMat = mat;\n  frontMat.alpha = 1.0;\n  RayTraceAuxiliary frontAux = outAux;\n  vec4 front = integrateOnePathSample(frontSi, ray, frontMat, frontAux);\n  outAux.albedo = mix(backAux.albedo, frontAux.albedo, coverage);\n  vec3 blendedNormal = mix(backAux.normal, frontAux.normal, coverage);\n  outAux.normal = dot(blendedNormal, blendedNormal) > 1e-12\n    ? normalize(blendedNormal)\n    : vec3(0.0);\n  outAux.isBlank = backAux.isBlank && frontAux.isBlank;\n  return mix(back, front, coverage);\n}\n\n// Path tracing integrator as described in\n// http://www.pbr-book.org/3ed-2018/Light_Transport_I_Surface_Reflection/Path_Tracing.html#\nvec4 integrator(Ray ray, out RayTraceAuxiliary outAux) {\n\n  SurfaceInteraction si;\n  OpenPbrResolvedMaterial mat;\n\n  si.albedoSampled = false;\n#ifdef HAS_MEDIUM\n  si.mediumType = 0;\n  si.mediumExtinction = vec3(0.0);\n  si.mediumScattering = vec3(0.0);\n  si.mediumAnisotropy = 0.0;\n#endif\n\n  intersectScene(ray, si, false);\n  getMaterial(mat, si.materialIndex, si.uv, si.uv1, si.instanceIndex);\n  si.isTransparency = mat.transmissionWeight > 0.001 || mat.subsurfaceWeight > 0.001 || mat.alpha < 0.999;\n\n#ifdef HAS_BEVEL\n  if (bevelEnabled && mat.bevel > 0.0) {\n    si.normal = getBevelNormal(si, mat.bevel);\n  }\n#endif\n\n  // Keep a clean first-hit fallback for denoising. Glass retains this stable\n  // guide; other delta paths may replace it at their first non-delta hit.\n  if (si.hit && (mat.materialType == STANDARD || mat.materialType == UNLIT)) {\n    outAux.albedo = mat.transmissionWeight > 0.5 ? vec3(1.0) : mat.baseColor;\n    outAux.normal = dot(si.normal, si.position - vec3(viewInv[3])) > 0.0\n      ? -si.normal\n      : si.normal;\n    // A refracted/reflected continuation is stochastic and therefore not a\n    // clean OIDN feature. Keep the stable primary glass guide instead.\n    si.albedoSampled = mat.transmissionWeight > 0.5;\n  }\n\n  if (mat.transmissionDispersionScale > 0.001) {\n    mat.specularIor = sampling_cauchy_ior(\n      pathWavelength,\n      mat.specularIor,\n      mat.transmissionDispersionScale,\n      mat.dispersionAbbeNumber\n    );\n  }\n  return integrateOnePath(si, ray, mat, outAux);\n}\n\nvoid main() {\n\n  initRandom();\n  rng_initialize(v_Texcoord * viewportSize, int(uint(sampleCount) ^ sampleHash(uint(sequenceSeed))));\n\n\n  pathWavelength = dispersionWavelengths == 1 ? 0.0 : wavelength;\n  heroWavelength = wavelength;\n  if (dispersionWavelengths == 1 && wavelength > 0.0) {\n    float channel = floor(sample1D(CAMERA_WAVELENGTH) * 3.0);\n    heroWavelength = channel < 1.0 ? 650.0 : channel < 2.0 ? 510.0 : 475.0;\n  }\n\n  // Thin lens model with depth-of-field\n  // http://www.pbr-book.org/3ed-2018/Camera_Models/Projective_Camera_Models.html#TheThinLensModelandDepthofField\n  Ray cam = primaryCameraRay();\n\n  RayTraceAuxiliary outAux;\n  outAux.albedo = vec3(0.0);\n  outAux.normal = vec3(0.0);\n  outAux.isBlank = false;\n  outAux.isShadowCatcher = false;\n\n  vec4 liAndAlpha = integrator(cam, outAux);\n\n  // Clamp at Integration Level to reduce fireflies.\n  // TODO Path level configuration?\n#ifdef CLAMPING\n  float clamping = float(CLAMPING);\n  liAndAlpha.rgb = clamp(liAndAlpha.rgb, -clamping, clamping);\n#endif\n\n  // Each sample will be accumulated three times.\n  if (pathWavelength > 0.0) {\n    // RGB will be normalized using accumated hit in out_albedo.a\n    liAndAlpha.rgb *= 3.0;\n    if (dispersionWavelengths != 1) {\n      // Full spectral samples use three additive passes. Preview only submits\n      // one hero wavelength, so its alpha must not be divided.\n      liAndAlpha.a /= 3.0;\n    }\n  }\n  if (!(liAndAlpha.x < INF && liAndAlpha.x > -EPS)) {\n    liAndAlpha = vec4(0, 0, 0, 1);\n  }\n\n  out_color = liAndAlpha;\n  out_albedo = vec4(outAux.albedo, outAux.isBlank ? 0.0 : 1.0);\n  out_normal = vec4(outAux.normal, 1.0);\n  // Moments and count of the built-in denoiser's guide value. The catcher\n  // pass accumulates its own samples (see shadowCatcher.frag).\n  float guideValue = dot(liAndAlpha.rgb, vec3(0.2126, 0.7152, 0.0722));\n  out_moments = outAux.isShadowCatcher\n    ? vec4(0.0)\n    : vec4(guideValue, guideValue * guideValue, 1.0, 0.0);\n\n}`\n  });\n}\n"]}

package/lib/renderer/glsl/webglPipeline.frag.js

@@ -7,7 +7,7 @@ export const brightFragment = new FragmentShader({
         scale: Shader.uniform('float', 1)
     },
     main: glsl `
-const vec3 uC = vec3(0.2125, 0.7154, 0.0721);
+const vec3 uE = vec3(0.2125, 0.7154, 0.0721);
 vec4 sm(vec4 a, vec4 b, vec4 c) {
 return a + b + c - min(min(a, b), c) - max(max(a, b), c);
 }
@@ -19,7 +19,7 @@ vec4 s2 = sample_colorTex(v_Texcoord + vec2(d.x, 0.0));
 vec4 s3 = sample_colorTex(v_Texcoord - vec2(0.0, d.y));
 vec4 s4 = sample_colorTex(v_Texcoord + vec2(0.0, d.y));
 iW = sm(sm(iW, s1, s2), s3, s4);
-float lum = dot(iW.rgb, uC);
+float lum = dot(iW.rgb, uE);
 out_color = lum > threshold && iW.a > 0.0
 ? vec4(iW.rgb * scale, iW.a)
 : vec4(0.0, 0.0, 0.0, iW.a);

package/lib/renderer/materialComparison.generated.js

@@ -393,6 +393,11 @@ export function materialParametersEqual(material, values) {
         else if (!Object.is(value, previous))
             return false;
     }
+    {
+        const value = material.displacementBias, previous = values[57];
+        if (!Object.is(value, previous) && !arrayParametersEqual(value, previous))
+            return false;
+    }
     return true;
 }
 /** Mirrors captureMaterialTextures, including numeric texture-category scalars. */