@meimu/mutracer 0.1.3 → 0.1.5

package/lib/renderer/WGPUJNLMDenoiser.js

@@ -27,9 +27,9 @@ ${shadowCatcherAccumulationWGSL}
 fn main(@builtin(global_invocation_id) id: vec3u) {
 let size = params.size;
 if (id.x >= size.x || id.y >= size.y) { return; }
-let tT = id.x + (size.y - 1u - id.y) * size.x;
-let n = normalBuffer[tT].a;
-let moments = accumulation[tT].moments;
+let ua = id.x + (size.y - 1u - id.y) * size.x;
+let n = normalBuffer[ua].a;
+let moments = accumulation[ua].moments;
 let mean = moments.x / max(n, 1.0);
 
 var variance = -1.0;
@@ -53,28 +53,28 @@ fn main(@builtin(global_invocation_id) id: vec3u) {
 let size = params.size;
 if (id.x >= size.x || id.y >= size.y) { return; }
 let center = rawGuide[id.x + id.y * size.x];
-var lk = 0.0;
-var iY = 0.0;
-var mO = 0.0;
-var iS = 0.0;
+var lu = 0.0;
+var jc = 0.0;
+var mY = 0.0;
+var iX = 0.0;
 for (var dy = -1; dy <= 1; dy++) {
 for (var dx = -1; dx <= 1; dx++) {
 let q = clamp(vec2i(id.xy) + vec2i(dx, dy), vec2i(0), vec2i(size) - 1);
 let value = rawGuide[u32(q.x) + u32(q.y) * size.x];
-mO += value.x;
-iS += value.x * value.x;
+mY += value.x;
+iX += value.x * value.x;
 if (value.y >= 0.0) {
-lk += value.y;
-iY += 1.0;
+lu += value.y;
+jc += 1.0;
 }
 }
 }
 var variance: f32;
 if (center.y >= 0.0) {
-variance = lk / iY;
+variance = lu / jc;
 } else {
-let lj = mO / 9.0;
-variance = max(iS / 9.0 - lj * lj, 0.0) * 9.0 / 8.0;
+let lt = mY / 9.0;
+variance = max(iX / 9.0 - lt * lt, 0.0) * 9.0 / 8.0;
 }
 guide[id.x + id.y * size.x] = vec2f(center.x, variance);
 }
@@ -122,23 +122,23 @@ const INV_NORMAL_BANDWIDTH2 = ${(1 / normalBandwidth ** 2).toFixed(6)};
 
 const CENTER_WEIGHT_MIN = 0.01;
 
-fn ha(p: vec2i) -> u32 {
+fn hg(p: vec2i) -> u32 {
 let q = clamp(p, vec2i(0), vec2i(params.size) - 1);
 return u32(q.x) + u32(q.y) * params.size.x;
 }
 
-fn ln(q: vec2i, bs: vec4f, gO: vec3f) -> f32 {
+fn lw(q: vec2i, bs: vec4f, gT: vec3f) -> f32 {
 let albedo = textureLoad(albedoTex, q, 0);
 
 
-let oW = max((albedo.rgb + bs.rgb) * 0.5, vec3f(${JNLM_ALBEDO_FLOOR}));
-let kU = (albedo.rgb - bs.rgb) / oW;
-let iP = albedo.a - bs.a;
-let le = textureLoad(normalTex, q, 0).rgb - gO;
+let pf = max((albedo.rgb + bs.rgb) * 0.5, vec3f(${JNLM_ALBEDO_FLOOR}));
+let ld = (albedo.rgb - bs.rgb) / pf;
+let iU = albedo.a - bs.a;
+let lp = textureLoad(normalTex, q, 0).rgb - gT;
 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
 );
 }
 
@@ -153,36 +153,36 @@ let p = vec2i(id.xy);
 if (p.x >= size.x || p.y >= size.y) { return; }
 let step = i32(params.dilation);
 let bs = textureLoad(albedoTex, p, 0);
-let fw = textureLoad(normalTex, p, 0);
-let gO = fw.rgb;
-let index = ha(p);
+let fD = textureLoad(normalTex, p, 0);
+let gT = fD.rgb;
+let index = hg(p);
 
 
-if (fw.a <= 0.0 && textureLoad(shadowCatcherTex, p, 0).r <= 0.0) {
+if (fD.a <= 0.0 && textureLoad(shadowCatcherTex, p, 0).r <= 0.0) {
 outColor[index] = color[index];
 outGuide[index] = guide[index];
 return;
 }
 
-var kW: array<vec2f, PATCH_SIZE>;
+var lf: array<vec2f, PATCH_SIZE>;
 var k = 0;
 for (var dy = -PATCH_RADIUS; dy <= PATCH_RADIUS; dy++) {
 for (var dx = -PATCH_RADIUS; dx <= PATCH_RADIUS; dx++) {
-kW[k] = guide[ha(p + vec2i(dx, dy) * step)];
+lf[k] = guide[hg(p + vec2i(dx, dy) * step)];
 k++;
 }
 }
 let k2 = params.colorSensitivity * params.colorSensitivity;
 
 var sum = vec4f(0.0);
-let gR = max(bs.rgb, vec3f(${JNLM_ALBEDO_FLOOR}));
-var mf = vec3f(0.0);
-var gt = vec3f(0.0);
-var hn = vec3f(0.0);
-var pk = 0.0;
-var gv = 0.0;
-var nK = 0.0;
-var kD = 0.0;
+let gW = max(bs.rgb, vec3f(${JNLM_ALBEDO_FLOOR}));
+var mp = vec3f(0.0);
+var gy = vec3f(0.0);
+var hs = vec3f(0.0);
+var ps = 0.0;
+var gA = 0.0;
+var nU = 0.0;
+var kM = 0.0;
 for (var sy = -SEARCH_RADIUS; sy <= SEARCH_RADIUS; sy++) {
 for (var sx = -SEARCH_RADIUS; sx <= SEARCH_RADIUS; sx++) {
 let q = p + vec2i(sx, sy) * step;
@@ -191,63 +191,63 @@ if (
 q.x < 0 || q.y < 0 || q.x >= size.x || q.y >= size.y
 ) { continue; }
 
-let features = ln(q, bs, gO);
+let features = lw(q, bs, gT);
 if (features > 16.0) { continue; }
 
-var fT = 0.0;
+var fY = 0.0;
 k = 0;
 for (var dy = -PATCH_RADIUS; dy <= PATCH_RADIUS; dy++) {
 for (var dx = -PATCH_RADIUS; dx <= PATCH_RADIUS; dx++) {
-let a = kW[k];
-let b = guide[ha(q + vec2i(dx, dy) * step)];
-let qL = a.x - b.x;
-fT += (qL * qL
+let a = lf[k];
+let b = guide[hg(q + vec2i(dx, dy) * step)];
+let qU = a.x - b.x;
+fY += (qU * qU
 - VARIANCE_CANCELLATION * (a.y + min(a.y, b.y)))
 / (1e-10 + k2 * (a.y + b.y));
 k++;
 }
 }
-fT /= f32(PATCH_SIZE);
+fY /= f32(PATCH_SIZE);
 
-let weight = exp(-max(max(fT, 0.0), features));
-let index = ha(q);
+let weight = exp(-max(max(fY, 0.0), features));
+let index = hg(q);
 let c = color[index];
 let g = guide[index];
 
-let a = (textureLoad(albedoTex, q, 0).rgb - bs.rgb) / gR;
+let a = (textureLoad(albedoTex, q, 0).rgb - bs.rgb) / gW;
 let value = premultiplied(c);
 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);
+mp += a * weight;
+gy += a * a * weight;
+hs += a * value.rgb * weight;
+ps += g.x * weight;
+gA += g.y * weight * weight;
+nU += weight;
+kM = max(kM, weight);
 }
 }
 
 
 
 let center = color[index];
-let kV = guide[index];
-let dF = max(kD, CENTER_WEIGHT_MIN);
-let totalWeight = nK + dF;
-let tF = premultiplied(center);
-let mean = (sum + tF * dF) / totalWeight;
+let le = guide[index];
+let dG = max(kM, CENTER_WEIGHT_MIN);
+let totalWeight = nU + dG;
+let tM = premultiplied(center);
+let mean = (sum + tM * dG) / totalWeight;
 
 
-let ez = mf / totalWeight;
-let lo = max(gt / totalWeight - ez * ez, vec3f(0.0));
-let qm = hn / totalWeight - ez * mean.rgb;
+let ez = mp / totalWeight;
+let lA = max(gy / totalWeight - ez * ez, vec3f(0.0));
+let qu = hs / totalWeight - ez * mean.rgb;
 
 
 
-let qw = bs.rgb + ez * gR;
-let oq = mean.rgb * gR / max(qw, vec3f(${JNLM_ALBEDO_FLOOR}));
-let vs = clamp(qm / (lo + vec3f(${JNLM_ALBEDO_REGULARIZATION})), vec3f(0.0), oq);
-let rs = mean.rgb - vs * ez;
-let filtered = vec4f(max(rs, vec3f(0.0)), max(mean.a, 0.0));
+let qE = bs.rgb + ez * gW;
+let oz = mean.rgb * gW / max(qE, vec3f(${JNLM_ALBEDO_FLOOR}));
+let vB = clamp(qu / (lA + vec3f(${JNLM_ALBEDO_REGULARIZATION})), vec3f(0.0), oz);
+let rD = mean.rgb - vB * ez;
+let filtered = vec4f(max(rD, vec3f(0.0)), max(mean.a, 0.0));
 let rgb = select(
 center.rgb,
 filtered.rgb / max(filtered.a, 1e-6),
@@ -255,8 +255,8 @@ filtered.a > 1e-6
 );
 outColor[index] = vec4f(rgb, filtered.a);
 outGuide[index] = vec2f(
-(pk + kV.x * dF) / totalWeight,
-(gv + kV.y * dF * dF)
+(ps + le.x * dG) / totalWeight,
+(gA + le.y * dG * dG)
 / (totalWeight * totalWeight)
 );
 }

package/lib/renderer/WGPURayTraceOutput.js

@@ -16,33 +16,33 @@ ${shadowCatcherAccumulationWGSL}
 override outputWidth: f32;
 override outputHeight: f32;
 
-struct oU {
+struct pd {
 ${layers ? `@location(0) foreground: vec4f,
 @location(1) catcherBackground: vec4f` : `@location(0) color: vec4f,
 @location(1) normal: vec4f,
 @location(2) albedo: vec4f${catcher ? ',\n  @location(3) shadowCatcher: vec4f' : ''}`}
 }
 @fragment
-fn main(@builtin(position) fD: vec4f) -> oU {
+fn main(@builtin(position) fH: vec4f) -> pd {
 let size = vec2u(u32(outputWidth), u32(outputHeight));
-let fM = vec2u(u32(fD.x), size.y - u32(fD.y) - 1u);
-var idx = fM.x + fM.y * size.x;
+let fQ = vec2u(u32(fH.x), size.y - u32(fH.y) - 1u);
+var idx = fQ.x + fQ.y * size.x;
 
 
 
 
 if (sampleCount < 1.0 && normalBuffer[idx].a <= 0.0) {
-let uV = max(sampleTileGrid, vec2u(1u));
-let uF = min(
-((fM + uV / 2u) / uV) * uV,
-((size - vec2u(1u)) / uV) * uV
+let vc = max(sampleTileGrid, vec2u(1u));
+let uM = min(
+((fQ + vc / 2u) / vc) * vc,
+((size - vec2u(1u)) / vc) * vc
 );
-let sz = uF.x + uF.y * size.x;
-if (normalBuffer[sz].a > 0.0) {
-idx = sz;
+let sH = uM.x + uM.y * size.x;
+if (normalBuffer[sH].a > 0.0) {
+idx = sH;
 }
 }
-var output: oU;
+var output: pd;
 if (normalBuffer[idx].a <= 0.0) {
 ${layers ? `output.foreground = vec4f(0.0);
 output.catcherBackground = vec4f(0.0);` : `output.color = vec4f(0.0);
@@ -62,12 +62,12 @@ let hit = albedo.a;
 let total = max(normal.a, 1.0);
 ${layers ? `
 let shadow = shadowCatcherBuffer[idx];
-let iQ = max(hit - shadow.mask.b, 0.0);
+let iV = max(hit - shadow.mask.b, 0.0);
 
 
 output.foreground = vec4f(
 (color.rgb - shadow.background.rgb)
-/ select(total, iQ, iQ > 0.0),
+/ select(total, iV, iV > 0.0),
 clamp((color.a - shadow.mask.g) / total, 0.0, 1.0)
 );
 output.catcherBackground = shadow.background / total;

package/lib/renderer/WGPURayTracePass.d.ts

@@ -57,6 +57,8 @@ export declare function makeRayTraceUniform(): {
         sequenceSeed: Uint32Array<ArrayBuffer>;
         zSobolLogSPP: Uint32Array<ArrayBuffer>;
         sampleSequenceOffset: Uint32Array<ArrayBuffer>;
+        environmentRotation: Float32Array<ArrayBuffer>;
+        backgroundMapTransform: Float32Array<ArrayBuffer>;
     };
 };
 export declare function packAnalyticsLightsToBuffer(lights: AnalyticLight[], texturesIndices: number[], selectionPmfs: number[], iesProfileTexelOffsets?: ArrayLike<number>): Float32Array<ArrayBuffer>;

package/lib/renderer/WGPURayTracePass.js

@@ -24,7 +24,7 @@ import { WGPU_SCENE_FEATURE_BITS, wgpuSceneFeatureFlags } from './WGPUSceneFeatu
 import { mat4 } from '../math.js';
 import MaterialTable, { DEFAULT_MAX_TEXTURE_ARRAY_BYTES, materialUsesMedium } from './MaterialTable.js';
 import { numberArraysEqual } from './util.js';
-import { generateBackgroundMapFromSceneBackground } from './envMapCreation.js';
+import { generateBackgroundMapFromSceneBackground, environmentRotation, backgroundMapTransform } from './envMapCreation.js';
 import rayTraceCompute, { WORKGROUP_SIZE } from './wgsl/rayTrace.compute.js';
 import { CONSTANT_DIRECTIONAL_LIGHT, CONSTANT_RECT_LIGHT, CONSTANT_SPHERE_LIGHT, CONSTANT_SPOT_LIGHT } from './lightsUtil.js';
 import { envMapDistribution, environmentMapSourcesMatch } from './envMapDistribution.js';
@@ -89,7 +89,7 @@ export function isWebGPUPipelineSpecializationFailure(...errors) {
 /** CPU-side views over the `RayTraceUniform` WGSL struct. */
 export function makeRayTraceUniform() {
     // Created from https://webgpufundamentals.org/webgpu/lessons/resources/wgsl-offset-computer.html
-    const RayTraceUniformValues = new ArrayBuffer(176);
+    const RayTraceUniformValues = new ArrayBuffer(256);
     const RayTraceUniformViews = {
         outputSize: new Float32Array(RayTraceUniformValues, 0, 2),
         sampleCount: new Float32Array(RayTraceUniformValues, 8, 1),
@@ -119,11 +119,15 @@ export function makeRayTraceUniform() {
         sceneFeatureFlags: new Uint32Array(RayTraceUniformValues, 152, 1),
         sequenceSeed: new Uint32Array(RayTraceUniformValues, 156, 1),
         zSobolLogSPP: new Uint32Array(RayTraceUniformValues, 160, 1),
-        sampleSequenceOffset: new Uint32Array(RayTraceUniformValues, 164, 1)
+        sampleSequenceOffset: new Uint32Array(RayTraceUniformValues, 164, 1),
+        environmentRotation: new Float32Array(RayTraceUniformValues, 176, 16),
+        backgroundMapTransform: new Float32Array(RayTraceUniformValues, 240, 4)
     };
     // Fixed runtime trip bounds discourage thin-film loop unrolling. Keep 4 for
     // 2 polarizations/substrates and 3 channels, independent of BSDF budgets.
     RayTraceUniformViews.loopUnrollGuard[0] = 4;
+    RayTraceUniformViews.environmentRotation.set(environmentRotation([]));
+    RayTraceUniformViews.backgroundMapTransform.set(backgroundMapTransform());
     RayTraceUniformViews.bevel[0] = 1;
     RayTraceUniformViews.dispersionWavelengths[0] = 3;
     return {
@@ -179,7 +183,7 @@ export function packAnalyticsLightsToBuffer(lights, texturesIndices, selectionPm
             data[(off + 2) * 4 + 3] = light.radius;
             packVec3(off + 3, [
                 Math.cos((light.outerAngle * Math.PI) / 180),
-                Math.min(1, Math.max(0, 1 - light.innerAngle / light.outerAngle)),
+                Math.cos((Math.min(light.innerAngle, light.outerAngle) * Math.PI) / 180),
                 0
             ]);
         }
@@ -792,8 +796,6 @@ class WGPURayTracePass {
                 ...MATERIAL_TEXTURE_DEFINES,
                 'USE_ANISOTROPY_DIRECTIONS',
                 'USE_COAT_NORMAL_FRAMES',
-                'COLOR_OFF',
-                'USE_VERTEX_COLOR',
                 'HAS_ALPHA_BLEND',
                 'HAS_ALPHA_MASK'
             ];
@@ -1621,6 +1623,7 @@ ${rayTraceCompute({
         return true;
     }
     setBackground(background) {
+        this._rtUniform.views.backgroundMapTransform.set(backgroundMapTransform(background));
         this._constants.USE_BACKGROUND = !!background;
         const backgroundImage = background && !Array.isArray(background)
             ? generateBackgroundMapFromSceneBackground(background)
@@ -1913,6 +1916,9 @@ ${rayTraceCompute({
         // Retain the atlas uniform capacity when a stage/material is removed.
         // Shrinking the array would rebuild every pipeline again on the next edit.
         const NUM_MAPS = Math.max(Math.ceil(+materialData.defines.NUM_MAPS / 10) * 10, Number(this._constants.NUM_MAPS ?? 0), 20);
+        // Either layer's map requires independent normals, including a smooth
+        // coat over a mapped base. Unmapped materials retain the shared path.
+        const USE_COAT_NORMAL_FRAMES = materials.some(m => m.coatWeight > 0 && (!!m.normalMap || !!m.coatNormalMap));
         Object.assign(this._constants, {
             // Match the atlas UV selector. Keep the second set when any texture
             // needs it; material/texture edits already rebuild these constants.
@@ -1921,9 +1927,8 @@ ${rayTraceCompute({
             // triangle UV differentials rather than this vertex tangent.
             USE_TANGENT: mergedGeometry.tangent != null &&
                 materials.some(material => material.specularAnisotropy > 0 || material.coatAnisotropy > 0 || (!!material.coatNormalMap && material.coatWeight > 0)),
-            USE_COAT_NORMAL_FRAMES: materials.some(m => !!m.coatNormalMap && m.coatWeight > 0),
-            USE_ANISOTROPY_DIRECTIONS: materials.some(m => (!!m.coatNormalMap && m.coatWeight > 0) ||
-                m.specularAnisotropy > 0 && (m.specularAnisotropyModel === 'gltf' || !!m.anisotropyMap || m.specularAnisotropyRotation !== 0) ||
+            USE_COAT_NORMAL_FRAMES,
+            USE_ANISOTROPY_DIRECTIONS: USE_COAT_NORMAL_FRAMES || materials.some(m => m.specularAnisotropy > 0 && (m.specularAnisotropyModel === 'gltf' || !!m.anisotropyMap || m.specularAnisotropyRotation !== 0) ||
                 m.coatAnisotropy > 0 && m.coatAnisotropyRotation !== 0),
             HAS_MEDIUM,
             HAS_SHADOW_CATCHER: this._hasShadowCatcher,
@@ -2119,6 +2124,8 @@ ${rayTraceCompute({
         for (let i = 0; i < mapUvChannel.length; i++) {
             mapInfoData[numMaps * 8 + i * 4] = mapUvChannel[i];
             mapInfoData[numMaps * 8 + i * 4 + 1] = mapColorLinear[i];
+            mapInfoData[numMaps * 8 + i * 4 + 2] = materialData.bufferData.mapWrap[i * 2];
+            mapInfoData[numMaps * 8 + i * 4 + 3] = materialData.bufferData.mapWrap[i * 2 + 1];
         }
         let mapInfoUniform = this._mapInfoUniform;
         if (!mapInfoUniform || mapInfoUniform.size !== mapInfoData.byteLength) {
@@ -2186,6 +2193,7 @@ ${rayTraceCompute({
         const analyticLights = allAnalyticLights.slice(0, FIXED_LIGHT_COUNT);
         const numAnalyticLights = analyticLights.length;
         const envImage = this._sceneEnvironment.update(lights);
+        this._rtUniform.views.environmentRotation.set(environmentRotation(lights));
         this._rtUniform.views.lightsCount[0] = numAnalyticLights;
         this._setEnvMap(envImage);
         const lightTexturesChanged = this._rectLightTextures.update(analyticLights);