@meimu/mutracer 0.3.0 → 0.3.1

package/lib/renderer/wgsl/customDenoise.wgsl.js

@@ -5,19 +5,19 @@ let filtered = load_filteredTex(uv, 0).rgb;
 let foreground = load_foregroundTex(uv, 0);
 let background = load_backgroundTex(uv, 0);
 
-var mS = foreground;
-var mR = background;
+var nU = foreground;
+var nT = background;
 if (any(filtered != original)) {
-let wu = abs(original) > vec3f(0.000001);
-let ah = select(vec3f(1.0), original, wu);
-let scale = select(vec3f(1.0), filtered / ah, wu);
-let vO = select(filtered - original, vec3f(0.0), wu);
-mS = vec4f(foreground.rgb * scale + vO, foreground.a);
+let yr = abs(original) > vec3f(0.000001);
+let ah = select(vec3f(1.0), original, yr);
+let scale = select(vec3f(1.0), filtered / ah, yr);
+let xI = select(filtered - original, vec3f(0.0), yr);
+nU = vec4f(foreground.rgb * scale + xI, foreground.a);
 
-mR = vec4f(background.rgb * scale + vO * background.a, background.a);
+nT = vec4f(background.rgb * scale + xI * background.a, background.a);
 }
-output.foreground = mS;
-output.background = mR;
+output.foreground = nU;
+output.background = nT;
 `;
 /** Custom output alpha is ignored; retain the input composition's coverage. */
 export const customDenoiseCoverageMain = /* wgsl */ `

package/lib/renderer/wgsl/depthQuery.wgsl.d.ts

@@ -1,3 +1,3 @@
 /** Extra entry point in the ray-tracing module; reuses its scene bindings. */
-declare const _default: "\n@group(3) @binding(4) var<uniform> depthArea: vec4f;\n\n@compute @workgroup_size(7, 7)\nfn depthQuery(@builtin(global_invocation_id) id: vec3u) {\n  let index = id.x + id.y * 7u;\n  let offset = vec2f(id.xy) / 6.0 * 2.0 - 1.0;\n  let uv = depthArea.xy + depthArea.zw * offset * vec2f(1.0, -1.0);\n  outColor[index] = vec4f(0.0);\n  if (any(uv < vec2f(0.0)) || any(uv > vec2f(1.0))) { return; }\n  var ray = initCameraRay(uv);\n  let eye = cameraUniform.viewInv[3].xyz;\n  let forward = -normalize(cameraUniform.viewInv[2].xyz);\n  var si: SurfaceInteraction;\n  si.triangleIndex = -1;\n  // Ignore invisible catchers and alpha-cutout holes, without stochastic DOF\n  // or pixel jitter. A bounded continuation prevents coincident surfaces\n  // from keeping the query alive indefinitely.\n  for (var layer = 0; layer < 32; layer++) {\n    intersectScene(ray, &si, 0, false, false);\n    if (!si.hit) { return; }\n    var material: OpenPbrResolvedMaterial;\n    getMaterial(&material, si.materialIndex, si.uv, si.uv1, si.instanceIndex, si.vertexColor);\n    if (material.materialType != SHADOW_CATCHER && material.alpha > 0.0) {\n      outColor[index] = vec4f(max(dot(si.position - eye, forward), 0.0), 0.0, 0.0, 0.0);\n      return;\n    }\n    ray.o = si.position + ray.d * (EPS * 0.02);\n  }\n}\n";
+declare const _default: "\n@group(3) @binding(4) var<uniform> depthArea: vec4f;\n\n@compute @workgroup_size(7, 7)\nfn depthQuery(@builtin(global_invocation_id) id: vec3u) {\n  let index = id.x + id.y * 7u;\n  let picking = depthArea.z < 0.0;\n  if (picking && index != 0u) {return;}\n  let offset = vec2f(id.xy) / 6.0 * 2.0 - 1.0;\n  let uv = select(depthArea.xy + depthArea.zw * offset * vec2f(1.0, -1.0), depthArea.xy, picking);\n  outColor[index] = vec4f(0.0);\n  if (any(uv < vec2f(0.0)) || any(uv > vec2f(1.0))) { return; }\n  var ray = initCameraRay(uv);\n  let eye = cameraUniform.viewInv[3].xyz;\n  let forward = -normalize(cameraUniform.viewInv[2].xyz);\n  var si: SurfaceInteraction;\n  si.triangleIndex = -1;\n  // Ignore invisible catchers and alpha-cutout holes, without stochastic DOF\n  // or pixel jitter. A bounded continuation prevents coincident surfaces\n  // from keeping the query alive indefinitely.\n  for (var layer = 0; layer < 32; layer++) {\n    intersectScene(ray, &si, 0, false, false);\n    if (!si.hit) { return; }\n    var material: OpenPbrResolvedMaterial;\n    getMaterial(&material, si.materialIndex, si.uv, si.uv1, si.instanceIndex, si.vertexColor);\n    if (material.materialType != SHADOW_CATCHER && material.alpha > 0.0) {\n      if (picking) {\n        let instance = u32(si.instanceIndex) + 1u;\n        let materialIndex = u32(si.materialIndex) + 1u;\n        outColor[index] = vec4f(f32(instance & 65535u), f32(instance >> 16u),\n          f32(materialIndex & 65535u), f32(materialIndex >> 16u));\n      } else {\n        outColor[index] = vec4f(max(dot(si.position - eye, forward), 0.0), 0.0, 0.0, 0.0);\n      }\n      return;\n    }\n    ray.o = si.position + ray.d * (EPS * 0.02);\n  }\n}\n";
 export default _default;

package/lib/renderer/wgsl/depthQuery.wgsl.js

@@ -6,11 +6,13 @@ export default /* wgsl */ `
 @compute @workgroup_size(${DEPTH_SAMPLE_GRID}, ${DEPTH_SAMPLE_GRID})
 fn depthQuery(@builtin(global_invocation_id) id: vec3u) {
 let index = id.x + id.y * ${DEPTH_SAMPLE_GRID}u;
+let picking = depthArea.z < 0.0;
+if (picking && index != 0u) {return;}
 let offset = vec2f(id.xy) / ${DEPTH_SAMPLE_GRID - 1}.0 * 2.0 - 1.0;
-let uv = depthArea.xy + depthArea.zw * offset * vec2f(1.0, -1.0);
+let uv = select(depthArea.xy + depthArea.zw * offset * vec2f(1.0, -1.0), depthArea.xy, picking);
 outColor[index] = vec4f(0.0);
 if (any(uv < vec2f(0.0)) || any(uv > vec2f(1.0))) { return; }
-var ray = eT(uv);
+var ray = cV(uv);
 let eye = cameraUniform.viewInv[3].xyz;
 let forward = -normalize(cameraUniform.viewInv[2].xyz);
 var si: SurfaceInteraction;
@@ -24,7 +26,14 @@ if (!si.hit) { return; }
 var material: OpenPbrResolvedMaterial;
 getMaterial(&material, si.materialIndex, si.uv, si.uv1, si.instanceIndex, si.vertexColor);
 if (material.materialType != SHADOW_CATCHER && material.alpha > 0.0) {
+if (picking) {
+let instance = u32(si.instanceIndex) + 1u;
+let materialIndex = u32(si.materialIndex) + 1u;
+outColor[index] = vec4f(f32(instance & 65535u), f32(instance >> 16u),
+f32(materialIndex & 65535u), f32(materialIndex >> 16u));
+} else {
 outColor[index] = vec4f(max(dot(si.position - eye, forward), 0.0), 0.0, 0.0, 0.0);
+}
 return;
 }
 ray.o = si.position + ray.d * (EPS * 0.02);

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

@@ -1 +1 @@
-{"version":3,"file":"depthQuery.wgsl.js","sourceRoot":"","sources":["../../../src/renderer/wgsl/depthQuery.wgsl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAErD,8EAA8E;AAC9E,eAAe,UAAU,CAAC;;;2BAGC,iBAAiB,KAAK,iBAAiB;;4BAEpC,iBAAiB;8BACf,iBAAiB,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;CAwBpD,CAAC","sourcesContent":["import { DEPTH_SAMPLE_GRID } from '../depthQuery.js';\n\n/** Extra entry point in the ray-tracing module; reuses its scene bindings. */\nexport default /* wgsl */ `\n@group(3) @binding(4) var<uniform> depthArea: vec4f;\n\n@compute @workgroup_size(${DEPTH_SAMPLE_GRID}, ${DEPTH_SAMPLE_GRID})\nfn depthQuery(@builtin(global_invocation_id) id: vec3u) {\n  let index = id.x + id.y * ${DEPTH_SAMPLE_GRID}u;\n  let offset = vec2f(id.xy) / ${DEPTH_SAMPLE_GRID - 1}.0 * 2.0 - 1.0;\n  let uv = depthArea.xy + depthArea.zw * offset * vec2f(1.0, -1.0);\n  outColor[index] = vec4f(0.0);\n  if (any(uv < vec2f(0.0)) || any(uv > vec2f(1.0))) { return; }\n  var ray = initCameraRay(uv);\n  let eye = cameraUniform.viewInv[3].xyz;\n  let forward = -normalize(cameraUniform.viewInv[2].xyz);\n  var si: SurfaceInteraction;\n  si.triangleIndex = -1;\n  // Ignore invisible catchers and alpha-cutout holes, without stochastic DOF\n  // or pixel jitter. A bounded continuation prevents coincident surfaces\n  // from keeping the query alive indefinitely.\n  for (var layer = 0; layer < 32; layer++) {\n    intersectScene(ray, &si, 0, false, false);\n    if (!si.hit) { return; }\n    var material: OpenPbrResolvedMaterial;\n    getMaterial(&material, si.materialIndex, si.uv, si.uv1, si.instanceIndex, si.vertexColor);\n    if (material.materialType != SHADOW_CATCHER && material.alpha > 0.0) {\n      outColor[index] = vec4f(max(dot(si.position - eye, forward), 0.0), 0.0, 0.0, 0.0);\n      return;\n    }\n    ray.o = si.position + ray.d * (EPS * 0.02);\n  }\n}\n`;\n"]}
+{"version":3,"file":"depthQuery.wgsl.js","sourceRoot":"","sources":["../../../src/renderer/wgsl/depthQuery.wgsl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAErD,8EAA8E;AAC9E,eAAe,UAAU,CAAC;;;2BAGC,iBAAiB,KAAK,iBAAiB;;4BAEpC,iBAAiB;;;8BAGf,iBAAiB,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BpD,CAAC","sourcesContent":["import { DEPTH_SAMPLE_GRID } from '../depthQuery.js';\n\n/** Extra entry point in the ray-tracing module; reuses its scene bindings. */\nexport default /* wgsl */ `\n@group(3) @binding(4) var<uniform> depthArea: vec4f;\n\n@compute @workgroup_size(${DEPTH_SAMPLE_GRID}, ${DEPTH_SAMPLE_GRID})\nfn depthQuery(@builtin(global_invocation_id) id: vec3u) {\n  let index = id.x + id.y * ${DEPTH_SAMPLE_GRID}u;\n  let picking = depthArea.z < 0.0;\n  if (picking && index != 0u) {return;}\n  let offset = vec2f(id.xy) / ${DEPTH_SAMPLE_GRID - 1}.0 * 2.0 - 1.0;\n  let uv = select(depthArea.xy + depthArea.zw * offset * vec2f(1.0, -1.0), depthArea.xy, picking);\n  outColor[index] = vec4f(0.0);\n  if (any(uv < vec2f(0.0)) || any(uv > vec2f(1.0))) { return; }\n  var ray = initCameraRay(uv);\n  let eye = cameraUniform.viewInv[3].xyz;\n  let forward = -normalize(cameraUniform.viewInv[2].xyz);\n  var si: SurfaceInteraction;\n  si.triangleIndex = -1;\n  // Ignore invisible catchers and alpha-cutout holes, without stochastic DOF\n  // or pixel jitter. A bounded continuation prevents coincident surfaces\n  // from keeping the query alive indefinitely.\n  for (var layer = 0; layer < 32; layer++) {\n    intersectScene(ray, &si, 0, false, false);\n    if (!si.hit) { return; }\n    var material: OpenPbrResolvedMaterial;\n    getMaterial(&material, si.materialIndex, si.uv, si.uv1, si.instanceIndex, si.vertexColor);\n    if (material.materialType != SHADOW_CATCHER && material.alpha > 0.0) {\n      if (picking) {\n        let instance = u32(si.instanceIndex) + 1u;\n        let materialIndex = u32(si.materialIndex) + 1u;\n        outColor[index] = vec4f(f32(instance & 65535u), f32(instance >> 16u),\n          f32(materialIndex & 65535u), f32(materialIndex >> 16u));\n      } else {\n        outColor[index] = vec4f(max(dot(si.position - eye, forward), 0.0), 0.0, 0.0, 0.0);\n      }\n      return;\n    }\n    ray.o = si.position + ray.d * (EPS * 0.02);\n  }\n}\n`;\n"]}

package/lib/renderer/wgsl/easu.wgsl.d.ts

@@ -0,0 +1,2 @@
+export declare const easuShader = "\n@group(0) @binding(0) var colorImage: texture_2d<f32>;\n@group(0) @binding(1) var<uniform> outputSize: vec4f;\n@vertex fn vertex(@builtin(vertex_index) index: u32) -> @builtin(position) vec4f {\n  let p = vec2f(f32((index << 1u) & 2u), f32(index & 2u));\n  return vec4f(p * 2.0 - 1.0, 0.0, 1.0);\n}\nconst offsets = array<vec2i,12>(vec2i(0,-1),vec2i(1,-1),vec2i(-1,0),vec2i(0,0),vec2i(1,0),vec2i(2,0),\n  vec2i(-1,1),vec2i(0,1),vec2i(1,1),vec2i(2,1),vec2i(0,2),vec2i(1,2));\nfn loadColor(p: vec2i) -> vec4f {return textureLoad(colorImage, clamp(p,vec2i(0),vec2i(textureDimensions(colorImage))-1),0);}\nfn gradient(a: f32,b: f32,c: f32,d: f32,e: f32,w: f32) -> vec3f {\n  let direction = vec2f(d-b,e-a);\n  let length = clamp(abs(direction)/max(vec2f(max(abs(d-c),abs(c-b)),max(abs(e-c),abs(c-a))),vec2f(1e-8)),vec2f(0),vec2f(1));\n  return vec3f(direction,dot(length,length))*w;\n}\nfn easuWeight(offset: vec2f, direction: vec2f, length: vec2f, lobe: f32) -> f32 {\n  let v = vec2f(dot(offset,direction),dot(offset,vec2f(-direction.y,direction.x)))*length;\n  let distance = min(dot(v,v),1.0/lobe);\n  let b = 0.4*distance-1.0;\n  let a = lobe*distance-1.0;\n  return (1.5625*b*b-0.5625)*a*a;\n}\n@fragment fn fragment(@builtin(position) position: vec4f) -> @location(0) vec4f {\n  let point = position.xy*vec2f(textureDimensions(colorImage))/outputSize.xy-0.5;\n  let base = vec2i(floor(point)); let phase = fract(point);\n  var colors: array<vec4f,12>;\n  var luma: array<f32,12>;\n  // FSR expects [0,1]. Normalize the neighborhood for direction estimation\n  // in extended-range output; filter the original RGB without clipping it to 1.\n  var range = 1.0;\n  for(var i=0u;i<12u;i++){colors[i]=loadColor(base+offsets[i]);range=max(range,max(max(colors[i].r,colors[i].g),colors[i].b));}\n  for(var i=0u;i<12u;i++){luma[i]=dot(colors[i].rgb/range,vec3f(0.5,1.0,0.5));}\n  let g = gradient(luma[0],luma[2],luma[3],luma[4],luma[7],(1.0-phase.x)*(1.0-phase.y))+\n    gradient(luma[1],luma[3],luma[4],luma[5],luma[8],phase.x*(1.0-phase.y))+\n    gradient(luma[3],luma[6],luma[7],luma[8],luma[10],(1.0-phase.x)*phase.y)+\n    gradient(luma[4],luma[7],luma[8],luma[9],luma[11],phase.x*phase.y);\n  var direction = vec2f(1.0,0.0);\n  if(dot(g.xy,g.xy)>=1.0/32768.0){direction=normalize(g.xy);}\n  let edge = (g.z*0.5)*(g.z*0.5);\n  let stretch = dot(direction,direction)/max(abs(direction.x),abs(direction.y));\n  let length = vec2f(1.0+(stretch-1.0)*edge,1.0-0.5*edge);\n  let lobe = 0.5+(0.21-0.5)*edge;\n  var result=vec4f(0); var total=0.0;\n  for(var i=0u;i<12u;i++){\n    let weight=easuWeight(vec2f(offsets[i])-phase,direction,length,lobe);\n    result+=colors[i]*weight;total+=weight;\n  }\n  let lower=min(min(colors[3],colors[4]),min(colors[7],colors[8]));\n  let upper=max(max(colors[3],colors[4]),max(colors[7],colors[8]));\n  return clamp(result/total,lower,upper);\n}\n";
+export declare const areaDownsampleShader = "\n@group(0) @binding(0) var colorImage: texture_2d<f32>;\n@group(0) @binding(1) var<uniform> outputSize: vec4f;\n@vertex fn vertex(@builtin(vertex_index) index: u32) -> @builtin(position) vec4f {\n  let p = vec2f(f32((index << 1u) & 2u), f32(index & 2u));\n  return vec4f(p * 2.0 - 1.0, 0.0, 1.0);\n}\n@fragment fn fragment(@builtin(position) position: vec4f) -> @location(0) vec4f {\n  let scale = vec2f(textureDimensions(colorImage))/outputSize.xy;\n  let start = floor(position.xy)*scale; let end = start+scale;\n  var sum = vec4f(0);\n  for (var y = i32(floor(start.y)); y < i32(ceil(end.y)); y++) {\n    for (var x = i32(floor(start.x)); x < i32(ceil(end.x)); x++) {\n      let overlap = max(vec2f(0), min(vec2f(vec2i(x+1,y+1)), end)-max(vec2f(vec2i(x,y)), start));\n      let color = textureLoad(colorImage, vec2i(x,y), 0);\n      sum += vec4f(color.rgb*color.a, color.a)*overlap.x*overlap.y;\n    }\n  }\n  return vec4f(sum.rgb/max(sum.a, 1e-8), sum.a/(scale.x*scale.y));\n}\n";

package/lib/renderer/wgsl/easu.wgsl.js

@@ -0,0 +1,80 @@
+// Adapted from AMD FidelityFX FSR 1, ffx_fsr1.h v1.20210629,
+// FsrEasuSetF/FsrEasuTapF/FsrEasuF (32-bit path). MIT; see LICENSES/FidelityFX-FSR.txt.
+// https://github.com/GPUOpen-Effects/FidelityFX-FSR/blob/master/ffx-fsr/ffx_fsr1.h
+// Uses exact reciprocals instead of the reference's low precision approximations.
+export const easuShader = /* wgsl */ `
+@group(0) @binding(0) var colorImage: texture_2d<f32>;
+@group(0) @binding(1) var<uniform> outputSize: vec4f;
+@vertex fn vertex(@builtin(vertex_index) index: u32) -> @builtin(position) vec4f {
+let p = vec2f(f32((index << 1u) & 2u), f32(index & 2u));
+return vec4f(p * 2.0 - 1.0, 0.0, 1.0);
+}
+const offsets = array<vec2i,12>(vec2i(0,-1),vec2i(1,-1),vec2i(-1,0),vec2i(0,0),vec2i(1,0),vec2i(2,0),
+vec2i(-1,1),vec2i(0,1),vec2i(1,1),vec2i(2,1),vec2i(0,2),vec2i(1,2));
+fn ns(p: vec2i) -> vec4f {return textureLoad(colorImage, clamp(p,vec2i(0),vec2i(textureDimensions(colorImage))-1),0);}
+fn tB(a: f32,b: f32,c: f32,d: f32,e: f32,w: f32) -> vec3f {
+let direction = vec2f(d-b,e-a);
+let length = clamp(abs(direction)/max(vec2f(max(abs(d-c),abs(c-b)),max(abs(e-c),abs(c-a))),vec2f(1e-8)),vec2f(0),vec2f(1));
+return vec3f(direction,dot(length,length))*w;
+}
+fn sJ(offset: vec2f, direction: vec2f, length: vec2f, lobe: f32) -> f32 {
+let v = vec2f(dot(offset,direction),dot(offset,vec2f(-direction.y,direction.x)))*length;
+let distance = min(dot(v,v),1.0/lobe);
+let b = 0.4*distance-1.0;
+let a = lobe*distance-1.0;
+return (1.5625*b*b-0.5625)*a*a;
+}
+@fragment fn fragment(@builtin(position) position: vec4f) -> @location(0) vec4f {
+let point = position.xy*vec2f(textureDimensions(colorImage))/outputSize.xy-0.5;
+let base = vec2i(floor(point)); let phase = fract(point);
+var colors: array<vec4f,12>;
+var lQ: array<f32,12>;
+
+
+var range = 1.0;
+for(var i=0u;i<12u;i++){colors[i]=ns(base+offsets[i]);range=max(range,max(max(colors[i].r,colors[i].g),colors[i].b));}
+for(var i=0u;i<12u;i++){lQ[i]=dot(colors[i].rgb/range,vec3f(0.5,1.0,0.5));}
+let g = tB(lQ[0],lQ[2],lQ[3],lQ[4],lQ[7],(1.0-phase.x)*(1.0-phase.y))+
+tB(lQ[1],lQ[3],lQ[4],lQ[5],lQ[8],phase.x*(1.0-phase.y))+
+tB(lQ[3],lQ[6],lQ[7],lQ[8],lQ[10],(1.0-phase.x)*phase.y)+
+tB(lQ[4],lQ[7],lQ[8],lQ[9],lQ[11],phase.x*phase.y);
+var direction = vec2f(1.0,0.0);
+if(dot(g.xy,g.xy)>=1.0/32768.0){direction=normalize(g.xy);}
+let edge = (g.z*0.5)*(g.z*0.5);
+let qD = dot(direction,direction)/max(abs(direction.x),abs(direction.y));
+let length = vec2f(1.0+(qD-1.0)*edge,1.0-0.5*edge);
+let lobe = 0.5+(0.21-0.5)*edge;
+var result=vec4f(0); var total=0.0;
+for(var i=0u;i<12u;i++){
+let weight=sJ(vec2f(offsets[i])-phase,direction,length,lobe);
+result+=colors[i]*weight;total+=weight;
+}
+let lower=min(min(colors[3],colors[4]),min(colors[7],colors[8]));
+let upper=max(max(colors[3],colors[4]),max(colors[7],colors[8]));
+return clamp(result/total,lower,upper);
+}
+`;
+// Not part of FSR: exact area average for inputs larger than the output,
+// alpha-weighted so transparent texels do not darken coverage edges.
+export const areaDownsampleShader = /* wgsl */ `
+@group(0) @binding(0) var colorImage: texture_2d<f32>;
+@group(0) @binding(1) var<uniform> outputSize: vec4f;
+@vertex fn vertex(@builtin(vertex_index) index: u32) -> @builtin(position) vec4f {
+let p = vec2f(f32((index << 1u) & 2u), f32(index & 2u));
+return vec4f(p * 2.0 - 1.0, 0.0, 1.0);
+}
+@fragment fn fragment(@builtin(position) position: vec4f) -> @location(0) vec4f {
+let scale = vec2f(textureDimensions(colorImage))/outputSize.xy;
+let start = floor(position.xy)*scale; let end = start+scale;
+var sum = vec4f(0);
+for (var y = i32(floor(start.y)); y < i32(ceil(end.y)); y++) {
+for (var x = i32(floor(start.x)); x < i32(ceil(end.x)); x++) {
+let tK = max(vec2f(0), min(vec2f(vec2i(x+1,y+1)), end)-max(vec2f(vec2i(x,y)), start));
+let color = textureLoad(colorImage, vec2i(x,y), 0);
+sum += vec4f(color.rgb*color.a, color.a)*tK.x*tK.y;
+}
+}
+return vec4f(sum.rgb/max(sum.a, 1e-8), sum.a/(scale.x*scale.y));
+}
+`;
+//# sourceMappingURL=easu.wgsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"easu.wgsl.js","sourceRoot":"","sources":["../../../src/renderer/wgsl/easu.wgsl.ts"],"names":[],"mappings":"AAAA,6DAA6D;AAC7D,wFAAwF;AACxF,mFAAmF;AACnF,kFAAkF;AAClF,MAAM,CAAC,MAAM,UAAU,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmDpC,CAAC;AAEF,yEAAyE;AACzE,qEAAqE;AACrE,MAAM,CAAC,MAAM,oBAAoB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;CAoB9C,CAAC","sourcesContent":["// Adapted from AMD FidelityFX FSR 1, ffx_fsr1.h v1.20210629,\n// FsrEasuSetF/FsrEasuTapF/FsrEasuF (32-bit path). MIT; see LICENSES/FidelityFX-FSR.txt.\n// https://github.com/GPUOpen-Effects/FidelityFX-FSR/blob/master/ffx-fsr/ffx_fsr1.h\n// Uses exact reciprocals instead of the reference's low precision approximations.\nexport const easuShader = /* wgsl */ `\n@group(0) @binding(0) var colorImage: texture_2d<f32>;\n@group(0) @binding(1) var<uniform> outputSize: vec4f;\n@vertex fn vertex(@builtin(vertex_index) index: u32) -> @builtin(position) vec4f {\n  let p = vec2f(f32((index << 1u) & 2u), f32(index & 2u));\n  return vec4f(p * 2.0 - 1.0, 0.0, 1.0);\n}\nconst offsets = array<vec2i,12>(vec2i(0,-1),vec2i(1,-1),vec2i(-1,0),vec2i(0,0),vec2i(1,0),vec2i(2,0),\n  vec2i(-1,1),vec2i(0,1),vec2i(1,1),vec2i(2,1),vec2i(0,2),vec2i(1,2));\nfn loadColor(p: vec2i) -> vec4f {return textureLoad(colorImage, clamp(p,vec2i(0),vec2i(textureDimensions(colorImage))-1),0);}\nfn gradient(a: f32,b: f32,c: f32,d: f32,e: f32,w: f32) -> vec3f {\n  let direction = vec2f(d-b,e-a);\n  let length = clamp(abs(direction)/max(vec2f(max(abs(d-c),abs(c-b)),max(abs(e-c),abs(c-a))),vec2f(1e-8)),vec2f(0),vec2f(1));\n  return vec3f(direction,dot(length,length))*w;\n}\nfn easuWeight(offset: vec2f, direction: vec2f, length: vec2f, lobe: f32) -> f32 {\n  let v = vec2f(dot(offset,direction),dot(offset,vec2f(-direction.y,direction.x)))*length;\n  let distance = min(dot(v,v),1.0/lobe);\n  let b = 0.4*distance-1.0;\n  let a = lobe*distance-1.0;\n  return (1.5625*b*b-0.5625)*a*a;\n}\n@fragment fn fragment(@builtin(position) position: vec4f) -> @location(0) vec4f {\n  let point = position.xy*vec2f(textureDimensions(colorImage))/outputSize.xy-0.5;\n  let base = vec2i(floor(point)); let phase = fract(point);\n  var colors: array<vec4f,12>;\n  var luma: array<f32,12>;\n  // FSR expects [0,1]. Normalize the neighborhood for direction estimation\n  // in extended-range output; filter the original RGB without clipping it to 1.\n  var range = 1.0;\n  for(var i=0u;i<12u;i++){colors[i]=loadColor(base+offsets[i]);range=max(range,max(max(colors[i].r,colors[i].g),colors[i].b));}\n  for(var i=0u;i<12u;i++){luma[i]=dot(colors[i].rgb/range,vec3f(0.5,1.0,0.5));}\n  let g = gradient(luma[0],luma[2],luma[3],luma[4],luma[7],(1.0-phase.x)*(1.0-phase.y))+\n    gradient(luma[1],luma[3],luma[4],luma[5],luma[8],phase.x*(1.0-phase.y))+\n    gradient(luma[3],luma[6],luma[7],luma[8],luma[10],(1.0-phase.x)*phase.y)+\n    gradient(luma[4],luma[7],luma[8],luma[9],luma[11],phase.x*phase.y);\n  var direction = vec2f(1.0,0.0);\n  if(dot(g.xy,g.xy)>=1.0/32768.0){direction=normalize(g.xy);}\n  let edge = (g.z*0.5)*(g.z*0.5);\n  let stretch = dot(direction,direction)/max(abs(direction.x),abs(direction.y));\n  let length = vec2f(1.0+(stretch-1.0)*edge,1.0-0.5*edge);\n  let lobe = 0.5+(0.21-0.5)*edge;\n  var result=vec4f(0); var total=0.0;\n  for(var i=0u;i<12u;i++){\n    let weight=easuWeight(vec2f(offsets[i])-phase,direction,length,lobe);\n    result+=colors[i]*weight;total+=weight;\n  }\n  let lower=min(min(colors[3],colors[4]),min(colors[7],colors[8]));\n  let upper=max(max(colors[3],colors[4]),max(colors[7],colors[8]));\n  return clamp(result/total,lower,upper);\n}\n`;\n\n// Not part of FSR: exact area average for inputs larger than the output,\n// alpha-weighted so transparent texels do not darken coverage edges.\nexport const areaDownsampleShader = /* wgsl */ `\n@group(0) @binding(0) var colorImage: texture_2d<f32>;\n@group(0) @binding(1) var<uniform> outputSize: vec4f;\n@vertex fn vertex(@builtin(vertex_index) index: u32) -> @builtin(position) vec4f {\n  let p = vec2f(f32((index << 1u) & 2u), f32(index & 2u));\n  return vec4f(p * 2.0 - 1.0, 0.0, 1.0);\n}\n@fragment fn fragment(@builtin(position) position: vec4f) -> @location(0) vec4f {\n  let scale = vec2f(textureDimensions(colorImage))/outputSize.xy;\n  let start = floor(position.xy)*scale; let end = start+scale;\n  var sum = vec4f(0);\n  for (var y = i32(floor(start.y)); y < i32(ceil(end.y)); y++) {\n    for (var x = i32(floor(start.x)); x < i32(ceil(end.x)); x++) {\n      let overlap = max(vec2f(0), min(vec2f(vec2i(x+1,y+1)), end)-max(vec2f(vec2i(x,y)), start));\n      let color = textureLoad(colorImage, vec2i(x,y), 0);\n      sum += vec4f(color.rgb*color.a, color.a)*overlap.x*overlap.y;\n    }\n  }\n  return vec4f(sum.rgb/max(sum.a, 1e-8), sum.a/(scale.x*scale.y));\n}\n`;\n"]}

package/lib/renderer/wgsl/easuDetail.wgsl.d.ts

@@ -0,0 +1,21 @@
+/** Scene-linear log2 range covered by the tone lookup table. */
+export declare const TONE_LUT_LOG2: readonly [-24, 24];
+export declare const TONE_LUT_SIZE = 1024;
+/** Detail compensation defaults and fixed regularizers shared by the Web and native passes. */
+export declare const EASU_DETAIL: {
+    ratioRange: readonly [0.7, 1.43];
+    depthThreshold: number;
+    coverageThreshold: number;
+    minimumAlbedo: number;
+    depthTolerance: number;
+    guidedEpsilon: number;
+};
+/**
+ * guided: scale only the albedo-correlated part of local scene-linear radiance (default);
+ * separate: lobe-share approximation; silhouettes: depth-guided edge reconstruction.
+ * The last two are retained for comparisons.
+ */
+export declare function easuDetailShader(separate?: boolean, silhouettes?: boolean, guided?: boolean): string;
+export declare const albedoDownsampleShader: (depthOutput?: boolean) => string;
+export declare const toneLutShader: string;
+export declare const guidedCoefficientShader: string;

package/lib/renderer/wgsl/easuDetail.wgsl.js

@@ -0,0 +1,230 @@
+import { easuShader } from './easu.wgsl.js';
+import { composeDefine } from './compose.frag.wgsl.js';
+/** Scene-linear log2 range covered by the tone lookup table. */
+export const TONE_LUT_LOG2 = [-24, 24];
+export const TONE_LUT_SIZE = 1024;
+/** Detail compensation defaults and fixed regularizers shared by the Web and native passes. */
+export const EASU_DETAIL = {
+    ratioRange: [0.7, 1.43], depthThreshold: 0.02, coverageThreshold: 0.95,
+    // Albedo below this is treated as black; relative depth tolerance floor.
+    minimumAlbedo: 1e-3, depthTolerance: 1e-4,
+    // Regularizes the local albedo variance of the albedo-radiance fit, in squared albedo units.
+    guidedEpsilon: 1e-4,
+};
+// Tone table lookups and display encoding shared by the detail passes; tone.x is the maximum display value.
+const toneCodingDefine = /* wgsl */ `
+
+
+@group(0) @binding(8) var toneLut: texture_2d<f32>;
+@group(0) @binding(9) var<uniform> tone: vec4f;
+fn vZ(row: i32, u: vec3f) -> vec3f {
+let last=f32(textureDimensions(toneLut).x-1u);let p=clamp(u,vec3f(0),vec3f(1))*last;
+let i=vec3i(floor(p));let j=min(i+1,vec3i(i32(last)));let f=p-floor(p);
+var result=vec3f(0);
+for(var c=0;c<3;c++){result[c]=mix(textureLoad(toneLut,vec2i(i[c],row),0)[c],textureLoad(toneLut,vec2i(j[c],row),0)[c],f[c]);}
+return result;
+}
+fn uM(AK: vec3f) -> vec3f {return vZ(0,(AK-(${TONE_LUT_LOG2[0]}.0))/${TONE_LUT_LOG2[1] - TONE_LUT_LOG2[0]}.0);}
+fn uN(d: vec3f) -> vec3f {return vZ(1,sqrt(max(d,vec3f(0))/tone.x));}
+
+
+
+
+fn zk(d: vec3f, fw: vec3f) -> vec3f {
+let x=uN(d);
+let changed=max(d+uM(x+log2(max(fw,vec3f(1e-6))))-uM(x),vec3f(0));
+return select(changed,d,abs(fw-vec3f(1))<vec3f(1e-4));
+}
+fn pS(c: vec3f) -> vec3f {
+let a=max(c,vec3f(0));
+return select(pow((a+0.055)/1.055,vec3f(2.4)),a/12.92,a<=vec3f(0.04045));
+}
+fn tp(c: vec3f) -> vec3f {
+let a=max(c,vec3f(0));
+return select(1.055*pow(a,vec3f(1.0/2.4))-0.055,a*12.92,a<=vec3f(0.0031308));
+}
+`;
+/**
+ * guided: scale only the albedo-correlated part of local scene-linear radiance (default);
+ * separate: lobe-share approximation; silhouettes: depth-guided edge reconstruction.
+ * The last two are retained for comparisons.
+ */
+export function easuDetailShader(separate = false, silhouettes = false, guided = true) {
+    return easuShader.replace(`@vertex fn vertex`, /* wgsl */ `
+@group(0) @binding(2) var diffuseHi: texture_2d<f32>;
+@group(0) @binding(3) var specularHi: texture_2d<f32>;
+@group(0) @binding(4) var depthHi: texture_2d<f32>;
+@group(0) @binding(5) var diffuseLo: texture_2d<f32>;
+@group(0) @binding(6) var specularLo: texture_2d<f32>;
+@group(0) @binding(7) var<uniform> detail: vec4f;
+${silhouettes ? '@group(0) @binding(10) var depthLo: texture_2d<f32>;' : ''}
+${guided ? '@group(0) @binding(11) var slopeLo: texture_2d<f32>;\n@group(0) @binding(12) var offsetLo: texture_2d<f32>;' : ''}
+fn cY(image: texture_2d<f32>, p: vec2i) -> vec4f {
+return textureLoad(image,clamp(p,vec2i(0),vec2i(textureDimensions(image))-1),0);
+}
+${toneCodingDefine}
+@vertex fn vertex`).replace(`return clamp(result/total,lower,upper);`, /* wgsl */ `
+let color=clamp(result/total,lower,upper);
+var diffuse=vec4f(0);var specular=vec4f(0);
+for(var i=0u;i<12u;i++){
+
+let weight=sJ(vec2f(offsets[i])-phase,direction,length,lobe);
+diffuse+=cY(diffuseLo,base+offsets[i])*weight;
+specular+=cY(specularLo,base+offsets[i])*weight;
+}
+let dlo=min(min(cY(diffuseLo,base),cY(diffuseLo,base+vec2i(1,0))),min(cY(diffuseLo,base+vec2i(0,1)),cY(diffuseLo,base+vec2i(1,1))));
+let dhi=max(max(cY(diffuseLo,base),cY(diffuseLo,base+vec2i(1,0))),max(cY(diffuseLo,base+vec2i(0,1)),cY(diffuseLo,base+vec2i(1,1))));
+let slo=min(min(cY(specularLo,base),cY(specularLo,base+vec2i(1,0))),min(cY(specularLo,base+vec2i(0,1)),cY(specularLo,base+vec2i(1,1))));
+let shi=max(max(cY(specularLo,base),cY(specularLo,base+vec2i(1,0))),max(cY(specularLo,base+vec2i(0,1)),cY(specularLo,base+vec2i(1,1))));
+diffuse=clamp(diffuse/total,dlo,dhi);specular=clamp(specular/total,slo,shi);
+${guided ? `var slope=vec4f(0);var pn=vec4f(0);
+for(var i=0u;i<12u;i++){
+let weight=sJ(vec2f(offsets[i])-phase,direction,length,lobe);
+slope+=cY(slopeLo,base+offsets[i])*weight;pn+=cY(offsetLo,base+offsets[i])*weight;
+}
+var qk=cY(slopeLo,base);var te=qk;var kI=cY(offsetLo,base);var ow=kI;
+for(var k=1;k<4;k++){
+let q=base+vec2i(k&1,k>>1u);let a=cY(slopeLo,q);let b=cY(offsetLo,q);
+qk=min(qk,a);te=max(te,a);kI=min(kI,b);ow=max(ow,b);
+}
+slope=clamp(slope/total,qk,te);pn=clamp(pn/total,kI,ow);` : ''}
+let p=vec2i(position.xy);let size=vec2i(textureDimensions(depthHi));
+let d=textureLoad(diffuseHi,p,0);let s=textureLoad(specularHi,p,0);let z=textureLoad(depthHi,p,0).xy;
+let sf=max(detail.w,detail.z*abs(z.x));
+let radius=max(vec2i(1),vec2i(ceil(outputSize.xy/vec2f(textureDimensions(colorImage)))));
+
+
+var silhouette=false;let inverse=1.0/max(z.x,1e-6);
+let directions=array<vec2i,4>(vec2i(1,0),vec2i(0,1),vec2i(1,1),vec2i(1,-1));
+for(var k=0;k<4;k++){
+let a=textureLoad(depthHi,clamp(p+directions[k]*radius,vec2i(0),size-1),0).xy;
+let b=textureLoad(depthHi,clamp(p-directions[k]*radius,vec2i(0),size-1),0).xy;
+silhouette=silhouette || abs(a.y-z.y)>0.5 || abs(b.y-z.y)>0.5 ||
+(min(min(a.y,b.y),z.y)>0.0 && abs(1.0/max(a.x,1e-6)+1.0/max(b.x,1e-6)-2.0*inverse)>detail.z*inverse);
+}
+${silhouettes ? `  
+let guided=min(d.a,s.a)>=detail.y;
+if(silhouette && z.y>=0.5 && !guided){return color;}
+if(silhouette){
+
+
+
+let center=vec2i(round(point));var front=vec4f(0);var back=vec4f(0);var oK=0.0;var pO=0.0;
+for(var y=-1;y<=1;y++){for(var x=-1;x<=1;x++){
+let q=center+vec2i(x,y);let offset=vec2f(q)-point;
+let rB=cY(depthLo,q).xy;let yO=exp(-dot(offset,offset));
+let Ab=exp(-pow(abs(rB.x-z.x)/sf,2.0));
+let sample=ns(q);let value=vec4f(pS(sample.rgb),sample.a);
+let f=yO*rB.y*rB.y*select(1.0,Ab,z.y>0.0);let b=yO*(1.0-rB.y)*(1.0-rB.y);
+front+=value*f;oK+=f;back+=value*b;pO+=b;
+}}
+let ug=oK>1e-3;let xs=pO>1e-3;
+if(!ug && !xs){return color;}
+var zE=select(back/max(pO,1e-8),front/max(oK,1e-8),ug);
+if(ug && xs){zE=mix(back/pO,front/oK,z.y);}
+return vec4f(tp(zE.rgb),zE.a);
+}
+` : '  if(silhouette){return color;}\n'}  let valid=min(min(d.a,s.a),min(diffuse.a,specular.a))>=detail.y && z.y>=detail.y;
+if(!valid){return color;}
+let low=diffuse.rgb+specular.rgb;
+var fw=clamp((d.rgb+s.rgb)/max(low,vec3f(detail.x)),vec3f(outputSize.z),vec3f(outputSize.w));
+${separate ? `
+
+let share=diffuse.rgb/max(low,vec3f(detail.x));
+let rd=clamp(d.rgb/max(diffuse.rgb,vec3f(detail.x)),vec3f(outputSize.z),vec3f(outputSize.w));
+let rs=clamp(s.rgb/max(specular.rgb,vec3f(detail.x)),vec3f(outputSize.z),vec3f(outputSize.w));
+fw=share*rd+(vec3f(1)-share)*rs;` : ''}
+${guided ? `
+
+
+let yJ=slope.rgb*low+pn.rgb;
+fw=select(fw,clamp((slope.rgb*(d.rgb+s.rgb)+pn.rgb)/max(yJ,vec3f(1e-8)),vec3f(outputSize.z),vec3f(outputSize.w)),yJ>vec3f(1e-8));` : ''}
+fw=select(vec3f(1),fw,low>vec3f(detail.x));
+
+return vec4f(tp(zk(pS(color.rgb),fw)),color.a);`);
+}
+// Exact box overlap integrates noninteger footprints instead of point sampling.
+export const albedoDownsampleShader = (depthOutput = false) => /* wgsl */ `
+@group(0) @binding(0) var diffuse: texture_2d<f32>;
+@group(0) @binding(1) var specular: texture_2d<f32>;
+@group(0) @binding(2) var<uniform> outputSize: vec4f;
+@group(0) @binding(3) var depth: texture_2d<f32>;
+@vertex fn vertex(@builtin(vertex_index) index: u32) -> @builtin(position) vec4f {
+let p=vec2f(f32((index<<1u)&2u),f32(index&2u));return vec4f(p*2.0-1.0,0,1);
+}
+struct uS {@location(0) diffuse: vec4f, @location(1) specular: vec4f, ${depthOutput ? '@location(2) depth: vec4f,' : ''}}
+@fragment fn fragment(@builtin(position) p: vec4f) -> uS {
+let scale=vec2f(textureDimensions(diffuse))/outputSize.xy;
+let start=floor(p.xy)*scale;let end=start+scale;
+var d=vec4f(0);var s=vec4f(0);var nearest=3.4e38;var hits=0.0;
+for(var y=i32(floor(start.y));y<i32(ceil(end.y));y++){
+for(var x=i32(floor(start.x));x<i32(ceil(end.x));x++){
+let tK=max(vec2f(0),min(vec2f(vec2i(x+1,y+1)),end)-max(vec2f(vec2i(x,y)),start));let weight=tK.x*tK.y;
+let a=textureLoad(diffuse,vec2i(x,y),0);let b=textureLoad(specular,vec2i(x,y),0);let z=textureLoad(depth,vec2i(x,y),0).xy;
+d+=vec4f(a.rgb*a.a,a.a)*weight;s+=vec4f(b.rgb*b.a,b.a)*weight;
+hits+=z.y*weight;if(z.y>0.0){nearest=min(nearest,z.x);}
+}
+}
+var result: uS;
+${depthOutput ? 'result.depth=vec4f(select(0.0,nearest,hits>0.0),hits/(scale.x*scale.y),0,0);' : ''}
+result.diffuse=vec4f(d.rgb/max(d.a,1e-8),d.a/(scale.x*scale.y));
+result.specular=vec4f(s.rgb/max(s.a,1e-8),s.a/(scale.x*scale.y));return result;
+}
+`;
+// Builds the tone lookup rows for the current grading and tone mapping.
+// toneMappingParams: x mode, y maximum display value, z exposure, w 1 for extended output.
+export const toneLutShader = /* wgsl */ `
+@group(0) @binding(0) var<uniform> toneMappingParams: vec4f;
+@group(0) @binding(1) var<uniform> colorGradingParams: vec4f;
+${composeDefine}
+fn xP(x: f32) -> vec3f {
+var v=fm(vec3f(x)*toneMappingParams.z);
+if(toneMappingParams.w<0.5){v=bH(v);}
+return v;
+}
+@vertex fn vertex(@builtin(vertex_index) index: u32) -> @builtin(position) vec4f {
+let p=vec2f(f32((index<<1u)&2u),f32(index&2u));return vec4f(p*2.0-1.0,0,1);
+}
+@fragment fn fragment(@builtin(position) p: vec4f) -> @location(0) vec4f {
+let u=floor(p.x)/${TONE_LUT_SIZE - 1}.0;
+if(p.y<1.0){return vec4f(xP(exp2(mix(${TONE_LUT_LOG2[0]}.0,${TONE_LUT_LOG2[1]}.0,u))),1);}
+let d=u*u*toneMappingParams.y;var result=vec3f(0);
+for(var c=0;c<3;c++){
+var lo=${TONE_LUT_LOG2[0]}.0;var hi=${TONE_LUT_LOG2[1]}.0;
+for(var i=0;i<28;i++){let mid=0.5*(lo+hi);if(xP(exp2(mid))[c]<d){lo=mid;}else{hi=mid;}}
+result[c]=0.5*(lo+hi);
+}
+return vec4f(result,1);
+}
+`;
+// Per low-resolution pixel, fits scene-linear radiance x ~ slope * albedo + offset over a
+// 3x3 window of guided samples, per channel (a guided-filter regression). Flat albedo
+// gives slope ~0, so its radiance is not modulated; tone.y regularizes the variance.
+export const guidedCoefficientShader = /* wgsl */ `
+@group(0) @binding(0) var colorImage: texture_2d<f32>;
+@group(0) @binding(1) var diffuseLo: texture_2d<f32>;
+@group(0) @binding(2) var specularLo: texture_2d<f32>;
+${toneCodingDefine}
+fn yg(image: texture_2d<f32>, p: vec2i) -> vec4f {return textureLoad(image,clamp(p,vec2i(0),vec2i(textureDimensions(image))-1),0);}
+@vertex fn vertex(@builtin(vertex_index) index: u32) -> @builtin(position) vec4f {
+let p=vec2f(f32((index<<1u)&2u),f32(index&2u));return vec4f(p*2.0-1.0,0,1);
+}
+struct uS {@location(0) slope: vec4f, @location(1) offset: vec4f,}
+@fragment fn fragment(@builtin(position) position: vec4f) -> uS {
+let center=vec2i(position.xy);
+var weight=0.0;var gt=vec3f(0);var nj=vec3f(0);var rC=vec3f(0);var sS=vec3f(0);
+for(var y=-1;y<=1;y++){for(var x=-1;x<=1;x++){
+let q=center+vec2i(x,y);let d=yg(diffuseLo,q);let s=yg(specularLo,q);
+let w=step(0.5,min(d.a,s.a));let albedo=d.rgb+s.rgb;
+let radiance=exp2(uN(pS(yg(colorImage,q).rgb)));
+weight+=w;gt+=albedo*w;nj+=radiance*w;rC+=albedo*radiance*w;sS+=albedo*albedo*w;
+}}
+var result: uS;
+if(weight<1.0){return result;}
+gt/=weight;nj/=weight;rC/=weight;sS/=weight;
+let slope=max((rC-gt*nj)/(sS-gt*gt+vec3f(tone.y)),vec3f(0));
+result.slope=vec4f(slope,1);result.offset=vec4f(nj-slope*gt,1);
+return result;
+}
+`;
+//# sourceMappingURL=easuDetail.wgsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"easuDetail.wgsl.js","sourceRoot":"","sources":["../../../src/renderer/wgsl/easuDetail.wgsl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAC,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAC,aAAa,EAAC,MAAM,wBAAwB,CAAC;AAErD,gEAAgE;AAChE,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAU,CAAC;AAChD,MAAM,CAAC,MAAM,aAAa,GAAG,IAAI,CAAC;AAClC,+FAA+F;AAC/F,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,UAAU,EAAE,CAAC,GAAG,EAAE,IAAI,CAAU,EAAE,cAAc,EAAE,IAAI,EAAE,iBAAiB,EAAE,IAAI;IAC/E,yEAAyE;IACzE,aAAa,EAAE,IAAI,EAAE,cAAc,EAAE,IAAI;IACzC,6FAA6F;IAC7F,aAAa,EAAE,IAAI;CACpB,CAAC;AAEF,4GAA4G;AAC5G,MAAM,gBAAgB,GAAG,UAAU,CAAC;;;;;;;;;;;;8CAYiC,aAAa,CAAC,CAAC,CAAC,QAAQ,aAAa,CAAC,CAAC,CAAC,GAAC,aAAa,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;CAmB7H,CAAC;AAEF;;;;GAIG;AACH,MAAM,UAAU,gBAAgB,CAAC,QAAQ,GAAG,KAAK,EAAE,WAAW,GAAG,KAAK,EAAE,MAAM,GAAG,IAAI;IACnF,OAAO,UAAU,CAAC,OAAO,CAAC,mBAAmB,EAAE,UAAU,CAAC;;;;;;;EAO1D,WAAW,CAAC,CAAC,CAAC,sDAAsD,CAAC,CAAC,CAAC,EAAE;EACzE,MAAM,CAAC,CAAC,CAAC,6GAA6G,CAAC,CAAC,CAAC,EAAE;;;;EAI3H,gBAAgB;kBACA,CAAC,CAAC,OAAO,CAAC,yCAAyC,EAAE,UAAU,CAAC;;;;;;;;;;;;;;EAc9E,MAAM,CAAC,CAAC,CAAC;;;;;;;;;;yDAUoG,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;;EAelH,WAAW,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;CAsBjB,CAAC,CAAC,CAAC,mCAAmC;;;;EAInC,QAAQ,CAAC,CAAC,CAAC;;;;;iCAKuB,CAAC,CAAC,CAAC,EAAE;EACvC,MAAM,CAAC,CAAC,CAAC;;;;kIAI8I,CAAC,CAAC,CAAC,EAAE;;;gDAGhF,CAAC,CAAC;AAClF,CAAC;AAED,gFAAgF;AAChF,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,WAAW,GAAG,KAAK,EAAE,EAAE,CAAC,UAAU,CAAC;;;;;;;;wEAQE,WAAW,CAAC,CAAC,CAAC,4BAA4B,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;EAcvH,WAAW,CAAC,CAAC,CAAC,8EAA8E,CAAC,CAAC,CAAC,EAAE;;;;CAIpG,CAAC;AAEF,wEAAwE;AACxE,2FAA2F;AAC3F,MAAM,CAAC,MAAM,aAAa,GAAG,UAAU,CAAC;;;EAGtC,aAAa;;;;;;;;;;mBAUM,aAAa,GAAG,CAAC;uCACS,aAAa,CAAC,CAAC,CAAC,MAAM,aAAa,CAAC,CAAC,CAAC;;;SAGxE,aAAa,CAAC,CAAC,CAAC,aAAa,aAAa,CAAC,CAAC,CAAC;;;;;;CAMzD,CAAC;AAEF,0FAA0F;AAC1F,sFAAsF;AACtF,qFAAqF;AACrF,MAAM,CAAC,MAAM,uBAAuB,GAAG,UAAU,CAAC;;;;EAIhD,gBAAgB;;;;;;;;;;;;;;;;;;;;;;CAsBjB,CAAC","sourcesContent":["import {easuShader} from './easu.wgsl.js';\nimport {composeDefine} from './compose.frag.wgsl.js';\n\n/** Scene-linear log2 range covered by the tone lookup table. */\nexport const TONE_LUT_LOG2 = [-24, 24] as const;\nexport const TONE_LUT_SIZE = 1024;\n/** Detail compensation defaults and fixed regularizers shared by the Web and native passes. */\nexport const EASU_DETAIL = {\n  ratioRange: [0.7, 1.43] as const, depthThreshold: 0.02, coverageThreshold: 0.95,\n  // Albedo below this is treated as black; relative depth tolerance floor.\n  minimumAlbedo: 1e-3, depthTolerance: 1e-4,\n  // Regularizes the local albedo variance of the albedo-radiance fit, in squared albedo units.\n  guidedEpsilon: 1e-4,\n};\n\n// Tone table lookups and display encoding shared by the detail passes; tone.x is the maximum display value.\nconst toneCodingDefine = /* wgsl */ `\n// Row 0: display value of a gray scene-linear input at TONE_LUT_LOG2 stops, per channel.\n// Row 1: log2 scene-linear input per channel for display values (sqrt-spaced up to tone.x).\n@group(0) @binding(8) var toneLut: texture_2d<f32>;\n@group(0) @binding(9) var<uniform> tone: vec4f;\nfn toneLutRow(row: i32, u: vec3f) -> vec3f {\n  let last=f32(textureDimensions(toneLut).x-1u);let p=clamp(u,vec3f(0),vec3f(1))*last;\n  let i=vec3i(floor(p));let j=min(i+1,vec3i(i32(last)));let f=p-floor(p);\n  var result=vec3f(0);\n  for(var c=0;c<3;c++){result[c]=mix(textureLoad(toneLut,vec2i(i[c],row),0)[c],textureLoad(toneLut,vec2i(j[c],row),0)[c],f[c]);}\n  return result;\n}\nfn toneForward(log2x: vec3f) -> vec3f {return toneLutRow(0,(log2x-(${TONE_LUT_LOG2[0]}.0))/${TONE_LUT_LOG2[1]-TONE_LUT_LOG2[0]}.0);}\nfn toneInverse(d: vec3f) -> vec3f {return toneLutRow(1,sqrt(max(d,vec3f(0))/tone.x));}\n// Applies a scene-linear albedo ratio before the display transform: displayed\n// RGB is mapped back to scene-linear per channel, scaled and mapped forward, so\n// curve shoulders and toes respond as the tone mapper would. Only the change is\n// added to the displayed value, which keeps it exact where the ratio is 1.\nfn toneAware(d: vec3f, ratio: vec3f) -> vec3f {\n  let x=toneInverse(d);\n  let changed=max(d+toneForward(x+log2(max(ratio,vec3f(1e-6))))-toneForward(x),vec3f(0));\n  return select(changed,d,abs(ratio-vec3f(1))<vec3f(1e-4));\n}\nfn detailDecode(c: vec3f) -> vec3f {\n  let a=max(c,vec3f(0));\n  return select(pow((a+0.055)/1.055,vec3f(2.4)),a/12.92,a<=vec3f(0.04045));\n}\nfn detailEncode(c: vec3f) -> vec3f {\n  let a=max(c,vec3f(0));\n  return select(1.055*pow(a,vec3f(1.0/2.4))-0.055,a*12.92,a<=vec3f(0.0031308));\n}\n`;\n\n/**\n * guided: scale only the albedo-correlated part of local scene-linear radiance (default);\n * separate: lobe-share approximation; silhouettes: depth-guided edge reconstruction.\n * The last two are retained for comparisons.\n */\nexport function easuDetailShader(separate = false, silhouettes = false, guided = true) {\n  return easuShader.replace(`@vertex fn vertex`, /* wgsl */ `\n@group(0) @binding(2) var diffuseHi: texture_2d<f32>;\n@group(0) @binding(3) var specularHi: texture_2d<f32>;\n@group(0) @binding(4) var depthHi: texture_2d<f32>;\n@group(0) @binding(5) var diffuseLo: texture_2d<f32>;\n@group(0) @binding(6) var specularLo: texture_2d<f32>;\n@group(0) @binding(7) var<uniform> detail: vec4f;\n${silhouettes ? '@group(0) @binding(10) var depthLo: texture_2d<f32>;' : ''}\n${guided ? '@group(0) @binding(11) var slopeLo: texture_2d<f32>;\\n@group(0) @binding(12) var offsetLo: texture_2d<f32>;' : ''}\nfn loadLow(image: texture_2d<f32>, p: vec2i) -> vec4f {\n  return textureLoad(image,clamp(p,vec2i(0),vec2i(textureDimensions(image))-1),0);\n}\n${toneCodingDefine}\n@vertex fn vertex`).replace(`return clamp(result/total,lower,upper);`, /* wgsl */ `\n  let color=clamp(result/total,lower,upper);\n  var diffuse=vec4f(0);var specular=vec4f(0);\n  for(var i=0u;i<12u;i++){\n    // Identical direction, phase, support and weights as beauty.\n    let weight=easuWeight(vec2f(offsets[i])-phase,direction,length,lobe);\n    diffuse+=loadLow(diffuseLo,base+offsets[i])*weight;\n    specular+=loadLow(specularLo,base+offsets[i])*weight;\n  }\n  let dlo=min(min(loadLow(diffuseLo,base),loadLow(diffuseLo,base+vec2i(1,0))),min(loadLow(diffuseLo,base+vec2i(0,1)),loadLow(diffuseLo,base+vec2i(1,1))));\n  let dhi=max(max(loadLow(diffuseLo,base),loadLow(diffuseLo,base+vec2i(1,0))),max(loadLow(diffuseLo,base+vec2i(0,1)),loadLow(diffuseLo,base+vec2i(1,1))));\n  let slo=min(min(loadLow(specularLo,base),loadLow(specularLo,base+vec2i(1,0))),min(loadLow(specularLo,base+vec2i(0,1)),loadLow(specularLo,base+vec2i(1,1))));\n  let shi=max(max(loadLow(specularLo,base),loadLow(specularLo,base+vec2i(1,0))),max(loadLow(specularLo,base+vec2i(0,1)),loadLow(specularLo,base+vec2i(1,1))));\n  diffuse=clamp(diffuse/total,dlo,dhi);specular=clamp(specular/total,slo,shi);\n  ${guided ? `var slope=vec4f(0);var intercept=vec4f(0);\n  for(var i=0u;i<12u;i++){\n    let weight=easuWeight(vec2f(offsets[i])-phase,direction,length,lobe);\n    slope+=loadLow(slopeLo,base+offsets[i])*weight;intercept+=loadLow(offsetLo,base+offsets[i])*weight;\n  }\n  var lowerSlope=loadLow(slopeLo,base);var upperSlope=lowerSlope;var lowerIntercept=loadLow(offsetLo,base);var upperIntercept=lowerIntercept;\n  for(var k=1;k<4;k++){\n    let q=base+vec2i(k&1,k>>1u);let a=loadLow(slopeLo,q);let b=loadLow(offsetLo,q);\n    lowerSlope=min(lowerSlope,a);upperSlope=max(upperSlope,a);lowerIntercept=min(lowerIntercept,b);upperIntercept=max(upperIntercept,b);\n  }\n  slope=clamp(slope/total,lowerSlope,upperSlope);intercept=clamp(intercept/total,lowerIntercept,upperIntercept);` : ''}\n  let p=vec2i(position.xy);let size=vec2i(textureDimensions(depthHi));\n  let d=textureLoad(diffuseHi,p,0);let s=textureLoad(specularHi,p,0);let z=textureLoad(depthHi,p,0).xy;\n  let tolerance=max(detail.w,detail.z*abs(z.x));\n  let radius=max(vec2i(1),vec2i(ceil(outputSize.xy/vec2f(textureDimensions(colorImage)))));\n  // A silhouette changes hit coverage or breaks the planarity of inverse depth,\n  // which is linear in screen space on planes; sloped planes are not silhouettes.\n  var silhouette=false;let inverse=1.0/max(z.x,1e-6);\n  let directions=array<vec2i,4>(vec2i(1,0),vec2i(0,1),vec2i(1,1),vec2i(1,-1));\n  for(var k=0;k<4;k++){\n    let a=textureLoad(depthHi,clamp(p+directions[k]*radius,vec2i(0),size-1),0).xy;\n    let b=textureLoad(depthHi,clamp(p-directions[k]*radius,vec2i(0),size-1),0).xy;\n    silhouette=silhouette || abs(a.y-z.y)>0.5 || abs(b.y-z.y)>0.5 ||\n      (min(min(a.y,b.y),z.y)>0.0 && abs(1.0/max(a.x,1e-6)+1.0/max(b.x,1e-6)-2.0*inverse)>detail.z*inverse);\n  }\n  ${silhouettes ? `  // Transmissive and other unguided hits show surfaces behind their depth; keep EASU there.\n  let guided=min(d.a,s.a)>=detail.y;\n  if(silhouette && z.y>=0.5 && !guided){return color;}\n  if(silhouette){\n    // Silhouettes: estimate this surface's color from covered low-resolution neighbors\n    // at a similar nearest depth, the background from uncovered ones, and mix them by\n    // this pixel's full-resolution hit coverage, which keeps edges antialiased.\n    let center=vec2i(round(point));var front=vec4f(0);var back=vec4f(0);var frontWeight=0.0;var backWeight=0.0;\n    for(var y=-1;y<=1;y++){for(var x=-1;x<=1;x++){\n      let q=center+vec2i(x,y);let offset=vec2f(q)-point;\n      let lowDepth=loadLow(depthLo,q).xy;let spatial=exp(-dot(offset,offset));\n      let similar=exp(-pow(abs(lowDepth.x-z.x)/tolerance,2.0));\n      let sample=loadColor(q);let value=vec4f(detailDecode(sample.rgb),sample.a);\n      let f=spatial*lowDepth.y*lowDepth.y*select(1.0,similar,z.y>0.0);let b=spatial*(1.0-lowDepth.y)*(1.0-lowDepth.y);\n      front+=value*f;frontWeight+=f;back+=value*b;backWeight+=b;\n    }}\n    let haveFront=frontWeight>1e-3;let haveBack=backWeight>1e-3;\n    if(!haveFront && !haveBack){return color;}\n    var mixed=select(back/max(backWeight,1e-8),front/max(frontWeight,1e-8),haveFront);\n    if(haveFront && haveBack){mixed=mix(back/backWeight,front/frontWeight,z.y);}\n    return vec4f(detailEncode(mixed.rgb),mixed.a);\n  }\n` : '  if(silhouette){return color;}\\n'}  let valid=min(min(d.a,s.a),min(diffuse.a,specular.a))>=detail.y && z.y>=detail.y;\n  if(!valid){return color;}\n  let low=diffuse.rgb+specular.rgb;\n  var ratio=clamp((d.rgb+s.rgb)/max(low,vec3f(detail.x)),vec3f(outputSize.z),vec3f(outputSize.w));\n  ${separate ? `\n  // Estimate beauty lobe shares from low albedo; no separate beauty lobes are available.\n  let share=diffuse.rgb/max(low,vec3f(detail.x));\n  let rd=clamp(d.rgb/max(diffuse.rgb,vec3f(detail.x)),vec3f(outputSize.z),vec3f(outputSize.w));\n  let rs=clamp(s.rgb/max(specular.rgb,vec3f(detail.x)),vec3f(outputSize.z),vec3f(outputSize.w));\n  ratio=share*rd+(vec3f(1)-share)*rs;` : ''}\n  ${guided ? `// Local radiance is modeled as slope * albedo + intercept. Only the albedo-correlated\n  // part follows the full-resolution albedo; the intercept, such as specular highlights,\n  // does not. Pure diffuse (zero intercept) reduces to the albedo ratio.\n  let modeled=slope.rgb*low+intercept.rgb;\n  ratio=select(ratio,clamp((slope.rgb*(d.rgb+s.rgb)+intercept.rgb)/max(modeled,vec3f(1e-8)),vec3f(outputSize.z),vec3f(outputSize.w)),modeled>vec3f(1e-8));` : ''}\n  ratio=select(vec3f(1),ratio,low>vec3f(detail.x));\n  // Albedo ratios are scene-linear; the composed image is tone mapped and sRGB encoded.\n  return vec4f(detailEncode(toneAware(detailDecode(color.rgb),ratio)),color.a);`);\n}\n\n// Exact box overlap integrates noninteger footprints instead of point sampling.\nexport const albedoDownsampleShader = (depthOutput = false) => /* wgsl */ `\n@group(0) @binding(0) var diffuse: texture_2d<f32>;\n@group(0) @binding(1) var specular: texture_2d<f32>;\n@group(0) @binding(2) var<uniform> outputSize: vec4f;\n@group(0) @binding(3) var depth: texture_2d<f32>;\n@vertex fn vertex(@builtin(vertex_index) index: u32) -> @builtin(position) vec4f {\n  let p=vec2f(f32((index<<1u)&2u),f32(index&2u));return vec4f(p*2.0-1.0,0,1);\n}\nstruct Result {@location(0) diffuse: vec4f, @location(1) specular: vec4f, ${depthOutput ? '@location(2) depth: vec4f,' : ''}}\n@fragment fn fragment(@builtin(position) p: vec4f) -> Result {\n  let scale=vec2f(textureDimensions(diffuse))/outputSize.xy;\n  let start=floor(p.xy)*scale;let end=start+scale;\n  var d=vec4f(0);var s=vec4f(0);var nearest=3.4e38;var hits=0.0;\n  for(var y=i32(floor(start.y));y<i32(ceil(end.y));y++){\n    for(var x=i32(floor(start.x));x<i32(ceil(end.x));x++){\n      let overlap=max(vec2f(0),min(vec2f(vec2i(x+1,y+1)),end)-max(vec2f(vec2i(x,y)),start));let weight=overlap.x*overlap.y;\n      let a=textureLoad(diffuse,vec2i(x,y),0);let b=textureLoad(specular,vec2i(x,y),0);let z=textureLoad(depth,vec2i(x,y),0).xy;\n      d+=vec4f(a.rgb*a.a,a.a)*weight;s+=vec4f(b.rgb*b.a,b.a)*weight;\n      hits+=z.y*weight;if(z.y>0.0){nearest=min(nearest,z.x);}\n    }\n  }\n  var result: Result;\n  ${depthOutput ? 'result.depth=vec4f(select(0.0,nearest,hits>0.0),hits/(scale.x*scale.y),0,0);' : ''}\n  result.diffuse=vec4f(d.rgb/max(d.a,1e-8),d.a/(scale.x*scale.y));\n  result.specular=vec4f(s.rgb/max(s.a,1e-8),s.a/(scale.x*scale.y));return result;\n}\n`;\n\n// Builds the tone lookup rows for the current grading and tone mapping.\n// toneMappingParams: x mode, y maximum display value, z exposure, w 1 for extended output.\nexport const toneLutShader = /* wgsl */ `\n@group(0) @binding(0) var<uniform> toneMappingParams: vec4f;\n@group(0) @binding(1) var<uniform> colorGradingParams: vec4f;\n${composeDefine}\nfn toneGray(x: f32) -> vec3f {\n  var v=gradeColor(vec3f(x)*toneMappingParams.z);\n  if(toneMappingParams.w<0.5){v=applyToneMapping(v);}\n  return v;\n}\n@vertex fn vertex(@builtin(vertex_index) index: u32) -> @builtin(position) vec4f {\n  let p=vec2f(f32((index<<1u)&2u),f32(index&2u));return vec4f(p*2.0-1.0,0,1);\n}\n@fragment fn fragment(@builtin(position) p: vec4f) -> @location(0) vec4f {\n  let u=floor(p.x)/${TONE_LUT_SIZE - 1}.0;\n  if(p.y<1.0){return vec4f(toneGray(exp2(mix(${TONE_LUT_LOG2[0]}.0,${TONE_LUT_LOG2[1]}.0,u))),1);}\n  let d=u*u*toneMappingParams.y;var result=vec3f(0);\n  for(var c=0;c<3;c++){\n    var lo=${TONE_LUT_LOG2[0]}.0;var hi=${TONE_LUT_LOG2[1]}.0;\n    for(var i=0;i<28;i++){let mid=0.5*(lo+hi);if(toneGray(exp2(mid))[c]<d){lo=mid;}else{hi=mid;}}\n    result[c]=0.5*(lo+hi);\n  }\n  return vec4f(result,1);\n}\n`;\n\n// Per low-resolution pixel, fits scene-linear radiance x ~ slope * albedo + offset over a\n// 3x3 window of guided samples, per channel (a guided-filter regression). Flat albedo\n// gives slope ~0, so its radiance is not modulated; tone.y regularizes the variance.\nexport const guidedCoefficientShader = /* wgsl */ `\n@group(0) @binding(0) var colorImage: texture_2d<f32>;\n@group(0) @binding(1) var diffuseLo: texture_2d<f32>;\n@group(0) @binding(2) var specularLo: texture_2d<f32>;\n${toneCodingDefine}\nfn loadAt(image: texture_2d<f32>, p: vec2i) -> vec4f {return textureLoad(image,clamp(p,vec2i(0),vec2i(textureDimensions(image))-1),0);}\n@vertex fn vertex(@builtin(vertex_index) index: u32) -> @builtin(position) vec4f {\n  let p=vec2f(f32((index<<1u)&2u),f32(index&2u));return vec4f(p*2.0-1.0,0,1);\n}\nstruct Result {@location(0) slope: vec4f, @location(1) offset: vec4f,}\n@fragment fn fragment(@builtin(position) position: vec4f) -> Result {\n  let center=vec2i(position.xy);\n  var weight=0.0;var meanAlbedo=vec3f(0);var meanRadiance=vec3f(0);var meanProduct=vec3f(0);var meanSquare=vec3f(0);\n  for(var y=-1;y<=1;y++){for(var x=-1;x<=1;x++){\n    let q=center+vec2i(x,y);let d=loadAt(diffuseLo,q);let s=loadAt(specularLo,q);\n    let w=step(0.5,min(d.a,s.a));let albedo=d.rgb+s.rgb;\n    let radiance=exp2(toneInverse(detailDecode(loadAt(colorImage,q).rgb)));\n    weight+=w;meanAlbedo+=albedo*w;meanRadiance+=radiance*w;meanProduct+=albedo*radiance*w;meanSquare+=albedo*albedo*w;\n  }}\n  var result: Result;\n  if(weight<1.0){return result;}\n  meanAlbedo/=weight;meanRadiance/=weight;meanProduct/=weight;meanSquare/=weight;\n  let slope=max((meanProduct-meanAlbedo*meanRadiance)/(meanSquare-meanAlbedo*meanAlbedo+vec3f(tone.y)),vec3f(0));\n  result.slope=vec4f(slope,1);result.offset=vec4f(meanRadiance-slope*meanAlbedo,1);\n  return result;\n}\n`;\n"]}