minerva-design 1.3.0 → 1.5.0

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","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","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)\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 { 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], 1],\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`;\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) * 0.45;\n  out.coverage = min(1.0, raw * raw / (radius * radius));\n  return out;\n}\n\n@fragment\nfn fs(in: Out) -> @location(0) 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  if (u.light.w > 0.5) {\n    // additive light fades with the distance\n    alpha = alpha * (1.0 - in.fog);\n  } else {\n    rgb = mix(rgb, u.fog.rgb, in.fog);\n  }\n  alpha = alpha * in.coverage * 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;\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) * 0.45;\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  if (u_light.w > 0.5) {\n    alpha = alpha * (1.0 - v_fog);\n  } else {\n    rgb = mix(rgb, u_fog.rgb, v_fog);\n  }\n  alpha = alpha * v_coverage * 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":";;AA2BA,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;EAAI;CAAC,CAC9C;AACF,GAIMC,IAA2B,kcAsBpBC,IAAyB,GAAGD,EAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsE1CE,IAAuB,GAAGF,EAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCxCG,IAAwB,GAAGH,EAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDhDI,IAAgB,6KAUhBC,IAAiB,2hCAgCjBC,IAAiB,wjCAmCjBC,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 @@
+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=e=>e.indices.length>0&&e.indices.length%6==0,u=e=>{let t=new Float32Array(e.vertices,0,Math.min(e.vertices.byteLength/4,e.vertexCount*i)),n=[1/0,1/0,1/0],r=[-1/0,-1/0,-1/0];for(let e=0;e+2<t.length;e+=i)for(let i=0;i<3;i++){let a=t[e+i]??0;a<(n[i]??0)&&(n[i]=a),a>(r[i]??0)&&(r[i]=a)}return[0,1,2].map(e=>n[e]<=r[e]?(n[e]+r[e])/2:0)},d=()=>{let e=new Map,t=new Map,i=null,d=0,f=null,p=!1,m=0,h=null,g=(t,n,i,o)=>{let s=t.indices.length/6;if(!l(t)||s<2||s>262144)return t;o.add(t.key);let c=e.get(t.key),u=!c||c.version!==t.version||c.source!==t.indices;if(u||i){(!h||h.keys.length<s)&&(h={keys:new Float32Array(Math.max(s,1024)),counts:new Uint32Array(r)});let i=c&&!u&&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,h),c={version:t.version,source:t.indices,indices:i,order:++m},e.set(t.key,c)}return{...t,indices:c.indices,order:c.order}},_=(e,n)=>{let r=t.get(e.key);(!r||r.version!==e.version)&&(r={version:e.version,center:u(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)};return(r,a)=>{let u=r.filter(c);if(u.length===0)return e.clear(),t.clear(),i=null,r;let m=!s(f,a.viewProj)||p!==a.orthographic;m&&(f=Float32Array.from(a.viewProj),p=a.orthographic);let h=new Set,v=0;for(let e of u)v+=e.indices.length/6;let y=[];if(u.length>=2&&v<=262144&&u.every(l)){let e=u.map(e=>`${e.key}@${e.version}@${e.opacity}`).join(`|`);(!i||i.signature!==e)&&(i={signature:e,item:o(u,n,++d)});let t=g(i.item,a,m,h),s=!1;for(let e of r)c(e)?s||(y.push(t),s=!0):y.push(e)}else{i=null;let e=u.map(e=>({m:e,depth:_(e,a)})).sort((e,t)=>t.depth-e.depth).map(e=>g(e.m,a,m,h)),t=0;for(let n of r)y.push(c(n)?e[t++]:n)}for(let t of e.keys())h.has(t)||e.delete(t);for(let e of t.keys())u.some(t=>t.key===e)||t.delete(e);return y}};exports.MAX_SORTED_QUADS=t,exports.MERGED_KEY=n,exports.createDepthSorter=d,exports.mergeMeshes=o,exports.sortQuads=a;
+//# sourceMappingURL=sort.cjs.map

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

@@ -0,0 +1 @@
+{"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","isQuadMesh","meshCenter","f","k","createDepthSorter","sorted","centers","merged","mergedVersion","view","order","sortMesh","seen","entry","stale","moved","out","frame","centerDepth","transparent","items","result","signature","placed","it","ordered","next","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// 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. Canvas2D sorts every triangle of every item\n// itself (painter's algorithm).\n\nimport type { Frame3D, Item3D, MeshItem } from \"./render-types\";\nimport { 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/** 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 */\nconst meshCenter = (item: MeshItem): [number, number, number] => {\n  const f = new Float32Array(\n    item.vertices,\n    0,\n    Math.min(item.vertices.byteLength / 4, item.vertexCount * FLOATS),\n  );\n  const min = [Infinity, Infinity, Infinity];\n  const max = [-Infinity, -Infinity, -Infinity];\n  for (let o = 0; o + 2 < f.length; o += FLOATS) {\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 meshes: 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 ordered by decreasing depth of their\n * center, each with its own quads sorted. `order` changes when only the\n * 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 a mesh (larger: farther) */\n  const centerDepth = (item: MeshItem, frame: Frame3D) => {\n    let entry = centers.get(item.key);\n    if (!entry || entry.version !== item.version) {\n      entry = { version: item.version, center: meshCenter(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  return (items: readonly Item3D[], frame: Frame3D): readonly Item3D[] => {\n    const transparent = items.filter(isTransparentMesh);\n    if (transparent.length === 0) {\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 (\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      // farthest mesh first, its own quads sorted\n      const ordered = transparent\n        .map((m) => ({ m, depth: centerDepth(m, frame) }))\n        .sort((a, b) => b.depth - a.depth)\n        .map((e) => sortMesh(e.m, frame, moved, seen));\n      let next = 0;\n      for (const it of items)\n        result.push(isTransparentMesh(it) ? ordered[next++]! : it);\n    }\n    for (const key of sorted.keys()) if (!seen.has(key)) sorted.delete(key);\n    for (const key of centers.keys())\n      if (!transparent.some((m) => m.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

@@ -0,0 +1,29 @@
+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
+ * 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;
+/**
+ * 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;
+/**
+ * Sorter of the transparent meshes: 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 ordered by decreasing depth of their
+ * center, each with its own quads sorted. `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,29 @@
+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
+ * 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;
+/**
+ * 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;
+/**
+ * Sorter of the transparent meshes: 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 ordered by decreasing depth of their
+ * center, each with its own quads sorted. `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,145 @@
+import { writesDepth as e } from "./render-types.js";
+//#region src/engine/three-d/sort.ts
+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 = Infinity, g = -Infinity;
+	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 = /* @__PURE__ */ 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(t), l = (e) => e.indices.length > 0 && e.indices.length % 6 == 0, u = (e) => {
+	let t = new Float32Array(e.vertices, 0, Math.min(e.vertices.byteLength / 4, e.vertexCount * i)), n = [
+		Infinity,
+		Infinity,
+		Infinity
+	], r = [
+		-Infinity,
+		-Infinity,
+		-Infinity
+	];
+	for (let e = 0; e + 2 < t.length; e += i) for (let i = 0; i < 3; i++) {
+		let a = t[e + i] ?? 0;
+		a < (n[i] ?? 0) && (n[i] = a), a > (r[i] ?? 0) && (r[i] = a);
+	}
+	return [
+		0,
+		1,
+		2
+	].map((e) => n[e] <= r[e] ? (n[e] + r[e]) / 2 : 0);
+}, d = () => {
+	let e = /* @__PURE__ */ new Map(), t = /* @__PURE__ */ new Map(), i = null, d = 0, f = null, p = !1, m = 0, h = null, g = (t, n, i, o) => {
+		let s = t.indices.length / 6;
+		if (!l(t) || s < 2 || s > 262144) return t;
+		o.add(t.key);
+		let c = e.get(t.key), u = !c || c.version !== t.version || c.source !== t.indices;
+		if (u || i) {
+			(!h || h.keys.length < s) && (h = {
+				keys: new Float32Array(Math.max(s, 1024)),
+				counts: new Uint32Array(r)
+			});
+			let i = c && !u && 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, h), c = {
+				version: t.version,
+				source: t.indices,
+				indices: i,
+				order: ++m
+			}, e.set(t.key, c);
+		}
+		return {
+			...t,
+			indices: c.indices,
+			order: c.order
+		};
+	}, _ = (e, n) => {
+		let r = t.get(e.key);
+		(!r || r.version !== e.version) && (r = {
+			version: e.version,
+			center: u(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);
+	};
+	return (r, a) => {
+		let u = r.filter(c);
+		if (u.length === 0) return e.clear(), t.clear(), i = null, r;
+		let m = !s(f, a.viewProj) || p !== a.orthographic;
+		m && (f = Float32Array.from(a.viewProj), p = a.orthographic);
+		let h = /* @__PURE__ */ new Set(), v = 0;
+		for (let e of u) v += e.indices.length / 6;
+		let y = [];
+		if (u.length >= 2 && v <= 262144 && u.every(l)) {
+			let e = u.map((e) => `${e.key}@${e.version}@${e.opacity}`).join("|");
+			(!i || i.signature !== e) && (i = {
+				signature: e,
+				item: o(u, n, ++d)
+			});
+			let t = g(i.item, a, m, h), s = !1;
+			for (let e of r) c(e) ? s || (y.push(t), s = !0) : y.push(e);
+		} else {
+			i = null;
+			let e = u.map((e) => ({
+				m: e,
+				depth: _(e, a)
+			})).sort((e, t) => t.depth - e.depth).map((e) => g(e.m, a, m, h)), t = 0;
+			for (let n of r) y.push(c(n) ? e[t++] : n);
+		}
+		for (let t of e.keys()) h.has(t) || e.delete(t);
+		for (let e of t.keys()) u.some((t) => t.key === e) || t.delete(e);
+		return y;
+	};
+};
+//#endregion
+export { t as MAX_SORTED_QUADS, n as MERGED_KEY, d as createDepthSorter, o as mergeMeshes, a 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","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","scale","b","keys","counts","sum","at","j","mergeMeshes","vertexCount","indexCount","m","meshes","bytes","base","length","opacity","a","source","sameMatrix","i","isTransparentMesh","item","writesDepth","isQuadMesh","meshCenter","f","k","createDepthSorter","sorted","centers","merged","mergedVersion","view","order","sortMesh","entry","stale","moved","out","frame","centerDepth","transparent","items","seen","result","signature","placed","it","ordered","next","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// 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. Canvas2D sorts every triangle of every item\n// itself (painter's algorithm).\n\nimport type { Frame3D, Item3D, MeshItem } from \"./render-types\";\nimport { 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/** 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 */\nconst meshCenter = (item: MeshItem): [number, number, number] => {\n  const f = new Float32Array(\n    item.vertices,\n    0,\n    Math.min(item.vertices.byteLength / 4, item.vertexCount * FLOATS),\n  );\n  const min = [Infinity, Infinity, Infinity];\n  const max = [-Infinity, -Infinity, -Infinity];\n  for (let o = 0; o + 2 < f.length; o += FLOATS) {\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 meshes: 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 ordered by decreasing depth of their\n * center, each with its own quads sorted. `order` changes when only the\n * 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 a mesh (larger: farther) */\n  const centerDepth = (item: MeshItem, frame: Frame3D) => {\n    let entry = centers.get(item.key);\n    if (!entry || entry.version !== item.version) {\n      entry = { version: item.version, center: meshCenter(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  return (items: readonly Item3D[], frame: Frame3D): readonly Item3D[] => {\n    const transparent = items.filter(isTransparentMesh);\n    if (transparent.length === 0) {\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 (\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      // farthest mesh first, its own quads sorted\n      const ordered = transparent\n        .map((m) => ({ m, depth: centerDepth(m, frame) }))\n        .sort((a, b) => b.depth - a.depth)\n        .map((e) => sortMesh(e.m, frame, moved, seen));\n      let next = 0;\n      for (const it of items)\n        result.push(isTransparentMesh(it) ? ordered[next++]! : it);\n    }\n    for (const key of sorted.keys()) if (!seen.has(key)) sorted.delete(key);\n    for (const key of centers.keys())\n      if (!transparent.some((m) => m.key === key)) centers.delete(key);\n    return result;\n  };\n};\n"],"mappings":"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"}