minerva-design 1.6.0 → 1.7.0

package/dist/charts/engine/three-d/oit.cjs

@@ -1,27 +1,51 @@
-var e=64,t=12,n=.01,r=.999,i=.6,a=1,o=6,s=.35,c=e=>Number.isInteger(e)?e.toFixed(1):String(e),l=`
+var e=64,t=12,n=.01,r=.999,i=.6,a=1,o=6,s=.35,c=.002,l=.05,u=1.4,d=e=>Number.isInteger(e)?e.toFixed(1):String(e),f=`
+@group(1) @binding(0) var frontTex: texture_2d<f32>;
+
 struct Oit {
-  @location(0) accum: vec4f,
-  @location(1) extra: vec4f,
+  @location(0) front: vec4f,
+  @location(1) accum: vec4f,
+  @location(2) extra: vec4f,
+  @location(3) behind: vec4f,
 };
 
-fn oit(c: vec4f, depth: f32) -> Oit {
+fn oit(c: vec4f, depth: f32, xy: vec4f) -> Oit {
   var o: Oit;
+  o.front = vec4f(0.0);
+  o.accum = vec4f(0.0);
+  o.extra = vec4f(0.0);
+  o.behind = vec4f(0.0);
+  let z = clamp(depth, 0.0, 1.0);
+  let near = z <= textureLoad(frontTex, vec2i(xy.xy), 0).r + ${d(c)};
   if (u.light.w > 0.5) {
-    o.accum = vec4f(0.0);
-    o.extra = vec4f(c.rgb, 0.0);
+    if (near) { o.extra = vec4f(c.rgb, 0.0); } else { o.behind = vec4f(c.rgb, 0.0); }
+    return o;
+  }
+  if (near) {
+    o.front = c;
     return o;
   }
-  let a = clamp(c.a, 0.0, ${c(r)});
-  let w = max(${c(n)}, ${c(e)} * exp2(-${c(t)} * clamp(depth, 0.0, 1.0)));
+  let a = clamp(c.a, 0.0, ${d(r)});
+  let w = max(${d(n)}, ${d(e)} * exp2(-${d(t)} * z));
   o.accum = vec4f(c.rgb, a) * w;
   o.extra = vec4f(0.0, 0.0, 0.0, -log(1.0 - a));
   return o;
 }
-`,u=`${`
+
+fn frontDepth(c: vec4f, depth: f32) -> vec4f {
+  if (c.a < ${d(l)}) { discard; }
+  return vec4f(clamp(depth, 0.0, 1.0));
+}
+
+fn screenLight(c: vec4f) -> vec4f {
+  if (u.light.w < 0.5) { return c; }
+  let v = vec3f(1.0) - exp(-${d(u)} * max(c.rgb, vec3f(0.0)));
+  return vec4f(v, max(max(v.r, v.g), v.b));
+}
+`,p=`${`
 fn shoulder(x: f32) -> f32 {
-  if (x <= ${c(i)}) { return x; }
-  let t = (x - ${c(i)}) / ${c(.4)};
-  return ${c(i)} + ${c(.4)} * t / (1.0 + t);
+  if (x <= ${d(i)}) { return x; }
+  let t = (x - ${d(i)}) / ${d(.4)};
+  return ${d(i)} + ${d(.4)} * t / (1.0 + t);
 }
 
 fn toneMap(rgb: vec3f) -> vec3f {
@@ -29,11 +53,14 @@ fn toneMap(rgb: vec3f) -> vec3f {
   if (m <= 1e-6) { return rgb; }
   let peak = shoulder(m);
   let scaled = rgb * (peak / m);
-  return mix(scaled, vec3f(peak), smoothstep(${c(a)}, ${c(o)}, m) * ${c(s)});
+  return mix(scaled, vec3f(peak), smoothstep(${d(a)}, ${d(o)}, m) * ${d(s)});
 }
 `}
-@group(0) @binding(0) var accumTex: texture_2d<f32>;
-@group(0) @binding(1) var extraTex: texture_2d<f32>;
+@group(0) @binding(0) var frontTex: texture_2d<f32>;
+@group(0) @binding(1) var accumTex: texture_2d<f32>;
+@group(0) @binding(2) var extraTex: texture_2d<f32>;
+@group(0) @binding(3) var behindTex: texture_2d<f32>;
+
 
 @vertex
 fn vs(@builtin(vertex_index) vi: u32) -> @builtin(position) vec4f {
@@ -44,66 +71,124 @@ fn vs(@builtin(vertex_index) vi: u32) -> @builtin(position) vec4f {
 @fragment
 fn fs(@builtin(position) position: vec4f) -> @location(0) vec4f {
   let xy = vec2i(position.xy);
+  let front = textureLoad(frontTex, xy, 0);
   let accum = textureLoad(accumTex, xy, 0);
   let extra = textureLoad(extraTex, xy, 0);
-  let alpha = 1.0 - exp(-extra.a);
+  let behind = textureLoad(behindTex, xy, 0);
+  let tau = max(extra.a, 0.0);
+  let restAlpha = 1.0 - exp(-tau);
+  let rest = accum.rgb * (restAlpha / max(accum.a, 1e-6));
+  let sum = max(front.a, 0.0);
+  let scale = select(1.0, 1.0 / max(sum, 1e-6), sum > 1.0);
+  let fa = sum * scale;
+  let alpha = fa + restAlpha * (1.0 - fa);
+  let color = front.rgb * scale + rest * (1.0 - fa);
+  let meanT = select(1.0, restAlpha / max(tau, 1e-6), tau > 1e-4);
+  let t = (1.0 - fa) * meanT;
+  let back = toneMap(behind.rgb);
+  let backAlpha = clamp(max(max(back.r, back.g), back.b), 0.0, 1.0);
+  let under = color + back * t;
+  let underAlpha = min(1.0, alpha + backAlpha * t);
   let light = toneMap(extra.rgb);
   let lightAlpha = clamp(max(max(light.r, light.g), light.b), 0.0, 1.0);
-  let rgb = accum.rgb * (alpha / max(accum.a, 1e-6)) + light * (1.0 - alpha);
-  let a = alpha + lightAlpha * (1.0 - alpha);
+  let a = lightAlpha + underAlpha * (1.0 - lightAlpha);
+  let rgb = light + under * (1.0 - lightAlpha);
   if (a <= 0.0) { discard; }
   return vec4f(rgb, a);
 }
-`,d=`
-layout(location = 0) out vec4 o_accum;
-layout(location = 1) out vec4 o_extra;
+`,m=`
+uniform highp sampler2D u_front;
+layout(location = 0) out vec4 o_front;
+layout(location = 1) out vec4 o_accum;
+layout(location = 2) out vec4 o_extra;
+layout(location = 3) out vec4 o_behind;
 void emitOit(vec4 c, float depth) {
+  o_front = vec4(0.0);
+  o_accum = vec4(0.0);
+  o_extra = vec4(0.0);
+  o_behind = vec4(0.0);
+  float z = clamp(depth, 0.0, 1.0);
+  bool near = z <= texelFetch(u_front, ivec2(gl_FragCoord.xy), 0).r + ${d(c)};
   if (u_light.w > 0.5) {
-    o_accum = vec4(0.0);
-    o_extra = vec4(c.rgb, 0.0);
+    if (near) o_extra = vec4(c.rgb, 0.0); else o_behind = vec4(c.rgb, 0.0);
+    return;
+  }
+  if (near) {
+    o_front = c;
     return;
   }
-  float a = clamp(c.a, 0.0, ${c(r)});
-  float w = max(${c(n)}, ${c(e)} * exp2(-${c(t)} * clamp(depth, 0.0, 1.0)));
+  float a = clamp(c.a, 0.0, ${d(r)});
+  float w = max(${d(n)}, ${d(e)} * exp2(-${d(t)} * z));
   o_accum = vec4(c.rgb, a) * w;
   o_extra = vec4(0.0, 0.0, 0.0, -log(1.0 - a));
 }
 #define EMIT(c, d) emitOit(c, d)
-`,f={vertex:`#version 300 es
+`,h=`
+out vec4 fragColor;
+void emitFront(vec4 c, float depth) {
+  if (c.a < ${d(l)}) discard;
+  fragColor = vec4(clamp(depth, 0.0, 1.0));
+}
+#define EMIT(c, d) emitFront(c, d)
+`,g=e=>`
+vec4 screenLight(vec4 c) {
+  if (u_light.w < 0.5) return c;
+  vec3 v = vec3(1.0) - exp(-${d(u)} * max(c.rgb, vec3(0.0)));
+  return vec4(v, max(max(v.r, v.g), v.b));
+}
+#define EMIT(c, d) ${e} = screenLight(c)
+`,_={vertex:`#version 300 es
 void main() {
   vec2 p = vec2(float((gl_VertexID << 1) & 2), float(gl_VertexID & 2)) * 2.0 - 1.0;
   gl_Position = vec4(p, 0.0, 1.0);
 }
 `,fragment:`#version 300 es
 precision highp float;
+uniform sampler2D u_frontColor;
 uniform sampler2D u_accum;
 uniform sampler2D u_extra;
+uniform sampler2D u_behind;
 out vec4 fragColor;
 ${`
 float shoulder(float x) {
-  if (x <= ${c(i)}) return x;
-  float t = (x - ${c(i)}) / ${c(.4)};
-  return ${c(i)} + ${c(.4)} * t / (1.0 + t);
+  if (x <= ${d(i)}) return x;
+  float t = (x - ${d(i)}) / ${d(.4)};
+  return ${d(i)} + ${d(.4)} * t / (1.0 + t);
 }
 vec3 toneMap(vec3 rgb) {
   float m = max(max(rgb.r, rgb.g), rgb.b);
   if (m <= 1e-6) return rgb;
   float peak = shoulder(m);
   vec3 scaled = rgb * (peak / m);
-  return mix(scaled, vec3(peak), smoothstep(${c(a)}, ${c(o)}, m) * ${c(s)});
+  return mix(scaled, vec3(peak), smoothstep(${d(a)}, ${d(o)}, m) * ${d(s)});
 }
 `}
 void main() {
   ivec2 xy = ivec2(gl_FragCoord.xy);
+  vec4 front = texelFetch(u_frontColor, xy, 0);
   vec4 accum = texelFetch(u_accum, xy, 0);
   vec4 extra = texelFetch(u_extra, xy, 0);
-  float alpha = 1.0 - exp(-extra.a);
+  vec4 behind = texelFetch(u_behind, xy, 0);
+  float tau = max(extra.a, 0.0);
+  float restAlpha = 1.0 - exp(-tau);
+  vec3 rest = accum.rgb * (restAlpha / max(accum.a, 1e-6));
+  float sum = max(front.a, 0.0);
+  float scale = sum > 1.0 ? 1.0 / sum : 1.0;
+  float fa = sum * scale;
+  float alpha = fa + restAlpha * (1.0 - fa);
+  vec3 color = front.rgb * scale + rest * (1.0 - fa);
+  float meanT = tau > 1e-4 ? restAlpha / tau : 1.0;
+  float t = (1.0 - fa) * meanT;
+  vec3 back = toneMap(behind.rgb);
+  float backAlpha = clamp(max(max(back.r, back.g), back.b), 0.0, 1.0);
+  vec3 under = color + back * t;
+  float underAlpha = min(1.0, alpha + backAlpha * t);
   vec3 light = toneMap(extra.rgb);
   float lightAlpha = clamp(max(max(light.r, light.g), light.b), 0.0, 1.0);
-  vec3 rgb = accum.rgb * (alpha / max(accum.a, 1e-6)) + light * (1.0 - alpha);
-  float a = alpha + lightAlpha * (1.0 - alpha);
+  float a = lightAlpha + underAlpha * (1.0 - lightAlpha);
+  vec3 rgb = light + under * (1.0 - lightAlpha);
   if (a <= 0.0) discard;
   fragColor = vec4(rgb, a);
 }
-`};exports.GLSL_COMPOSITE=f,exports.GLSL_OIT=d,exports.TONE_KNEE=i,exports.WGSL_COMPOSITE=u,exports.WGSL_OIT=l;
+`};exports.FRONT_EPSILON=c,exports.FRONT_MIN_ALPHA=l,exports.GLSL_COMPOSITE=_,exports.GLSL_FRONT=h,exports.GLSL_OIT=m,exports.SCREEN_GAIN=u,exports.TONE_KNEE=i,exports.WGSL_COMPOSITE=p,exports.WGSL_OIT=f,exports.glslScreen=g;
 //# sourceMappingURL=oit.cjs.map

package/dist/charts/engine/three-d/oit.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"oit.cjs","names":["WEIGHT_SCALE","WEIGHT_FALLOFF","WEIGHT_MIN","MAX_ALPHA","TONE_KNEE","WHITE_FROM","WHITE_TO","WHITE_AMOUNT","f","v","WGSL_OIT","WGSL_COMPOSITE","GLSL_OIT","GLSL_COMPOSITE"],"sources":["../../../../../charts/src/engine/three-d/oit.ts"],"sourcesContent":["// Weighted blended order-independent transparency (McGuire & Bavoil 2013)\n// of the WebGPU and WebGL2 backends, and the tone mapping of the additive\n// light. The blended items (transparent meshes, blended and additive points)\n// are drawn in any order, without writing depth, into two float targets\n// cleared to 0 and blended by plain addition (one, one):\n//\n//   accum  rgb: Σ premultiplied color × w   a: Σ alpha × w\n//   extra  rgb: Σ additive light            a: Σ −ln(1 − alpha)\n//\n// w favours the fragments near the camera (`oitWeight`). The revealage\n// Π(1 − alpha) is stored as the sum of its logarithms so that every target\n// uses the same additive blending (WebGL2 has no per-target blend\n// functions). The composite pass blends over the opaque scene:\n//\n//   transparent = (accum.rgb / accum.a) × (1 − e^−extra.a), alpha 1 − e^−extra.a\n//   light       = toneMap(extra.rgb), alpha its largest channel\n//\n// `toneMap` keeps the colors below a knee and rolls the brighter ones off\n// towards 1 (Reinhard) by their largest channel (hue preserving), whitening\n// only the very bright light a little: dense glowing clouds saturate\n// gracefully instead of clipping to white.\n\n/** Weight of the closest fragments; halves every 1/12 of the depth range */\nconst WEIGHT_SCALE = 64;\nconst WEIGHT_FALLOFF = 12;\nconst WEIGHT_MIN = 0.01;\n/** Largest alpha of a blended fragment (keeps −ln(1 − alpha) finite) */\nconst MAX_ALPHA = 0.999;\n/** Light values below the knee are kept */\nexport const TONE_KNEE = 0.6;\n/** Light values where the whitening starts / is full, and its amount */\nconst WHITE_FROM = 1;\nconst WHITE_TO = 6;\nconst WHITE_AMOUNT = 0.35;\n\n/**\n * Weight of a blended fragment at a depth (0 nearest … 1 farthest point of\n * the box sphere): 64 × 2^(−12 depth), at least 0.01. Accumulated in half\n * floats: about a thousand layers of the nearest fragments fit.\n */\nexport const oitWeight = (depth: number): number =>\n  Math.max(\n    WEIGHT_MIN,\n    WEIGHT_SCALE *\n      Math.pow(2, -WEIGHT_FALLOFF * Math.min(1, Math.max(0, depth))),\n  );\n\n/**\n * Soft shoulder: identity below `TONE_KNEE`, then a Reinhard roll-off\n * towards 1 (never reached) with a continuous slope: bright regions keep a\n * gradient instead of a flat plateau\n */\nexport const shoulder = (x: number): number => {\n  if (x <= TONE_KNEE) return x;\n  const t = (x - TONE_KNEE) / (1 - TONE_KNEE);\n  return TONE_KNEE + (1 - TONE_KNEE) * (t / (1 + t));\n};\n\nconst smoothstep = (a: number, b: number, x: number) => {\n  const t = Math.min(1, Math.max(0, (x - a) / (b - a)));\n  return t * t * (3 - 2 * t);\n};\n\n/** Tone mapping of additive light (linear, premultiplied) */\nexport const toneMap = (\n  rgb: readonly [number, number, number],\n): [number, number, number] => {\n  const m = Math.max(rgb[0], rgb[1], rgb[2]);\n  if (m <= 1e-6) return [rgb[0], rgb[1], rgb[2]];\n  const peak = shoulder(m);\n  const s = peak / m;\n  const white = smoothstep(WHITE_FROM, WHITE_TO, m) * WHITE_AMOUNT;\n  return [\n    rgb[0] * s + (peak - rgb[0] * s) * white,\n    rgb[1] * s + (peak - rgb[1] * s) * white,\n    rgb[2] * s + (peak - rgb[2] * s) * white,\n  ];\n};\n\n/** What a blended fragment adds to the two targets (JS mirror of the shaders) */\nexport const oitFragment = (\n  premultiplied: readonly [number, number, number, number],\n  depth: number,\n  additive: boolean,\n): { accum: number[]; extra: number[] } => {\n  const [r, g, b, alpha] = premultiplied;\n  if (additive) return { accum: [0, 0, 0, 0], extra: [r, g, b, 0] };\n  const a = Math.min(MAX_ALPHA, Math.max(0, alpha));\n  const w = oitWeight(depth);\n  return {\n    accum: [r * w, g * w, b * w, a * w],\n    extra: [0, 0, 0, -Math.log(1 - a)],\n  };\n};\n\n/** Composite of the targets: a premultiplied color (JS mirror of the shaders) */\nexport const oitComposite = (\n  accum: readonly number[],\n  extra: readonly number[],\n): [number, number, number, number] => {\n  const alpha = 1 - Math.exp(-(extra[3] ?? 0));\n  const k = alpha / Math.max(accum[3] ?? 0, 1e-6);\n  const light = toneMap([extra[0] ?? 0, extra[1] ?? 0, extra[2] ?? 0]);\n  const lightAlpha = Math.min(1, Math.max(light[0], light[1], light[2]));\n  const behind = 1 - alpha;\n  return [\n    (accum[0] ?? 0) * k + light[0] * behind,\n    (accum[1] ?? 0) * k + light[1] * behind,\n    (accum[2] ?? 0) * k + light[2] * behind,\n    alpha + lightAlpha * behind,\n  ];\n};\n\nconst f = (v: number) => (Number.isInteger(v) ? v.toFixed(1) : String(v));\n\n// ------------------------------------------------------------------- WGSL\n\n/** Second fragment entry point of the points and meshes: `fsOit` */\nexport const WGSL_OIT = /* wgsl */ `\nstruct Oit {\n  @location(0) accum: vec4f,\n  @location(1) extra: vec4f,\n};\n\nfn oit(c: vec4f, depth: f32) -> Oit {\n  var o: Oit;\n  if (u.light.w > 0.5) {\n    o.accum = vec4f(0.0);\n    o.extra = vec4f(c.rgb, 0.0);\n    return o;\n  }\n  let a = clamp(c.a, 0.0, ${f(MAX_ALPHA)});\n  let w = max(${f(WEIGHT_MIN)}, ${f(WEIGHT_SCALE)} * exp2(-${f(WEIGHT_FALLOFF)} * clamp(depth, 0.0, 1.0)));\n  o.accum = vec4f(c.rgb, a) * w;\n  o.extra = vec4f(0.0, 0.0, 0.0, -log(1.0 - a));\n  return o;\n}\n`;\n\nconst WGSL_TONE = /* wgsl */ `\nfn shoulder(x: f32) -> f32 {\n  if (x <= ${f(TONE_KNEE)}) { return x; }\n  let t = (x - ${f(TONE_KNEE)}) / ${f(1 - TONE_KNEE)};\n  return ${f(TONE_KNEE)} + ${f(1 - TONE_KNEE)} * t / (1.0 + t);\n}\n\nfn toneMap(rgb: vec3f) -> vec3f {\n  let m = max(max(rgb.r, rgb.g), rgb.b);\n  if (m <= 1e-6) { return rgb; }\n  let peak = shoulder(m);\n  let scaled = rgb * (peak / m);\n  return mix(scaled, vec3f(peak), smoothstep(${f(WHITE_FROM)}, ${f(WHITE_TO)}, m) * ${f(WHITE_AMOUNT)});\n}\n`;\n\n/** Full-screen composite of the two targets over the opaque scene */\nexport const WGSL_COMPOSITE = /* wgsl */ `${WGSL_TONE}\n@group(0) @binding(0) var accumTex: texture_2d<f32>;\n@group(0) @binding(1) var extraTex: texture_2d<f32>;\n\n@vertex\nfn vs(@builtin(vertex_index) vi: u32) -> @builtin(position) vec4f {\n  let p = vec2f(f32((vi << 1u) & 2u), f32(vi & 2u)) * 2.0 - 1.0;\n  return vec4f(p, 0.0, 1.0);\n}\n\n@fragment\nfn fs(@builtin(position) position: vec4f) -> @location(0) vec4f {\n  let xy = vec2i(position.xy);\n  let accum = textureLoad(accumTex, xy, 0);\n  let extra = textureLoad(extraTex, xy, 0);\n  let alpha = 1.0 - exp(-extra.a);\n  let light = toneMap(extra.rgb);\n  let lightAlpha = clamp(max(max(light.r, light.g), light.b), 0.0, 1.0);\n  let rgb = accum.rgb * (alpha / max(accum.a, 1e-6)) + light * (1.0 - alpha);\n  let a = alpha + lightAlpha * (1.0 - alpha);\n  if (a <= 0.0) { discard; }\n  return vec4f(rgb, a);\n}\n`;\n\n// ------------------------------------------------------------------- GLSL\n\n/** Outputs of the OIT variants (GLSL ES 3.0): `EMIT(color, depth)` */\nexport const GLSL_OIT = `\nlayout(location = 0) out vec4 o_accum;\nlayout(location = 1) out vec4 o_extra;\nvoid emitOit(vec4 c, float depth) {\n  if (u_light.w > 0.5) {\n    o_accum = vec4(0.0);\n    o_extra = vec4(c.rgb, 0.0);\n    return;\n  }\n  float a = clamp(c.a, 0.0, ${f(MAX_ALPHA)});\n  float w = max(${f(WEIGHT_MIN)}, ${f(WEIGHT_SCALE)} * exp2(-${f(WEIGHT_FALLOFF)} * clamp(depth, 0.0, 1.0)));\n  o_accum = vec4(c.rgb, a) * w;\n  o_extra = vec4(0.0, 0.0, 0.0, -log(1.0 - a));\n}\n#define EMIT(c, d) emitOit(c, d)\n`;\n\nconst GLSL_TONE = `\nfloat shoulder(float x) {\n  if (x <= ${f(TONE_KNEE)}) return x;\n  float t = (x - ${f(TONE_KNEE)}) / ${f(1 - TONE_KNEE)};\n  return ${f(TONE_KNEE)} + ${f(1 - TONE_KNEE)} * t / (1.0 + t);\n}\nvec3 toneMap(vec3 rgb) {\n  float m = max(max(rgb.r, rgb.g), rgb.b);\n  if (m <= 1e-6) return rgb;\n  float peak = shoulder(m);\n  vec3 scaled = rgb * (peak / m);\n  return mix(scaled, vec3(peak), smoothstep(${f(WHITE_FROM)}, ${f(WHITE_TO)}, m) * ${f(WHITE_AMOUNT)});\n}\n`;\n\n/** Composite program of WebGL2 (full-screen triangle from `gl_VertexID`) */\nexport const GLSL_COMPOSITE = {\n  vertex: `#version 300 es\nvoid main() {\n  vec2 p = vec2(float((gl_VertexID << 1) & 2), float(gl_VertexID & 2)) * 2.0 - 1.0;\n  gl_Position = vec4(p, 0.0, 1.0);\n}\n`,\n  fragment: `#version 300 es\nprecision highp float;\nuniform sampler2D u_accum;\nuniform sampler2D u_extra;\nout vec4 fragColor;\n${GLSL_TONE}\nvoid main() {\n  ivec2 xy = ivec2(gl_FragCoord.xy);\n  vec4 accum = texelFetch(u_accum, xy, 0);\n  vec4 extra = texelFetch(u_extra, xy, 0);\n  float alpha = 1.0 - exp(-extra.a);\n  vec3 light = toneMap(extra.rgb);\n  float lightAlpha = clamp(max(max(light.r, light.g), light.b), 0.0, 1.0);\n  vec3 rgb = accum.rgb * (alpha / max(accum.a, 1e-6)) + light * (1.0 - alpha);\n  float a = alpha + lightAlpha * (1.0 - alpha);\n  if (a <= 0.0) discard;\n  fragColor = vec4(rgb, a);\n}\n`,\n};\n"],"mappings":"AAuBA,IAAMA,EAAe,GACfC,EAAiB,GACjBC,EAAa,IAEbC,EAAY,KAELC,EAAY,GAEnBC,EAAa,EACbC,EAAW,EACXC,EAAe,IAgFfC,EAAK,GAAe,OAAO,UAAUC,CAAC,EAAIA,EAAE,QAAQ,CAAC,EAAI,OAAOA,CAAC,EAK1DC,EAAsB;;;;;;;;;;;;;4BAaPF,EAAEL,CAAS,EAAE;gBACzBK,EAAEN,CAAU,EAAE,IAAIM,EAAER,CAAY,EAAE,WAAWQ,EAAEP,CAAc,EAAE;;;;;EAwBlEU,EAA4B,GAAG;;aAf/BH,EAAEJ,CAAS,EAAE;iBACTI,EAAEJ,CAAS,EAAE,MAAMI,EAAE,EAAa,EAAE;WAC1CA,EAAEJ,CAAS,EAAE,KAAKI,EAAE,EAAa,EAAE;;;;;;;;+CAQCA,EAAEH,CAAU,EAAE,IAAIG,EAAEF,CAAQ,EAAE,SAASE,EAAED,CAAY,EAAE;;EAKhD;;;;;;;;;;;;;;;;;;;;;;;EA4BzCK,EAAW;;;;;;;;;8BASMJ,EAAEL,CAAS,EAAE;kBACzBK,EAAEN,CAAU,EAAE,IAAIM,EAAER,CAAY,EAAE,WAAWQ,EAAEP,CAAc,EAAE;;;;;EAuBpEY,EAAiB,CAC5B,OAAQ;;;;;EAMR,SAAU;;;;;EAKV;;aA1BWL,EAAEJ,CAAS,EAAE;mBACPI,EAAEJ,CAAS,EAAE,MAAMI,EAAE,EAAa,EAAE;WAC5CA,EAAEJ,CAAS,EAAE,KAAKI,EAAE,EAAa,EAAE;;;;;;;8CAOAA,EAAEH,CAAU,EAAE,IAAIG,EAAEF,CAAQ,EAAE,SAASE,EAAED,CAAY,EAAE;;EAiBzF;;;;;;;;;;;;;CAcZ"}
+{"version":3,"file":"oit.cjs","names":["WEIGHT_SCALE","WEIGHT_FALLOFF","WEIGHT_MIN","MAX_ALPHA","TONE_KNEE","WHITE_FROM","WHITE_TO","WHITE_AMOUNT","FRONT_EPSILON","FRONT_MIN_ALPHA","SCREEN_GAIN","f","v","WGSL_OIT","WGSL_COMPOSITE","GLSL_OIT","GLSL_FRONT","glslScreen","output","GLSL_COMPOSITE"],"sources":["../../../../../charts/src/engine/three-d/oit.ts"],"sourcesContent":["// Order-independent transparency of the WebGPU and WebGL2 backends: a hybrid\n// of an exact front layer and weighted blended OIT (McGuire & Bavoil 2013)\n// behind it, and the tone mapping of the additive light.\n//\n// 1. Front pass: the blended (non-additive) items write the depth of their\n//    visible fragments (alpha ≥ `FRONT_MIN_ALPHA`, depth 0 nearest … 1\n//    farthest point of the box sphere) into a single-channel float target\n//    cleared to `FRONT_CLEAR`, blended by `min`: the depth of the front-most\n//    transparent layer of every pixel. No depth test: a transparent fragment\n//    in front of the opaque scene is always nearer than a hidden one.\n// 2. Main pass: every blended item, in any order, without writing depth,\n//    into four float targets cleared to 0 and blended by plain addition:\n//\n//      front   rgba: Σ premultiplied color of the fragments of the front layer\n//                    (at most `FRONT_EPSILON` behind its depth): exact\n//      accum   rgb: Σ premultiplied color × w   a: Σ alpha × w (the rest)\n//      extra   rgb: Σ additive light in front of the front layer\n//              a:   Σ −ln(1 − alpha) of the rest (its revealage)\n//      behind  rgb: Σ additive light behind the front layer\n//\n//    w favours the fragments near the camera (`oitWeight`). The revealage\n//    Π(1 − alpha) is stored as the sum of its logarithms so that every\n//    target uses the same additive blending (WebGL2 has no per-target blend\n//    functions).\n// 3. Composite over the opaque scene (`oitComposite`): the front layer over\n//    the weighted average of the rest; the light behind the front layer,\n//    attenuated by it and by the mean transmittance of the rest, under the\n//    layers; the light in front of them over everything. Far-apart layers\n//    stay exact for the nearest one (plain WBOIT lets the farther layers\n//    bleed through), and glowing points behind a surface are dimmed by it.\n//\n// `toneMap` keeps the light below a knee and rolls the brighter light off\n// towards 1 (Reinhard) by its largest channel (hue preserving), whitening\n// only the very bright light a little: dense glowing clouds saturate\n// gracefully instead of clipping to white. Without float targets (WebGL 1,\n// Canvas2D), the light accumulates by screen blending, 1 − Π(1 − light):\n// the exponential `1 − e^(−SCREEN_GAIN × Σ light)` of its sum, close to the\n// same curve (`screenTone`); Canvas2D inverts it per pixel and applies\n// `toneMap` exactly.\n\n/** Weight of the closest fragments; halves every 1/12 of the depth range */\nconst WEIGHT_SCALE = 64;\nconst WEIGHT_FALLOFF = 12;\nconst WEIGHT_MIN = 0.01;\n/** Largest alpha of a blended fragment (keeps −ln(1 − alpha) finite) */\nconst MAX_ALPHA = 0.999;\n/** Light values below the knee are kept */\nexport const TONE_KNEE = 0.6;\n/** Light values where the whitening starts / is full, and its amount */\nconst WHITE_FROM = 1;\nconst WHITE_TO = 6;\nconst WHITE_AMOUNT = 0.35;\n/**\n * Depth (fraction of the box sphere diameter) within which the fragments\n * belong to the front layer: a few half-float steps\n */\nexport const FRONT_EPSILON = 2e-3;\n/** Front depth of the pixels without transparent fragment */\nexport const FRONT_CLEAR = 4;\n/** Fainter fragments don't define the front layer (soft edges, glows) */\nexport const FRONT_MIN_ALPHA = 0.05;\n/**\n * Gain of the exponential tone curve of the screen-blended light (WebGL 1,\n * no float targets): 1 − e^(−1.4 x) stays within 0.06 of `toneMap`'s curve\n */\nexport const SCREEN_GAIN = 1.4;\n\nconst clamp01 = (v: number) => Math.min(1, Math.max(0, v));\n\n/**\n * Weight of a blended fragment at a depth (0 nearest … 1 farthest point of\n * the box sphere): 64 × 2^(−12 depth), at least 0.01. Accumulated in half\n * floats: about a thousand layers of the nearest fragments fit.\n */\nexport const oitWeight = (depth: number): number =>\n  Math.max(\n    WEIGHT_MIN,\n    WEIGHT_SCALE * Math.pow(2, -WEIGHT_FALLOFF * clamp01(depth)),\n  );\n\n/**\n * Soft shoulder: identity below `TONE_KNEE`, then a Reinhard roll-off\n * towards 1 (never reached) with a continuous slope: bright regions keep a\n * gradient instead of a flat plateau\n */\nexport const shoulder = (x: number): number => {\n  if (x <= TONE_KNEE) return x;\n  const t = (x - TONE_KNEE) / (1 - TONE_KNEE);\n  return TONE_KNEE + (1 - TONE_KNEE) * (t / (1 + t));\n};\n\nconst smoothstep = (a: number, b: number, x: number) => {\n  const t = clamp01((x - a) / (b - a));\n  return t * t * (3 - 2 * t);\n};\n\n/**\n * Tone mapping of additive light (linear, premultiplied), into `out` when\n * given (no allocation: per pixel on the CPU)\n */\nexport const toneMap = (\n  rgb: readonly [number, number, number],\n  out: [number, number, number] = [0, 0, 0],\n): [number, number, number] => {\n  const m = Math.max(rgb[0], rgb[1], rgb[2]);\n  if (m <= 1e-6) {\n    out[0] = rgb[0];\n    out[1] = rgb[1];\n    out[2] = rgb[2];\n    return out;\n  }\n  const peak = shoulder(m);\n  const s = peak / m;\n  const white = smoothstep(WHITE_FROM, WHITE_TO, m) * WHITE_AMOUNT;\n  const r = rgb[0] * s;\n  const g = rgb[1] * s;\n  const b = rgb[2] * s;\n  out[0] = r + (peak - r) * white;\n  out[1] = g + (peak - g) * white;\n  out[2] = b + (peak - b) * white;\n  return out;\n};\n\n/**\n * Screen-blended light: what an additive fragment of light `x` (one channel)\n * writes with the blending `(one, one − src color)`. The framebuffer then\n * holds `1 − e^(−SCREEN_GAIN Σx)`: the light is tone mapped as it adds up.\n */\nexport const screenTone = (x: number): number =>\n  1 - Math.exp(-SCREEN_GAIN * Math.max(0, x));\n\n/** What a blended fragment adds to the four targets */\nexport interface OitOutput {\n  front: number[];\n  accum: number[];\n  extra: number[];\n  behind: number[];\n}\n\nconst ZERO = [0, 0, 0, 0] as const;\n\n/**\n * Depth of the front layer of a pixel from its blended fragments (JS\n * mirror of the front pass): the nearest visible non-additive fragment\n */\nexport const oitFrontDepth = (\n  fragments: readonly {\n    color: readonly [number, number, number, number];\n    depth: number;\n    additive?: boolean;\n  }[],\n): number => {\n  let front = FRONT_CLEAR;\n  for (const f of fragments) {\n    if (f.additive || f.color[3] < FRONT_MIN_ALPHA) continue;\n    front = Math.min(front, clamp01(f.depth));\n  }\n  return front;\n};\n\n/**\n * What a blended fragment adds to the targets (JS mirror of the shaders),\n * `front` the depth of the front layer of its pixel (`oitFrontDepth`)\n */\nexport const oitFragment = (\n  premultiplied: readonly [number, number, number, number],\n  depth: number,\n  additive: boolean,\n  front: number = FRONT_CLEAR,\n): OitOutput => {\n  const [r, g, b, alpha] = premultiplied;\n  const near = clamp01(depth) <= front + FRONT_EPSILON;\n  const out: OitOutput = {\n    front: [...ZERO],\n    accum: [...ZERO],\n    extra: [...ZERO],\n    behind: [...ZERO],\n  };\n  if (additive) {\n    if (near) out.extra = [r, g, b, 0];\n    else out.behind = [r, g, b, 0];\n    return out;\n  }\n  if (near) {\n    out.front = [r, g, b, alpha];\n    return out;\n  }\n  const a = Math.min(MAX_ALPHA, Math.max(0, alpha));\n  const w = oitWeight(depth);\n  out.accum = [r * w, g * w, b * w, a * w];\n  out.extra = [0, 0, 0, -Math.log(1 - a)];\n  return out;\n};\n\n/**\n * Composite of the targets: a premultiplied color blended over the opaque\n * scene (JS mirror of the shaders)\n */\nexport const oitComposite = (\n  accum: readonly number[],\n  extra: readonly number[],\n  front: readonly number[] = ZERO,\n  behind: readonly number[] = ZERO,\n): [number, number, number, number] => {\n  // the rest: weighted average color, alpha from the revealage\n  const tau = Math.max(0, extra[3] ?? 0);\n  const restAlpha = 1 - Math.exp(-tau);\n  const k = restAlpha / Math.max(accum[3] ?? 0, 1e-6);\n  // the front layer (several fragments at its depth: normalized)\n  const sum = Math.max(0, front[3] ?? 0);\n  const scale = sum > 1 ? 1 / sum : 1;\n  const fa = sum * scale;\n  const alpha = fa + restAlpha * (1 - fa);\n  const color = [0, 1, 2].map(\n    (i) => (front[i] ?? 0) * scale + (accum[i] ?? 0) * k * (1 - fa),\n  );\n  // light behind the front layer, mixed through the rest: its mean\n  // transmittance (1 − e^−τ) / τ\n  const meanT = tau > 1e-4 ? restAlpha / tau : 1;\n  const t = (1 - fa) * meanT;\n  const back = toneMap([behind[0] ?? 0, behind[1] ?? 0, behind[2] ?? 0]);\n  const backAlpha = clamp01(Math.max(back[0], back[1], back[2]));\n  const under = color.map((c, i) => c + back[i]! * t);\n  const underAlpha = Math.min(1, alpha + backAlpha * t);\n  // light in front of every layer\n  const light = toneMap([extra[0] ?? 0, extra[1] ?? 0, extra[2] ?? 0]);\n  const lightAlpha = clamp01(Math.max(light[0], light[1], light[2]));\n  return [\n    light[0] + under[0]! * (1 - lightAlpha),\n    light[1] + under[1]! * (1 - lightAlpha),\n    light[2] + under[2]! * (1 - lightAlpha),\n    lightAlpha + underAlpha * (1 - lightAlpha),\n  ];\n};\n\nconst f = (v: number) => (Number.isInteger(v) ? v.toFixed(1) : String(v));\n\n// ------------------------------------------------------------------- WGSL\n\n/**\n * Transparency outputs of the points and meshes (`fsOit`, `fsFront`): the\n * front depth texture is bound in group 1 by the main pass only\n */\nexport const WGSL_OIT = /* wgsl */ `\n@group(1) @binding(0) var frontTex: texture_2d<f32>;\n\nstruct Oit {\n  @location(0) front: vec4f,\n  @location(1) accum: vec4f,\n  @location(2) extra: vec4f,\n  @location(3) behind: vec4f,\n};\n\nfn oit(c: vec4f, depth: f32, xy: vec4f) -> Oit {\n  var o: Oit;\n  o.front = vec4f(0.0);\n  o.accum = vec4f(0.0);\n  o.extra = vec4f(0.0);\n  o.behind = vec4f(0.0);\n  let z = clamp(depth, 0.0, 1.0);\n  let near = z <= textureLoad(frontTex, vec2i(xy.xy), 0).r + ${f(FRONT_EPSILON)};\n  if (u.light.w > 0.5) {\n    if (near) { o.extra = vec4f(c.rgb, 0.0); } else { o.behind = vec4f(c.rgb, 0.0); }\n    return o;\n  }\n  if (near) {\n    o.front = c;\n    return o;\n  }\n  let a = clamp(c.a, 0.0, ${f(MAX_ALPHA)});\n  let w = max(${f(WEIGHT_MIN)}, ${f(WEIGHT_SCALE)} * exp2(-${f(WEIGHT_FALLOFF)} * z));\n  o.accum = vec4f(c.rgb, a) * w;\n  o.extra = vec4f(0.0, 0.0, 0.0, -log(1.0 - a));\n  return o;\n}\n\nfn frontDepth(c: vec4f, depth: f32) -> vec4f {\n  if (c.a < ${f(FRONT_MIN_ALPHA)}) { discard; }\n  return vec4f(clamp(depth, 0.0, 1.0));\n}\n\nfn screenLight(c: vec4f) -> vec4f {\n  if (u.light.w < 0.5) { return c; }\n  let v = vec3f(1.0) - exp(-${f(SCREEN_GAIN)} * max(c.rgb, vec3f(0.0)));\n  return vec4f(v, max(max(v.r, v.g), v.b));\n}\n`;\n\nconst WGSL_TONE = /* wgsl */ `\nfn shoulder(x: f32) -> f32 {\n  if (x <= ${f(TONE_KNEE)}) { return x; }\n  let t = (x - ${f(TONE_KNEE)}) / ${f(1 - TONE_KNEE)};\n  return ${f(TONE_KNEE)} + ${f(1 - TONE_KNEE)} * t / (1.0 + t);\n}\n\nfn toneMap(rgb: vec3f) -> vec3f {\n  let m = max(max(rgb.r, rgb.g), rgb.b);\n  if (m <= 1e-6) { return rgb; }\n  let peak = shoulder(m);\n  let scaled = rgb * (peak / m);\n  return mix(scaled, vec3f(peak), smoothstep(${f(WHITE_FROM)}, ${f(WHITE_TO)}, m) * ${f(WHITE_AMOUNT)});\n}\n`;\n\n/** Full-screen composite of the four targets over the opaque scene */\nexport const WGSL_COMPOSITE = /* wgsl */ `${WGSL_TONE}\n@group(0) @binding(0) var frontTex: texture_2d<f32>;\n@group(0) @binding(1) var accumTex: texture_2d<f32>;\n@group(0) @binding(2) var extraTex: texture_2d<f32>;\n@group(0) @binding(3) var behindTex: texture_2d<f32>;\n\n\n@vertex\nfn vs(@builtin(vertex_index) vi: u32) -> @builtin(position) vec4f {\n  let p = vec2f(f32((vi << 1u) & 2u), f32(vi & 2u)) * 2.0 - 1.0;\n  return vec4f(p, 0.0, 1.0);\n}\n\n@fragment\nfn fs(@builtin(position) position: vec4f) -> @location(0) vec4f {\n  let xy = vec2i(position.xy);\n  let front = textureLoad(frontTex, xy, 0);\n  let accum = textureLoad(accumTex, xy, 0);\n  let extra = textureLoad(extraTex, xy, 0);\n  let behind = textureLoad(behindTex, xy, 0);\n  let tau = max(extra.a, 0.0);\n  let restAlpha = 1.0 - exp(-tau);\n  let rest = accum.rgb * (restAlpha / max(accum.a, 1e-6));\n  let sum = max(front.a, 0.0);\n  let scale = select(1.0, 1.0 / max(sum, 1e-6), sum > 1.0);\n  let fa = sum * scale;\n  let alpha = fa + restAlpha * (1.0 - fa);\n  let color = front.rgb * scale + rest * (1.0 - fa);\n  let meanT = select(1.0, restAlpha / max(tau, 1e-6), tau > 1e-4);\n  let t = (1.0 - fa) * meanT;\n  let back = toneMap(behind.rgb);\n  let backAlpha = clamp(max(max(back.r, back.g), back.b), 0.0, 1.0);\n  let under = color + back * t;\n  let underAlpha = min(1.0, alpha + backAlpha * t);\n  let light = toneMap(extra.rgb);\n  let lightAlpha = clamp(max(max(light.r, light.g), light.b), 0.0, 1.0);\n  let a = lightAlpha + underAlpha * (1.0 - lightAlpha);\n  let rgb = light + under * (1.0 - lightAlpha);\n  if (a <= 0.0) { discard; }\n  return vec4f(rgb, a);\n}\n`;\n\n// ------------------------------------------------------------------- GLSL\n\n/**\n * Outputs of the OIT variants (GLSL ES 3.0): `EMIT(color, depth)`; the\n * front depth texture is `u_front`\n */\nexport const GLSL_OIT = `\nuniform highp sampler2D u_front;\nlayout(location = 0) out vec4 o_front;\nlayout(location = 1) out vec4 o_accum;\nlayout(location = 2) out vec4 o_extra;\nlayout(location = 3) out vec4 o_behind;\nvoid emitOit(vec4 c, float depth) {\n  o_front = vec4(0.0);\n  o_accum = vec4(0.0);\n  o_extra = vec4(0.0);\n  o_behind = vec4(0.0);\n  float z = clamp(depth, 0.0, 1.0);\n  bool near = z <= texelFetch(u_front, ivec2(gl_FragCoord.xy), 0).r + ${f(FRONT_EPSILON)};\n  if (u_light.w > 0.5) {\n    if (near) o_extra = vec4(c.rgb, 0.0); else o_behind = vec4(c.rgb, 0.0);\n    return;\n  }\n  if (near) {\n    o_front = c;\n    return;\n  }\n  float a = clamp(c.a, 0.0, ${f(MAX_ALPHA)});\n  float w = max(${f(WEIGHT_MIN)}, ${f(WEIGHT_SCALE)} * exp2(-${f(WEIGHT_FALLOFF)} * z));\n  o_accum = vec4(c.rgb, a) * w;\n  o_extra = vec4(0.0, 0.0, 0.0, -log(1.0 - a));\n}\n#define EMIT(c, d) emitOit(c, d)\n`;\n\n/** Output of the front pass (GLSL ES 3.0): the depth of visible fragments */\nexport const GLSL_FRONT = `\nout vec4 fragColor;\nvoid emitFront(vec4 c, float depth) {\n  if (c.a < ${f(FRONT_MIN_ALPHA)}) discard;\n  fragColor = vec4(clamp(depth, 0.0, 1.0));\n}\n#define EMIT(c, d) emitFront(c, d)\n`;\n\n/**\n * Plain output (`output` the output variable): additive light screen\n * blended, tone mapped as it adds up (`screenTone`)\n */\nexport const glslScreen = (output: string) => `\nvec4 screenLight(vec4 c) {\n  if (u_light.w < 0.5) return c;\n  vec3 v = vec3(1.0) - exp(-${f(SCREEN_GAIN)} * max(c.rgb, vec3(0.0)));\n  return vec4(v, max(max(v.r, v.g), v.b));\n}\n#define EMIT(c, d) ${output} = screenLight(c)\n`;\n\nconst GLSL_TONE = `\nfloat shoulder(float x) {\n  if (x <= ${f(TONE_KNEE)}) return x;\n  float t = (x - ${f(TONE_KNEE)}) / ${f(1 - TONE_KNEE)};\n  return ${f(TONE_KNEE)} + ${f(1 - TONE_KNEE)} * t / (1.0 + t);\n}\nvec3 toneMap(vec3 rgb) {\n  float m = max(max(rgb.r, rgb.g), rgb.b);\n  if (m <= 1e-6) return rgb;\n  float peak = shoulder(m);\n  vec3 scaled = rgb * (peak / m);\n  return mix(scaled, vec3(peak), smoothstep(${f(WHITE_FROM)}, ${f(WHITE_TO)}, m) * ${f(WHITE_AMOUNT)});\n}\n`;\n\n/** Composite program of WebGL2 (full-screen triangle from `gl_VertexID`) */\nexport const GLSL_COMPOSITE = {\n  vertex: `#version 300 es\nvoid main() {\n  vec2 p = vec2(float((gl_VertexID << 1) & 2), float(gl_VertexID & 2)) * 2.0 - 1.0;\n  gl_Position = vec4(p, 0.0, 1.0);\n}\n`,\n  fragment: `#version 300 es\nprecision highp float;\nuniform sampler2D u_frontColor;\nuniform sampler2D u_accum;\nuniform sampler2D u_extra;\nuniform sampler2D u_behind;\nout vec4 fragColor;\n${GLSL_TONE}\nvoid main() {\n  ivec2 xy = ivec2(gl_FragCoord.xy);\n  vec4 front = texelFetch(u_frontColor, xy, 0);\n  vec4 accum = texelFetch(u_accum, xy, 0);\n  vec4 extra = texelFetch(u_extra, xy, 0);\n  vec4 behind = texelFetch(u_behind, xy, 0);\n  float tau = max(extra.a, 0.0);\n  float restAlpha = 1.0 - exp(-tau);\n  vec3 rest = accum.rgb * (restAlpha / max(accum.a, 1e-6));\n  float sum = max(front.a, 0.0);\n  float scale = sum > 1.0 ? 1.0 / sum : 1.0;\n  float fa = sum * scale;\n  float alpha = fa + restAlpha * (1.0 - fa);\n  vec3 color = front.rgb * scale + rest * (1.0 - fa);\n  float meanT = tau > 1e-4 ? restAlpha / tau : 1.0;\n  float t = (1.0 - fa) * meanT;\n  vec3 back = toneMap(behind.rgb);\n  float backAlpha = clamp(max(max(back.r, back.g), back.b), 0.0, 1.0);\n  vec3 under = color + back * t;\n  float underAlpha = min(1.0, alpha + backAlpha * t);\n  vec3 light = toneMap(extra.rgb);\n  float lightAlpha = clamp(max(max(light.r, light.g), light.b), 0.0, 1.0);\n  float a = lightAlpha + underAlpha * (1.0 - lightAlpha);\n  vec3 rgb = light + under * (1.0 - lightAlpha);\n  if (a <= 0.0) discard;\n  fragColor = vec4(rgb, a);\n}\n`,\n};\n"],"mappings":"AAyCA,IAAMA,EAAe,GACfC,EAAiB,GACjBC,EAAa,IAEbC,EAAY,KAELC,EAAY,GAEnBC,EAAa,EACbC,EAAW,EACXC,EAAe,IAKRC,EAAgB,KAIhBC,EAAkB,IAKlBC,EAAc,IA0KrBC,EAAK,GAAe,OAAO,UAAUC,CAAC,EAAIA,EAAE,QAAQ,CAAC,EAAI,OAAOA,CAAC,EAQ1DC,EAAsB;;;;;;;;;;;;;;;;;+DAiB4BF,EAAEH,CAAa,EAAE;;;;;;;;;4BASpDG,EAAER,CAAS,EAAE;gBACzBQ,EAAET,CAAU,EAAE,IAAIS,EAAEX,CAAY,EAAE,WAAWW,EAAEV,CAAc,EAAE;;;;;;;cAOjEU,EAAEF,CAAe,EAAE;;;;;;8BAMHE,EAAED,CAAW,EAAE;;;EAsBhCI,EAA4B,GAAG;;aAf/BH,EAAEP,CAAS,EAAE;iBACTO,EAAEP,CAAS,EAAE,MAAMO,EAAE,EAAa,EAAE;WAC1CA,EAAEP,CAAS,EAAE,KAAKO,EAAE,EAAa,EAAE;;;;;;;;+CAQCA,EAAEN,CAAU,EAAE,IAAIM,EAAEL,CAAQ,EAAE,SAASK,EAAEJ,CAAY,EAAE;;EAKhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiDzCQ,EAAW;;;;;;;;;;;;wEAYgDJ,EAAEH,CAAa,EAAE;;;;;;;;;8BAS3DG,EAAER,CAAS,EAAE;kBACzBQ,EAAET,CAAU,EAAE,IAAIS,EAAEX,CAAY,EAAE,WAAWW,EAAEV,CAAc,EAAE;;;;;EAQpEe,EAAa;;;cAGZL,EAAEF,CAAe,EAAE;;;;EAUpBQ,EAAc,GAAmB;;;8BAGhBN,EAAED,CAAW,EAAE;;;qBAGxBQ,EAAO;EAmBfC,EAAiB,CAC5B,OAAQ;;;;;EAMR,SAAU;;;;;;;EAOV;;aA5BWR,EAAEP,CAAS,EAAE;mBACPO,EAAEP,CAAS,EAAE,MAAMO,EAAE,EAAa,EAAE;WAC5CA,EAAEP,CAAS,EAAE,KAAKO,EAAE,EAAa,EAAE;;;;;;;8CAOAA,EAAEN,CAAU,EAAE,IAAIM,EAAEL,CAAQ,EAAE,SAASK,EAAEJ,CAAY,EAAE;;EAmBzF;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BZ"}

package/dist/charts/engine/three-d/oit.d.cts

@@ -1,5 +1,19 @@
 /** Light values below the knee are kept */
 export declare const TONE_KNEE = 0.6;
+/**
+ * Depth (fraction of the box sphere diameter) within which the fragments
+ * belong to the front layer: a few half-float steps
+ */
+export declare const FRONT_EPSILON = 0.002;
+/** Front depth of the pixels without transparent fragment */
+export declare const FRONT_CLEAR = 4;
+/** Fainter fragments don't define the front layer (soft edges, glows) */
+export declare const FRONT_MIN_ALPHA = 0.05;
+/**
+ * Gain of the exponential tone curve of the screen-blended light (WebGL 1,
+ * no float targets): 1 − e^(−1.4 x) stays within 0.06 of `toneMap`'s curve
+ */
+export declare const SCREEN_GAIN = 1.4;
 /**
  * Weight of a blended fragment at a depth (0 nearest … 1 farthest point of
  * the box sphere): 64 × 2^(−12 depth), at least 0.01. Accumulated in half
@@ -12,21 +26,62 @@ export declare const oitWeight: (depth: number) => number;
  * gradient instead of a flat plateau
  */
 export declare const shoulder: (x: number) => number;
-/** Tone mapping of additive light (linear, premultiplied) */
-export declare const toneMap: (rgb: readonly [number, number, number]) => [number, number, number];
-/** What a blended fragment adds to the two targets (JS mirror of the shaders) */
-export declare const oitFragment: (premultiplied: readonly [number, number, number, number], depth: number, additive: boolean) => {
+/**
+ * Tone mapping of additive light (linear, premultiplied), into `out` when
+ * given (no allocation: per pixel on the CPU)
+ */
+export declare const toneMap: (rgb: readonly [number, number, number], out?: [number, number, number]) => [number, number, number];
+/**
+ * Screen-blended light: what an additive fragment of light `x` (one channel)
+ * writes with the blending `(one, one − src color)`. The framebuffer then
+ * holds `1 − e^(−SCREEN_GAIN Σx)`: the light is tone mapped as it adds up.
+ */
+export declare const screenTone: (x: number) => number;
+/** What a blended fragment adds to the four targets */
+export interface OitOutput {
+    front: number[];
     accum: number[];
     extra: number[];
-};
-/** Composite of the targets: a premultiplied color (JS mirror of the shaders) */
-export declare const oitComposite: (accum: readonly number[], extra: readonly number[]) => [number, number, number, number];
-/** Second fragment entry point of the points and meshes: `fsOit` */
+    behind: number[];
+}
+/**
+ * Depth of the front layer of a pixel from its blended fragments (JS
+ * mirror of the front pass): the nearest visible non-additive fragment
+ */
+export declare const oitFrontDepth: (fragments: readonly {
+    color: readonly [number, number, number, number];
+    depth: number;
+    additive?: boolean;
+}[]) => number;
+/**
+ * What a blended fragment adds to the targets (JS mirror of the shaders),
+ * `front` the depth of the front layer of its pixel (`oitFrontDepth`)
+ */
+export declare const oitFragment: (premultiplied: readonly [number, number, number, number], depth: number, additive: boolean, front?: number) => OitOutput;
+/**
+ * Composite of the targets: a premultiplied color blended over the opaque
+ * scene (JS mirror of the shaders)
+ */
+export declare const oitComposite: (accum: readonly number[], extra: readonly number[], front?: readonly number[], behind?: readonly number[]) => [number, number, number, number];
+/**
+ * Transparency outputs of the points and meshes (`fsOit`, `fsFront`): the
+ * front depth texture is bound in group 1 by the main pass only
+ */
 export declare const WGSL_OIT: string;
-/** Full-screen composite of the two targets over the opaque scene */
+/** Full-screen composite of the four targets over the opaque scene */
 export declare const WGSL_COMPOSITE: string;
-/** Outputs of the OIT variants (GLSL ES 3.0): `EMIT(color, depth)` */
+/**
+ * Outputs of the OIT variants (GLSL ES 3.0): `EMIT(color, depth)`; the
+ * front depth texture is `u_front`
+ */
 export declare const GLSL_OIT: string;
+/** Output of the front pass (GLSL ES 3.0): the depth of visible fragments */
+export declare const GLSL_FRONT: string;
+/**
+ * Plain output (`output` the output variable): additive light screen
+ * blended, tone mapped as it adds up (`screenTone`)
+ */
+export declare const glslScreen: (output: string) => string;
 /** Composite program of WebGL2 (full-screen triangle from `gl_VertexID`) */
 export declare const GLSL_COMPOSITE: {
     vertex: string;

package/dist/charts/engine/three-d/oit.d.ts

@@ -1,5 +1,19 @@
 /** Light values below the knee are kept */
 export declare const TONE_KNEE = 0.6;
+/**
+ * Depth (fraction of the box sphere diameter) within which the fragments
+ * belong to the front layer: a few half-float steps
+ */
+export declare const FRONT_EPSILON = 0.002;
+/** Front depth of the pixels without transparent fragment */
+export declare const FRONT_CLEAR = 4;
+/** Fainter fragments don't define the front layer (soft edges, glows) */
+export declare const FRONT_MIN_ALPHA = 0.05;
+/**
+ * Gain of the exponential tone curve of the screen-blended light (WebGL 1,
+ * no float targets): 1 − e^(−1.4 x) stays within 0.06 of `toneMap`'s curve
+ */
+export declare const SCREEN_GAIN = 1.4;
 /**
  * Weight of a blended fragment at a depth (0 nearest … 1 farthest point of
  * the box sphere): 64 × 2^(−12 depth), at least 0.01. Accumulated in half
@@ -12,21 +26,62 @@ export declare const oitWeight: (depth: number) => number;
  * gradient instead of a flat plateau
  */
 export declare const shoulder: (x: number) => number;
-/** Tone mapping of additive light (linear, premultiplied) */
-export declare const toneMap: (rgb: readonly [number, number, number]) => [number, number, number];
-/** What a blended fragment adds to the two targets (JS mirror of the shaders) */
-export declare const oitFragment: (premultiplied: readonly [number, number, number, number], depth: number, additive: boolean) => {
+/**
+ * Tone mapping of additive light (linear, premultiplied), into `out` when
+ * given (no allocation: per pixel on the CPU)
+ */
+export declare const toneMap: (rgb: readonly [number, number, number], out?: [number, number, number]) => [number, number, number];
+/**
+ * Screen-blended light: what an additive fragment of light `x` (one channel)
+ * writes with the blending `(one, one − src color)`. The framebuffer then
+ * holds `1 − e^(−SCREEN_GAIN Σx)`: the light is tone mapped as it adds up.
+ */
+export declare const screenTone: (x: number) => number;
+/** What a blended fragment adds to the four targets */
+export interface OitOutput {
+    front: number[];
     accum: number[];
     extra: number[];
-};
-/** Composite of the targets: a premultiplied color (JS mirror of the shaders) */
-export declare const oitComposite: (accum: readonly number[], extra: readonly number[]) => [number, number, number, number];
-/** Second fragment entry point of the points and meshes: `fsOit` */
+    behind: number[];
+}
+/**
+ * Depth of the front layer of a pixel from its blended fragments (JS
+ * mirror of the front pass): the nearest visible non-additive fragment
+ */
+export declare const oitFrontDepth: (fragments: readonly {
+    color: readonly [number, number, number, number];
+    depth: number;
+    additive?: boolean;
+}[]) => number;
+/**
+ * What a blended fragment adds to the targets (JS mirror of the shaders),
+ * `front` the depth of the front layer of its pixel (`oitFrontDepth`)
+ */
+export declare const oitFragment: (premultiplied: readonly [number, number, number, number], depth: number, additive: boolean, front?: number) => OitOutput;
+/**
+ * Composite of the targets: a premultiplied color blended over the opaque
+ * scene (JS mirror of the shaders)
+ */
+export declare const oitComposite: (accum: readonly number[], extra: readonly number[], front?: readonly number[], behind?: readonly number[]) => [number, number, number, number];
+/**
+ * Transparency outputs of the points and meshes (`fsOit`, `fsFront`): the
+ * front depth texture is bound in group 1 by the main pass only
+ */
 export declare const WGSL_OIT: string;
-/** Full-screen composite of the two targets over the opaque scene */
+/** Full-screen composite of the four targets over the opaque scene */
 export declare const WGSL_COMPOSITE: string;
-/** Outputs of the OIT variants (GLSL ES 3.0): `EMIT(color, depth)` */
+/**
+ * Outputs of the OIT variants (GLSL ES 3.0): `EMIT(color, depth)`; the
+ * front depth texture is `u_front`
+ */
 export declare const GLSL_OIT: string;
+/** Output of the front pass (GLSL ES 3.0): the depth of visible fragments */
+export declare const GLSL_FRONT: string;
+/**
+ * Plain output (`output` the output variable): additive light screen
+ * blended, tone mapped as it adds up (`screenTone`)
+ */
+export declare const glslScreen: (output: string) => string;
 /** Composite program of WebGL2 (full-screen triangle from `gl_VertexID`) */
 export declare const GLSL_COMPOSITE: {
     vertex: string;