@meimu/mutracer 0.3.0 → 0.3.1

package/lib/renderer/wgsl/aovTraceDisplay.wgsl.js

@@ -0,0 +1,56 @@
+import original from './aovTrace.wgsl.js';
+import { aovCompactStorage } from './aovCompact.wgsl.js';
+// Web-only storage specialization. The default shader (also used by native)
+// remains byte-identical; geometry/material evaluation comes from that source.
+export default aovCompactStorage + '\noverride AOV_DISPLAY: bool = false;\n' + original
+    .replace(`var<storage, read_write> aovAccum: array<AovAccumulation>;`, `var<storage, read_write> aovAccum: array<u32>;`)
+    .replace(`fn lC(`, /* wgsl */ `fn zQ(index: u32) -> AovAccumulation {
+if(AOV_COMPACT){
+let o=index*6u;
+return AovAccumulation(vec4f(bitcast<f32>(aovAccum[o]),0,0,0),vec4f(0,0,0,bitcast<f32>(aovAccum[o+1u])),
+rY(vec2u(aovAccum[o+2u],aovAccum[o+3u])),rY(vec2u(aovAccum[o+4u],aovAccum[o+5u])));
+}
+let o=index*16u;
+return AovAccumulation(bitcast<vec4f>(vec4u(aovAccum[o],aovAccum[o+1u],aovAccum[o+2u],aovAccum[o+3u])),
+bitcast<vec4f>(vec4u(aovAccum[o+4u],aovAccum[o+5u],aovAccum[o+6u],aovAccum[o+7u])),
+bitcast<vec4f>(vec4u(aovAccum[o+8u],aovAccum[o+9u],aovAccum[o+10u],aovAccum[o+11u])),
+bitcast<vec4f>(vec4u(aovAccum[o+12u],aovAccum[o+13u],aovAccum[o+14u],aovAccum[o+15u])));
+}
+fn xg(index: u32,pixel: AovAccumulation){
+if(AOV_COMPACT){
+let o=index*6u;let d=yD(pixel.diffuse);let s=yD(pixel.specular);
+aovAccum[o]=bitcast<u32>(pixel.depthRoughness.x);aovAccum[o+1u]=bitcast<u32>(pixel.position.w);
+aovAccum[o+2u]=d.x;aovAccum[o+3u]=d.y;aovAccum[o+4u]=s.x;aovAccum[o+5u]=s.y;
+}else{
+let AJ=array<vec4f,4>(pixel.depthRoughness,pixel.position,pixel.diffuse,pixel.specular);
+for(var nZ=0u;nZ<4u;nZ++){for(var channel=0u;channel<4u;channel++){aovAccum[index*16u+nZ*4u+channel]=bitcast<u32>(AJ[nZ][channel]);}}
+}
+}
+fn lC(`)
+    .replace(`if (sample == 0u) { aovAccum[index] = AovAccumulation(); }`, `var pixel=AovAccumulation(); if(sample>0u){pixel=zQ(index);}`)
+    .replace(`if (!jS(ray, &si, &material)) { return; }`, `if (!jS(ray, &si, &material)) { xg(index,pixel); return; }`)
+    .split(`aovAccum[index].`).join(`pixel.`)
+    .replace(`pixel.position += vec4f(si.position, 1.0);`, `pixel.position += vec4f(si.position, 1.0); xg(index,pixel);`)
+    .replace(`(material.transmissionDispersionScale > 0.0);`, `(material.transmissionDispersionScale > 0.0) | (AOV_DISPLAY && material.transmissionWeight > 0.0);`)
+    // Texture colors are resolved material inputs, not directional quadrature.
+    // Web requests them as diffuseColor/specularColor (mask bits 7-8); native
+    // display AOVs (AOV_DISPLAY) still request them through the albedo bits.
+    // Uniform layer factors cancel in detail ratios, so coat, fuzz, sheen-like
+    // and anisotropic surfaces stay valid; transmission and cutouts do not.
+    .replace(`if (AOV_REFLECTANCE && (aovParameters.w & 24u) != 0u && !unsupported) {`, /* wgsl */ `let tX = select((aovParameters.w >> 7u) & 3u, (aovParameters.w >> 3u) & 3u, AOV_DISPLAY);
+if (tX != 0u) {
+let zR = (material.materialType != STANDARD) | (material.alpha < 1.0) | (material.transmissionWeight > 0.0) |
+(dot(material.mediumScattering, material.mediumScattering) > 0.0);
+if (!zR) {
+let metal = clamp(material.baseMetalness, 0.0, 1.0);
+let base = material.baseWeight * material.baseColor;
+let layer = mix(vec3f(1.0), material.coatColor, clamp(material.coatWeight, 0.0, 1.0));
+let f = (material.specularIor - 1.0) / (material.specularIor + 1.0);
+if ((tX & 1u) != 0u) { pixel.diffuse += vec4f(layer * base * (1.0 - metal), 1.0); }
+if ((tX & 2u) != 0u) { pixel.specular += vec4f(layer * (metal * base + (1.0 - metal) * material.specularWeight * material.specularColor * f * f), 1.0); }
+}
+}
+if (!AOV_DISPLAY && AOV_REFLECTANCE && (aovParameters.w & 24u) != 0u && !unsupported) {`)
+    .replace(`pixel.diffuse+=vec4f(reflectance.diffuse,1.0);`, `if ((aovParameters.w & 8u) != 0u) { pixel.diffuse+=vec4f(reflectance.diffuse,1.0); }`)
+    .replace(`pixel.specular+=vec4f(reflectance.specular,1.0);`, `if ((aovParameters.w & 16u) != 0u) { pixel.specular+=vec4f(reflectance.specular,1.0); }`);
+//# sourceMappingURL=aovTraceDisplay.wgsl.js.map

package/lib/renderer/wgsl/aovTraceDisplay.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aovTraceDisplay.wgsl.js","sourceRoot":"","sources":["../../../src/renderer/wgsl/aovTraceDisplay.wgsl.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,oBAAoB,CAAC;AAC1C,OAAO,EAAC,iBAAiB,EAAC,MAAM,sBAAsB,CAAC;AAEvD,4EAA4E;AAC5E,+EAA+E;AAC/E,eAAe,iBAAiB,GAAG,yCAAyC,GAAG,QAAQ;KACpF,OAAO,CAAC,4DAA4D,EAAE,gDAAgD,CAAC;KACvH,OAAO,CAAC,QAAe,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;OAsBzB,CAAC;KACZ,OAAO,CAAC,4DAA4D,EAAE,8DAAmE,CAAC;KAC1I,OAAO,CAAC,2CAAmD,EAAE,4DAA0E,CAAC;KACxI,KAAK,CAAC,kBAAkB,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC;KACxC,OAAO,CAAC,4CAA4C,EAAE,6DAAmE,CAAC;KAC1H,OAAO,CAAC,+CAA+C,EAAE,oGAAoG,CAAC;IAC/J,2EAA2E;IAC3E,0EAA0E;IAC1E,yEAAyE;IACzE,2EAA2E;IAC3E,wEAAwE;KACvE,OAAO,CAAC,yEAAyE,EAAE,UAAU,CAAC;;;;;;;;;;;;;wFAaP,CAAC;KACxF,OAAO,CAAC,gDAAgD,EAAE,sFAAsF,CAAC;KACjJ,OAAO,CAAC,kDAAkD,EAAE,yFAAyF,CAAC,CAAC","sourcesContent":["import original from './aovTrace.wgsl.js';\nimport {aovCompactStorage} from './aovCompact.wgsl.js';\n\n// Web-only storage specialization. The default shader (also used by native)\n// remains byte-identical; geometry/material evaluation comes from that source.\nexport default aovCompactStorage + '\\noverride AOV_DISPLAY: bool = false;\\n' + original\n  .replace(`var<storage, read_write> aovAccum: array<AovAccumulation>;`, `var<storage, read_write> aovAccum: array<u32>;`)\n  .replace(`fn aovMatrix(`, /* wgsl */ `fn aovLoad(index: u32) -> AovAccumulation {\n  if(AOV_COMPACT){\n    let o=index*6u;\n    return AovAccumulation(vec4f(bitcast<f32>(aovAccum[o]),0,0,0),vec4f(0,0,0,bitcast<f32>(aovAccum[o+1u])),\n      aovUnpack(vec2u(aovAccum[o+2u],aovAccum[o+3u])),aovUnpack(vec2u(aovAccum[o+4u],aovAccum[o+5u])));\n  }\n  let o=index*16u;\n  return AovAccumulation(bitcast<vec4f>(vec4u(aovAccum[o],aovAccum[o+1u],aovAccum[o+2u],aovAccum[o+3u])),\n    bitcast<vec4f>(vec4u(aovAccum[o+4u],aovAccum[o+5u],aovAccum[o+6u],aovAccum[o+7u])),\n    bitcast<vec4f>(vec4u(aovAccum[o+8u],aovAccum[o+9u],aovAccum[o+10u],aovAccum[o+11u])),\n    bitcast<vec4f>(vec4u(aovAccum[o+12u],aovAccum[o+13u],aovAccum[o+14u],aovAccum[o+15u])));\n}\nfn aovStore(index: u32,pixel: AovAccumulation){\n  if(AOV_COMPACT){\n    let o=index*6u;let d=aovPack(pixel.diffuse);let s=aovPack(pixel.specular);\n    aovAccum[o]=bitcast<u32>(pixel.depthRoughness.x);aovAccum[o+1u]=bitcast<u32>(pixel.position.w);\n    aovAccum[o+2u]=d.x;aovAccum[o+3u]=d.y;aovAccum[o+4u]=s.x;aovAccum[o+5u]=s.y;\n  }else{\n    let lanes=array<vec4f,4>(pixel.depthRoughness,pixel.position,pixel.diffuse,pixel.specular);\n    for(var lane=0u;lane<4u;lane++){for(var channel=0u;channel<4u;channel++){aovAccum[index*16u+lane*4u+channel]=bitcast<u32>(lanes[lane][channel]);}}\n  }\n}\nfn aovMatrix(`)\n  .replace(`if (sample == 0u) { aovAccum[index] = AovAccumulation(); }`, `var pixel=AovAccumulation(); if(sample>0u){pixel=aovLoad(index);}`)\n  .replace(`if (!aovSurface(ray, &si, &material)) { return; }`, `if (!aovSurface(ray, &si, &material)) { aovStore(index,pixel); return; }`)\n  .split(`aovAccum[index].`).join(`pixel.`)\n  .replace(`pixel.position += vec4f(si.position, 1.0);`, `pixel.position += vec4f(si.position, 1.0); aovStore(index,pixel);`)\n  .replace(`(material.transmissionDispersionScale > 0.0);`, `(material.transmissionDispersionScale > 0.0) | (AOV_DISPLAY && material.transmissionWeight > 0.0);`)\n  // Texture colors are resolved material inputs, not directional quadrature.\n  // Web requests them as diffuseColor/specularColor (mask bits 7-8); native\n  // display AOVs (AOV_DISPLAY) still request them through the albedo bits.\n  // Uniform layer factors cancel in detail ratios, so coat, fuzz, sheen-like\n  // and anisotropic surfaces stay valid; transmission and cutouts do not.\n  .replace(`if (AOV_REFLECTANCE && (aovParameters.w & 24u) != 0u && !unsupported) {`, /* wgsl */ `let colorMask = select((aovParameters.w >> 7u) & 3u, (aovParameters.w >> 3u) & 3u, AOV_DISPLAY);\n  if (colorMask != 0u) {\n    let blocked = (material.materialType != STANDARD) | (material.alpha < 1.0) | (material.transmissionWeight > 0.0) |\n      (dot(material.mediumScattering, material.mediumScattering) > 0.0);\n    if (!blocked) {\n      let metal = clamp(material.baseMetalness, 0.0, 1.0);\n      let base = material.baseWeight * material.baseColor;\n      let layer = mix(vec3f(1.0), material.coatColor, clamp(material.coatWeight, 0.0, 1.0));\n      let f = (material.specularIor - 1.0) / (material.specularIor + 1.0);\n      if ((colorMask & 1u) != 0u) { pixel.diffuse += vec4f(layer * base * (1.0 - metal), 1.0); }\n      if ((colorMask & 2u) != 0u) { pixel.specular += vec4f(layer * (metal * base + (1.0 - metal) * material.specularWeight * material.specularColor * f * f), 1.0); }\n    }\n  }\n  if (!AOV_DISPLAY && AOV_REFLECTANCE && (aovParameters.w & 24u) != 0u && !unsupported) {`)\n  .replace(`pixel.diffuse+=vec4f(reflectance.diffuse,1.0);`, `if ((aovParameters.w & 8u) != 0u) { pixel.diffuse+=vec4f(reflectance.diffuse,1.0); }`)\n  .replace(`pixel.specular+=vec4f(reflectance.specular,1.0);`, `if ((aovParameters.w & 16u) != 0u) { pixel.specular+=vec4f(reflectance.specular,1.0); }`);\n"]}

package/lib/renderer/wgsl/bloom.wgsl.js

@@ -3,7 +3,7 @@
 // https://github.com/keijiro/KinoBloom/blob/master/Assets/Kino/Bloom/Shader/Bloom.cginc#L96
 // See THIRD_PARTY_NOTICES.md and LICENSES/KinoBloom-MIT.txt.
 export const bloomBrightDefine = /* wgsl */ `
-fn tV(a: vec4f, b: vec4f, c: vec4f) -> vec4f {
+fn vE(a: vec4f, b: vec4f, c: vec4f) -> vec4f {
 return a + b + c - min(min(a, b), c) - max(max(a, b), c);
 }
 `;
@@ -11,26 +11,26 @@ export const bloomBrightMain = /* wgsl */ `
 
 let d = vec3i(1, 1, 0);
 
-var cR = load_colorTex(uv, 0);
+var texel = load_colorTex(uv, 0);
 let s1 = load_colorTex(uv - d.xz, 0);
 let s2 = load_colorTex(uv + d.xz, 0);
 let s3 = load_colorTex(uv - d.zy, 0);
 let s4 = load_colorTex(uv + d.zy, 0);
-cR = tV(tV(cR, s1, s2), s3, s4);
+texel = vE(vE(texel, s1, s2), s3, s4);
 
 
-let lum = dot(cR.rgb, vec3f(0.2125, 0.7154, 0.0721));
+let lum = dot(texel.rgb, vec3f(0.2125, 0.7154, 0.0721));
 var color: vec4f;
-if (lum > threshold && cR.a > 0.0) {
-color = vec4f(cR.rgb * scale, cR.a);
+if (lum > threshold && texel.a > 0.0) {
+color = vec4f(texel.rgb * scale, texel.a);
 } else {
 
-color = vec4f(vec3(0.0), cR.a);
+color = vec4f(vec3(0.0), texel.a);
 }
 output.color = color;
 `;
 export const bloomDownDefine = /* wgsl */ `
-fn yo(c: vec3f) -> f32 {
+fn Am(c: vec3f) -> f32 {
 return max(max(c.r, c.g), c.b);
 }
 `;
@@ -44,25 +44,25 @@ output.color = sample_colorTex_linearSampler(uv2 + d.xy) * 0.25
 + sample_colorTex_linearSampler(uv2 + d.zw) * 0.25;
 `;
 export const bloomBlurDefine = /* wgsl */ `
-const yu = array<f32, 9>(0.07, 0.09, 0.12, 0.14, 0.16, 0.14, 0.12, 0.09, 0.07);
+const Au = array<f32, 9>(0.07, 0.09, 0.12, 0.14, 0.16, 0.14, 0.12, 0.09, 0.07);
 `;
 export const bloomBlurMain = /* wgsl */ `
-let yh = vec2f(colorTexRegion());
-let off = direction / yh * size;
+let Ae = vec2f(colorTexRegion());
+let off = direction / Ae * size;
 
 var sum = vec4f(0.0);
-var uI = 0.0;
+var wr = 0.0;
 for (var i = 0; i < 9; i++) {
-let w = yu[i];
+let w = Au[i];
 sum += sample_colorTex_linearSampler(uv2 + off * f32(i - 4)) * w;
-uI += w;
+wr += w;
 }
-output.color = sum / max(uI, 0.01);
+output.color = sum / max(wr, 0.01);
 `;
 export const bloomBlendMain = /* wgsl */ `
-let yq = sample_colorTex1_linearSampler(uv2);
-let yr = sample_colorTex2_linearSampler(uv2);
-output.color = mix(yq, yr, weight);
+let Ao = sample_colorTex1_linearSampler(uv2);
+let Ap = sample_colorTex2_linearSampler(uv2);
+output.color = mix(Ao, Ap, weight);
 `;
 export const BLOOM_LEVELS = 6;
 export function bloomBlurSize(radius) {

package/lib/renderer/wgsl/causticLight.compute.d.ts

@@ -1,6 +1,6 @@
 export declare const CAUSTIC_UNIFORM_BYTES = 112;
 export declare const causticUnitRandomWgsl = "\n  fn causticUnitRandom(value:f32)->f32 {\n    return clamp((value-EPS)/(1.0-2.0*EPS),0.0,0.99999994);\n  }\n";
-export declare function causticLightCompute(constants: Record<string, boolean | number>, blasLayoutMask: number, hasDisplacement: boolean, mode?: 'lightTracing' | 'photonMapping', sceneIntersections?: string, fullEmissionRandom?: boolean): string;
+export declare function causticLightCompute(constants: Record<string, boolean | number>, blasLayoutMask: number, hasDisplacement: boolean, mode?: 'lightTracing' | 'photonMapping', sceneIntersections?: string, fullEmissionRandom?: boolean, perInstanceBounds?: boolean, compactVertices?: boolean, independentTextures?: boolean): string;
 export declare const causticAccumulateCompute = "\n  @group(0) @binding(0) var<storage,read_write> splats:array<atomic<u32>>;\n  @group(0) @binding(1) var<storage,read_write> accumulation:array<vec4f>;\n  @compute @workgroup_size(64)\n  fn main(@builtin(global_invocation_id) id:vec3u, @builtin(num_workgroups) groups:vec3u) {\n    // Large images exceed one dispatch row; preserve the linear pixel order.\n    let pixel=id.x+id.y*groups.x*64u;\n    if(pixel>=arrayLength(&accumulation)) {\n      return;\n    }\n    let i=pixel*3u;\n    accumulation[pixel]+=vec4f(vec3f(bitcast<f32>(atomicLoad(&splats[i])),bitcast<f32>(atomicLoad(&splats[i+1u])),bitcast<f32>(atomicLoad(&splats[i+2u]))),1.0);\n  }\n";
 /** Native buffer resolve has the same independent batch normalization as web. */
 export declare const causticBufferCompositeCompute = "\n  @group(0)@binding(0)var<storage,read>pt:array<vec4f>;\n  @group(0)@binding(1)var<storage,read>caustics:array<vec4f>;\n  @group(0)@binding(2)var<storage,read>normal:array<vec4f>;\n  @group(0)@binding(3)var<storage,read_write>output:array<vec4f>;\n  @compute @workgroup_size(64)fn main(@builtin(global_invocation_id)id:vec3u,@builtin(num_workgroups)groups:vec3u) {\n    // Large images exceed one dispatch row; preserve the linear pixel order.\n    let pixel=id.x+id.y*groups.x*64u;\n    if(pixel>=arrayLength(&output)) {\n      return;\n    }\n    let c=caustics[pixel];\n    let p=pt[pixel];\n    output[pixel]=vec4f(p.rgb+c.rgb/max(c.a,1.0)*normal[pixel].a,p.a);\n  }\n";