minerva-design 1.2.0 → 1.4.0

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

@@ -0,0 +1,191 @@
+//#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
+	], [
+		n.eye[0],
+		n.eye[1],
+		n.eye[2],
+		t.kind === "lines" ? t.bias : 0
+	], [
+		n.light[0],
+		n.light[1],
+		n.light[2],
+		0
+	], n.lighting, [
+		t.opacity,
+		i,
+		n.distance,
+		n.radius
+	], [
+		n.fog[0],
+		n.fog[1],
+		n.fog[2],
+		1
+	]);
+}, 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}
+struct Out {
+  @builtin(position) position: vec4f,
+  @location(0) offset: vec2f,
+  @location(1) radius: f32,
+  @location(2) color: vec4f,
+  @location(3) fog: f32,
+};
+
+@vertex
+fn vs(
+  @builtin(vertex_index) vi: u32,
+  @location(0) pos: vec3f,
+  @location(1) size: f32,
+  @location(2) color: vec4f,
+) -> Out {
+  var out: Out;
+  let corner = vec2f(f32(vi & 1u), f32(vi >> 1u)) * 2.0 - 1.0;
+  let clip = u.viewProj * vec4f(pos, 1.0);
+  var factor = 1.0;
+  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 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;
+  return out;
+}
+
+@fragment
+fn fs(in: Out) -> @location(0) 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;
+  return vec4f(rgb * alpha, alpha);
+}
+`, a = `${r}
+struct Out {
+  @builtin(position) position: vec4f,
+  @location(0) world: vec3f,
+  @location(1) normal: vec3f,
+  @location(2) color: vec4f,
+};
+
+@vertex
+fn vs(
+  @location(0) pos: vec3f,
+  @location(1) normal: vec3f,
+  @location(2) color: vec4f,
+) -> Out {
+  var out: Out;
+  out.position = toWebGpuDepth(u.viewProj * vec4f(pos, 1.0));
+  out.world = pos;
+  out.normal = normal;
+  out.color = color;
+  return out;
+}
+
+@fragment
+fn fs(in: Out) -> @location(0) vec4f {
+  var n = normalize(in.normal);
+  let v = normalize(u.eye.xyz - in.world);
+  if (dot(n, v) < 0.0) { n = -n; }
+  let l = u.light.xyz;
+  let diffuse = max(dot(n, l), 0.0);
+  let h = normalize(l + v);
+  let specular = pow(max(dot(n, h), 0.0), u.material.w) * u.material.z;
+  let rgb = in.color.rgb * (u.material.x + u.material.y * diffuse) + vec3f(specular);
+  let alpha = in.color.a * u.params.x;
+  return vec4f(rgb * alpha, alpha);
+}
+`, o = `${r}
+struct Out {
+  @builtin(position) position: vec4f,
+  @location(0) across: f32,
+  @location(1) color: vec4f,
+};
+
+@vertex
+fn vs(
+  @builtin(vertex_index) vi: u32,
+  @location(0) a: vec3f,
+  @location(1) b: vec3f,
+  @location(2) color: vec4f,
+) -> Out {
+  var out: Out;
+  let corner = vec2f(f32(vi & 1u), f32(vi >> 1u));
+  let ca = u.viewProj * vec4f(a, 1.0);
+  let cb = u.viewProj * vec4f(b, 1.0);
+  let halfSize = u.viewport.xy * 0.5;
+  let sa = ca.xy / ca.w * halfSize;
+  let sb = cb.xy / cb.w * halfSize;
+  var dir = sb - sa;
+  let len = length(dir);
+  dir = select(vec2f(1.0, 0.0), dir / len, len > 1e-6);
+  let normal = vec2f(-dir.y, dir.x);
+  let w = max(0.5, u.params.y * u.viewport.z * 0.5) + 0.5;
+  let clip = select(ca, cb, corner.x > 0.5);
+  let side = corner.y * 2.0 - 1.0;
+  let pixel = select(sa, sb, corner.x > 0.5) + dir * (corner.x * 2.0 - 1.0) * w + normal * side * w;
+  let z = clip.z - u.eye.w * clip.w;
+  out.position = toWebGpuDepth(vec4f(pixel / halfSize * clip.w, z, clip.w));
+  out.across = side * w;
+  out.color = color;
+  return out;
+}
+
+@fragment
+fn fs(in: Out) -> @location(0) vec4f {
+  let core = u.params.y * u.viewport.z * 0.5;
+  let coverage = clamp(max(core, 0.5) + 0.5 - abs(in.across), 0.0, 1.0) * min(1.0, core * 2.0);
+  let alpha = coverage * in.color.a * u.params.x;
+  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}`
+} : {
+	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)
+}), _ = {
+	points: [
+		"a_corner",
+		"a_pos",
+		"a_size",
+		"a_color"
+	],
+	mesh: [
+		"a_pos",
+		"a_normal",
+		"a_color"
+	],
+	lines: [
+		"a_corner",
+		"a_a",
+		"a_b",
+		"a_color"
+	]
+};
+//#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 };
+
+//# sourceMappingURL=shaders.js.map

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

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

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

@@ -0,0 +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;
+//# sourceMappingURL=sort.cjs.map

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

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

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

@@ -0,0 +1,18 @@
+import { Frame3D, Item3D } from './render-types.cjs';
+/** Largest transparent mesh sorted (quads): a 512 × 512 surface grid */
+export declare const MAX_SORTED_QUADS: number;
+/**
+ * Writes into `out` the quads of `indices` (6 indices each) ordered by
+ * decreasing camera depth: view depth (clip w) in perspective, clip z in
+ * orthographic projection. Equal depths keep their order.
+ */
+export declare const sortQuads: (indices: Uint32Array, vertices: Float32Array, viewProj: Float32Array, orthographic: boolean, out: Uint32Array, scratch: {
+    keys: Float32Array;
+    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)
+ */
+export declare const createDepthSorter: () => (items: readonly Item3D[], frame: Frame3D) => readonly Item3D[];

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

@@ -0,0 +1,18 @@
+import { Frame3D, Item3D } from './render-types.js';
+/** Largest transparent mesh sorted (quads): a 512 × 512 surface grid */
+export declare const MAX_SORTED_QUADS: number;
+/**
+ * Writes into `out` the quads of `indices` (6 indices each) ordered by
+ * decreasing camera depth: view depth (clip w) in perspective, clip z in
+ * orthographic projection. Equal depths keep their order.
+ */
+export declare const sortQuads: (indices: Uint32Array, vertices: Float32Array, viewProj: Float32Array, orthographic: boolean, out: Uint32Array, scratch: {
+    keys: Float32Array;
+    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)
+ */
+export declare const createDepthSorter: () => (items: readonly Item3D[], frame: Frame3D) => readonly Item3D[];

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

@@ -0,0 +1,71 @@
+//#region src/engine/three-d/sort.ts
+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 = Infinity, g = -Infinity;
+	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 = /* @__PURE__ */ 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 = /* @__PURE__ */ 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;
+	};
+};
+//#endregion
+export { e as MAX_SORTED_QUADS, a as createDepthSorter, r as sortQuads };
+
+//# sourceMappingURL=sort.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sort.js","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","scale","b","keys","counts","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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"}