minerva-design 1.4.0 → 1.6.0

package/dist/charts/engine/three-d/shaders.js

@@ -1,39 +1,62 @@
+import { writesDepth as e } from "./render-types.js";
+import { GLSL_OIT as t, WGSL_OIT as n } from "./oit.js";
 //#region src/engine/three-d/shaders.ts
-var e = (e, t, n, r, i, a, o, s) => (e.set(t, 0), e.set(n, 16), e.set(r, 20), e.set(i, 24), e.set(a, 28), e.set(o, 32), e.set(s, 36), e), t = (t, n, r) => {
-	let i = t.kind === "points" ? +!!t.perspective : t.kind === "lines" ? t.width : 0;
-	return e(r, n.viewProj, [
-		n.width,
-		n.height,
-		n.dpr,
-		+!!n.orthographic
+var r = (e, t, n, r, i, a, o, s) => (e.set(t, 0), e.set(n, 16), e.set(r, 20), e.set(i, 24), e.set(a, 28), e.set(o, 32), e.set(s, 36), e), i = (e, t, n) => {
+	let i = e.kind === "points" ? +!!e.perspective : e.kind === "lines" ? e.width : 0;
+	return r(n, t.viewProj, [
+		t.width,
+		t.height,
+		t.dpr,
+		+!!t.orthographic
 	], [
-		n.eye[0],
-		n.eye[1],
-		n.eye[2],
-		t.kind === "lines" ? t.bias : 0
+		t.eye[0],
+		t.eye[1],
+		t.eye[2],
+		e.kind === "lines" ? e.bias : e.kind === "points" ? e.style ?? 0 : 0
 	], [
-		n.light[0],
-		n.light[1],
-		n.light[2],
-		0
-	], n.lighting, [
-		t.opacity,
+		t.light[0],
+		t.light[1],
+		t.light[2],
+		e.kind === "points" && e.additive ? 1 : 0
+	], t.lighting, [
+		e.opacity,
 		i,
-		n.distance,
-		n.radius
+		t.distance,
+		t.radius
 	], [
-		n.fog[0],
-		n.fog[1],
-		n.fog[2],
-		1
+		t.fog[0],
+		t.fog[1],
+		t.fog[2],
+		t.exposure
 	]);
-}, n = (e) => e.opacity >= 1, r = "\nstruct U {\n  viewProj: mat4x4f,\n  viewport: vec4f,\n  eye: vec4f,\n  light: vec4f,\n  material: vec4f,\n  params: vec4f,\n  fog: vec4f,\n};\n@group(0) @binding(0) var<uniform> u: U;\n\nfn toWebGpuDepth(p: vec4f) -> vec4f {\n  return vec4f(p.x, p.y, (p.z + p.w) * 0.5, p.w);\n}\n\nfn depthCue(world: vec3f) -> f32 {\n  let near = u.params.z - u.params.w;\n  return clamp((length(world - u.eye.xyz) - near) / (2.0 * u.params.w), 0.0, 1.0);\n}\n", i = `${r}
+}, a = `
+struct U {
+  viewProj: mat4x4f,
+  viewport: vec4f,
+  eye: vec4f,
+  light: vec4f,
+  material: vec4f,
+  params: vec4f,
+  fog: vec4f,
+};
+@group(0) @binding(0) var<uniform> u: U;
+
+fn toWebGpuDepth(p: vec4f) -> vec4f {
+  return vec4f(p.x, p.y, (p.z + p.w) * 0.5, p.w);
+}
+
+fn depthCue(world: vec3f) -> f32 {
+  let near = u.params.z - u.params.w;
+  return clamp((length(world - u.eye.xyz) - near) / (2.0 * u.params.w), 0.0, 1.0);
+}
+${n}`, o = `${a}
 struct Out {
   @builtin(position) position: vec4f,
   @location(0) offset: vec2f,
   @location(1) radius: f32,
   @location(2) color: vec4f,
   @location(3) fog: f32,
+  @location(4) coverage: f32,
 };
 
 @vertex
@@ -50,34 +73,62 @@ fn vs(
   if (u.params.y > 0.5 && u.viewport.w < 0.5) {
     factor = clamp(u.params.z / max(clip.w, 1e-6), 0.5, 2.0);
   }
-  let radius = max(0.5, size * u.viewport.z * factor * 0.5);
-  let reach = radius + 1.0;
+  let glow = u.eye.w > 1.5;
+  let raw = max(size, 0.0) * u.viewport.z * factor * 0.5;
+  let radius = max(raw, select(0.5, 0.75, glow));
+  let reach = select(radius + 1.0, radius * 2.2 + 1.0, glow);
   let shift = corner * reach * 2.0 / u.viewport.xy * clip.w;
   out.position = toWebGpuDepth(vec4f(clip.xy + shift, clip.z, clip.w));
   out.offset = corner * reach;
   out.radius = radius;
   out.color = color;
-  out.fog = depthCue(pos) * 0.45;
+  out.fog = depthCue(pos);
+  out.coverage = min(1.0, raw * raw / (radius * radius));
   return out;
 }
 
-@fragment
-fn fs(in: Out) -> @location(0) vec4f {
+fn shade(in: Out) -> vec4f {
   let d = length(in.offset);
-  var alpha = clamp(in.radius + 0.5 - d, 0.0, 1.0);
-  if (alpha <= 0.0) { discard; }
-  let q = min(d / in.radius, 1.0);
-  let n = vec3f(in.offset.x / in.radius, in.offset.y / in.radius, sqrt(max(0.0, 1.0 - q * q)));
-  let l = normalize(vec3f(-0.45, 0.55, 0.7));
-  let lambert = max(dot(n, l), 0.0);
-  let shaded = in.color.rgb * (0.62 + 0.45 * lambert) + vec3f(pow(lambert, 18.0) * 0.28);
-  let sphere = smoothstep(1.5, 3.5, in.radius);
-  var rgb = mix(in.color.rgb, shaded, sphere);
-  rgb = mix(rgb, u.fog.rgb, in.fog);
-  alpha = alpha * in.color.a * u.params.x;
+  let r = in.radius;
+  var alpha = clamp(r + 0.5 - d, 0.0, 1.0);
+  var rgb = in.color.rgb;
+  if (u.eye.w > 1.5) {
+    // glow: an anti-aliased core and a gaussian halo
+    let core = clamp(r * 0.6 + 0.5 - d, 0.0, 1.0);
+    let q = d / r;
+    alpha = core + (1.0 - core) * exp(-1.2 * q * q);
+    rgb = rgb + (vec3f(1.0) - rgb) * (0.2 * core);
+  } else if (u.eye.w < 0.5) {
+    let q = min(d / r, 1.0);
+    let n = vec3f(in.offset.x / r, in.offset.y / r, sqrt(max(0.0, 1.0 - q * q)));
+    let l = normalize(vec3f(-0.45, 0.55, 0.7));
+    let lambert = max(dot(n, l), 0.0);
+    let shaded = rgb * (0.62 + 0.45 * lambert) + vec3f(pow(lambert, 18.0) * 0.28);
+    rgb = mix(rgb, shaded, smoothstep(1.5, 3.5, r));
+  }
+  if (alpha <= 0.004) { discard; }
+  let fog = in.fog * 0.45;
+  if (u.light.w > 0.5) {
+    // additive light fades with the distance
+    alpha = alpha * (1.0 - fog);
+    rgb = rgb * u.fog.w;
+  } else {
+    rgb = mix(rgb, u.fog.rgb, fog);
+  }
+  alpha = alpha * in.coverage * in.color.a * u.params.x;
   return vec4f(rgb * alpha, alpha);
 }
-`, a = `${r}
+
+@fragment
+fn fs(in: Out) -> @location(0) vec4f {
+  return shade(in);
+}
+
+@fragment
+fn fsOit(in: Out) -> Oit {
+  return oit(shade(in), in.fog);
+}
+`, s = `${a}
 struct Out {
   @builtin(position) position: vec4f,
   @location(0) world: vec3f,
@@ -99,8 +150,7 @@ fn vs(
   return out;
 }
 
-@fragment
-fn fs(in: Out) -> @location(0) vec4f {
+fn shade(in: Out) -> vec4f {
   var n = normalize(in.normal);
   let v = normalize(u.eye.xyz - in.world);
   if (dot(n, v) < 0.0) { n = -n; }
@@ -112,7 +162,17 @@ fn fs(in: Out) -> @location(0) vec4f {
   let alpha = in.color.a * u.params.x;
   return vec4f(rgb * alpha, alpha);
 }
-`, o = `${r}
+
+@fragment
+fn fs(in: Out) -> @location(0) vec4f {
+  return shade(in);
+}
+
+@fragment
+fn fsOit(in: Out) -> Oit {
+  return oit(shade(in), depthCue(in.world));
+}
+`, c = `${a}
 struct Out {
   @builtin(position) position: vec4f,
   @location(0) across: f32,
@@ -156,17 +216,20 @@ fn fs(in: Out) -> @location(0) vec4f {
   if (alpha <= 0.0) { discard; }
   return vec4f(in.color.rgb * alpha, alpha);
 }
-`, s = "\nuniform mat4 u_viewProj;\nuniform vec4 u_viewport;\nuniform vec4 u_eye;\nuniform vec4 u_light;\nuniform vec4 u_material;\nuniform vec4 u_params;\nuniform vec4 u_fog;\n", c = "\nattribute vec2 a_corner;\nattribute vec3 a_pos;\nattribute float a_size;\nattribute vec4 a_color;\nvarying vec2 v_offset;\nvarying float v_radius;\nvarying vec4 v_color;\nvarying float v_fog;\nvoid main() {\n  vec2 corner = a_corner * 2.0 - 1.0;\n  vec4 clip = u_viewProj * vec4(a_pos, 1.0);\n  float factor = 1.0;\n  if (u_params.y > 0.5 && u_viewport.w < 0.5) {\n    factor = clamp(u_params.z / max(clip.w, 1e-6), 0.5, 2.0);\n  }\n  float radius = max(0.5, a_size * u_viewport.z * factor * 0.5);\n  float reach = radius + 1.0;\n  vec2 shift = corner * reach * 2.0 / u_viewport.xy * clip.w;\n  gl_Position = vec4(clip.xy + shift, clip.z, clip.w);\n  v_offset = corner * reach;\n  v_radius = radius;\n  v_color = a_color;\n  float near = u_params.z - u_params.w;\n  v_fog = clamp((length(a_pos - u_eye.xyz) - near) / (2.0 * u_params.w), 0.0, 1.0) * 0.45;\n}\n", l = "\nvarying vec2 v_offset;\nvarying float v_radius;\nvarying vec4 v_color;\nvarying float v_fog;\nvoid main() {\n  float d = length(v_offset);\n  float alpha = clamp(v_radius + 0.5 - d, 0.0, 1.0);\n  if (alpha <= 0.0) discard;\n  float q = min(d / v_radius, 1.0);\n  vec3 n = vec3(v_offset / v_radius, sqrt(max(0.0, 1.0 - q * q)));\n  vec3 l = normalize(vec3(-0.45, 0.55, 0.7));\n  float lambert = max(dot(n, l), 0.0);\n  vec3 shaded = v_color.rgb * (0.62 + 0.45 * lambert) + vec3(pow(lambert, 18.0) * 0.28);\n  float sphere = smoothstep(1.5, 3.5, v_radius);\n  vec3 rgb = mix(v_color.rgb, shaded, sphere);\n  rgb = mix(rgb, u_fog.rgb, v_fog);\n  alpha = alpha * v_color.a * u_params.x;\n  FRAG = vec4(rgb * alpha, alpha);\n}\n", u = "\nattribute vec3 a_pos;\nattribute vec3 a_normal;\nattribute vec4 a_color;\nvarying vec3 v_world;\nvarying vec3 v_normal;\nvarying vec4 v_color;\nvoid main() {\n  gl_Position = u_viewProj * vec4(a_pos, 1.0);\n  v_world = a_pos;\n  v_normal = a_normal;\n  v_color = a_color;\n}\n", d = "\nvarying vec3 v_world;\nvarying vec3 v_normal;\nvarying vec4 v_color;\nvoid main() {\n  vec3 n = normalize(v_normal);\n  vec3 v = normalize(u_eye.xyz - v_world);\n  if (dot(n, v) < 0.0) n = -n;\n  vec3 l = u_light.xyz;\n  float diffuse = max(dot(n, l), 0.0);\n  vec3 h = normalize(l + v);\n  float specular = pow(max(dot(n, h), 0.0), u_material.w) * u_material.z;\n  vec3 rgb = v_color.rgb * (u_material.x + u_material.y * diffuse) + vec3(specular);\n  float alpha = v_color.a * u_params.x;\n  FRAG = vec4(rgb * alpha, alpha);\n}\n", f = "\nattribute vec2 a_corner;\nattribute vec3 a_a;\nattribute vec3 a_b;\nattribute vec4 a_color;\nvarying float v_across;\nvarying vec4 v_color;\nvoid main() {\n  vec4 ca = u_viewProj * vec4(a_a, 1.0);\n  vec4 cb = u_viewProj * vec4(a_b, 1.0);\n  vec2 halfSize = u_viewport.xy * 0.5;\n  vec2 sa = ca.xy / ca.w * halfSize;\n  vec2 sb = cb.xy / cb.w * halfSize;\n  vec2 dir = sb - sa;\n  float len = length(dir);\n  dir = len > 1e-6 ? dir / len : vec2(1.0, 0.0);\n  vec2 normal = vec2(-dir.y, dir.x);\n  float w = max(0.5, u_params.y * u_viewport.z * 0.5) + 0.5;\n  bool atEnd = a_corner.x > 0.5;\n  vec4 clip = atEnd ? cb : ca;\n  float side = a_corner.y * 2.0 - 1.0;\n  vec2 pixel = (atEnd ? sb : sa) + dir * (a_corner.x * 2.0 - 1.0) * w + normal * side * w;\n  gl_Position = vec4(pixel / halfSize * clip.w, clip.z - u_eye.w * clip.w, clip.w);\n  v_across = side * w;\n  v_color = a_color;\n}\n", p = "\nvarying float v_across;\nvarying vec4 v_color;\nvoid main() {\n  float core = u_params.y * u_viewport.z * 0.5;\n  float coverage = clamp(max(core, 0.5) + 0.5 - abs(v_across), 0.0, 1.0) * min(1.0, core * 2.0);\n  float alpha = coverage * v_color.a * u_params.x;\n  if (alpha <= 0.0) discard;\n  FRAG = vec4(v_color.rgb * alpha, alpha);\n}\n", m = "\n#ifdef GL_FRAGMENT_PRECISION_HIGH\nprecision highp float;\n#else\nprecision mediump float;\n#endif\n", h = (e, t, n) => n === 2 ? {
-	vertex: `#version 300 es\n#define attribute in\n#define varying out\n${s}${e}`,
-	fragment: `#version 300 es\nprecision highp float;\n#define varying in\nout vec4 fragColor;\n#define FRAG fragColor\n${s}${t}`
+`, l = "\nuniform mat4 u_viewProj;\nuniform vec4 u_viewport;\nuniform vec4 u_eye;\nuniform vec4 u_light;\nuniform vec4 u_material;\nuniform vec4 u_params;\nuniform vec4 u_fog;\n", u = "\nattribute vec2 a_corner;\nattribute vec3 a_pos;\nattribute float a_size;\nattribute vec4 a_color;\nvarying vec2 v_offset;\nvarying float v_radius;\nvarying vec4 v_color;\nvarying float v_fog;\nvarying float v_coverage;\nvoid main() {\n  vec2 corner = a_corner * 2.0 - 1.0;\n  vec4 clip = u_viewProj * vec4(a_pos, 1.0);\n  float factor = 1.0;\n  if (u_params.y > 0.5 && u_viewport.w < 0.5) {\n    factor = clamp(u_params.z / max(clip.w, 1e-6), 0.5, 2.0);\n  }\n  bool glow = u_eye.w > 1.5;\n  float raw = max(a_size, 0.0) * u_viewport.z * factor * 0.5;\n  float radius = max(raw, glow ? 0.75 : 0.5);\n  float reach = glow ? radius * 2.2 + 1.0 : radius + 1.0;\n  vec2 shift = corner * reach * 2.0 / u_viewport.xy * clip.w;\n  gl_Position = vec4(clip.xy + shift, clip.z, clip.w);\n  v_offset = corner * reach;\n  v_radius = radius;\n  v_color = a_color;\n  float near = u_params.z - u_params.w;\n  v_fog = clamp((length(a_pos - u_eye.xyz) - near) / (2.0 * u_params.w), 0.0, 1.0);\n  v_coverage = min(1.0, raw * raw / (radius * radius));\n}\n", d = "\nvarying vec2 v_offset;\nvarying float v_radius;\nvarying vec4 v_color;\nvarying float v_fog;\nvarying float v_coverage;\nvoid main() {\n  float d = length(v_offset);\n  float r = v_radius;\n  float alpha = clamp(r + 0.5 - d, 0.0, 1.0);\n  vec3 rgb = v_color.rgb;\n  if (u_eye.w > 1.5) {\n    float core = clamp(r * 0.6 + 0.5 - d, 0.0, 1.0);\n    float q = d / r;\n    alpha = core + (1.0 - core) * exp(-1.2 * q * q);\n    rgb = rgb + (vec3(1.0) - rgb) * (0.2 * core);\n  } else if (u_eye.w < 0.5) {\n    float q = min(d / r, 1.0);\n    vec3 n = vec3(v_offset / r, sqrt(max(0.0, 1.0 - q * q)));\n    vec3 l = normalize(vec3(-0.45, 0.55, 0.7));\n    float lambert = max(dot(n, l), 0.0);\n    vec3 shaded = rgb * (0.62 + 0.45 * lambert) + vec3(pow(lambert, 18.0) * 0.28);\n    rgb = mix(rgb, shaded, smoothstep(1.5, 3.5, r));\n  }\n  if (alpha <= 0.004) discard;\n  float fog = v_fog * 0.45;\n  if (u_light.w > 0.5) {\n    alpha = alpha * (1.0 - fog);\n    rgb = rgb * u_fog.w;\n  } else {\n    rgb = mix(rgb, u_fog.rgb, fog);\n  }\n  alpha = alpha * v_coverage * v_color.a * u_params.x;\n  EMIT(vec4(rgb * alpha, alpha), v_fog);\n}\n", f = "\nattribute vec3 a_pos;\nattribute vec3 a_normal;\nattribute vec4 a_color;\nvarying vec3 v_world;\nvarying vec3 v_normal;\nvarying vec4 v_color;\nvoid main() {\n  gl_Position = u_viewProj * vec4(a_pos, 1.0);\n  v_world = a_pos;\n  v_normal = a_normal;\n  v_color = a_color;\n}\n", p = "\nvarying vec3 v_world;\nvarying vec3 v_normal;\nvarying vec4 v_color;\nvoid main() {\n  vec3 n = normalize(v_normal);\n  vec3 v = normalize(u_eye.xyz - v_world);\n  if (dot(n, v) < 0.0) n = -n;\n  vec3 l = u_light.xyz;\n  float diffuse = max(dot(n, l), 0.0);\n  vec3 h = normalize(l + v);\n  float specular = pow(max(dot(n, h), 0.0), u_material.w) * u_material.z;\n  vec3 rgb = v_color.rgb * (u_material.x + u_material.y * diffuse) + vec3(specular);\n  float alpha = v_color.a * u_params.x;\n  float near = u_params.z - u_params.w;\n  float depth = (length(v_world - u_eye.xyz) - near) / (2.0 * u_params.w);\n  EMIT(vec4(rgb * alpha, alpha), depth);\n}\n", m = "\nattribute vec2 a_corner;\nattribute vec3 a_a;\nattribute vec3 a_b;\nattribute vec4 a_color;\nvarying float v_across;\nvarying vec4 v_color;\nvoid main() {\n  vec4 ca = u_viewProj * vec4(a_a, 1.0);\n  vec4 cb = u_viewProj * vec4(a_b, 1.0);\n  vec2 halfSize = u_viewport.xy * 0.5;\n  vec2 sa = ca.xy / ca.w * halfSize;\n  vec2 sb = cb.xy / cb.w * halfSize;\n  vec2 dir = sb - sa;\n  float len = length(dir);\n  dir = len > 1e-6 ? dir / len : vec2(1.0, 0.0);\n  vec2 normal = vec2(-dir.y, dir.x);\n  float w = max(0.5, u_params.y * u_viewport.z * 0.5) + 0.5;\n  bool atEnd = a_corner.x > 0.5;\n  vec4 clip = atEnd ? cb : ca;\n  float side = a_corner.y * 2.0 - 1.0;\n  vec2 pixel = (atEnd ? sb : sa) + dir * (a_corner.x * 2.0 - 1.0) * w + normal * side * w;\n  gl_Position = vec4(pixel / halfSize * clip.w, clip.z - u_eye.w * clip.w, clip.w);\n  v_across = side * w;\n  v_color = a_color;\n}\n", h = "\nvarying float v_across;\nvarying vec4 v_color;\nvoid main() {\n  float core = u_params.y * u_viewport.z * 0.5;\n  float coverage = clamp(max(core, 0.5) + 0.5 - abs(v_across), 0.0, 1.0) * min(1.0, core * 2.0);\n  float alpha = coverage * v_color.a * u_params.x;\n  if (alpha <= 0.0) discard;\n  EMIT(vec4(v_color.rgb * alpha, alpha), 0.0);\n}\n", g = "\n#ifdef GL_FRAGMENT_PRECISION_HIGH\nprecision highp float;\n#else\nprecision mediump float;\n#endif\n", _ = (e, n, r, i = !1) => r === 2 ? {
+	vertex: `#version 300 es\n#define attribute in\n#define varying out\n${l}${e}`,
+	fragment: `#version 300 es\nprecision highp float;\n#define varying in\n${l}${i ? t : "out vec4 fragColor;\n#define EMIT(c, d) fragColor = (c)\n"}${n}`
 } : {
-	vertex: `${s}${e}`,
-	fragment: `${m}#define FRAG gl_FragColor\n${s}${t}`
-}, g = (e) => ({
-	points: h(c, l, e),
-	mesh: h(u, d, e),
-	lines: h(f, p, e)
-}), _ = {
+	vertex: `${l}${e}`,
+	fragment: `${g}#define EMIT(c, d) gl_FragColor = (c)\n${l}${n}`
+}, v = (e) => ({
+	points: _(u, d, e),
+	mesh: _(f, p, e),
+	lines: _(m, h, e)
+}), y = () => ({
+	points: _(u, d, 2, !0),
+	mesh: _(f, p, 2, !0)
+}), b = {
 	points: [
 		"a_corner",
 		"a_pos",
@@ -186,6 +249,6 @@ fn fs(in: Out) -> @location(0) vec4f {
 	]
 };
 //#endregion
-export { _ as GLSL_ATTRIBUTES, o as WGSL_LINES, a as WGSL_MESH, i as WGSL_POINTS, g as glslPrograms, t as itemUniforms, n as writesDepth };
+export { b as GLSL_ATTRIBUTES, c as WGSL_LINES, s as WGSL_MESH, o as WGSL_POINTS, y as glslOitPrograms, v as glslPrograms, i as itemUniforms, e as writesDepth };
 
 //# sourceMappingURL=shaders.js.map

package/dist/charts/engine/three-d/shaders.js.map

@@ -1 +1 @@
-{"version":3,"file":"shaders.js","names":["writeUniforms","out","viewProj","viewport","eye","light","material","params","fog","itemUniforms","second","item","frame","writesDepth","WGSL_UNIFORMS","WGSL_POINTS","WGSL_MESH","WGSL_LINES","GLSL_UNIFORMS","GLSL_POINTS_VS","GLSL_POINTS_FS","GLSL_MESH_VS","GLSL_MESH_FS","GLSL_LINES_VS","GLSL_LINES_FS","PRECISION","glsl","version","vs","fs","glslPrograms","GLSL_ATTRIBUTES"],"sources":["../../../../../charts/src/engine/three-d/shaders.ts"],"sourcesContent":["// Shaders of the 3D data layer: instanced point billboards shaded as small\n// spheres, lit triangles (two-sided Lambert + Blinn-Phong) and screen-space\n// wide line segments. WGSL for WebGPU, GLSL ES 1.0 for WebGL (turned into\n// GLSL ES 3.0 for WebGL2 by a macro prefix). Outputs are premultiplied.\n//\n// Uniforms (WGSL struct, GLSL vec4 uniforms of the same names):\n//   viewProj  world -> clip (OpenGL depth convention)\n//   viewport  drawing buffer width, height (device px), dpr, orthographic\n//   eye       camera position, depth bias of the lines (NDC)\n//   light     unit vector towards the light\n//   material  ambient, diffuse, specular, shininess\n//   params    opacity, perspective sizes (0/1) | line width (CSS px), distance, radius\n//   fog       background color (far points fade towards it)\n\nimport type { Frame3D, Item3D } from \"./render-types\";\n\n/** Bytes of the WGSL uniform struct */\nexport const UNIFORM_BYTES = 160;\n\n/** Writes the uniforms of an item in the WGSL struct layout */\nconst writeUniforms = (\n  out: Float32Array,\n  viewProj: Float32Array,\n  viewport: readonly [number, number, number, number],\n  eye: readonly [number, number, number, number],\n  light: readonly [number, number, number, number],\n  material: readonly [number, number, number, number],\n  params: readonly [number, number, number, number],\n  fog: readonly [number, number, number, number],\n): Float32Array => {\n  out.set(viewProj, 0);\n  out.set(viewport, 16);\n  out.set(eye, 20);\n  out.set(light, 24);\n  out.set(material, 28);\n  out.set(params, 32);\n  out.set(fog, 36);\n  return out;\n};\n\n/** Uniform values of an item (40 floats, the WGSL struct layout) */\nexport const itemUniforms = (\n  item: Item3D,\n  frame: Frame3D,\n  out: Float32Array,\n): Float32Array => {\n  const second =\n    item.kind === \"points\"\n      ? item.perspective\n        ? 1\n        : 0\n      : item.kind === \"lines\"\n        ? item.width\n        : 0;\n  return writeUniforms(\n    out,\n    frame.viewProj,\n    [frame.width, frame.height, frame.dpr, frame.orthographic ? 1 : 0],\n    [\n      frame.eye[0],\n      frame.eye[1],\n      frame.eye[2],\n      item.kind === \"lines\" ? item.bias : 0,\n    ],\n    [frame.light[0], frame.light[1], frame.light[2], 0],\n    frame.lighting,\n    [item.opacity, second, frame.distance, frame.radius],\n    [frame.fog[0], frame.fog[1], frame.fog[2], 1],\n  );\n};\n\n/** Whether an item writes the depth buffer (opaque items) */\nexport const writesDepth = (item: Item3D): boolean => item.opacity >= 1;\n\n// ------------------------------------------------------------------- WGSL\n\nconst WGSL_UNIFORMS = /* wgsl */ `\nstruct U {\n  viewProj: mat4x4f,\n  viewport: vec4f,\n  eye: vec4f,\n  light: vec4f,\n  material: vec4f,\n  params: vec4f,\n  fog: vec4f,\n};\n@group(0) @binding(0) var<uniform> u: U;\n\nfn toWebGpuDepth(p: vec4f) -> vec4f {\n  return vec4f(p.x, p.y, (p.z + p.w) * 0.5, p.w);\n}\n\nfn depthCue(world: vec3f) -> f32 {\n  let near = u.params.z - u.params.w;\n  return clamp((length(world - u.eye.xyz) - near) / (2.0 * u.params.w), 0.0, 1.0);\n}\n`;\n\nexport const WGSL_POINTS = /* wgsl */ `${WGSL_UNIFORMS}\nstruct Out {\n  @builtin(position) position: vec4f,\n  @location(0) offset: vec2f,\n  @location(1) radius: f32,\n  @location(2) color: vec4f,\n  @location(3) fog: f32,\n};\n\n@vertex\nfn vs(\n  @builtin(vertex_index) vi: u32,\n  @location(0) pos: vec3f,\n  @location(1) size: f32,\n  @location(2) color: vec4f,\n) -> Out {\n  var out: Out;\n  let corner = vec2f(f32(vi & 1u), f32(vi >> 1u)) * 2.0 - 1.0;\n  let clip = u.viewProj * vec4f(pos, 1.0);\n  var factor = 1.0;\n  if (u.params.y > 0.5 && u.viewport.w < 0.5) {\n    factor = clamp(u.params.z / max(clip.w, 1e-6), 0.5, 2.0);\n  }\n  let radius = max(0.5, size * u.viewport.z * factor * 0.5);\n  let reach = radius + 1.0;\n  let shift = corner * reach * 2.0 / u.viewport.xy * clip.w;\n  out.position = toWebGpuDepth(vec4f(clip.xy + shift, clip.z, clip.w));\n  out.offset = corner * reach;\n  out.radius = radius;\n  out.color = color;\n  out.fog = depthCue(pos) * 0.45;\n  return out;\n}\n\n@fragment\nfn fs(in: Out) -> @location(0) vec4f {\n  let d = length(in.offset);\n  var alpha = clamp(in.radius + 0.5 - d, 0.0, 1.0);\n  if (alpha <= 0.0) { discard; }\n  let q = min(d / in.radius, 1.0);\n  let n = vec3f(in.offset.x / in.radius, in.offset.y / in.radius, sqrt(max(0.0, 1.0 - q * q)));\n  let l = normalize(vec3f(-0.45, 0.55, 0.7));\n  let lambert = max(dot(n, l), 0.0);\n  let shaded = in.color.rgb * (0.62 + 0.45 * lambert) + vec3f(pow(lambert, 18.0) * 0.28);\n  let sphere = smoothstep(1.5, 3.5, in.radius);\n  var rgb = mix(in.color.rgb, shaded, sphere);\n  rgb = mix(rgb, u.fog.rgb, in.fog);\n  alpha = alpha * in.color.a * u.params.x;\n  return vec4f(rgb * alpha, alpha);\n}\n`;\n\nexport const WGSL_MESH = /* wgsl */ `${WGSL_UNIFORMS}\nstruct Out {\n  @builtin(position) position: vec4f,\n  @location(0) world: vec3f,\n  @location(1) normal: vec3f,\n  @location(2) color: vec4f,\n};\n\n@vertex\nfn vs(\n  @location(0) pos: vec3f,\n  @location(1) normal: vec3f,\n  @location(2) color: vec4f,\n) -> Out {\n  var out: Out;\n  out.position = toWebGpuDepth(u.viewProj * vec4f(pos, 1.0));\n  out.world = pos;\n  out.normal = normal;\n  out.color = color;\n  return out;\n}\n\n@fragment\nfn fs(in: Out) -> @location(0) vec4f {\n  var n = normalize(in.normal);\n  let v = normalize(u.eye.xyz - in.world);\n  if (dot(n, v) < 0.0) { n = -n; }\n  let l = u.light.xyz;\n  let diffuse = max(dot(n, l), 0.0);\n  let h = normalize(l + v);\n  let specular = pow(max(dot(n, h), 0.0), u.material.w) * u.material.z;\n  let rgb = in.color.rgb * (u.material.x + u.material.y * diffuse) + vec3f(specular);\n  let alpha = in.color.a * u.params.x;\n  return vec4f(rgb * alpha, alpha);\n}\n`;\n\nexport const WGSL_LINES = /* wgsl */ `${WGSL_UNIFORMS}\nstruct Out {\n  @builtin(position) position: vec4f,\n  @location(0) across: f32,\n  @location(1) color: vec4f,\n};\n\n@vertex\nfn vs(\n  @builtin(vertex_index) vi: u32,\n  @location(0) a: vec3f,\n  @location(1) b: vec3f,\n  @location(2) color: vec4f,\n) -> Out {\n  var out: Out;\n  let corner = vec2f(f32(vi & 1u), f32(vi >> 1u));\n  let ca = u.viewProj * vec4f(a, 1.0);\n  let cb = u.viewProj * vec4f(b, 1.0);\n  let halfSize = u.viewport.xy * 0.5;\n  let sa = ca.xy / ca.w * halfSize;\n  let sb = cb.xy / cb.w * halfSize;\n  var dir = sb - sa;\n  let len = length(dir);\n  dir = select(vec2f(1.0, 0.0), dir / len, len > 1e-6);\n  let normal = vec2f(-dir.y, dir.x);\n  let w = max(0.5, u.params.y * u.viewport.z * 0.5) + 0.5;\n  let clip = select(ca, cb, corner.x > 0.5);\n  let side = corner.y * 2.0 - 1.0;\n  let pixel = select(sa, sb, corner.x > 0.5) + dir * (corner.x * 2.0 - 1.0) * w + normal * side * w;\n  let z = clip.z - u.eye.w * clip.w;\n  out.position = toWebGpuDepth(vec4f(pixel / halfSize * clip.w, z, clip.w));\n  out.across = side * w;\n  out.color = color;\n  return out;\n}\n\n@fragment\nfn fs(in: Out) -> @location(0) vec4f {\n  let core = u.params.y * u.viewport.z * 0.5;\n  let coverage = clamp(max(core, 0.5) + 0.5 - abs(in.across), 0.0, 1.0) * min(1.0, core * 2.0);\n  let alpha = coverage * in.color.a * u.params.x;\n  if (alpha <= 0.0) { discard; }\n  return vec4f(in.color.rgb * alpha, alpha);\n}\n`;\n\n// ------------------------------------------------------------------- GLSL\n\nconst GLSL_UNIFORMS = `\nuniform mat4 u_viewProj;\nuniform vec4 u_viewport;\nuniform vec4 u_eye;\nuniform vec4 u_light;\nuniform vec4 u_material;\nuniform vec4 u_params;\nuniform vec4 u_fog;\n`;\n\nconst GLSL_POINTS_VS = `\nattribute vec2 a_corner;\nattribute vec3 a_pos;\nattribute float a_size;\nattribute vec4 a_color;\nvarying vec2 v_offset;\nvarying float v_radius;\nvarying vec4 v_color;\nvarying float v_fog;\nvoid main() {\n  vec2 corner = a_corner * 2.0 - 1.0;\n  vec4 clip = u_viewProj * vec4(a_pos, 1.0);\n  float factor = 1.0;\n  if (u_params.y > 0.5 && u_viewport.w < 0.5) {\n    factor = clamp(u_params.z / max(clip.w, 1e-6), 0.5, 2.0);\n  }\n  float radius = max(0.5, a_size * u_viewport.z * factor * 0.5);\n  float reach = radius + 1.0;\n  vec2 shift = corner * reach * 2.0 / u_viewport.xy * clip.w;\n  gl_Position = vec4(clip.xy + shift, clip.z, clip.w);\n  v_offset = corner * reach;\n  v_radius = radius;\n  v_color = a_color;\n  float near = u_params.z - u_params.w;\n  v_fog = clamp((length(a_pos - u_eye.xyz) - near) / (2.0 * u_params.w), 0.0, 1.0) * 0.45;\n}\n`;\n\nconst GLSL_POINTS_FS = `\nvarying vec2 v_offset;\nvarying float v_radius;\nvarying vec4 v_color;\nvarying float v_fog;\nvoid main() {\n  float d = length(v_offset);\n  float alpha = clamp(v_radius + 0.5 - d, 0.0, 1.0);\n  if (alpha <= 0.0) discard;\n  float q = min(d / v_radius, 1.0);\n  vec3 n = vec3(v_offset / v_radius, sqrt(max(0.0, 1.0 - q * q)));\n  vec3 l = normalize(vec3(-0.45, 0.55, 0.7));\n  float lambert = max(dot(n, l), 0.0);\n  vec3 shaded = v_color.rgb * (0.62 + 0.45 * lambert) + vec3(pow(lambert, 18.0) * 0.28);\n  float sphere = smoothstep(1.5, 3.5, v_radius);\n  vec3 rgb = mix(v_color.rgb, shaded, sphere);\n  rgb = mix(rgb, u_fog.rgb, v_fog);\n  alpha = alpha * v_color.a * u_params.x;\n  FRAG = vec4(rgb * alpha, alpha);\n}\n`;\n\nconst GLSL_MESH_VS = `\nattribute vec3 a_pos;\nattribute vec3 a_normal;\nattribute vec4 a_color;\nvarying vec3 v_world;\nvarying vec3 v_normal;\nvarying vec4 v_color;\nvoid main() {\n  gl_Position = u_viewProj * vec4(a_pos, 1.0);\n  v_world = a_pos;\n  v_normal = a_normal;\n  v_color = a_color;\n}\n`;\n\nconst GLSL_MESH_FS = `\nvarying vec3 v_world;\nvarying vec3 v_normal;\nvarying vec4 v_color;\nvoid main() {\n  vec3 n = normalize(v_normal);\n  vec3 v = normalize(u_eye.xyz - v_world);\n  if (dot(n, v) < 0.0) n = -n;\n  vec3 l = u_light.xyz;\n  float diffuse = max(dot(n, l), 0.0);\n  vec3 h = normalize(l + v);\n  float specular = pow(max(dot(n, h), 0.0), u_material.w) * u_material.z;\n  vec3 rgb = v_color.rgb * (u_material.x + u_material.y * diffuse) + vec3(specular);\n  float alpha = v_color.a * u_params.x;\n  FRAG = vec4(rgb * alpha, alpha);\n}\n`;\n\nconst GLSL_LINES_VS = `\nattribute vec2 a_corner;\nattribute vec3 a_a;\nattribute vec3 a_b;\nattribute vec4 a_color;\nvarying float v_across;\nvarying vec4 v_color;\nvoid main() {\n  vec4 ca = u_viewProj * vec4(a_a, 1.0);\n  vec4 cb = u_viewProj * vec4(a_b, 1.0);\n  vec2 halfSize = u_viewport.xy * 0.5;\n  vec2 sa = ca.xy / ca.w * halfSize;\n  vec2 sb = cb.xy / cb.w * halfSize;\n  vec2 dir = sb - sa;\n  float len = length(dir);\n  dir = len > 1e-6 ? dir / len : vec2(1.0, 0.0);\n  vec2 normal = vec2(-dir.y, dir.x);\n  float w = max(0.5, u_params.y * u_viewport.z * 0.5) + 0.5;\n  bool atEnd = a_corner.x > 0.5;\n  vec4 clip = atEnd ? cb : ca;\n  float side = a_corner.y * 2.0 - 1.0;\n  vec2 pixel = (atEnd ? sb : sa) + dir * (a_corner.x * 2.0 - 1.0) * w + normal * side * w;\n  gl_Position = vec4(pixel / halfSize * clip.w, clip.z - u_eye.w * clip.w, clip.w);\n  v_across = side * w;\n  v_color = a_color;\n}\n`;\n\nconst GLSL_LINES_FS = `\nvarying float v_across;\nvarying vec4 v_color;\nvoid main() {\n  float core = u_params.y * u_viewport.z * 0.5;\n  float coverage = clamp(max(core, 0.5) + 0.5 - abs(v_across), 0.0, 1.0) * min(1.0, core * 2.0);\n  float alpha = coverage * v_color.a * u_params.x;\n  if (alpha <= 0.0) discard;\n  FRAG = vec4(v_color.rgb * alpha, alpha);\n}\n`;\n\nconst PRECISION = `\n#ifdef GL_FRAGMENT_PRECISION_HIGH\nprecision highp float;\n#else\nprecision mediump float;\n#endif\n`;\n\nexport interface GlslSource {\n  vertex: string;\n  fragment: string;\n}\n\nconst glsl = (vs: string, fs: string, version: 1 | 2): GlslSource =>\n  version === 2\n    ? {\n        vertex: `#version 300 es\\n#define attribute in\\n#define varying out\\n${GLSL_UNIFORMS}${vs}`,\n        fragment: `#version 300 es\\nprecision highp float;\\n#define varying in\\nout vec4 fragColor;\\n#define FRAG fragColor\\n${GLSL_UNIFORMS}${fs}`,\n      }\n    : {\n        vertex: `${GLSL_UNIFORMS}${vs}`,\n        fragment: `${PRECISION}#define FRAG gl_FragColor\\n${GLSL_UNIFORMS}${fs}`,\n      };\n\n/** GLSL programs of the three primitives for WebGL (1) or WebGL2 */\nexport const glslPrograms = (version: 1 | 2) => ({\n  points: glsl(GLSL_POINTS_VS, GLSL_POINTS_FS, version),\n  mesh: glsl(GLSL_MESH_VS, GLSL_MESH_FS, version),\n  lines: glsl(GLSL_LINES_VS, GLSL_LINES_FS, version),\n});\n\n/** Attribute names of every program, bound to locations 0, 1, ... */\nexport const GLSL_ATTRIBUTES = {\n  points: [\"a_corner\", \"a_pos\", \"a_size\", \"a_color\"],\n  mesh: [\"a_pos\", \"a_normal\", \"a_color\"],\n  lines: [\"a_corner\", \"a_a\", \"a_b\", \"a_color\"],\n} as const;\n"],"mappings":";AAoBA,IAAMA,KACJ,GACA,GACA,GACA,GACA,GACA,GACA,GACA,OAEAC,EAAI,IAAIC,GAAU,CAAC,GACnBD,EAAI,IAAIE,GAAU,EAAE,GACpBF,EAAI,IAAIG,GAAK,EAAE,GACfH,EAAI,IAAII,GAAO,EAAE,GACjBJ,EAAI,IAAIK,GAAU,EAAE,GACpBL,EAAI,IAAIM,GAAQ,EAAE,GAClBN,EAAI,IAAIO,GAAK,EAAE,GACRP,IAIIQ,KACX,GACA,GACA,MACiB;CACjB,IAAMC,IACJC,EAAK,SAAS,WACV,KAAK,cAGLA,EAAK,SAAS,UACZA,EAAK,QACL;CACR,OAAOX,EACLC,GACAW,EAAM,UACN;EAACA,EAAM;EAAOA,EAAM;EAAQA,EAAM;EAAK,KAAM;CAAoB,GACjE;EACEA,EAAM,IAAI;EACVA,EAAM,IAAI;EACVA,EAAM,IAAI;EACVD,EAAK,SAAS,UAAUA,EAAK,OAAO;CACtC,GACA;EAACC,EAAM,MAAM;EAAIA,EAAM,MAAM;EAAIA,EAAM,MAAM;EAAI;CAAC,GAClDA,EAAM,UACN;EAACD,EAAK;EAASD;EAAQE,EAAM;EAAUA,EAAM;CAAM,GACnD;EAACA,EAAM,IAAI;EAAIA,EAAM,IAAI;EAAIA,EAAM,IAAI;EAAI;CAAC,CAC9C;AACF,GAGaC,KAAe,MAA0BF,EAAK,WAAW,GAIhEG,IAA2B,kcAsBpBC,IAAyB,GAAGD,EAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoD1CE,IAAuB,GAAGF,EAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCxCG,IAAwB,GAAGH,EAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDhDI,IAAgB,6KAUhBC,IAAiB,i2BA4BjBC,IAAiB,ytBAsBjBC,IAAe,0RAefC,IAAe,whBAkBfC,IAAgB,+3BA4BhBC,IAAgB,yVAYhBC,IAAY,0GAaZC,KAAQ,GAAY,GAAY,MACpCC,MAAY,IACR;CACE,QAAQ,+DAA+DT,IAAgBU;CACvF,UAAU,6GAA6GV,IAAgBW;AACzI,IACA;CACE,QAAQ,GAAGX,IAAgBU;CAC3B,UAAU,GAAGH,EAAU,6BAA6BP,IAAgBW;AACtE,GAGOC,KAAgB,OAAoB;CAC/C,QAAQJ,EAAKP,GAAgBC,GAAgBO,CAAO;CACpD,MAAMD,EAAKL,GAAcC,GAAcK,CAAO;CAC9C,OAAOD,EAAKH,GAAeC,GAAeG,CAAO;AACnD,IAGaI,IAAkB;CAC7B,QAAQ;EAAC;EAAY;EAAS;EAAU;CAAS;CACjD,MAAM;EAAC;EAAS;EAAY;CAAS;CACrC,OAAO;EAAC;EAAY;EAAO;EAAO;CAAS;AAC7C"}
+{"version":3,"file":"shaders.js","names":["writeUniforms","out","viewProj","viewport","eye","light","material","params","fog","itemUniforms","second","item","frame","WGSL_UNIFORMS","WGSL_OIT","WGSL_POINTS","WGSL_MESH","WGSL_LINES","GLSL_UNIFORMS","GLSL_POINTS_VS","GLSL_POINTS_FS","GLSL_MESH_VS","GLSL_MESH_FS","GLSL_LINES_VS","GLSL_LINES_FS","PRECISION","glsl","version","vs","oit","GLSL_OIT","fs","glslPrograms","glslOitPrograms","GLSL_ATTRIBUTES","writesDepth"],"sources":["../../../../../charts/src/engine/three-d/shaders.ts"],"sourcesContent":["// Shaders of the 3D data layer: instanced point billboards (shaded spheres,\n// flat discs or glowing discs), lit triangles (two-sided Lambert +\n// Blinn-Phong) and screen-space wide line segments. WGSL for WebGPU, GLSL ES\n// 1.0 for WebGL (turned into GLSL ES 3.0 for WebGL2 by a macro prefix).\n// Outputs are premultiplied.\n//\n// Uniforms (WGSL struct, GLSL vec4 uniforms of the same names):\n//   viewProj  world -> clip (OpenGL depth convention)\n//   viewport  drawing buffer width, height (device px), dpr, orthographic\n//   eye       camera position, depth bias of the lines (NDC) | point style\n//   light     unit vector towards the light, additive points (0/1)\n//   material  ambient, diffuse, specular, shininess\n//   params    opacity, perspective sizes (0/1) | line width (CSS px), distance, radius\n//   fog       background color (far points fade towards it), exposure of the\n//             additive light\n//\n// Points and meshes have a second fragment entry point writing the targets\n// of the order-independent transparency (`oit.ts`): `fsOit` in WGSL, the\n// `oit` variant of the GLSL programs (WebGL2).\n//\n// Point sizes are CSS pixels times the device pixel ratio (billboards: no\n// point size limit). Dots thinner than the smallest drawn radius keep their\n// energy: their alpha scales with the area they would cover.\n\nimport { GLSL_OIT, WGSL_OIT } from \"./oit\";\nimport { POINT_SPHERE, type Frame3D, type Item3D } from \"./render-types\";\n\nexport { writesDepth } from \"./render-types\";\n\n/** Bytes of the WGSL uniform struct */\nexport const UNIFORM_BYTES = 160;\n\n/** Writes the uniforms of an item in the WGSL struct layout */\nconst writeUniforms = (\n  out: Float32Array,\n  viewProj: Float32Array,\n  viewport: readonly [number, number, number, number],\n  eye: readonly [number, number, number, number],\n  light: readonly [number, number, number, number],\n  material: readonly [number, number, number, number],\n  params: readonly [number, number, number, number],\n  fog: readonly [number, number, number, number],\n): Float32Array => {\n  out.set(viewProj, 0);\n  out.set(viewport, 16);\n  out.set(eye, 20);\n  out.set(light, 24);\n  out.set(material, 28);\n  out.set(params, 32);\n  out.set(fog, 36);\n  return out;\n};\n\n/** Uniform values of an item (40 floats, the WGSL struct layout) */\nexport const itemUniforms = (\n  item: Item3D,\n  frame: Frame3D,\n  out: Float32Array,\n): Float32Array => {\n  const second =\n    item.kind === \"points\"\n      ? item.perspective\n        ? 1\n        : 0\n      : item.kind === \"lines\"\n        ? item.width\n        : 0;\n  return writeUniforms(\n    out,\n    frame.viewProj,\n    [frame.width, frame.height, frame.dpr, frame.orthographic ? 1 : 0],\n    [\n      frame.eye[0],\n      frame.eye[1],\n      frame.eye[2],\n      item.kind === \"lines\"\n        ? item.bias\n        : item.kind === \"points\"\n          ? (item.style ?? POINT_SPHERE)\n          : 0,\n    ],\n    [\n      frame.light[0],\n      frame.light[1],\n      frame.light[2],\n      item.kind === \"points\" && item.additive ? 1 : 0,\n    ],\n    frame.lighting,\n    [item.opacity, second, frame.distance, frame.radius],\n    [frame.fog[0], frame.fog[1], frame.fog[2], frame.exposure],\n  );\n};\n\n// ------------------------------------------------------------------- WGSL\n\nconst WGSL_UNIFORMS = /* wgsl */ `\nstruct U {\n  viewProj: mat4x4f,\n  viewport: vec4f,\n  eye: vec4f,\n  light: vec4f,\n  material: vec4f,\n  params: vec4f,\n  fog: vec4f,\n};\n@group(0) @binding(0) var<uniform> u: U;\n\nfn toWebGpuDepth(p: vec4f) -> vec4f {\n  return vec4f(p.x, p.y, (p.z + p.w) * 0.5, p.w);\n}\n\nfn depthCue(world: vec3f) -> f32 {\n  let near = u.params.z - u.params.w;\n  return clamp((length(world - u.eye.xyz) - near) / (2.0 * u.params.w), 0.0, 1.0);\n}\n${WGSL_OIT}`;\n\nexport const WGSL_POINTS = /* wgsl */ `${WGSL_UNIFORMS}\nstruct Out {\n  @builtin(position) position: vec4f,\n  @location(0) offset: vec2f,\n  @location(1) radius: f32,\n  @location(2) color: vec4f,\n  @location(3) fog: f32,\n  @location(4) coverage: f32,\n};\n\n@vertex\nfn vs(\n  @builtin(vertex_index) vi: u32,\n  @location(0) pos: vec3f,\n  @location(1) size: f32,\n  @location(2) color: vec4f,\n) -> Out {\n  var out: Out;\n  let corner = vec2f(f32(vi & 1u), f32(vi >> 1u)) * 2.0 - 1.0;\n  let clip = u.viewProj * vec4f(pos, 1.0);\n  var factor = 1.0;\n  if (u.params.y > 0.5 && u.viewport.w < 0.5) {\n    factor = clamp(u.params.z / max(clip.w, 1e-6), 0.5, 2.0);\n  }\n  let glow = u.eye.w > 1.5;\n  let raw = max(size, 0.0) * u.viewport.z * factor * 0.5;\n  let radius = max(raw, select(0.5, 0.75, glow));\n  let reach = select(radius + 1.0, radius * 2.2 + 1.0, glow);\n  let shift = corner * reach * 2.0 / u.viewport.xy * clip.w;\n  out.position = toWebGpuDepth(vec4f(clip.xy + shift, clip.z, clip.w));\n  out.offset = corner * reach;\n  out.radius = radius;\n  out.color = color;\n  out.fog = depthCue(pos);\n  out.coverage = min(1.0, raw * raw / (radius * radius));\n  return out;\n}\n\nfn shade(in: Out) -> vec4f {\n  let d = length(in.offset);\n  let r = in.radius;\n  var alpha = clamp(r + 0.5 - d, 0.0, 1.0);\n  var rgb = in.color.rgb;\n  if (u.eye.w > 1.5) {\n    // glow: an anti-aliased core and a gaussian halo\n    let core = clamp(r * 0.6 + 0.5 - d, 0.0, 1.0);\n    let q = d / r;\n    alpha = core + (1.0 - core) * exp(-1.2 * q * q);\n    rgb = rgb + (vec3f(1.0) - rgb) * (0.2 * core);\n  } else if (u.eye.w < 0.5) {\n    let q = min(d / r, 1.0);\n    let n = vec3f(in.offset.x / r, in.offset.y / r, sqrt(max(0.0, 1.0 - q * q)));\n    let l = normalize(vec3f(-0.45, 0.55, 0.7));\n    let lambert = max(dot(n, l), 0.0);\n    let shaded = rgb * (0.62 + 0.45 * lambert) + vec3f(pow(lambert, 18.0) * 0.28);\n    rgb = mix(rgb, shaded, smoothstep(1.5, 3.5, r));\n  }\n  if (alpha <= 0.004) { discard; }\n  let fog = in.fog * 0.45;\n  if (u.light.w > 0.5) {\n    // additive light fades with the distance\n    alpha = alpha * (1.0 - fog);\n    rgb = rgb * u.fog.w;\n  } else {\n    rgb = mix(rgb, u.fog.rgb, fog);\n  }\n  alpha = alpha * in.coverage * in.color.a * u.params.x;\n  return vec4f(rgb * alpha, alpha);\n}\n\n@fragment\nfn fs(in: Out) -> @location(0) vec4f {\n  return shade(in);\n}\n\n@fragment\nfn fsOit(in: Out) -> Oit {\n  return oit(shade(in), in.fog);\n}\n`;\n\nexport const WGSL_MESH = /* wgsl */ `${WGSL_UNIFORMS}\nstruct Out {\n  @builtin(position) position: vec4f,\n  @location(0) world: vec3f,\n  @location(1) normal: vec3f,\n  @location(2) color: vec4f,\n};\n\n@vertex\nfn vs(\n  @location(0) pos: vec3f,\n  @location(1) normal: vec3f,\n  @location(2) color: vec4f,\n) -> Out {\n  var out: Out;\n  out.position = toWebGpuDepth(u.viewProj * vec4f(pos, 1.0));\n  out.world = pos;\n  out.normal = normal;\n  out.color = color;\n  return out;\n}\n\nfn shade(in: Out) -> vec4f {\n  var n = normalize(in.normal);\n  let v = normalize(u.eye.xyz - in.world);\n  if (dot(n, v) < 0.0) { n = -n; }\n  let l = u.light.xyz;\n  let diffuse = max(dot(n, l), 0.0);\n  let h = normalize(l + v);\n  let specular = pow(max(dot(n, h), 0.0), u.material.w) * u.material.z;\n  let rgb = in.color.rgb * (u.material.x + u.material.y * diffuse) + vec3f(specular);\n  let alpha = in.color.a * u.params.x;\n  return vec4f(rgb * alpha, alpha);\n}\n\n@fragment\nfn fs(in: Out) -> @location(0) vec4f {\n  return shade(in);\n}\n\n@fragment\nfn fsOit(in: Out) -> Oit {\n  return oit(shade(in), depthCue(in.world));\n}\n`;\n\nexport const WGSL_LINES = /* wgsl */ `${WGSL_UNIFORMS}\nstruct Out {\n  @builtin(position) position: vec4f,\n  @location(0) across: f32,\n  @location(1) color: vec4f,\n};\n\n@vertex\nfn vs(\n  @builtin(vertex_index) vi: u32,\n  @location(0) a: vec3f,\n  @location(1) b: vec3f,\n  @location(2) color: vec4f,\n) -> Out {\n  var out: Out;\n  let corner = vec2f(f32(vi & 1u), f32(vi >> 1u));\n  let ca = u.viewProj * vec4f(a, 1.0);\n  let cb = u.viewProj * vec4f(b, 1.0);\n  let halfSize = u.viewport.xy * 0.5;\n  let sa = ca.xy / ca.w * halfSize;\n  let sb = cb.xy / cb.w * halfSize;\n  var dir = sb - sa;\n  let len = length(dir);\n  dir = select(vec2f(1.0, 0.0), dir / len, len > 1e-6);\n  let normal = vec2f(-dir.y, dir.x);\n  let w = max(0.5, u.params.y * u.viewport.z * 0.5) + 0.5;\n  let clip = select(ca, cb, corner.x > 0.5);\n  let side = corner.y * 2.0 - 1.0;\n  let pixel = select(sa, sb, corner.x > 0.5) + dir * (corner.x * 2.0 - 1.0) * w + normal * side * w;\n  let z = clip.z - u.eye.w * clip.w;\n  out.position = toWebGpuDepth(vec4f(pixel / halfSize * clip.w, z, clip.w));\n  out.across = side * w;\n  out.color = color;\n  return out;\n}\n\n@fragment\nfn fs(in: Out) -> @location(0) vec4f {\n  let core = u.params.y * u.viewport.z * 0.5;\n  let coverage = clamp(max(core, 0.5) + 0.5 - abs(in.across), 0.0, 1.0) * min(1.0, core * 2.0);\n  let alpha = coverage * in.color.a * u.params.x;\n  if (alpha <= 0.0) { discard; }\n  return vec4f(in.color.rgb * alpha, alpha);\n}\n`;\n\n// ------------------------------------------------------------------- GLSL\n\nconst GLSL_UNIFORMS = `\nuniform mat4 u_viewProj;\nuniform vec4 u_viewport;\nuniform vec4 u_eye;\nuniform vec4 u_light;\nuniform vec4 u_material;\nuniform vec4 u_params;\nuniform vec4 u_fog;\n`;\n\nconst GLSL_POINTS_VS = `\nattribute vec2 a_corner;\nattribute vec3 a_pos;\nattribute float a_size;\nattribute vec4 a_color;\nvarying vec2 v_offset;\nvarying float v_radius;\nvarying vec4 v_color;\nvarying float v_fog;\nvarying float v_coverage;\nvoid main() {\n  vec2 corner = a_corner * 2.0 - 1.0;\n  vec4 clip = u_viewProj * vec4(a_pos, 1.0);\n  float factor = 1.0;\n  if (u_params.y > 0.5 && u_viewport.w < 0.5) {\n    factor = clamp(u_params.z / max(clip.w, 1e-6), 0.5, 2.0);\n  }\n  bool glow = u_eye.w > 1.5;\n  float raw = max(a_size, 0.0) * u_viewport.z * factor * 0.5;\n  float radius = max(raw, glow ? 0.75 : 0.5);\n  float reach = glow ? radius * 2.2 + 1.0 : radius + 1.0;\n  vec2 shift = corner * reach * 2.0 / u_viewport.xy * clip.w;\n  gl_Position = vec4(clip.xy + shift, clip.z, clip.w);\n  v_offset = corner * reach;\n  v_radius = radius;\n  v_color = a_color;\n  float near = u_params.z - u_params.w;\n  v_fog = clamp((length(a_pos - u_eye.xyz) - near) / (2.0 * u_params.w), 0.0, 1.0);\n  v_coverage = min(1.0, raw * raw / (radius * radius));\n}\n`;\n\nconst GLSL_POINTS_FS = `\nvarying vec2 v_offset;\nvarying float v_radius;\nvarying vec4 v_color;\nvarying float v_fog;\nvarying float v_coverage;\nvoid main() {\n  float d = length(v_offset);\n  float r = v_radius;\n  float alpha = clamp(r + 0.5 - d, 0.0, 1.0);\n  vec3 rgb = v_color.rgb;\n  if (u_eye.w > 1.5) {\n    float core = clamp(r * 0.6 + 0.5 - d, 0.0, 1.0);\n    float q = d / r;\n    alpha = core + (1.0 - core) * exp(-1.2 * q * q);\n    rgb = rgb + (vec3(1.0) - rgb) * (0.2 * core);\n  } else if (u_eye.w < 0.5) {\n    float q = min(d / r, 1.0);\n    vec3 n = vec3(v_offset / r, sqrt(max(0.0, 1.0 - q * q)));\n    vec3 l = normalize(vec3(-0.45, 0.55, 0.7));\n    float lambert = max(dot(n, l), 0.0);\n    vec3 shaded = rgb * (0.62 + 0.45 * lambert) + vec3(pow(lambert, 18.0) * 0.28);\n    rgb = mix(rgb, shaded, smoothstep(1.5, 3.5, r));\n  }\n  if (alpha <= 0.004) discard;\n  float fog = v_fog * 0.45;\n  if (u_light.w > 0.5) {\n    alpha = alpha * (1.0 - fog);\n    rgb = rgb * u_fog.w;\n  } else {\n    rgb = mix(rgb, u_fog.rgb, fog);\n  }\n  alpha = alpha * v_coverage * v_color.a * u_params.x;\n  EMIT(vec4(rgb * alpha, alpha), v_fog);\n}\n`;\n\nconst GLSL_MESH_VS = `\nattribute vec3 a_pos;\nattribute vec3 a_normal;\nattribute vec4 a_color;\nvarying vec3 v_world;\nvarying vec3 v_normal;\nvarying vec4 v_color;\nvoid main() {\n  gl_Position = u_viewProj * vec4(a_pos, 1.0);\n  v_world = a_pos;\n  v_normal = a_normal;\n  v_color = a_color;\n}\n`;\n\nconst GLSL_MESH_FS = `\nvarying vec3 v_world;\nvarying vec3 v_normal;\nvarying vec4 v_color;\nvoid main() {\n  vec3 n = normalize(v_normal);\n  vec3 v = normalize(u_eye.xyz - v_world);\n  if (dot(n, v) < 0.0) n = -n;\n  vec3 l = u_light.xyz;\n  float diffuse = max(dot(n, l), 0.0);\n  vec3 h = normalize(l + v);\n  float specular = pow(max(dot(n, h), 0.0), u_material.w) * u_material.z;\n  vec3 rgb = v_color.rgb * (u_material.x + u_material.y * diffuse) + vec3(specular);\n  float alpha = v_color.a * u_params.x;\n  float near = u_params.z - u_params.w;\n  float depth = (length(v_world - u_eye.xyz) - near) / (2.0 * u_params.w);\n  EMIT(vec4(rgb * alpha, alpha), depth);\n}\n`;\n\nconst GLSL_LINES_VS = `\nattribute vec2 a_corner;\nattribute vec3 a_a;\nattribute vec3 a_b;\nattribute vec4 a_color;\nvarying float v_across;\nvarying vec4 v_color;\nvoid main() {\n  vec4 ca = u_viewProj * vec4(a_a, 1.0);\n  vec4 cb = u_viewProj * vec4(a_b, 1.0);\n  vec2 halfSize = u_viewport.xy * 0.5;\n  vec2 sa = ca.xy / ca.w * halfSize;\n  vec2 sb = cb.xy / cb.w * halfSize;\n  vec2 dir = sb - sa;\n  float len = length(dir);\n  dir = len > 1e-6 ? dir / len : vec2(1.0, 0.0);\n  vec2 normal = vec2(-dir.y, dir.x);\n  float w = max(0.5, u_params.y * u_viewport.z * 0.5) + 0.5;\n  bool atEnd = a_corner.x > 0.5;\n  vec4 clip = atEnd ? cb : ca;\n  float side = a_corner.y * 2.0 - 1.0;\n  vec2 pixel = (atEnd ? sb : sa) + dir * (a_corner.x * 2.0 - 1.0) * w + normal * side * w;\n  gl_Position = vec4(pixel / halfSize * clip.w, clip.z - u_eye.w * clip.w, clip.w);\n  v_across = side * w;\n  v_color = a_color;\n}\n`;\n\nconst GLSL_LINES_FS = `\nvarying float v_across;\nvarying vec4 v_color;\nvoid main() {\n  float core = u_params.y * u_viewport.z * 0.5;\n  float coverage = clamp(max(core, 0.5) + 0.5 - abs(v_across), 0.0, 1.0) * min(1.0, core * 2.0);\n  float alpha = coverage * v_color.a * u_params.x;\n  if (alpha <= 0.0) discard;\n  EMIT(vec4(v_color.rgb * alpha, alpha), 0.0);\n}\n`;\n\nconst PRECISION = `\n#ifdef GL_FRAGMENT_PRECISION_HIGH\nprecision highp float;\n#else\nprecision mediump float;\n#endif\n`;\n\nexport interface GlslSource {\n  vertex: string;\n  fragment: string;\n}\n\nconst glsl = (\n  vs: string,\n  fs: string,\n  version: 1 | 2,\n  oit = false,\n): GlslSource =>\n  version === 2\n    ? {\n        vertex: `#version 300 es\\n#define attribute in\\n#define varying out\\n${GLSL_UNIFORMS}${vs}`,\n        fragment: `#version 300 es\\nprecision highp float;\\n#define varying in\\n${GLSL_UNIFORMS}${\n          oit\n            ? GLSL_OIT\n            : \"out vec4 fragColor;\\n#define EMIT(c, d) fragColor = (c)\\n\"\n        }${fs}`,\n      }\n    : {\n        vertex: `${GLSL_UNIFORMS}${vs}`,\n        fragment: `${PRECISION}#define EMIT(c, d) gl_FragColor = (c)\\n${GLSL_UNIFORMS}${fs}`,\n      };\n\n/** GLSL programs of the three primitives for WebGL (1) or WebGL2 */\nexport const glslPrograms = (version: 1 | 2) => ({\n  points: glsl(GLSL_POINTS_VS, GLSL_POINTS_FS, version),\n  mesh: glsl(GLSL_MESH_VS, GLSL_MESH_FS, version),\n  lines: glsl(GLSL_LINES_VS, GLSL_LINES_FS, version),\n});\n\n/**\n * Variants of the points and meshes writing the targets of the\n * order-independent transparency (WebGL2)\n */\nexport const glslOitPrograms = () => ({\n  points: glsl(GLSL_POINTS_VS, GLSL_POINTS_FS, 2, true),\n  mesh: glsl(GLSL_MESH_VS, GLSL_MESH_FS, 2, true),\n});\n\n/** Attribute names of every program, bound to locations 0, 1, ... */\nexport const GLSL_ATTRIBUTES = {\n  points: [\"a_corner\", \"a_pos\", \"a_size\", \"a_color\"],\n  mesh: [\"a_pos\", \"a_normal\", \"a_color\"],\n  lines: [\"a_corner\", \"a_a\", \"a_b\", \"a_color\"],\n} as const;\n"],"mappings":";;;AAiCA,IAAMA,KACJ,GACA,GACA,GACA,GACA,GACA,GACA,GACA,OAEAC,EAAI,IAAIC,GAAU,CAAC,GACnBD,EAAI,IAAIE,GAAU,EAAE,GACpBF,EAAI,IAAIG,GAAK,EAAE,GACfH,EAAI,IAAII,GAAO,EAAE,GACjBJ,EAAI,IAAIK,GAAU,EAAE,GACpBL,EAAI,IAAIM,GAAQ,EAAE,GAClBN,EAAI,IAAIO,GAAK,EAAE,GACRP,IAIIQ,KACX,GACA,GACA,MACiB;CACjB,IAAMC,IACJC,EAAK,SAAS,WACV,KAAK,cAGLA,EAAK,SAAS,UACZA,EAAK,QACL;CACR,OAAOX,EACLC,GACAW,EAAM,UACN;EAACA,EAAM;EAAOA,EAAM;EAAQA,EAAM;EAAK,KAAM;CAAoB,GACjE;EACEA,EAAM,IAAI;EACVA,EAAM,IAAI;EACVA,EAAM,IAAI;EACVD,EAAK,SAAS,UACVA,EAAK,OACLA,EAAK,SAAS,WACXA,EAAK,SAAA,IACN;CACR,GACA;EACEC,EAAM,MAAM;EACZA,EAAM,MAAM;EACZA,EAAM,MAAM;EACZD,EAAK,SAAS,YAAYA,EAAK,WAAW,IAAI;CAChD,GACAC,EAAM,UACN;EAACD,EAAK;EAASD;EAAQE,EAAM;EAAUA,EAAM;CAAM,GACnD;EAACA,EAAM,IAAI;EAAIA,EAAM,IAAI;EAAIA,EAAM,IAAI;EAAIA,EAAM;CAAQ,CAC3D;AACF,GAIMC,IAA2B;;;;;;;;;;;;;;;;;;;;EAoB/BC,KAEWC,IAAyB,GAAGF,EAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiF1CG,IAAuB,GAAGH,EAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CxCI,IAAwB,GAAGJ,EAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDhDK,IAAgB,6KAUhBC,IAAiB,ohCAgCjBC,IAAiB,inCAqCjBC,IAAe,0RAefC,IAAe,mpBAoBfC,IAAgB,+3BA4BhBC,IAAgB,6VAYhBC,IAAY,0GAaZC,KACJ,GACA,GACA,GACA,IAAM,OAENC,MAAY,IACR;CACE,QAAQ,+DAA+DT,IAAgBU;CACvF,UAAU,gEAAgEV,IACxEW,IACIC,IACA,8DACHC;AACL,IACA;CACE,QAAQ,GAAGb,IAAgBU;CAC3B,UAAU,GAAGH,EAAU,yCAAyCP,IAAgBa;AAClF,GAGOC,KAAgB,OAAoB;CAC/C,QAAQN,EAAKP,GAAgBC,GAAgBO,CAAO;CACpD,MAAMD,EAAKL,GAAcC,GAAcK,CAAO;CAC9C,OAAOD,EAAKH,GAAeC,GAAeG,CAAO;AACnD,IAMaM,WAAyB;CACpC,QAAQP,EAAKP,GAAgBC,GAAgB,GAAG,EAAI;CACpD,MAAMM,EAAKL,GAAcC,GAAc,GAAG,EAAI;AAChD,IAGaY,IAAkB;CAC7B,QAAQ;EAAC;EAAY;EAAS;EAAU;CAAS;CACjD,MAAM;EAAC;EAAS;EAAY;CAAS;CACrC,OAAO;EAAC;EAAY;EAAO;EAAO;CAAS;AAC7C"}

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

@@ -1,2 +1,2 @@
-var e=1<<18,t=65536,n=7,r=(e,r,i,a,o,s)=>{let c=Math.floor(e.length/6),{keys:l,counts:u}=s,d=a?2:3,f=i[d]??0,p=i[d+4]??0,m=i[d+8]??0,h=1/0,g=-1/0;for(let t=0;t<c;t++){let i=t*6,a=0,o=0,s=0;for(let t=0;t<4;t++){let c=(e[i+(t===3?5:t)]??0)*n;a+=r[c]??0,o+=r[c+1]??0,s+=r[c+2]??0}let c=f*a+p*o+m*s;l[t]=c,c<h&&(h=c),c>g&&(g=c)}u.fill(0);let _=g>h?65535/(g-h):0;for(let e=0;e<c;e++){let t=Math.min(65535,Math.max(0,Math.floor((g-(l[e]??g))*_)));l[e]=t,u[t]=(u[t]??0)+1}let v=0;for(let e=0;e<t;e++){let t=u[e]??0;u[e]=v,v+=t}for(let t=0;t<c;t++){let n=l[t]??0,r=(u[n]??0)*6;u[n]=(u[n]??0)+1;let i=t*6;for(let t=0;t<6;t++)o[r+t]=e[i+t]??0}},i=(e,t)=>{if(!e)return!1;for(let n=0;n<16;n++)if(e[n]!==t[n])return!1;return!0},a=()=>{let e=new Map,n=null,a=!1,o=0,s=null,c=e=>e.kind===`mesh`&&e.opacity<1&&e.indices.length>=12&&e.indices.length%6==0&&e.indices.length/6<=262144;return(l,u)=>{if(!l.some(c))return e.clear(),l;let d=!i(n,u.viewProj)||a!==u.orthographic;d&&(n=Float32Array.from(u.viewProj),a=u.orthographic);let f=new Set,p=l.map(n=>{if(!c(n))return n;f.add(n.key);let i=e.get(n.key),a=!i||i.version!==n.version||i.source!==n.indices;if(a||d){let c=n.indices.length/6;(!s||s.keys.length<c)&&(s={keys:new Float32Array(Math.max(c,1024)),counts:new Uint32Array(t)});let l=i&&!a&&i.indices.length===n.indices.length?i.indices:new Uint32Array(n.indices.length);r(n.indices,new Float32Array(n.vertices),u.viewProj,u.orthographic,l,s),i={version:n.version,source:n.indices,indices:l,order:++o},e.set(n.key,i)}return{...n,indices:i.indices,order:i.order}});for(let t of e.keys())f.has(t)||e.delete(t);return p}};exports.MAX_SORTED_QUADS=e,exports.createDepthSorter=a,exports.sortQuads=r;
+const e=require("./render-types.cjs");var t=1<<18,n=`transparent`,r=65536,i=7,a=(e,t,n,a,o,s)=>{let c=Math.floor(e.length/6),{keys:l,counts:u}=s,d=a?2:3,f=n[d]??0,p=n[d+4]??0,m=n[d+8]??0,h=1/0,g=-1/0;for(let n=0;n<c;n++){let r=n*6,a=0,o=0,s=0;for(let n=0;n<4;n++){let c=(e[r+(n===3?5:n)]??0)*i;a+=t[c]??0,o+=t[c+1]??0,s+=t[c+2]??0}let c=f*a+p*o+m*s;l[n]=c,c<h&&(h=c),c>g&&(g=c)}u.fill(0);let _=g>h?65535/(g-h):0;for(let e=0;e<c;e++){let t=Math.min(65535,Math.max(0,Math.floor((g-(l[e]??g))*_)));l[e]=t,u[t]=(u[t]??0)+1}let v=0;for(let e=0;e<r;e++){let t=u[e]??0;u[e]=v,v+=t}for(let t=0;t<c;t++){let n=l[t]??0,r=(u[n]??0)*6;u[n]=(u[n]??0)+1;let i=t*6;for(let t=0;t<6;t++)o[r+t]=e[i+t]??0}},o=(e,t,n)=>{let r=0,i=0;for(let t of e)r+=t.vertexCount,i+=t.indices.length;let a=new ArrayBuffer(r*28),o=new Uint8Array(a),s=new Uint32Array(i),c=0,l=0;for(let t of e){let e=Math.min(t.vertices.byteLength,t.vertexCount*28);o.set(new Uint8Array(t.vertices,0,e),c*28);let n=Math.max(0,Math.min(1,t.opacity));if(n<1)for(let e=0;e<t.vertexCount;e++){let t=(c+e)*28+27;o[t]=Math.round((o[t]??0)*n)}let r=t.indices;for(let e=0;e<r.length;e++)s[l+e]=(r[e]??0)+c;c+=t.vertexCount,l+=r.length}return{kind:`mesh`,key:t,version:n,opacity:1,transparent:!0,vertices:a,vertexCount:r,indices:s}},s=(e,t)=>{if(!e)return!1;for(let n=0;n<16;n++)if(e[n]!==t[n])return!1;return!0},c=t=>t.kind===`mesh`&&!e.writesDepth(t),l=t=>t.kind!==`lines`&&!e.writesDepth(t),u=e=>e.indices.length>0&&e.indices.length%6==0,d=e=>{let t=e.kind===`mesh`,n=t?e.vertices:e.data,r=(t?28:20)/4,i=t?e.vertexCount:e.count,a=new Float32Array(n,0,Math.min(Math.floor(n.byteLength/4),i*r)),o=[1/0,1/0,1/0],s=[-1/0,-1/0,-1/0];for(let e=0;e+2<a.length;e+=r)for(let t=0;t<3;t++){let n=a[e+t]??0;n<(o[t]??0)&&(o[t]=n),n>(s[t]??0)&&(s[t]=n)}return[0,1,2].map(e=>o[e]<=s[e]?(o[e]+s[e])/2:0)},f=()=>{let e=new Map,t=new Map,i=null,f=0,p=null,m=!1,h=0,g=null,_=(t,n,i,o)=>{let s=t.indices.length/6;if(!u(t)||s<2||s>262144)return t;o.add(t.key);let c=e.get(t.key),l=!c||c.version!==t.version||c.source!==t.indices;if(l||i){(!g||g.keys.length<s)&&(g={keys:new Float32Array(Math.max(s,1024)),counts:new Uint32Array(r)});let i=c&&!l&&c.indices.length===t.indices.length?c.indices:new Uint32Array(t.indices.length);a(t.indices,new Float32Array(t.vertices),n.viewProj,n.orthographic,i,g),c={version:t.version,source:t.indices,indices:i,order:++h},e.set(t.key,c)}return{...t,indices:c.indices,order:c.order}},v=(e,n)=>{let r=t.get(e.key);(!r||r.version!==e.version)&&(r={version:e.version,center:d(e)},t.set(e.key,r));let i=n.viewProj,a=n.orthographic?2:3,[o,s,c]=r.center;return(i[a]??0)*o+(i[a+4]??0)*s+(i[a+8]??0)*c+(i[a+12]??0)},y=(e,t)=>{let n=[];if(e.forEach((e,t)=>{l(e)&&n.push(t)}),n.length<2)return e;let r=n.map((n,r)=>({item:e[n],k:r,depth:v(e[n],t)})).sort((e,t)=>t.depth-e.depth||e.k-t.k);return n.forEach((t,n)=>{e[t]=r[n].item}),e};return(r,a)=>{let d=r.filter(c),h=r.filter(l);if(d.length===0&&h.length<2)return e.clear(),t.clear(),i=null,r;let g=!s(p,a.viewProj)||m!==a.orthographic;g&&(p=Float32Array.from(a.viewProj),m=a.orthographic);let v=new Set,b=0;for(let e of d)b+=e.indices.length/6;let x=[];if(d.length===0)i=null,x.push(...r);else if(d.length>=2&&b<=262144&&d.every(u)){let e=d.map(e=>`${e.key}@${e.version}@${e.opacity}`).join(`|`);(!i||i.signature!==e)&&(i={signature:e,item:o(d,n,++f)});let t=_(i.item,a,g,v),s=!1;for(let e of r)c(e)?s||(x.push(t),s=!0):x.push(e)}else{i=null;let e=0,t=d.map(e=>_(e,a,g,v));for(let n of r)x.push(c(n)?t[e++]:n)}for(let t of e.keys())v.has(t)||e.delete(t);y(x,a);for(let e of t.keys())x.some(t=>t.key===e)||t.delete(e);return x}};exports.MAX_SORTED_QUADS=t,exports.MERGED_KEY=n,exports.createDepthSorter=f,exports.itemCenter=d,exports.mergeMeshes=o,exports.sortQuads=a;
 //# sourceMappingURL=sort.cjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"sort.cjs","names":["MAX_SORTED_QUADS","BUCKETS","FLOATS","sortQuads","quads","indices","scratch","row","orthographic","mx","viewProj","my","mz","min","max","q","o","x","y","z","c","v","vertices","depth","counts","scale","b","keys","sum","at","j","sameMatrix","a","i","createDepthSorter","sorted","view","order","sortable","item","items","moved","frame","seen","result","entry","stale","out","key"],"sources":["../../../../../charts/src/engine/three-d/sort.ts"],"sourcesContent":["// Back-to-front order of the transparent meshes for the GPU backends:\n// transparent items are drawn without writing depth, so their triangles must\n// come farthest first to blend correctly where a surface folds over itself.\n// Meshes are made of quads (6 indices: two triangles sharing an edge, as\n// built for surface cells and bar faces); quads are sorted by the camera\n// depth of their center with a bucket sort (O(n)), and only again when the\n// camera moved. Canvas2D sorts every triangle itself (painter's algorithm).\n\nimport type { Frame3D, Item3D, MeshItem } from \"./render-types\";\nimport { VERTEX_STRIDE } from \"./render-types\";\n\n/** Largest transparent mesh sorted (quads): a 512 × 512 surface grid */\nexport const MAX_SORTED_QUADS = 1 << 18;\n\nconst BUCKETS = 1 << 16;\nconst FLOATS = VERTEX_STRIDE / 4;\n\n/**\n * Writes into `out` the quads of `indices` (6 indices each) ordered by\n * decreasing camera depth: view depth (clip w) in perspective, clip z in\n * orthographic projection. Equal depths keep their order.\n */\nexport const sortQuads = (\n  indices: Uint32Array,\n  vertices: Float32Array,\n  viewProj: Float32Array,\n  orthographic: boolean,\n  out: Uint32Array,\n  scratch: { keys: Float32Array; counts: Uint32Array },\n): void => {\n  const quads = Math.floor(indices.length / 6);\n  const { keys, counts } = scratch;\n  // depth = row 4 (w) or row 3 (z) of the column-major matrix\n  const row = orthographic ? 2 : 3;\n  const mx = viewProj[row] ?? 0;\n  const my = viewProj[row + 4] ?? 0;\n  const mz = viewProj[row + 8] ?? 0;\n  let min = Infinity;\n  let max = -Infinity;\n  for (let q = 0; q < quads; q++) {\n    const o = q * 6;\n    let x = 0;\n    let y = 0;\n    let z = 0;\n    // the 4 corners: indices 0, 1, 2 and 5 of the quad\n    for (let c = 0; c < 4; c++) {\n      const v = (indices[o + (c === 3 ? 5 : c)] ?? 0) * FLOATS;\n      x += vertices[v] ?? 0;\n      y += vertices[v + 1] ?? 0;\n      z += vertices[v + 2] ?? 0;\n    }\n    const depth = mx * x + my * y + mz * z;\n    keys[q] = depth;\n    if (depth < min) min = depth;\n    if (depth > max) max = depth;\n  }\n  counts.fill(0);\n  const scale = max > min ? (BUCKETS - 1) / (max - min) : 0;\n  // bucket 0 = farthest (clamped: the keys are rounded to float32)\n  for (let q = 0; q < quads; q++) {\n    const b = Math.min(\n      BUCKETS - 1,\n      Math.max(0, Math.floor((max - (keys[q] ?? max)) * scale)),\n    );\n    keys[q] = b;\n    counts[b] = (counts[b] ?? 0) + 1;\n  }\n  let sum = 0;\n  for (let b = 0; b < BUCKETS; b++) {\n    const c = counts[b] ?? 0;\n    counts[b] = sum;\n    sum += c;\n  }\n  for (let q = 0; q < quads; q++) {\n    const b = keys[q] ?? 0;\n    const at = (counts[b] ?? 0) * 6;\n    counts[b] = (counts[b] ?? 0) + 1;\n    const o = q * 6;\n    for (let j = 0; j < 6; j++) out[at + j] = indices[o + j] ?? 0;\n  }\n};\n\ninterface SortedMesh {\n  version: number;\n  source: Uint32Array;\n  indices: Uint32Array;\n  order: number;\n}\n\nconst sameMatrix = (a: Float32Array | null, b: Float32Array) => {\n  if (!a) return false;\n  for (let i = 0; i < 16; i++) if (a[i] !== b[i]) return false;\n  return true;\n};\n\n/**\n * Sorter of the transparent meshes: returns the items with the transparent\n * meshes' indices in back-to-front order (`order` changes when only the\n * indices must be uploaded again)\n */\nexport const createDepthSorter = () => {\n  const sorted = new Map<string, SortedMesh>();\n  let view: Float32Array | null = null;\n  let orthographic = false;\n  let order = 0;\n  let scratch: { keys: Float32Array; counts: Uint32Array } | null = null;\n\n  const sortable = (item: Item3D): item is MeshItem =>\n    item.kind === \"mesh\" &&\n    item.opacity < 1 &&\n    item.indices.length >= 12 &&\n    item.indices.length % 6 === 0 &&\n    item.indices.length / 6 <= MAX_SORTED_QUADS;\n\n  return (items: readonly Item3D[], frame: Frame3D): readonly Item3D[] => {\n    if (!items.some(sortable)) {\n      sorted.clear();\n      return items;\n    }\n    const moved =\n      !sameMatrix(view, frame.viewProj) || orthographic !== frame.orthographic;\n    if (moved) {\n      view = Float32Array.from(frame.viewProj);\n      orthographic = frame.orthographic;\n    }\n    const seen = new Set<string>();\n    const result = items.map((item): Item3D => {\n      if (!sortable(item)) return item;\n      seen.add(item.key);\n      let entry = sorted.get(item.key);\n      const stale =\n        !entry ||\n        entry.version !== item.version ||\n        entry.source !== item.indices;\n      if (stale || moved) {\n        const quads = item.indices.length / 6;\n        if (!scratch || scratch.keys.length < quads)\n          scratch = {\n            keys: new Float32Array(Math.max(quads, 1024)),\n            counts: new Uint32Array(BUCKETS),\n          };\n        const out =\n          entry && !stale && entry.indices.length === item.indices.length\n            ? entry.indices\n            : new Uint32Array(item.indices.length);\n        sortQuads(\n          item.indices,\n          new Float32Array(item.vertices),\n          frame.viewProj,\n          frame.orthographic,\n          out,\n          scratch,\n        );\n        entry = {\n          version: item.version,\n          source: item.indices,\n          indices: out,\n          order: ++order,\n        };\n        sorted.set(item.key, entry);\n      }\n      return { ...item, indices: entry!.indices, order: entry!.order };\n    });\n    for (const key of sorted.keys()) if (!seen.has(key)) sorted.delete(key);\n    return result;\n  };\n};\n"],"mappings":"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"}
+{"version":3,"file":"sort.cjs","names":["writesDepth","require_render_types","MAX_SORTED_QUADS","MERGED_KEY","BUCKETS","FLOATS","sortQuads","quads","indices","scratch","row","orthographic","mx","viewProj","my","mz","min","max","q","o","x","y","z","c","v","vertices","depth","counts","scale","b","keys","sum","at","j","mergeMeshes","vertexCount","indexCount","m","meshes","bytes","base","length","opacity","a","source","sameMatrix","i","isTransparentMesh","item","isBlended","isQuadMesh","itemCenter","mesh","buffer","stride","count","f","k","createDepthSorter","sorted","centers","merged","mergedVersion","view","order","sortMesh","seen","entry","stale","moved","out","frame","centerDepth","byDepth","slots","items","it","ordered","transparent","blended","result","signature","placed","next","own","key"],"sources":["../../../../../charts/src/engine/three-d/sort.ts"],"sourcesContent":["// Back-to-front order of the transparent items for the GPU backends without\n// order-independent transparency (WebGL 1, no float render targets):\n// transparent items are drawn without writing depth, so their triangles must\n// come farthest first to blend correctly where a surface folds over itself\n// or where several transparent surfaces / bar series overlap. Meshes are\n// made of quads (6 indices: two triangles sharing an edge, as built for\n// surface cells and bar faces); quads are sorted by the camera depth of\n// their center with a bucket sort (O(n)), and only again when the camera\n// moved. Several transparent meshes are merged into one item (opacity baked\n// into the vertex colors) so that their quads are sorted together; above\n// the sort budget, the meshes are drawn by decreasing depth of their center\n// with their own quads sorted. Blended point clouds and the transparent\n// meshes are then drawn by decreasing depth of their center. Canvas2D sorts\n// every triangle and dot of every item itself (painter's algorithm).\n\nimport type { Frame3D, Item3D, MeshItem } from \"./render-types\";\nimport { POINT_STRIDE, VERTEX_STRIDE, writesDepth } from \"./render-types\";\n\n/** Largest number of transparent quads sorted: a 512 × 512 surface grid */\nexport const MAX_SORTED_QUADS = 1 << 18;\n\n/** Key of the merged transparent meshes */\nexport const MERGED_KEY = \"transparent\";\n\nconst BUCKETS = 1 << 16;\nconst FLOATS = VERTEX_STRIDE / 4;\n\n/**\n * Writes into `out` the quads of `indices` (6 indices each) ordered by\n * decreasing camera depth: view depth (clip w) in perspective, clip z in\n * orthographic projection. Equal depths keep their order.\n */\nexport const sortQuads = (\n  indices: Uint32Array,\n  vertices: Float32Array,\n  viewProj: Float32Array,\n  orthographic: boolean,\n  out: Uint32Array,\n  scratch: { keys: Float32Array; counts: Uint32Array },\n): void => {\n  const quads = Math.floor(indices.length / 6);\n  const { keys, counts } = scratch;\n  // depth = row 4 (w) or row 3 (z) of the column-major matrix\n  const row = orthographic ? 2 : 3;\n  const mx = viewProj[row] ?? 0;\n  const my = viewProj[row + 4] ?? 0;\n  const mz = viewProj[row + 8] ?? 0;\n  let min = Infinity;\n  let max = -Infinity;\n  for (let q = 0; q < quads; q++) {\n    const o = q * 6;\n    let x = 0;\n    let y = 0;\n    let z = 0;\n    // the 4 corners: indices 0, 1, 2 and 5 of the quad\n    for (let c = 0; c < 4; c++) {\n      const v = (indices[o + (c === 3 ? 5 : c)] ?? 0) * FLOATS;\n      x += vertices[v] ?? 0;\n      y += vertices[v + 1] ?? 0;\n      z += vertices[v + 2] ?? 0;\n    }\n    const depth = mx * x + my * y + mz * z;\n    keys[q] = depth;\n    if (depth < min) min = depth;\n    if (depth > max) max = depth;\n  }\n  counts.fill(0);\n  const scale = max > min ? (BUCKETS - 1) / (max - min) : 0;\n  // bucket 0 = farthest (clamped: the keys are rounded to float32)\n  for (let q = 0; q < quads; q++) {\n    const b = Math.min(\n      BUCKETS - 1,\n      Math.max(0, Math.floor((max - (keys[q] ?? max)) * scale)),\n    );\n    keys[q] = b;\n    counts[b] = (counts[b] ?? 0) + 1;\n  }\n  let sum = 0;\n  for (let b = 0; b < BUCKETS; b++) {\n    const c = counts[b] ?? 0;\n    counts[b] = sum;\n    sum += c;\n  }\n  for (let q = 0; q < quads; q++) {\n    const b = keys[q] ?? 0;\n    const at = (counts[b] ?? 0) * 6;\n    counts[b] = (counts[b] ?? 0) + 1;\n    const o = q * 6;\n    for (let j = 0; j < 6; j++) out[at + j] = indices[o + j] ?? 0;\n  }\n};\n\n/**\n * One transparent item made of several meshes: vertices concatenated (the\n * opacity of every mesh multiplies the alpha of its vertex colors), indices\n * shifted. Drawn with opacity 1, without writing depth.\n */\nexport const mergeMeshes = (\n  meshes: readonly MeshItem[],\n  key: string,\n  version: number,\n): MeshItem => {\n  let vertexCount = 0;\n  let indexCount = 0;\n  for (const m of meshes) {\n    vertexCount += m.vertexCount;\n    indexCount += m.indices.length;\n  }\n  const vertices = new ArrayBuffer(vertexCount * VERTEX_STRIDE);\n  const bytes = new Uint8Array(vertices);\n  const indices = new Uint32Array(indexCount);\n  let base = 0;\n  let at = 0;\n  for (const m of meshes) {\n    const length = Math.min(\n      m.vertices.byteLength,\n      m.vertexCount * VERTEX_STRIDE,\n    );\n    bytes.set(new Uint8Array(m.vertices, 0, length), base * VERTEX_STRIDE);\n    const opacity = Math.max(0, Math.min(1, m.opacity));\n    if (opacity < 1) {\n      for (let v = 0; v < m.vertexCount; v++) {\n        const a = (base + v) * VERTEX_STRIDE + 27;\n        bytes[a] = Math.round((bytes[a] ?? 0) * opacity);\n      }\n    }\n    const source = m.indices;\n    for (let j = 0; j < source.length; j++)\n      indices[at + j] = (source[j] ?? 0) + base;\n    base += m.vertexCount;\n    at += source.length;\n  }\n  return {\n    kind: \"mesh\",\n    key,\n    version,\n    opacity: 1,\n    transparent: true,\n    vertices,\n    vertexCount,\n    indices,\n  };\n};\n\ninterface SortedMesh {\n  version: number;\n  source: Uint32Array;\n  indices: Uint32Array;\n  order: number;\n}\n\nconst sameMatrix = (a: Float32Array | null, b: Float32Array) => {\n  if (!a) return false;\n  for (let i = 0; i < 16; i++) if (a[i] !== b[i]) return false;\n  return true;\n};\n\nconst isTransparentMesh = (item: Item3D): item is MeshItem =>\n  item.kind === \"mesh\" && !writesDepth(item);\n\n/** Drawn without writing depth (transparent meshes, blended points) */\nconst isBlended = (item: Item3D) => item.kind !== \"lines\" && !writesDepth(item);\n\n/** Made of whole quads: its triangles can be sorted by pairs */\nconst isQuadMesh = (item: MeshItem) =>\n  item.indices.length > 0 && item.indices.length % 6 === 0;\n\n/** Center of the bounding box of a mesh's vertices or a cloud's points */\nexport const itemCenter = (item: Item3D): [number, number, number] => {\n  const mesh = item.kind === \"mesh\";\n  const buffer = mesh ? item.vertices : item.data;\n  const stride = (mesh ? VERTEX_STRIDE : POINT_STRIDE) / 4;\n  const count = mesh ? item.vertexCount : item.count;\n  const f = new Float32Array(\n    buffer,\n    0,\n    Math.min(Math.floor(buffer.byteLength / 4), count * stride),\n  );\n  const min = [Infinity, Infinity, Infinity];\n  const max = [-Infinity, -Infinity, -Infinity];\n  for (let o = 0; o + 2 < f.length; o += stride) {\n    for (let k = 0; k < 3; k++) {\n      const v = f[o + k] ?? 0;\n      if (v < (min[k] ?? 0)) min[k] = v;\n      if (v > (max[k] ?? 0)) max[k] = v;\n    }\n  }\n  return [0, 1, 2].map((k) =>\n    min[k]! <= max[k]! ? (min[k]! + max[k]!) / 2 : 0,\n  ) as [number, number, number];\n};\n\n/**\n * Sorter of the transparent items: returns the items with the transparent\n * meshes merged into one item (`MERGED_KEY`) whose quads are in back-to-front\n * order, or — above `MAX_SORTED_QUADS` or for meshes that aren't made of\n * quads — the transparent meshes each with its own quads sorted; the blended\n * items (meshes and point clouds) come by decreasing depth of their center.\n * `order` changes when only the indices must be uploaded again.\n */\nexport const createDepthSorter = () => {\n  const sorted = new Map<string, SortedMesh>();\n  const centers = new Map<\n    string,\n    { version: number; center: [number, number, number] }\n  >();\n  let merged: { signature: string; item: MeshItem } | null = null;\n  let mergedVersion = 0;\n  let view: Float32Array | null = null;\n  let orthographic = false;\n  let order = 0;\n  let scratch: { keys: Float32Array; counts: Uint32Array } | null = null;\n\n  /** Sorts the quads of a mesh when stale or when the camera moved */\n  const sortMesh = (\n    item: MeshItem,\n    frame: Frame3D,\n    moved: boolean,\n    seen: Set<string>,\n  ): MeshItem => {\n    const quads = item.indices.length / 6;\n    if (!isQuadMesh(item) || quads < 2 || quads > MAX_SORTED_QUADS) return item;\n    seen.add(item.key);\n    let entry = sorted.get(item.key);\n    const stale =\n      !entry || entry.version !== item.version || entry.source !== item.indices;\n    if (stale || moved) {\n      if (!scratch || scratch.keys.length < quads)\n        scratch = {\n          keys: new Float32Array(Math.max(quads, 1024)),\n          counts: new Uint32Array(BUCKETS),\n        };\n      const out =\n        entry && !stale && entry.indices.length === item.indices.length\n          ? entry.indices\n          : new Uint32Array(item.indices.length);\n      sortQuads(\n        item.indices,\n        new Float32Array(item.vertices),\n        frame.viewProj,\n        frame.orthographic,\n        out,\n        scratch,\n      );\n      entry = {\n        version: item.version,\n        source: item.indices,\n        indices: out,\n        order: ++order,\n      };\n      sorted.set(item.key, entry);\n    }\n    return { ...item, indices: entry!.indices, order: entry!.order };\n  };\n\n  /** Camera depth of the center of an item (larger: farther) */\n  const centerDepth = (item: Item3D, frame: Frame3D) => {\n    let entry = centers.get(item.key);\n    if (!entry || entry.version !== item.version) {\n      entry = { version: item.version, center: itemCenter(item) };\n      centers.set(item.key, entry);\n    }\n    const m = frame.viewProj;\n    const row = frame.orthographic ? 2 : 3;\n    const [x, y, z] = entry.center;\n    return (\n      (m[row] ?? 0) * x +\n      (m[row + 4] ?? 0) * y +\n      (m[row + 8] ?? 0) * z +\n      (m[row + 12] ?? 0)\n    );\n  };\n\n  /** The blended items of `items` by decreasing depth (stable) */\n  const byDepth = (items: Item3D[], frame: Frame3D): Item3D[] => {\n    const slots: number[] = [];\n    items.forEach((it, i) => {\n      if (isBlended(it)) slots.push(i);\n    });\n    if (slots.length < 2) return items;\n    const ordered = slots\n      .map((i, k) => ({\n        item: items[i]!,\n        k,\n        depth: centerDepth(items[i]!, frame),\n      }))\n      .sort((a, b) => b.depth - a.depth || a.k - b.k);\n    slots.forEach((i, k) => {\n      items[i] = ordered[k]!.item;\n    });\n    return items;\n  };\n\n  return (items: readonly Item3D[], frame: Frame3D): readonly Item3D[] => {\n    const transparent = items.filter(isTransparentMesh);\n    const blended = items.filter(isBlended);\n    if (transparent.length === 0 && blended.length < 2) {\n      sorted.clear();\n      centers.clear();\n      merged = null;\n      return items;\n    }\n    const moved =\n      !sameMatrix(view, frame.viewProj) || orthographic !== frame.orthographic;\n    if (moved) {\n      view = Float32Array.from(frame.viewProj);\n      orthographic = frame.orthographic;\n    }\n    const seen = new Set<string>();\n    let quads = 0;\n    for (const m of transparent) quads += m.indices.length / 6;\n    const result: Item3D[] = [];\n    if (transparent.length === 0) {\n      merged = null;\n      result.push(...items);\n    } else if (\n      transparent.length >= 2 &&\n      quads <= MAX_SORTED_QUADS &&\n      transparent.every(isQuadMesh)\n    ) {\n      // one item: every transparent quad sorted together\n      const signature = transparent\n        .map((m) => `${m.key}@${m.version}@${m.opacity}`)\n        .join(\"|\");\n      if (!merged || merged.signature !== signature) {\n        merged = {\n          signature,\n          item: mergeMeshes(transparent, MERGED_KEY, ++mergedVersion),\n        };\n      }\n      const item = sortMesh(merged.item, frame, moved, seen);\n      let placed = false;\n      for (const it of items) {\n        if (!isTransparentMesh(it)) result.push(it);\n        else if (!placed) {\n          result.push(item);\n          placed = true;\n        }\n      }\n    } else {\n      merged = null;\n      // each mesh with its own quads sorted (ordered with the clouds below)\n      let next = 0;\n      const own = transparent.map((m) => sortMesh(m, frame, moved, seen));\n      for (const it of items)\n        result.push(isTransparentMesh(it) ? own[next++]! : it);\n    }\n    for (const key of sorted.keys()) if (!seen.has(key)) sorted.delete(key);\n    byDepth(result, frame);\n    for (const key of centers.keys())\n      if (!result.some((it) => it.key === key)) centers.delete(key);\n    return result;\n  };\n};\n"],"mappings":"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"}

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

@@ -1,6 +1,8 @@
-import { Frame3D, Item3D } from './render-types.cjs';
-/** Largest transparent mesh sorted (quads): a 512 × 512 surface grid */
+import { Frame3D, Item3D, MeshItem } from './render-types.cjs';
+/** Largest number of transparent quads sorted: a 512 × 512 surface grid */
 export declare const MAX_SORTED_QUADS: number;
+/** Key of the merged transparent meshes */
+export declare const MERGED_KEY = "transparent";
 /**
  * Writes into `out` the quads of `indices` (6 indices each) ordered by
  * decreasing camera depth: view depth (clip w) in perspective, clip z in
@@ -11,8 +13,19 @@ export declare const sortQuads: (indices: Uint32Array, vertices: Float32Array, v
     counts: Uint32Array;
 }) => void;
 /**
- * Sorter of the transparent meshes: returns the items with the transparent
- * meshes' indices in back-to-front order (`order` changes when only the
- * indices must be uploaded again)
+ * One transparent item made of several meshes: vertices concatenated (the
+ * opacity of every mesh multiplies the alpha of its vertex colors), indices
+ * shifted. Drawn with opacity 1, without writing depth.
+ */
+export declare const mergeMeshes: (meshes: readonly MeshItem[], key: string, version: number) => MeshItem;
+/** Center of the bounding box of a mesh's vertices or a cloud's points */
+export declare const itemCenter: (item: Item3D) => [number, number, number];
+/**
+ * Sorter of the transparent items: returns the items with the transparent
+ * meshes merged into one item (`MERGED_KEY`) whose quads are in back-to-front
+ * order, or — above `MAX_SORTED_QUADS` or for meshes that aren't made of
+ * quads — the transparent meshes each with its own quads sorted; the blended
+ * items (meshes and point clouds) come by decreasing depth of their center.
+ * `order` changes when only the indices must be uploaded again.
  */
 export declare const createDepthSorter: () => (items: readonly Item3D[], frame: Frame3D) => readonly Item3D[];

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

@@ -1,6 +1,8 @@
-import { Frame3D, Item3D } from './render-types.js';
-/** Largest transparent mesh sorted (quads): a 512 × 512 surface grid */
+import { Frame3D, Item3D, MeshItem } from './render-types.js';
+/** Largest number of transparent quads sorted: a 512 × 512 surface grid */
 export declare const MAX_SORTED_QUADS: number;
+/** Key of the merged transparent meshes */
+export declare const MERGED_KEY = "transparent";
 /**
  * Writes into `out` the quads of `indices` (6 indices each) ordered by
  * decreasing camera depth: view depth (clip w) in perspective, clip z in
@@ -11,8 +13,19 @@ export declare const sortQuads: (indices: Uint32Array, vertices: Float32Array, v
     counts: Uint32Array;
 }) => void;
 /**
- * Sorter of the transparent meshes: returns the items with the transparent
- * meshes' indices in back-to-front order (`order` changes when only the
- * indices must be uploaded again)
+ * One transparent item made of several meshes: vertices concatenated (the
+ * opacity of every mesh multiplies the alpha of its vertex colors), indices
+ * shifted. Drawn with opacity 1, without writing depth.
+ */
+export declare const mergeMeshes: (meshes: readonly MeshItem[], key: string, version: number) => MeshItem;
+/** Center of the bounding box of a mesh's vertices or a cloud's points */
+export declare const itemCenter: (item: Item3D) => [number, number, number];
+/**
+ * Sorter of the transparent items: returns the items with the transparent
+ * meshes merged into one item (`MERGED_KEY`) whose quads are in back-to-front
+ * order, or — above `MAX_SORTED_QUADS` or for meshes that aren't made of
+ * quads — the transparent meshes each with its own quads sorted; the blended
+ * items (meshes and point clouds) come by decreasing depth of their center.
+ * `order` changes when only the indices must be uploaded again.
  */
 export declare const createDepthSorter: () => (items: readonly Item3D[], frame: Frame3D) => readonly Item3D[];