@meimu/mutracer 0.1.3 → 0.1.4

package/lib/renderer/WGPURenderingPipeline.js

@@ -40,30 +40,30 @@ encoded / 12.92,
 encoded <= vec3f(0.04045)
 );
 var result = linear;
-let jc = textureLoad(in_rawAlbedo, vec2i(globalId.xy), 0).a;
+let jg = textureLoad(in_rawAlbedo, vec2i(globalId.xy), 0).a;
 if (preserveSurfaceTexture != 0u) {
 
 
 
-let fM = vec2i(globalId.xy);
-let center = textureLoad(in_rawNormal, fM, 0);
+let fP = vec2i(globalId.xy);
+let center = textureLoad(in_rawNormal, fP, 0);
 let n = normalize(center.rgb * 2.0 - 1.0 + vec3f(1e-8));
-var mS = 0.0;
+var ng = 0.0;
 for (var y = -1; y <= 1; y++) {
 for (var x = -1; x <= 1; x++) {
-let tO = textureLoad(in_rawNormal,
-clamp(fM + vec2i(x, y), vec2i(0), imageSize - 1), 0);
-let nn = normalize(tO.rgb * 2.0 - 1.0 + vec3f(1e-8));
-mS = max(mS,
-max(1.0 - dot(n, nn), abs(center.a - tO.a)));
+let tV = textureLoad(in_rawNormal,
+clamp(fP + vec2i(x, y), vec2i(0), imageSize - 1), 0);
+let nn = normalize(tV.rgb * 2.0 - 1.0 + vec3f(1e-8));
+ng = max(ng,
+max(1.0 - dot(n, nn), abs(center.a - tV.a)));
 }
 }
-let ug = smoothstep(0.02, 0.1, mS);
-let raw = clamp(textureLoad(in_rawAlbedo, fM, 0).rgb,
+let un = smoothstep(0.02, 0.1, ng);
+let raw = clamp(textureLoad(in_rawAlbedo, fP, 0).rgb,
 vec3f(0.0), vec3f(1.0));
-result = mix(raw, linear, ug);
+result = mix(raw, linear, un);
 }
-out_albedo[index] = vec4f(result, jc);
+out_albedo[index] = vec4f(result, jg);
 `;
 export const oidnNormalSanitizeMain = /* wgsl */ `
 if (globalId.x >= u32(imageSize.x) || globalId.y >= u32(imageSize.y)) { return; }
@@ -375,11 +375,11 @@ output.color = color;
     oidnNormalSanitizePass.setOutputParams({ normal: { channels: 4 } });
     const outputPass = scratch.get('outputPass', () => new WGPUFullQuadPass('output', device, {
         fsMain: /* wgsl */ `
-let vF = min(
+let vM = min(
 vec2i(uv2 * vec2f(colorTexRegion())),
 vec2i(colorTexRegion()) - vec2i(1)
 );
-var color = load_colorTex(vF, 0);
+var color = load_colorTex(vM, 0);
 color = vec4(color.rgb * color.a, color.a);
 output.color = color;
 `,

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 lk = 0.0;
-float iY = 0.0;
-float mO = 0.0;
-float iS = 0.0;
+float lu = 0.0;
+float jc = 0.0;
+float mZ = 0.0;
+float iX = 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;
-mO += value.x;
-iS += value.x * value.x;
+mZ += value.x;
+iX += value.x * value.x;
 if (value.y >= 0.0) {
-lk += value.y;
-iY += 1.0;
+lu += value.y;
+jc += 1.0;
 }
 }
 }
 float variance;
 if (center.y >= 0.0) {
-variance = lk / iY;
+variance = lu / jc;
 } else {
-float lj = mO / 9.0;
-variance = max(iS / 9.0 - lj * lj, 0.0) * 9.0 / 8.0;
+float lt = mZ / 9.0;
+variance = max(iX / 9.0 - lt * lt, 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 nt(ivec2 p) {
+vec2 nI(ivec2 p) {
 return load_guideTex(clamp(p, ivec2(0), imageSize - 1), 0).xy;
 }
 
 
-vec4 rD(ivec2 p) {
+vec4 rL(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 ln(ivec2 q, vec4 bs, vec3 gO) {
+float lA(ivec2 q, vec4 bs, vec3 gS) {
 vec4 albedo = load_albedoTex(q, 0);
 
 
-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;
+vec3 pf = max((albedo.rgb + bs.rgb) * 0.5, vec3(${JNLM_ALBEDO_FLOOR}));
+vec3 ld = (albedo.rgb - bs.rgb) / pf;
+float iU = albedo.a - bs.a;
+vec3 lp = load_normalTex(q, 0).rgb - gS;
 return max(
-dot(kU, kU) * INV_ALBEDO_BANDWIDTH2
-+ iP * iP * INV_COVERAGE_BANDWIDTH2,
-dot(le, le) * INV_NORMAL_BANDWIDTH2
+dot(ld, ld) * INV_ALBEDO_BANDWIDTH2
++ iU * iU * INV_COVERAGE_BANDWIDTH2,
+dot(lp, lp) * INV_NORMAL_BANDWIDTH2
 );
 }
 
@@ -135,38 +135,38 @@ void main() {
 imageSize = guideTexRegion();
 ivec2 p = ivec2(gl_FragCoord.xy);
 vec4 bs = load_albedoTex(p, 0);
-vec4 fw = load_normalTex(p, 0);
-vec3 gO = fw.rgb;
+vec4 fC = load_normalTex(p, 0);
+vec3 gS = fC.rgb;
 
 
-if (fw.a <= 0.0 && load_shadowCatcherTex(p, 0).r <= 0.0) {
-vec4 c = rD(p);
+if (fC.a <= 0.0 && load_shadowCatcherTex(p, 0).r <= 0.0) {
+vec4 c = rL(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(nt(p), 0.0, 1.0);
+out_guide = vec4(nI(p), 0.0, 1.0);
 return;
 }
 
-vec2 kW[PATCH_SIZE];
+vec2 lf[PATCH_SIZE];
 int k = 0;
 for (int dy = -PATCH_RADIUS; dy <= PATCH_RADIUS; dy++) {
 for (int dx = -PATCH_RADIUS; dx <= PATCH_RADIUS; dx++) {
-kW[k] = nt(p + ivec2(dx, dy) * dilation);
+lf[k] = nI(p + ivec2(dx, dy) * dilation);
 k++;
 }
 }
 float k2 = colorSensitivity * colorSensitivity;
 
 vec4 sum = vec4(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 pk = 0.0;
-float gv = 0.0;
-float nK = 0.0;
-float kD = 0.0;
+vec3 gV = max(bs.rgb, vec3(${JNLM_ALBEDO_FLOOR}));
+vec3 mq = vec3(0.0);
+vec3 gx = vec3(0.0);
+vec3 hs = vec3(0.0);
+float ps = 0.0;
+float gz = 0.0;
+float nV = 0.0;
+float kM = 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,68 +174,68 @@ if (
 (sx == 0 && sy == 0) ||
 q.x < 0 || q.y < 0 || q.x >= imageSize.x || q.y >= imageSize.y
 ) continue;
-float features = ln(q, bs, gO);
+float features = lA(q, bs, gS);
 if (features > 16.0) continue;
 
-float fT = 0.0;
+float fX = 0.0;
 k = 0;
 for (int dy = -PATCH_RADIUS; dy <= PATCH_RADIUS; dy++) {
 for (int dx = -PATCH_RADIUS; dx <= PATCH_RADIUS; dx++) {
-vec2 a = kW[k];
-vec2 b = nt(q + ivec2(dx, dy) * dilation);
-float qL = a.x - b.x;
-fT += (qL * qL
+vec2 a = lf[k];
+vec2 b = nI(q + ivec2(dx, dy) * dilation);
+float qU = a.x - b.x;
+fX += (qU * qU
 - VARIANCE_CANCELLATION * (a.y + min(a.y, b.y)))
 / (1e-10 + k2 * (a.y + b.y));
 k++;
 }
 }
-fT /= float(PATCH_SIZE);
+fX /= float(PATCH_SIZE);
 
-float weight = exp(-max(max(fT, 0.0), features));
-vec2 g = nt(q);
+float weight = exp(-max(max(fX, 0.0), features));
+vec2 g = nI(q);
 
-vec3 a = (load_albedoTex(q, 0).rgb - bs.rgb) / gR;
-vec4 value = rD(q);
+vec3 a = (load_albedoTex(q, 0).rgb - bs.rgb) / gV;
+vec4 value = rL(q);
 sum += value * weight;
-mf += a * weight;
-gt += a * a * weight;
-hn += a * value.rgb * weight;
-pk += g.x * weight;
-gv += g.y * weight * weight;
-nK += weight;
-kD = max(kD, weight);
+mq += a * weight;
+gx += a * a * weight;
+hs += a * value.rgb * weight;
+ps += g.x * weight;
+gz += g.y * weight * weight;
+nV += weight;
+kM = max(kM, weight);
 }
 }
 
 
 
-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;
+vec4 center = rL(p);
+vec2 le = nI(p);
+float dG = max(kM, CENTER_WEIGHT_MIN);
+float totalWeight = nV + dG;
+vec4 mean = (sum + center * dG) / totalWeight;
 
 
-vec3 ez = mf / totalWeight;
-vec3 lo = max(gt / totalWeight - ez * ez, vec3(0.0));
-vec3 qm = hn / totalWeight - ez * mean.rgb;
+vec3 ez = mq / totalWeight;
+vec3 lB = max(gx / totalWeight - ez * ez, vec3(0.0));
+vec3 qu = hs / totalWeight - ez * mean.rgb;
 
 
 
-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 qE = bs.rgb + ez * gV;
+vec3 oA = mean.rgb * gV / max(qE, vec3(${JNLM_ALBEDO_FLOOR}));
+vec3 vB = clamp(qu / (lB + vec3(${JNLM_ALBEDO_REGULARIZATION})), vec3(0.0), oA);
+vec3 rD = mean.rgb - vB * ez;
+vec4 filtered = vec4(max(rD, 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(
-(pk + kV.x * dF) / totalWeight,
-(gv + kV.y * dF * dF)
+(ps + le.x * dG) / totalWeight,
+(gz + le.y * dG * dG)
 / (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 qa = max(sample_normalTex(v_Texcoord).a, 1.0) / sampleCount;
-float iQ = max(hit - mask.b * qa, 0.0);
+float qi = max(sample_normalTex(v_Texcoord).a, 1.0) / sampleCount;
+float iV = max(hit - mask.b * qi, 0.0);
 out_foreground = vec4(
-(light.rgb - background.rgb * qa)
-/ (iQ > 0.0 ? iQ : sampleCount),
+(light.rgb - background.rgb * qi)
+/ (iV > 0.0 ? iV : sampleCount),
 clamp((light.a - background.a) / sampleCount, 0.0, 1.0)
 );
 out_catcherBackground = background / sampleCount;

package/lib/renderer/WebGLRayTracePass.d.ts

@@ -49,6 +49,7 @@ declare class WebGLRayTracePass {
     private _hasBackground;
     private _groundedBackgroundParams;
     private _groundedBackgroundCenter;
+    private _backgroundMapTransform;
     private _bounces;
     private _bevelSamples;
     private _clamping?;

package/lib/renderer/WebGLRayTracePass.js

@@ -18,7 +18,7 @@ import { constants, Texture2D as WebGLTexture2D } from './webgl.js';
 import { WebGLFullQuadPass } from './WebGLFullQuadPass.js';
 import { mat4 } from '../math.js';
 import { buildBLAS, buildTLAS, concatBLASBuffers, refitBLAS, refitTLAS, mergeRefitRanges } from './bvhAccel.js';
-import { generateBackgroundMapFromSceneBackground } from './envMapCreation.js';
+import { generateBackgroundMapFromSceneBackground, environmentRotation, backgroundMapTransform } from './envMapCreation.js';
 import { envMapDistribution, environmentMapSourcesMatch } from './envMapDistribution.js';
 import createRayTraceFragmentShader from './glsl/rayTrace.frag.js';
 import shadowCatcherFrag from './glsl/shadowCatcher.frag.js';
@@ -105,6 +105,7 @@ class WebGLRayTracePass {
     _hasBackground = false;
     _groundedBackgroundParams = new Float32Array([0, 0, 0, 0]);
     _groundedBackgroundCenter = new Float32Array([0, 0]);
+    _backgroundMapTransform = backgroundMapTransform();
     _bounces = 2;
     _bevelSamples = DEFAULT_BEVEL_SAMPLES;
     _clamping;
@@ -237,6 +238,7 @@ class WebGLRayTracePass {
         this._hasEnvMap = !!envImage;
     }
     setBackground(background) {
+        this._backgroundMapTransform.set(backgroundMapTransform(background));
         const backgroundImage = background && generateBackgroundMapFromSceneBackground(background);
         if (backgroundImage) {
             this._backgroundTex.source = backgroundImage;
@@ -633,6 +635,9 @@ class WebGLRayTracePass {
             light.type === 'RectLight');
         const numAnalyticLights = analyticLights.length;
         const envImage = this._sceneEnvironment.update(lights);
+        const rotation = environmentRotation(lights);
+        const rotation3 = [rotation[0], rotation[1], rotation[2], rotation[4], rotation[5], rotation[6], rotation[8], rotation[9], rotation[10]];
+        this._tracePasses.forEach(pass => pass.setUniform('environmentRotation', rotation3));
         const envWeight = estimateEnvironmentPower(envImage);
         const analyticWeights = analyticLights.map(estimateAnalyticLightPower);
         const totalWeight = envWeight + analyticWeights.reduce((sum, weight) => sum + weight, 0);
@@ -778,6 +783,7 @@ class WebGLRayTracePass {
             pass.setUniform('iesProfileColumns', this._iesProfileColumns);
             pass.setUniform('groundedBackgroundParams', this._groundedBackgroundParams);
             pass.setUniform('groundedBackgroundCenter', this._groundedBackgroundCenter);
+            pass.setUniform('backgroundMapTransform', this._backgroundMapTransform);
             pass.setDefines({
                 // Double bounce fix on intel mac
                 // Limit the bounce to avoid long compilation time.