@meimu/mutracer 0.1.1 → 0.1.3

package/lib/renderer/WebGLJNLMDenoiser.js

@@ -45,27 +45,27 @@ void main() {
 ivec2 p = ivec2(gl_FragCoord.xy);
 ivec2 size = rawGuideTexRegion();
 vec2 center = load_rawGuideTex(p, 0).xy;
-float lg = 0.0;
-float iX = 0.0;
-float mL = 0.0;
-float iR = 0.0;
+float lk = 0.0;
+float iY = 0.0;
+float mO = 0.0;
+float iS = 0.0;
 for (int dy = -1; dy <= 1; dy++) {
 for (int dx = -1; dx <= 1; dx++) {
 vec2 value = load_rawGuideTex(clamp(p + ivec2(dx, dy), ivec2(0), size - 1), 0).xy;
-mL += value.x;
-iR += value.x * value.x;
+mO += value.x;
+iS += value.x * value.x;
 if (value.y >= 0.0) {
-lg += value.y;
-iX += 1.0;
+lk += value.y;
+iY += 1.0;
 }
 }
 }
 float variance;
 if (center.y >= 0.0) {
-variance = lg / iX;
+variance = lk / iY;
 } else {
-float lf = mL / 9.0;
-variance = max(iR / 9.0 - lf * lf, 0.0) * 9.0 / 8.0;
+float lj = mO / 9.0;
+variance = max(iS / 9.0 - lj * lj, 0.0) * 9.0 / 8.0;
 }
 out_guide = vec4(center.x, variance, 0.0, 1.0);
 }`
@@ -105,29 +105,29 @@ const filterFragment = new FragmentShader({
 
 ivec2 imageSize;
 
-vec2 nq(ivec2 p) {
+vec2 nt(ivec2 p) {
 return load_guideTex(clamp(p, ivec2(0), imageSize - 1), 0).xy;
 }
 
 
-vec4 rv(ivec2 p) {
+vec4 rD(ivec2 p) {
 vec4 c = load_colorTex(p, 0);
 if (decodeInput) c.rgb = pow(max(c.rgb, 0.0), vec3(2.2));
 return vec4(c.rgb * c.a, c.a);
 }
 
-float lk(ivec2 q, vec4 bs, vec3 gM) {
+float ln(ivec2 q, vec4 bs, vec3 gO) {
 vec4 albedo = load_albedoTex(q, 0);
 
 
-vec3 oS = max((albedo.rgb + bs.rgb) * 0.5, vec3(${JNLM_ALBEDO_FLOOR}));
-vec3 kR = (albedo.rgb - bs.rgb) / oS;
-float iO = albedo.a - bs.a;
-vec3 lb = load_normalTex(q, 0).rgb - gM;
+vec3 oW = max((albedo.rgb + bs.rgb) * 0.5, vec3(${JNLM_ALBEDO_FLOOR}));
+vec3 kU = (albedo.rgb - bs.rgb) / oW;
+float iP = albedo.a - bs.a;
+vec3 le = load_normalTex(q, 0).rgb - gO;
 return max(
-dot(kR, kR) * INV_ALBEDO_BANDWIDTH2
-+ iO * iO * INV_COVERAGE_BANDWIDTH2,
-dot(lb, lb) * INV_NORMAL_BANDWIDTH2
+dot(kU, kU) * INV_ALBEDO_BANDWIDTH2
++ iP * iP * INV_COVERAGE_BANDWIDTH2,
+dot(le, le) * INV_NORMAL_BANDWIDTH2
 );
 }
 
@@ -136,37 +136,37 @@ imageSize = guideTexRegion();
 ivec2 p = ivec2(gl_FragCoord.xy);
 vec4 bs = load_albedoTex(p, 0);
 vec4 fw = load_normalTex(p, 0);
-vec3 gM = fw.rgb;
+vec3 gO = fw.rgb;
 
 
 if (fw.a <= 0.0 && load_shadowCatcherTex(p, 0).r <= 0.0) {
-vec4 c = rv(p);
+vec4 c = rD(p);
 vec3 rgb = c.rgb / max(c.a, 1e-6);
 if (encodeOutput) rgb = pow(max(rgb, 0.0), vec3(1.0 / 2.2));
 out_color = vec4(rgb, c.a);
-out_guide = vec4(nq(p), 0.0, 1.0);
+out_guide = vec4(nt(p), 0.0, 1.0);
 return;
 }
 
-vec2 kT[PATCH_SIZE];
+vec2 kW[PATCH_SIZE];
 int k = 0;
 for (int dy = -PATCH_RADIUS; dy <= PATCH_RADIUS; dy++) {
 for (int dx = -PATCH_RADIUS; dx <= PATCH_RADIUS; dx++) {
-kT[k] = nq(p + ivec2(dx, dy) * dilation);
+kW[k] = nt(p + ivec2(dx, dy) * dilation);
 k++;
 }
 }
 float k2 = colorSensitivity * colorSensitivity;
 
 vec4 sum = vec4(0.0);
-vec3 gP = max(bs.rgb, vec3(${JNLM_ALBEDO_FLOOR}));
-vec3 mb = vec3(0.0);
-vec3 gs = vec3(0.0);
+vec3 gR = max(bs.rgb, vec3(${JNLM_ALBEDO_FLOOR}));
+vec3 mf = vec3(0.0);
+vec3 gt = vec3(0.0);
 vec3 hn = vec3(0.0);
-float pg = 0.0;
-float gu = 0.0;
-float nH = 0.0;
-float kA = 0.0;
+float pk = 0.0;
+float gv = 0.0;
+float nK = 0.0;
+float kD = 0.0;
 for (int sy = -SEARCH_RADIUS; sy <= SEARCH_RADIUS; sy++) {
 for (int sx = -SEARCH_RADIUS; sx <= SEARCH_RADIUS; sx++) {
 ivec2 q = p + ivec2(sx, sy) * dilation;
@@ -174,17 +174,17 @@ if (
 (sx == 0 && sy == 0) ||
 q.x < 0 || q.y < 0 || q.x >= imageSize.x || q.y >= imageSize.y
 ) continue;
-float features = lk(q, bs, gM);
+float features = ln(q, bs, gO);
 if (features > 16.0) continue;
 
 float fT = 0.0;
 k = 0;
 for (int dy = -PATCH_RADIUS; dy <= PATCH_RADIUS; dy++) {
 for (int dx = -PATCH_RADIUS; dx <= PATCH_RADIUS; dx++) {
-vec2 a = kT[k];
-vec2 b = nq(q + ivec2(dx, dy) * dilation);
-float qH = a.x - b.x;
-fT += (qH * qH
+vec2 a = kW[k];
+vec2 b = nt(q + ivec2(dx, dy) * dilation);
+float qL = a.x - b.x;
+fT += (qL * qL
 - VARIANCE_CANCELLATION * (a.y + min(a.y, b.y)))
 / (1e-10 + k2 * (a.y + b.y));
 k++;
@@ -193,49 +193,49 @@ k++;
 fT /= float(PATCH_SIZE);
 
 float weight = exp(-max(max(fT, 0.0), features));
-vec2 g = nq(q);
+vec2 g = nt(q);
 
-vec3 a = (load_albedoTex(q, 0).rgb - bs.rgb) / gP;
-vec4 value = rv(q);
+vec3 a = (load_albedoTex(q, 0).rgb - bs.rgb) / gR;
+vec4 value = rD(q);
 sum += value * weight;
-mb += a * weight;
-gs += a * a * weight;
+mf += a * weight;
+gt += a * a * weight;
 hn += a * value.rgb * weight;
-pg += g.x * weight;
-gu += g.y * weight * weight;
-nH += weight;
-kA = max(kA, weight);
+pk += g.x * weight;
+gv += g.y * weight * weight;
+nK += weight;
+kD = max(kD, weight);
 }
 }
 
 
 
-vec4 center = rv(p);
-vec2 kS = nq(p);
-float dF = max(kA, CENTER_WEIGHT_MIN);
-float totalWeight = nH + dF;
+vec4 center = rD(p);
+vec2 kV = nt(p);
+float dF = max(kD, CENTER_WEIGHT_MIN);
+float totalWeight = nK + dF;
 vec4 mean = (sum + center * dF) / totalWeight;
 
 
-vec3 ez = mb / totalWeight;
-vec3 ll = max(gs / totalWeight - ez * ez, vec3(0.0));
-vec3 qi = hn / totalWeight - ez * mean.rgb;
+vec3 ez = mf / totalWeight;
+vec3 lo = max(gt / totalWeight - ez * ez, vec3(0.0));
+vec3 qm = hn / totalWeight - ez * mean.rgb;
 
 
 
-vec3 qs = bs.rgb + ez * gP;
-vec3 ol = mean.rgb * gP / max(qs, vec3(${JNLM_ALBEDO_FLOOR}));
-vec3 vk = clamp(qi / (ll + vec3(${JNLM_ALBEDO_REGULARIZATION})), vec3(0.0), ol);
-vec3 rn = mean.rgb - vk * ez;
-vec4 filtered = vec4(max(rn, vec3(0.0)), max(mean.a, 0.0));
+vec3 qw = bs.rgb + ez * gR;
+vec3 oq = mean.rgb * gR / max(qw, vec3(${JNLM_ALBEDO_FLOOR}));
+vec3 vs = clamp(qm / (lo + vec3(${JNLM_ALBEDO_REGULARIZATION})), vec3(0.0), oq);
+vec3 rs = mean.rgb - vs * ez;
+vec4 filtered = vec4(max(rs, vec3(0.0)), max(mean.a, 0.0));
 vec3 rgb = filtered.a > 1e-6
 ? filtered.rgb / max(filtered.a, 1e-6)
 : center.rgb / max(center.a, 1e-6);
 if (encodeOutput) rgb = pow(max(rgb, 0.0), vec3(1.0 / 2.2));
 out_color = vec4(rgb, filtered.a);
 out_guide = vec4(
-(pg + kS.x * dF) / totalWeight,
-(gu + kS.y * dF * dF)
+(pk + kV.x * dF) / totalWeight,
+(gv + kV.y * dF * dF)
 / (totalWeight * totalWeight),
 0.0,
 1.0

package/lib/renderer/WebGLRayTraceOutputPass.js

@@ -42,11 +42,11 @@ vec4 mask = sample_shadowCatcherTex(v_Texcoord);
 vec4 background = sample_catcherBackgroundTex(v_Texcoord);
 float hit = sample_albedoTex(v_Texcoord).a;
 
-float pW = max(sample_normalTex(v_Texcoord).a, 1.0) / sampleCount;
-float iP = max(hit - mask.b * pW, 0.0);
+float qa = max(sample_normalTex(v_Texcoord).a, 1.0) / sampleCount;
+float iQ = max(hit - mask.b * qa, 0.0);
 out_foreground = vec4(
-(light.rgb - background.rgb * pW)
-/ (iP > 0.0 ? iP : sampleCount),
+(light.rgb - background.rgb * qa)
+/ (iQ > 0.0 ? iQ : sampleCount),
 clamp((light.a - background.a) / sampleCount, 0.0, 1.0)
 );
 out_catcherBackground = background / sampleCount;

package/lib/renderer/WebGLRayTracePass.js

@@ -397,7 +397,9 @@ class WebGLRayTracePass {
     _updateMeshData() {
         this._pendingGeometryUpdates.clear();
         this._needsUpdateMeshData = false;
-        const res = updateMeshInstances(this._meshes);
+        // GLSL intersects the original triangles, so its BVH must bound those
+        // triangles rather than WebGPU's displaced height prisms.
+        const res = updateMeshInstances(this._meshes, { displacement: false });
         this._preparedMeshData = res;
         this._membershipCache.capture(res);
         this._pendingMembershipData = undefined;