@meimu/mutracer 0.2.0 → 0.3.0

package/lib/renderer/wgsl/aovTrace.wgsl.js

@@ -15,20 +15,20 @@ struct AovCenter { identity: vec4u, motion: vec4f, }
 @group(3) @binding(9) var<storage, read> aovPrevious: array<AovCenter>;
 @group(3) @binding(8) var<uniform> aovParameters: vec4u;
 
-fn ow(offset: u32) -> mat4x4f {
+fn oi(offset: u32) -> mat4x4f {
 return mat4x4f(bitcast<vec4f>(vec4u(aovScene[offset], aovScene[offset+1u], aovScene[offset+2u], aovScene[offset+3u])),
 bitcast<vec4f>(vec4u(aovScene[offset+4u], aovScene[offset+5u], aovScene[offset+6u], aovScene[offset+7u])),
 bitcast<vec4f>(vec4u(aovScene[offset+8u], aovScene[offset+9u], aovScene[offset+10u], aovScene[offset+11u])),
 bitcast<vec4f>(vec4u(aovScene[offset+12u], aovScene[offset+13u], aovScene[offset+14u], aovScene[offset+15u])));
 }
-fn iN(offset:u32)->vec3f {return bitcast<vec3f>(vec3u(aovScene[offset],aovScene[offset+1u],aovScene[offset+2u]));}
-fn mQ(xe: Ray, si: ptr<function, SurfaceInteraction>, material: ptr<function, OpenPbrResolvedMaterial>) -> bool {
-var ray = xe;
+fn iu(offset:u32)->vec3f {return bitcast<vec3f>(vec3u(aovScene[offset],aovScene[offset+1u],aovScene[offset+2u]));}
+fn mC(xG: Ray, si: ptr<function, SurfaceInteraction>, material: ptr<function, OpenPbrResolvedMaterial>) -> bool {
+var ray = xG;
 (*si).triangleIndex = -1;
 for (var layer = 0; layer < 32; layer++) {
 intersectScene(ray, si, 0, false, false);
 if (!(*si).hit) { return false; }
-dg(material, (*si).materialIndex, (*si).uv, (*si).uv1, (*si).instanceIndex, (*si).vertexColor);
+getMaterial(material, (*si).materialIndex, (*si).uv, (*si).uv1, (*si).instanceIndex, (*si).vertexColor);
 if ((*material).materialType != SHADOW_CATCHER && (*material).alpha >= 0.5) { return true; }
 ray.o = (*si).position + ray.d * (EPS * 0.02);
 }
@@ -41,21 +41,21 @@ if (any(id.xy >= size)) { return; }
 let index = id.x + id.y * size.x;
 let sample = aovParameters.z;
 if (sample == 0u) { aovAccum[index] = AovAccumulation(); }
-aZ = id.xy; aQ = sample + rtUniform.sampleSequenceOffset;
-bT = 0u; cP = 0u;
-gW(id.xy, i32(aQ ^ dG(rtUniform.sequenceSeed)));
-let uv = (vec2f(id.xy) + dZ(CAMERA_PIXEL)) / vec2f(size);
-var ray = fj(uv);
+aI = id.xy; aC = sample + rtUniform.sampleSequenceOffset;
+samplingBounce = 0u; ca = 0u;
+fi(id.xy, i32(aC ^ cB(rtUniform.sequenceSeed)));
+let uv = (vec2f(id.xy) + sample2D(CAMERA_PIXEL)) / vec2f(size);
+var ray = eT(uv);
 if (cameraUniform.apertureRadius > 0.0) {
 let eye = cameraUniform.viewInv[3].xyz;
 let forward = -normalize(cameraUniform.viewInv[2].xyz);
-let jN = eye + ray.d * (cameraUniform.focusDistance / dot(ray.d, forward));
-let xU = cameraUniform.apertureRadius * kN(dZ(CAMERA_LENS));
-let origin = (cameraUniform.viewInv * vec4f(xU, 0.0, 1.0)).xyz;
-gC(&ray, origin, normalize(jN-origin));
+let ju = eye + ray.d * (cameraUniform.focusDistance / dot(ray.d, forward));
+let uV = cameraUniform.apertureRadius * kq(sample2D(CAMERA_LENS));
+let origin = (cameraUniform.viewInv * vec4f(uV, 0.0, 1.0)).xyz;
+initRay(&ray, origin, normalize(ju-origin));
 }
 var si: SurfaceInteraction; var material: OpenPbrResolvedMaterial;
-if (!mQ(ray, &si, &material)) { return; }
+if (!mC(ray, &si, &material)) { return; }
 let depth = max(dot(si.position-cameraUniform.viewInv[3].xyz, -normalize(cameraUniform.viewInv[2].xyz)), 0.0);
 let unsupported = (material.materialType != STANDARD) | (material.alpha < 1.0) |
 (material.coatWeight > 0.0) | (material.fuzzWeight > 0.0) |
@@ -66,17 +66,17 @@ let unsupported = (material.materialType != STANDARD) | (material.alpha < 1.0) |
 aovAccum[index].depthRoughness += vec4f(depth, material.specularRoughness, material.baseMetalness, select(0.0,1.0,unsupported));
 if (AOV_REFLECTANCE && (aovParameters.w & 24u) != 0u && !unsupported) {
 var normal=si.normal; var face=si.faceNormal;
-var cosine=-dot(normal,ray.d); var fu=-dot(face,ray.d);
+var cosine=-dot(normal,ray.d); var fa=-dot(face,ray.d);
 if (material.thinWalled && (material.transmissionWeight>0.0 || material.subsurfaceWeight>0.0)) {
 if(cosine<0.0){normal=-normal;cosine=-cosine;}
-if(fu<0.0){face=-face;fu=-fu;}
+if(fa<0.0){face=-face;fa=-fa;}
 }
-if(fu>=0.0 && cosine<0.0){normal=face;cosine=fu;}
+if(fa>=0.0 && cosine<0.0){normal=face;cosine=fa;}
 normal=select(-normal,normal,cosine>=0.0);
 material.inside=(cosine<=0.0) && !material.thinWalled;
 material.relativeIor=select(material.specularIor,1.0/material.specularIor,cosine>0.0);
-let prepared=ds(si.tangent,material,-ray.d,normal);
-let reflectance=hN(prepared, (aovParameters.w & 8u) != 0u, (aovParameters.w & 16u) != 0u);
+let prepared=bV(si.tangent,material,-ray.d,normal);
+let reflectance=hu(prepared, (aovParameters.w & 8u) != 0u, (aovParameters.w & 16u) != 0u);
 aovAccum[index].diffuse+=vec4f(reflectance.diffuse,1.0);
 aovAccum[index].specular+=vec4f(reflectance.specular,1.0);
 }
@@ -89,26 +89,26 @@ if (any(id.xy >= size)) { return; }
 let index = id.x + id.y * size.x;
 aovCenter[index] = AovCenter(vec4u(0xffffffffu), vec4f(0.0));
 let uv = (vec2f(id.xy) + 0.5) / vec2f(size);
-let ray = fj(uv);
+let ray = eT(uv);
 var si: SurfaceInteraction; var material: OpenPbrResolvedMaterial;
-if (!mQ(ray, &si, &material)) { return; }
+if (!mC(ray, &si, &material)) { return; }
 let offset = 52u + u32(si.instanceIndex) * 24u;
 let materialOffset = aovScene[16u];
 let primitiveOffset = aovScene[17u];
 aovCenter[index].identity = vec4u(aovScene[offset], aovScene[offset+1u],
 aovScene[materialOffset + u32(si.materialIndex)], aovScene[primitiveOffset + u32(si.triangleIndex)]);
-aovCenter[index].motion.z = dot(si.position-iN(36u),iN(40u));
+aovCenter[index].motion.z = dot(si.position-iu(36u),iu(40u));
 if (aovScene[offset+2u] == 0u) { return; }
-let qA = ow(offset+4u) * vec4f(si.position,1.0);
-let ps = ow(0u) * qA;
-if (ps.w <= 0.0) { return; }
-let tX=ps.xyz/ps.w;
-let iz=(tX.xy*0.5+0.5)*vec2f(size);
-if (any(iz < vec2f(0.0)) || any(iz >= vec2f(size)) || abs(tX.z)>1.0) { return; }
-let previous=aovPrevious[u32(iz.x)+u32(iz.y)*size.x];
-let qz=dot(qA.xyz-iN(44u),iN(48u));
-if (any(previous.identity.xy != aovCenter[index].identity.xy) || abs(previous.motion.z-qz)>max(1e-4,abs(qz)*1e-3)) { return; }
-let motion=(iz-(vec2f(id.xy)+0.5))*vec2f(1.0,-1.0);
+let qs = oi(offset+4u) * vec4f(si.position,1.0);
+let pg = oi(0u) * qs;
+if (pg.w <= 0.0) { return; }
+let ua=pg.xyz/pg.w;
+let hU=(ua.xy*0.5+0.5)*vec2f(size);
+if (any(hU < vec2f(0.0)) || any(hU >= vec2f(size)) || abs(ua.z)>1.0) { return; }
+let previous=aovPrevious[u32(hU.x)+u32(hU.y)*size.x];
+let qr=dot(qs.xyz-iu(44u),iu(48u));
+if (any(previous.identity.xy != aovCenter[index].identity.xy) || abs(previous.motion.z-qr)>max(1e-4,abs(qr)*1e-3)) { return; }
+let motion=(hU-(vec2f(id.xy)+0.5))*vec2f(1.0,-1.0);
 aovCenter[index].motion=vec4f(motion,aovCenter[index].motion.z,3.0);
 }
 `;

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 tS(a: vec4f, b: vec4f, c: vec4f) -> vec4f {
+fn tV(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 dk = load_colorTex(uv, 0);
+var cR = 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);
-dk = tS(tS(dk, s1, s2), s3, s4);
+cR = tV(tV(cR, s1, s2), s3, s4);
 
 
-let lum = dot(dk.rgb, vec3f(0.2125, 0.7154, 0.0721));
+let lum = dot(cR.rgb, vec3f(0.2125, 0.7154, 0.0721));
 var color: vec4f;
-if (lum > threshold && dk.a > 0.0) {
-color = vec4f(dk.rgb * scale, dk.a);
+if (lum > threshold && cR.a > 0.0) {
+color = vec4f(cR.rgb * scale, cR.a);
 } else {
 
-color = vec4f(vec3(0.0), dk.a);
+color = vec4f(vec3(0.0), cR.a);
 }
 output.color = color;
 `;
 export const bloomDownDefine = /* wgsl */ `
-fn xP(c: vec3f) -> f32 {
+fn yo(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 xT = array<f32, 9>(0.07, 0.09, 0.12, 0.14, 0.16, 0.14, 0.12, 0.09, 0.07);
+const yu = 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 xG = vec2f(colorTexRegion());
-let off = direction / xG * size;
+let yh = vec2f(colorTexRegion());
+let off = direction / yh * size;
 
 var sum = vec4f(0.0);
-var uE = 0.0;
+var uI = 0.0;
 for (var i = 0; i < 9; i++) {
-let w = xT[i];
+let w = yu[i];
 sum += sample_colorTex_linearSampler(uv2 + off * f32(i - 4)) * w;
-uE += w;
+uI += w;
 }
-output.color = sum / max(uE, 0.01);
+output.color = sum / max(uI, 0.01);
 `;
 export const bloomBlendMain = /* wgsl */ `
-let xQ = sample_colorTex1_linearSampler(uv2);
-let xR = sample_colorTex2_linearSampler(uv2);
-output.color = mix(xQ, xR, weight);
+let yq = sample_colorTex1_linearSampler(uv2);
+let yr = sample_colorTex2_linearSampler(uv2);
+output.color = mix(yq, yr, weight);
 `;
 export const BLOOM_LEVELS = 6;
 export function bloomBlurSize(radius) {

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

@@ -0,0 +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 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";