minerva-design 1.3.0 → 1.5.0

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

@@ -0,0 +1,220 @@
+import { project as e, rayBox as t, rayTriangle as n, screenRay as r } from "./math.js";
+//#region src/engine/three-d/pick.ts
+var i = 24, a = (e, t) => {
+	let n = Math.max(1, Math.ceil(t.width / i)), r = Math.max(1, Math.ceil(t.height / i)), a = new Int32Array(n * r + 1), o = t.viewProj, s = t.width / 2, c = t.height / 2, l = e.map((e) => {
+		let r = new Float32Array(e.count * 3), l = e.positions;
+		for (let u = 0; u < e.count; u++) {
+			let d = u * e.stride, f = l[d], p = l[d + 1], m = l[d + 2], h = o[3] * f + o[7] * p + o[11] * m + o[15], g = u * 3;
+			if (h <= 0) {
+				r[g] = NaN;
+				continue;
+			}
+			let _ = ((o[0] * f + o[4] * p + o[8] * m + o[12]) / h + 1) * s, v = (1 - (o[1] * f + o[5] * p + o[9] * m + o[13]) / h) * c;
+			if (_ < 0 || v < 0 || _ >= t.width || v >= t.height) {
+				r[g] = NaN;
+				continue;
+			}
+			r[g] = _, r[g + 1] = v, r[g + 2] = (o[2] * f + o[6] * p + o[10] * m + o[14]) / h, a[(v / i | 0) * n + (_ / i | 0)]++;
+		}
+		return r;
+	}), u = new Int32Array(n * r + 1);
+	for (let e = 0; e < n * r; e++) u[e + 1] = u[e] + a[e];
+	let d = u[n * r], f = new Uint16Array(d), p = new Int32Array(d), m = u.slice(0, n * r);
+	return l.forEach((e, t) => {
+		let r = e.length / 3;
+		for (let a = 0; a < r; a++) {
+			let r = e[a * 3];
+			if (r !== r) continue;
+			let o = (e[a * 3 + 1] / i | 0) * n + (r / i | 0), s = m[o]++;
+			f[s] = t, p[s] = a;
+		}
+	}), {
+		cell: i,
+		cols: n,
+		rows: r,
+		starts: u,
+		refTarget: f,
+		refPoint: p,
+		screen: l
+	};
+}, o = (e, t, n, r, i = 4) => {
+	let a = 0;
+	for (let e of t) a = e.sized ? Math.max(a, 32) : Math.max(a, e.defaultSize / 2);
+	let o = a + i, s = Math.max(0, Math.floor((n - o) / e.cell)), c = Math.min(e.cols - 1, Math.floor((n + o) / e.cell)), l = Math.max(0, Math.floor((r - o) / e.cell)), u = Math.min(e.rows - 1, Math.floor((r + o) / e.cell)), d = null, f = !1, p = Infinity;
+	for (let a = l; a <= u; a++) for (let o = s; o <= c; o++) {
+		let s = a * e.cols + o;
+		for (let a = e.starts[s]; a < e.starts[s + 1]; a++) {
+			let o = e.refTarget[a], s = e.refPoint[a], c = e.screen[o], l = t[o], u = c[s * 3] - n, m = c[s * 3 + 1] - r, h = c[s * 3 + 2], g = Math.hypot(u, m), _ = l.sized ? (l.positions[s * l.stride + 3] || l.defaultSize) / 2 : l.defaultSize / 2, v = g <= Math.max(_, 2);
+			!v && g > _ + i || (v ? !f || h < d.depth : !f && g < p) && (d = {
+				target: o,
+				point: s,
+				depth: h
+			}, f = v, p = g);
+		}
+	}
+	return d;
+}, s = 16, c = /* @__PURE__ */ new WeakMap(), l = (e) => {
+	let t = c.get(e);
+	if (t) return t;
+	let n = Math.ceil((e.cols - 1) / s), r = Math.ceil((e.rows - 1) / s), i = new Float32Array(n * r * 6), a = e.positions;
+	for (let t = 0; t < r; t++) for (let r = 0; r < n; r++) {
+		let o = [
+			Infinity,
+			Infinity,
+			Infinity
+		], c = [
+			-Infinity,
+			-Infinity,
+			-Infinity
+		];
+		for (let n = t * s; n <= Math.min(e.rows - 1, (t + 1) * s); n++) for (let t = r * s; t <= Math.min(e.cols - 1, (r + 1) * s); t++) {
+			let r = (n * e.cols + t) * 3;
+			for (let e = 0; e < 3; e++) {
+				let t = a[r + e];
+				t === t && (t < o[e] && (o[e] = t), t > c[e] && (c[e] = t));
+			}
+		}
+		i.set([...o, ...c], (t * n + r) * 6);
+	}
+	let o = {
+		bc: n,
+		br: r,
+		boxes: i
+	};
+	return c.set(e, o), o;
+}, u = (e, r) => {
+	let { bc: i, br: a, boxes: o } = l(r), c = r.positions, u = Infinity, d = -1, f = (t, r, i) => n(e, c[t * 3], c[t * 3 + 1], c[t * 3 + 2], c[r * 3], c[r * 3 + 1], c[r * 3 + 2], c[i * 3], c[i * 3 + 1], c[i * 3 + 2]);
+	for (let n = 0; n < a; n++) for (let a = 0; a < i; a++) {
+		let l = (n * i + a) * 6;
+		if (o[l] <= o[l + 3] && !(t(e, [
+			o[l],
+			o[l + 1],
+			o[l + 2]
+		], [
+			o[l + 3],
+			o[l + 4],
+			o[l + 5]
+		]) >= u)) for (let t = n * s; t < Math.min(r.rows - 1, (n + 1) * s); t++) for (let n = a * s; n < Math.min(r.cols - 1, (a + 1) * s); n++) {
+			let i = t * r.cols + n, a = i + 1, o = i + r.cols, s = o + 1;
+			if (c[i * 3 + 2] !== c[i * 3 + 2] || c[a * 3 + 2] !== c[a * 3 + 2] || c[o * 3 + 2] !== c[o * 3 + 2] || c[s * 3 + 2] !== c[s * 3 + 2]) continue;
+			let l = Math.min(f(i, a, s), f(i, s, o));
+			if (l < u) {
+				u = l;
+				let t = e.origin[0] + e.dir[0] * l, n = e.origin[1] + e.dir[1] * l, r = i, f = Infinity;
+				for (let e of [
+					i,
+					a,
+					o,
+					s
+				]) {
+					let i = (c[e * 3] - t) ** 2 + (c[e * 3 + 1] - n) ** 2;
+					i < f && (f = i, r = e);
+				}
+				d = r;
+			}
+		}
+	}
+	return d >= 0 ? {
+		distance: u,
+		vertex: d
+	} : null;
+}, d = (e, n) => {
+	let r = Infinity, i = -1, a = n.boxes;
+	for (let o = 0; o < n.count; o++) {
+		let n = o * 6, s = t(e, [
+			a[n],
+			a[n + 1],
+			a[n + 2]
+		], [
+			a[n + 3],
+			a[n + 4],
+			a[n + 5]
+		]);
+		s < r && (r = s, i = o);
+	}
+	return i >= 0 ? {
+		distance: r,
+		bar: i
+	} : null;
+}, f = () => {
+	let t = null, n = [];
+	return {
+		reset() {
+			t = null;
+		},
+		pick(i, s, c, l) {
+			let f = i.filter((e) => e.kind === "points"), p = null;
+			if (f.length) {
+				let e = [
+					s.viewProj,
+					s.width,
+					s.height,
+					...f
+				];
+				(!t || e.length !== n.length || e.some((e, t) => e !== n[t])) && (t = a(f, s), n = e);
+				let r = o(t, f, c, l);
+				if (r) {
+					let e = f[r.target], n = r.point * e.stride, i = [
+						e.positions[n],
+						e.positions[n + 1],
+						e.positions[n + 2]
+					], a = t.screen[r.target];
+					p = {
+						series: e.series,
+						kind: "points",
+						item: r.point,
+						world: i,
+						x: a[r.point * 3],
+						y: a[r.point * 3 + 1],
+						depth: r.depth
+					};
+				}
+			}
+			let m = r(s, c, l);
+			if (!m) return p;
+			for (let t of i) if (t.kind === "surface") {
+				let n = u(m, t);
+				if (!n) continue;
+				let r = n.vertex * 3, i = [
+					t.positions[r],
+					t.positions[r + 1],
+					t.positions[r + 2]
+				], a = e(s, i[0], i[1], i[2]);
+				if (p && p.depth <= a.depth + 1e-4) continue;
+				p = {
+					series: t.series,
+					kind: "surface",
+					item: n.vertex,
+					world: i,
+					x: a.x,
+					y: a.y,
+					depth: a.depth
+				};
+			} else if (t.kind === "bars") {
+				let n = d(m, t);
+				if (!n) continue;
+				let r = n.bar * 6, i = [
+					(t.boxes[r] + t.boxes[r + 3]) / 2,
+					(t.boxes[r + 1] + t.boxes[r + 4]) / 2,
+					t.boxes[r + 5]
+				], a = m.origin[0] + m.dir[0] * n.distance, o = m.origin[1] + m.dir[1] * n.distance, c = m.origin[2] + m.dir[2] * n.distance, l = e(s, a, o, c).depth;
+				if (p && p.depth <= l) continue;
+				let u = e(s, i[0], i[1], i[2]);
+				p = {
+					series: t.series,
+					kind: "bars",
+					item: n.bar,
+					world: i,
+					x: u.x,
+					y: u.y,
+					depth: l
+				};
+			}
+			return p;
+		}
+	};
+};
+//#endregion
+export { a as buildPointIndex, f as createPicker, o as pickPoint, d as rayBars, u as raySurface };
+
+//# sourceMappingURL=pick.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pick.js","names":["CELL","buildPointIndex","cols","frame","rows","counts","m","halfW","halfH","screen","targets","out","t","p","i","o","x","y","z","w","s","sx","sy","starts","total","refTarget","refPoint","fill","n","c","at","pickPoint","maxRadius","reach","slack","c0","index","c1","r0","r1","best","bestCovered","bestDistance","r","cell","k","target","dx","dy","depth","distance","radius","covered","BLOCK","blockCache","surfaceBlocks","cached","bc","br","boxes","b","a","lo","hi","v","blocks","raySurface","vertex","tri","rayTriangle","ray","v00","v01","v10","v11","d","hx","hy","nearest","nd","dd","rayBars","bar","rayBox","createPicker","indexKey","pointTargets","key","hit","world","screenRay","project","hz","anchor"],"sources":["../../../../../charts/src/engine/three-d/pick.ts"],"sourcesContent":["// Hover picking without the GPU: point clouds are bucketed into a screen\n// grid (rebuilt lazily when the camera moved), surfaces and bars are hit\n// by a ray (block bounding boxes over the surface grid, slab tests).\n\nimport type {\n  BarTarget,\n  PickTarget,\n  PointTarget,\n  SurfaceTarget,\n} from \"./geometry\";\nimport {\n  project,\n  rayBox,\n  rayTriangle,\n  screenRay,\n  type CameraFrame,\n  type Ray,\n  type Vec3,\n} from \"./math\";\n\nexport interface PickHit {\n  /** Series index */\n  series: number;\n  kind: PickTarget[\"kind\"];\n  /** Index of the drawn item (point, bar) or of the sampled surface vertex */\n  item: number;\n  /** World position of the hovered point / vertex / bar top */\n  world: Vec3;\n  /** Stage pixels */\n  x: number;\n  y: number;\n  /** Normalized depth (-1 near … 1 far) */\n  depth: number;\n}\n\n/** Screen-space bucket grid of the projected points of every point target */\nexport interface PointIndex {\n  cell: number;\n  cols: number;\n  rows: number;\n  /** Start of every cell in `refs` (length cols × rows + 1) */\n  starts: Int32Array;\n  /** Target index << 24 is too small for 1M points: two parallel arrays */\n  refTarget: Uint16Array;\n  refPoint: Int32Array;\n  /** Per target: projected x, y, depth (3 floats per point; NaN when off-screen) */\n  screen: Float32Array[];\n}\n\nconst CELL = 24;\n\nexport const buildPointIndex = (\n  targets: readonly PointTarget[],\n  frame: CameraFrame,\n): PointIndex => {\n  const cols = Math.max(1, Math.ceil(frame.width / CELL));\n  const rows = Math.max(1, Math.ceil(frame.height / CELL));\n  const counts = new Int32Array(cols * rows + 1);\n  const m = frame.viewProj;\n  const halfW = frame.width / 2;\n  const halfH = frame.height / 2;\n  const screen = targets.map((t) => {\n    const out = new Float32Array(t.count * 3);\n    const p = t.positions;\n    for (let i = 0; i < t.count; i++) {\n      const o = i * t.stride;\n      const x = p[o];\n      const y = p[o + 1];\n      const z = p[o + 2];\n      const w = m[3] * x + m[7] * y + m[11] * z + m[15];\n      const s = i * 3;\n      if (w <= 0) {\n        out[s] = NaN;\n        continue;\n      }\n      const sx = ((m[0] * x + m[4] * y + m[8] * z + m[12]) / w + 1) * halfW;\n      const sy = (1 - (m[1] * x + m[5] * y + m[9] * z + m[13]) / w) * halfH;\n      if (sx < 0 || sy < 0 || sx >= frame.width || sy >= frame.height) {\n        out[s] = NaN;\n        continue;\n      }\n      out[s] = sx;\n      out[s + 1] = sy;\n      out[s + 2] = (m[2] * x + m[6] * y + m[10] * z + m[14]) / w;\n      counts[((sy / CELL) | 0) * cols + ((sx / CELL) | 0)]++;\n    }\n    return out;\n  });\n  const starts = new Int32Array(cols * rows + 1);\n  for (let i = 0; i < cols * rows; i++) starts[i + 1] = starts[i] + counts[i];\n  const total = starts[cols * rows];\n  const refTarget = new Uint16Array(total);\n  const refPoint = new Int32Array(total);\n  const fill = starts.slice(0, cols * rows);\n  screen.forEach((out, t) => {\n    const n = out.length / 3;\n    for (let i = 0; i < n; i++) {\n      const sx = out[i * 3];\n      if (sx !== sx) continue;\n      const c = ((out[i * 3 + 1] / CELL) | 0) * cols + ((sx / CELL) | 0);\n      const at = fill[c]++;\n      refTarget[at] = t;\n      refPoint[at] = i;\n    }\n  });\n  return { cell: CELL, cols, rows, starts, refTarget, refPoint, screen };\n};\n\n/** Front-most point whose dot covers (x, y), else the closest within `slack` pixels */\nexport const pickPoint = (\n  index: PointIndex,\n  targets: readonly PointTarget[],\n  x: number,\n  y: number,\n  slack = 4,\n): { target: number; point: number; depth: number } | null => {\n  let maxRadius = 0;\n  for (const t of targets) {\n    if (t.sized) maxRadius = Math.max(maxRadius, 32);\n    else maxRadius = Math.max(maxRadius, t.defaultSize / 2);\n  }\n  const reach = maxRadius + slack;\n  const c0 = Math.max(0, Math.floor((x - reach) / index.cell));\n  const c1 = Math.min(index.cols - 1, Math.floor((x + reach) / index.cell));\n  const r0 = Math.max(0, Math.floor((y - reach) / index.cell));\n  const r1 = Math.min(index.rows - 1, Math.floor((y + reach) / index.cell));\n  let best: { target: number; point: number; depth: number } | null = null;\n  let bestCovered = false;\n  let bestDistance = Infinity;\n  for (let r = r0; r <= r1; r++) {\n    for (let c = c0; c <= c1; c++) {\n      const cell = r * index.cols + c;\n      for (let k = index.starts[cell]; k < index.starts[cell + 1]; k++) {\n        const t = index.refTarget[k];\n        const i = index.refPoint[k];\n        const s = index.screen[t];\n        const target = targets[t];\n        const dx = s[i * 3] - x;\n        const dy = s[i * 3 + 1] - y;\n        const depth = s[i * 3 + 2];\n        const distance = Math.hypot(dx, dy);\n        const radius = target.sized\n          ? (target.positions[i * target.stride + 3] || target.defaultSize) / 2\n          : target.defaultSize / 2;\n        const covered = distance <= Math.max(radius, 2);\n        if (!covered && distance > radius + slack) continue;\n        const better = covered\n          ? !bestCovered || depth < best!.depth\n          : !bestCovered && distance < bestDistance;\n        if (better) {\n          best = { target: t, point: i, depth };\n          bestCovered = covered;\n          bestDistance = distance;\n        }\n      }\n    }\n  }\n  return best;\n};\n\n// ---------------------------------------------------------------- surfaces\n\nconst BLOCK = 16;\n\ninterface SurfaceBlocks {\n  bc: number;\n  br: number;\n  /** min x, y, z, max x, y, z per block */\n  boxes: Float32Array;\n}\n\nconst blockCache = new WeakMap<SurfaceTarget, SurfaceBlocks>();\n\nconst surfaceBlocks = (t: SurfaceTarget): SurfaceBlocks => {\n  const cached = blockCache.get(t);\n  if (cached) return cached;\n  const bc = Math.ceil((t.cols - 1) / BLOCK);\n  const br = Math.ceil((t.rows - 1) / BLOCK);\n  const boxes = new Float32Array(bc * br * 6);\n  const p = t.positions;\n  for (let b = 0; b < br; b++) {\n    for (let a = 0; a < bc; a++) {\n      const lo = [Infinity, Infinity, Infinity];\n      const hi = [-Infinity, -Infinity, -Infinity];\n      for (let r = b * BLOCK; r <= Math.min(t.rows - 1, (b + 1) * BLOCK); r++) {\n        for (\n          let c = a * BLOCK;\n          c <= Math.min(t.cols - 1, (a + 1) * BLOCK);\n          c++\n        ) {\n          const o = (r * t.cols + c) * 3;\n          for (let k = 0; k < 3; k++) {\n            const v = p[o + k];\n            if (v !== v) continue;\n            if (v < lo[k]) lo[k] = v;\n            if (v > hi[k]) hi[k] = v;\n          }\n        }\n      }\n      boxes.set([...lo, ...hi], (b * bc + a) * 6);\n    }\n  }\n  const blocks = { bc, br, boxes };\n  blockCache.set(t, blocks);\n  return blocks;\n};\n\n/** Nearest hit of the ray on a surface: distance and nearest grid vertex */\nexport const raySurface = (\n  ray: Ray,\n  t: SurfaceTarget,\n): { distance: number; vertex: number } | null => {\n  const { bc, br, boxes } = surfaceBlocks(t);\n  const p = t.positions;\n  let best = Infinity;\n  let vertex = -1;\n  const tri = (a: number, b: number, c: number) => {\n    const d = rayTriangle(\n      ray,\n      p[a * 3],\n      p[a * 3 + 1],\n      p[a * 3 + 2],\n      p[b * 3],\n      p[b * 3 + 1],\n      p[b * 3 + 2],\n      p[c * 3],\n      p[c * 3 + 1],\n      p[c * 3 + 2],\n    );\n    return d;\n  };\n  for (let b = 0; b < br; b++) {\n    for (let a = 0; a < bc; a++) {\n      const o = (b * bc + a) * 6;\n      if (!(boxes[o] <= boxes[o + 3])) continue;\n      const enter = rayBox(\n        ray,\n        [boxes[o], boxes[o + 1], boxes[o + 2]],\n        [boxes[o + 3], boxes[o + 4], boxes[o + 5]],\n      );\n      if (enter >= best) continue;\n      for (let r = b * BLOCK; r < Math.min(t.rows - 1, (b + 1) * BLOCK); r++) {\n        for (\n          let c = a * BLOCK;\n          c < Math.min(t.cols - 1, (a + 1) * BLOCK);\n          c++\n        ) {\n          const v00 = r * t.cols + c;\n          const v01 = v00 + 1;\n          const v10 = v00 + t.cols;\n          const v11 = v10 + 1;\n          if (\n            p[v00 * 3 + 2] !== p[v00 * 3 + 2] ||\n            p[v01 * 3 + 2] !== p[v01 * 3 + 2] ||\n            p[v10 * 3 + 2] !== p[v10 * 3 + 2] ||\n            p[v11 * 3 + 2] !== p[v11 * 3 + 2]\n          ) {\n            continue;\n          }\n          const d = Math.min(tri(v00, v01, v11), tri(v00, v11, v10));\n          if (d < best) {\n            best = d;\n            // nearest corner of the cell to the hit point\n            const hx = ray.origin[0] + ray.dir[0] * d;\n            const hy = ray.origin[1] + ray.dir[1] * d;\n            let nearest = v00;\n            let nd = Infinity;\n            for (const v of [v00, v01, v10, v11]) {\n              const dd = (p[v * 3] - hx) ** 2 + (p[v * 3 + 1] - hy) ** 2;\n              if (dd < nd) {\n                nd = dd;\n                nearest = v;\n              }\n            }\n            vertex = nearest;\n          }\n        }\n      }\n    }\n  }\n  return vertex >= 0 ? { distance: best, vertex } : null;\n};\n\n/** Nearest bar hit by the ray */\nexport const rayBars = (\n  ray: Ray,\n  t: BarTarget,\n): { distance: number; bar: number } | null => {\n  let best = Infinity;\n  let bar = -1;\n  const b = t.boxes;\n  for (let i = 0; i < t.count; i++) {\n    const o = i * 6;\n    const d = rayBox(\n      ray,\n      [b[o], b[o + 1], b[o + 2]],\n      [b[o + 3], b[o + 4], b[o + 5]],\n    );\n    if (d < best) {\n      best = d;\n      bar = i;\n    }\n  }\n  return bar >= 0 ? { distance: best, bar } : null;\n};\n\n// -------------------------------------------------------------------- main\n\n/** Picks the front-most item under a stage pixel */\nexport const createPicker = () => {\n  let index: PointIndex | null = null;\n  let indexKey: unknown[] = [];\n\n  return {\n    /** Forgets the point index (camera, size or data changed) */\n    reset() {\n      index = null;\n    },\n    pick(\n      targets: readonly PickTarget[],\n      frame: CameraFrame,\n      x: number,\n      y: number,\n    ): PickHit | null {\n      const pointTargets = targets.filter(\n        (t): t is PointTarget => t.kind === \"points\",\n      );\n      let best: PickHit | null = null;\n      if (pointTargets.length) {\n        const key = [\n          frame.viewProj,\n          frame.width,\n          frame.height,\n          ...pointTargets,\n        ];\n        if (\n          !index ||\n          key.length !== indexKey.length ||\n          key.some((k, i) => k !== indexKey[i])\n        ) {\n          index = buildPointIndex(pointTargets, frame);\n          indexKey = key;\n        }\n        const hit = pickPoint(index, pointTargets, x, y);\n        if (hit) {\n          const t = pointTargets[hit.target];\n          const o = hit.point * t.stride;\n          const world: Vec3 = [\n            t.positions[o],\n            t.positions[o + 1],\n            t.positions[o + 2],\n          ];\n          const s = index.screen[hit.target];\n          best = {\n            series: t.series,\n            kind: \"points\",\n            item: hit.point,\n            world,\n            x: s[hit.point * 3],\n            y: s[hit.point * 3 + 1],\n            depth: hit.depth,\n          };\n        }\n      }\n      const ray = screenRay(frame, x, y);\n      if (!ray) return best;\n      for (const t of targets) {\n        if (t.kind === \"surface\") {\n          const hit = raySurface(ray, t);\n          if (!hit) continue;\n          const o = hit.vertex * 3;\n          const world: Vec3 = [\n            t.positions[o],\n            t.positions[o + 1],\n            t.positions[o + 2],\n          ];\n          const screen = project(frame, world[0], world[1], world[2]);\n          // points slightly behind a surface stay pickable where they show through\n          if (best && best.depth <= screen.depth + 1e-4) continue;\n          best = {\n            series: t.series,\n            kind: \"surface\",\n            item: hit.vertex,\n            world,\n            x: screen.x,\n            y: screen.y,\n            depth: screen.depth,\n          };\n        } else if (t.kind === \"bars\") {\n          const hit = rayBars(ray, t);\n          if (!hit) continue;\n          const o = hit.bar * 6;\n          const world: Vec3 = [\n            (t.boxes[o] + t.boxes[o + 3]) / 2,\n            (t.boxes[o + 1] + t.boxes[o + 4]) / 2,\n            t.boxes[o + 5],\n          ];\n          // the hit point decides the depth, the anchor is the top of the bar\n          const hx = ray.origin[0] + ray.dir[0] * hit.distance;\n          const hy = ray.origin[1] + ray.dir[1] * hit.distance;\n          const hz = ray.origin[2] + ray.dir[2] * hit.distance;\n          const depth = project(frame, hx, hy, hz).depth;\n          if (best && best.depth <= depth) continue;\n          const anchor = project(frame, world[0], world[1], world[2]);\n          best = {\n            series: t.series,\n            kind: \"bars\",\n            item: hit.bar,\n            world,\n            x: anchor.x,\n            y: anchor.y,\n            depth,\n          };\n        }\n      }\n      return best;\n    },\n  };\n};\n"],"mappings":"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"}

package/dist/charts/engine/three-d/render-types.cjs

@@ -0,0 +1,2 @@
+var e=e=>e.opacity<1?!1:e.kind===`mesh`?!e.transparent:e.kind!==`points`||!e.additive&&e.style!==2,t=t=>{let n=t=>t.kind===`mesh`?e(t)?0:3:t.kind===`points`?e(t)?1:2:4;return t.map((e,t)=>({item:e,i:t,r:n(e)})).sort((e,t)=>e.r-t.r||e.i-t.i).map(e=>e.item)};exports.drawOrder=t,exports.writesDepth=e;
+//# sourceMappingURL=render-types.cjs.map

package/dist/charts/engine/three-d/render-types.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-types.cjs","names":["writesDepth","item","drawOrder","rank","items","a","b"],"sources":["../../../../../charts/src/engine/three-d/render-types.ts"],"sourcesContent":["// Contract between the 3D chart and its data-layer backends.\n\nimport type { Rgba } from \"../color\";\nimport type { ChartRendererKind } from \"../types\";\nimport type { Vec3 } from \"./math\";\n\n/** Bytes per point instance: x, y, z f32, diameter (CSS px) f32, color unorm8x4 */\nexport const POINT_STRIDE = 20;\n/** Bytes per mesh vertex: position f32x3, normal f32x3, color unorm8x4 */\nexport const VERTEX_STRIDE = 28;\n/** Bytes per line segment instance: a f32x3, b f32x3, color unorm8x4 */\nexport const SEGMENT_STRIDE = 28;\n\ninterface ItemBase {\n  /** Identifies the GPU resources of the item */\n  key: string;\n  /** Changes when the buffers must be uploaded again */\n  version: number;\n  /** 0-1; below 1 the item is drawn without writing depth */\n  opacity: number;\n}\n\n/** Shapes of the points (`PointsItem.style`) */\nexport const POINT_SPHERE = 0;\nexport const POINT_DISC = 1;\nexport const POINT_GLOW = 2;\n\n/** Instanced billboards: shaded spheres, flat discs or glowing discs */\nexport interface PointsItem extends ItemBase {\n  kind: \"points\";\n  data: ArrayBuffer;\n  count: number;\n  /** Scales the dots with the distance (perspective) */\n  perspective: boolean;\n  /** `POINT_SPHERE`, `POINT_DISC` or `POINT_GLOW` (sphere when omitted) */\n  style?: number;\n  /** Adds the light of the dots (no depth writes, order independent) */\n  additive?: boolean;\n  /**\n   * The data was thinned to 1 point out of `thinned` (CPU backend): the\n   * drawn dots get denser to keep the look of the cloud\n   */\n  thinned?: number;\n}\n\n/** Lit triangles (surfaces, bars) */\nexport interface MeshItem extends ItemBase {\n  kind: \"mesh\";\n  vertices: ArrayBuffer;\n  vertexCount: number;\n  indices: Uint32Array;\n  /**\n   * Changes when only the order of the triangles changed (transparent meshes\n   * sorted back to front): the index buffer is rewritten, same length\n   */\n  order?: number;\n  /**\n   * Blended without writing depth whatever its `opacity` (merged transparent\n   * meshes: their opacity is baked into the vertex colors)\n   */\n  transparent?: boolean;\n}\n\n/** Screen-space wide segments (wireframes, contours, polylines) */\nexport interface LinesItem extends ItemBase {\n  kind: \"lines\";\n  data: ArrayBuffer;\n  count: number;\n  /** CSS pixels */\n  width: number;\n  /** Pulls the lines towards the camera (wireframes over their surface) */\n  bias: number;\n}\n\nexport type Item3D = PointsItem | MeshItem | LinesItem;\n\nexport interface Frame3D {\n  /** World -> clip (OpenGL convention) */\n  viewProj: Float32Array;\n  eye: Vec3;\n  /** Unit vector towards the light, in world space */\n  light: Vec3;\n  orthographic: boolean;\n  /** Distance of the camera to the box center (reference of the point sizes) */\n  distance: number;\n  /** Radius of the sphere around the box (depth cue range) */\n  radius: number;\n  /** Drawing buffer size in device pixels */\n  width: number;\n  height: number;\n  dpr: number;\n  /** ambient, diffuse, specular, shininess */\n  lighting: readonly [number, number, number, number];\n  /** Background color: far points fade towards it */\n  fog: Rgba;\n}\n\nexport interface Renderer3D {\n  readonly kind: ChartRendererKind;\n  readonly canvas: HTMLCanvasElement;\n  /** Drawing buffer size in device pixels */\n  resize(width: number, height: number): void;\n  render(items: readonly Item3D[], frame: Frame3D): void;\n  destroy(): void;\n}\n\n/** Whether an item writes the depth buffer (opaque items) */\nexport const writesDepth = (item: Item3D): boolean => {\n  if (item.opacity < 1) return false;\n  if (item.kind === \"mesh\") return !item.transparent;\n  if (item.kind === \"points\")\n    return !item.additive && item.style !== POINT_GLOW;\n  return true;\n};\n\n/**\n * Order of the draws: opaque meshes, opaque points, blended points,\n * transparent meshes, then lines (wireframes and contours stay visible over\n * transparent surfaces). Stable: items of a rank keep their order.\n */\nexport const drawOrder = (items: readonly Item3D[]): Item3D[] => {\n  const rank = (item: Item3D) =>\n    item.kind === \"mesh\"\n      ? writesDepth(item)\n        ? 0\n        : 3\n      : item.kind === \"points\"\n        ? writesDepth(item)\n          ? 1\n          : 2\n        : 4;\n  return items\n    .map((item, i) => ({ item, i, r: rank(item) }))\n    .sort((a, b) => a.r - b.r || a.i - b.i)\n    .map((e) => e.item);\n};\n"],"mappings":"AA2GA,IAAaA,EAAe,GACtBC,EAAK,QAAU,EAAU,GACzBA,EAAK,OAAS,OAAe,CAACA,EAAK,YACnCA,EAAK,OAAS,UACT,CAACA,EAAK,UAAYA,EAAK,QAAA,EASrBC,EAAa,GAAuC,CAC/D,IAAMC,EAAQ,GACZF,EAAK,OAAS,OACVD,EAAYC,CAAI,EACd,EACA,EACFA,EAAK,OAAS,SACZD,EAAYC,CAAI,EACd,EACA,EACF,EACR,OAAOG,EACJ,KAAK,EAAM,KAAO,CAAE,OAAM,IAAG,EAAGD,EAAKF,CAAI,CAAE,EAAE,CAAC,CAC9C,MAAM,EAAG,IAAMI,EAAE,EAAIC,EAAE,GAAKD,EAAE,EAAIC,EAAE,CAAC,CAAC,CACtC,IAAK,GAAM,EAAE,IAAI,CACtB"}

package/dist/charts/engine/three-d/render-types.d.cts

@@ -0,0 +1,103 @@
+import { Rgba } from '../color.cjs';
+import { ChartRendererKind } from '../types.cjs';
+import { Vec3 } from './math.cjs';
+/** Bytes per point instance: x, y, z f32, diameter (CSS px) f32, color unorm8x4 */
+export declare const POINT_STRIDE = 20;
+/** Bytes per mesh vertex: position f32x3, normal f32x3, color unorm8x4 */
+export declare const VERTEX_STRIDE = 28;
+/** Bytes per line segment instance: a f32x3, b f32x3, color unorm8x4 */
+export declare const SEGMENT_STRIDE = 28;
+interface ItemBase {
+    /** Identifies the GPU resources of the item */
+    key: string;
+    /** Changes when the buffers must be uploaded again */
+    version: number;
+    /** 0-1; below 1 the item is drawn without writing depth */
+    opacity: number;
+}
+/** Shapes of the points (`PointsItem.style`) */
+export declare const POINT_SPHERE = 0;
+export declare const POINT_DISC = 1;
+export declare const POINT_GLOW = 2;
+/** Instanced billboards: shaded spheres, flat discs or glowing discs */
+export interface PointsItem extends ItemBase {
+    kind: "points";
+    data: ArrayBuffer;
+    count: number;
+    /** Scales the dots with the distance (perspective) */
+    perspective: boolean;
+    /** `POINT_SPHERE`, `POINT_DISC` or `POINT_GLOW` (sphere when omitted) */
+    style?: number;
+    /** Adds the light of the dots (no depth writes, order independent) */
+    additive?: boolean;
+    /**
+     * The data was thinned to 1 point out of `thinned` (CPU backend): the
+     * drawn dots get denser to keep the look of the cloud
+     */
+    thinned?: number;
+}
+/** Lit triangles (surfaces, bars) */
+export interface MeshItem extends ItemBase {
+    kind: "mesh";
+    vertices: ArrayBuffer;
+    vertexCount: number;
+    indices: Uint32Array;
+    /**
+     * Changes when only the order of the triangles changed (transparent meshes
+     * sorted back to front): the index buffer is rewritten, same length
+     */
+    order?: number;
+    /**
+     * Blended without writing depth whatever its `opacity` (merged transparent
+     * meshes: their opacity is baked into the vertex colors)
+     */
+    transparent?: boolean;
+}
+/** Screen-space wide segments (wireframes, contours, polylines) */
+export interface LinesItem extends ItemBase {
+    kind: "lines";
+    data: ArrayBuffer;
+    count: number;
+    /** CSS pixels */
+    width: number;
+    /** Pulls the lines towards the camera (wireframes over their surface) */
+    bias: number;
+}
+export type Item3D = PointsItem | MeshItem | LinesItem;
+export interface Frame3D {
+    /** World -> clip (OpenGL convention) */
+    viewProj: Float32Array;
+    eye: Vec3;
+    /** Unit vector towards the light, in world space */
+    light: Vec3;
+    orthographic: boolean;
+    /** Distance of the camera to the box center (reference of the point sizes) */
+    distance: number;
+    /** Radius of the sphere around the box (depth cue range) */
+    radius: number;
+    /** Drawing buffer size in device pixels */
+    width: number;
+    height: number;
+    dpr: number;
+    /** ambient, diffuse, specular, shininess */
+    lighting: readonly [number, number, number, number];
+    /** Background color: far points fade towards it */
+    fog: Rgba;
+}
+export interface Renderer3D {
+    readonly kind: ChartRendererKind;
+    readonly canvas: HTMLCanvasElement;
+    /** Drawing buffer size in device pixels */
+    resize(width: number, height: number): void;
+    render(items: readonly Item3D[], frame: Frame3D): void;
+    destroy(): void;
+}
+/** Whether an item writes the depth buffer (opaque items) */
+export declare const writesDepth: (item: Item3D) => boolean;
+/**
+ * Order of the draws: opaque meshes, opaque points, blended points,
+ * transparent meshes, then lines (wireframes and contours stay visible over
+ * transparent surfaces). Stable: items of a rank keep their order.
+ */
+export declare const drawOrder: (items: readonly Item3D[]) => Item3D[];
+export {};

package/dist/charts/engine/three-d/render-types.d.ts

@@ -0,0 +1,103 @@
+import { Rgba } from '../color.js';
+import { ChartRendererKind } from '../types.js';
+import { Vec3 } from './math.js';
+/** Bytes per point instance: x, y, z f32, diameter (CSS px) f32, color unorm8x4 */
+export declare const POINT_STRIDE = 20;
+/** Bytes per mesh vertex: position f32x3, normal f32x3, color unorm8x4 */
+export declare const VERTEX_STRIDE = 28;
+/** Bytes per line segment instance: a f32x3, b f32x3, color unorm8x4 */
+export declare const SEGMENT_STRIDE = 28;
+interface ItemBase {
+    /** Identifies the GPU resources of the item */
+    key: string;
+    /** Changes when the buffers must be uploaded again */
+    version: number;
+    /** 0-1; below 1 the item is drawn without writing depth */
+    opacity: number;
+}
+/** Shapes of the points (`PointsItem.style`) */
+export declare const POINT_SPHERE = 0;
+export declare const POINT_DISC = 1;
+export declare const POINT_GLOW = 2;
+/** Instanced billboards: shaded spheres, flat discs or glowing discs */
+export interface PointsItem extends ItemBase {
+    kind: "points";
+    data: ArrayBuffer;
+    count: number;
+    /** Scales the dots with the distance (perspective) */
+    perspective: boolean;
+    /** `POINT_SPHERE`, `POINT_DISC` or `POINT_GLOW` (sphere when omitted) */
+    style?: number;
+    /** Adds the light of the dots (no depth writes, order independent) */
+    additive?: boolean;
+    /**
+     * The data was thinned to 1 point out of `thinned` (CPU backend): the
+     * drawn dots get denser to keep the look of the cloud
+     */
+    thinned?: number;
+}
+/** Lit triangles (surfaces, bars) */
+export interface MeshItem extends ItemBase {
+    kind: "mesh";
+    vertices: ArrayBuffer;
+    vertexCount: number;
+    indices: Uint32Array;
+    /**
+     * Changes when only the order of the triangles changed (transparent meshes
+     * sorted back to front): the index buffer is rewritten, same length
+     */
+    order?: number;
+    /**
+     * Blended without writing depth whatever its `opacity` (merged transparent
+     * meshes: their opacity is baked into the vertex colors)
+     */
+    transparent?: boolean;
+}
+/** Screen-space wide segments (wireframes, contours, polylines) */
+export interface LinesItem extends ItemBase {
+    kind: "lines";
+    data: ArrayBuffer;
+    count: number;
+    /** CSS pixels */
+    width: number;
+    /** Pulls the lines towards the camera (wireframes over their surface) */
+    bias: number;
+}
+export type Item3D = PointsItem | MeshItem | LinesItem;
+export interface Frame3D {
+    /** World -> clip (OpenGL convention) */
+    viewProj: Float32Array;
+    eye: Vec3;
+    /** Unit vector towards the light, in world space */
+    light: Vec3;
+    orthographic: boolean;
+    /** Distance of the camera to the box center (reference of the point sizes) */
+    distance: number;
+    /** Radius of the sphere around the box (depth cue range) */
+    radius: number;
+    /** Drawing buffer size in device pixels */
+    width: number;
+    height: number;
+    dpr: number;
+    /** ambient, diffuse, specular, shininess */
+    lighting: readonly [number, number, number, number];
+    /** Background color: far points fade towards it */
+    fog: Rgba;
+}
+export interface Renderer3D {
+    readonly kind: ChartRendererKind;
+    readonly canvas: HTMLCanvasElement;
+    /** Drawing buffer size in device pixels */
+    resize(width: number, height: number): void;
+    render(items: readonly Item3D[], frame: Frame3D): void;
+    destroy(): void;
+}
+/** Whether an item writes the depth buffer (opaque items) */
+export declare const writesDepth: (item: Item3D) => boolean;
+/**
+ * Order of the draws: opaque meshes, opaque points, blended points,
+ * transparent meshes, then lines (wireframes and contours stay visible over
+ * transparent surfaces). Stable: items of a rank keep their order.
+ */
+export declare const drawOrder: (items: readonly Item3D[]) => Item3D[];
+export {};

package/dist/charts/engine/three-d/render-types.js

@@ -0,0 +1,12 @@
+var e = (e) => e.opacity < 1 ? !1 : e.kind === "mesh" ? !e.transparent : e.kind !== "points" || !e.additive && e.style !== 2, t = (t) => {
+	let n = (t) => t.kind === "mesh" ? e(t) ? 0 : 3 : t.kind === "points" ? e(t) ? 1 : 2 : 4;
+	return t.map((e, t) => ({
+		item: e,
+		i: t,
+		r: n(e)
+	})).sort((e, t) => e.r - t.r || e.i - t.i).map((e) => e.item);
+};
+//#endregion
+export { t as drawOrder, e as writesDepth };
+
+//# sourceMappingURL=render-types.js.map

package/dist/charts/engine/three-d/render-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-types.js","names":["writesDepth","item","drawOrder","rank","items","a","b"],"sources":["../../../../../charts/src/engine/three-d/render-types.ts"],"sourcesContent":["// Contract between the 3D chart and its data-layer backends.\n\nimport type { Rgba } from \"../color\";\nimport type { ChartRendererKind } from \"../types\";\nimport type { Vec3 } from \"./math\";\n\n/** Bytes per point instance: x, y, z f32, diameter (CSS px) f32, color unorm8x4 */\nexport const POINT_STRIDE = 20;\n/** Bytes per mesh vertex: position f32x3, normal f32x3, color unorm8x4 */\nexport const VERTEX_STRIDE = 28;\n/** Bytes per line segment instance: a f32x3, b f32x3, color unorm8x4 */\nexport const SEGMENT_STRIDE = 28;\n\ninterface ItemBase {\n  /** Identifies the GPU resources of the item */\n  key: string;\n  /** Changes when the buffers must be uploaded again */\n  version: number;\n  /** 0-1; below 1 the item is drawn without writing depth */\n  opacity: number;\n}\n\n/** Shapes of the points (`PointsItem.style`) */\nexport const POINT_SPHERE = 0;\nexport const POINT_DISC = 1;\nexport const POINT_GLOW = 2;\n\n/** Instanced billboards: shaded spheres, flat discs or glowing discs */\nexport interface PointsItem extends ItemBase {\n  kind: \"points\";\n  data: ArrayBuffer;\n  count: number;\n  /** Scales the dots with the distance (perspective) */\n  perspective: boolean;\n  /** `POINT_SPHERE`, `POINT_DISC` or `POINT_GLOW` (sphere when omitted) */\n  style?: number;\n  /** Adds the light of the dots (no depth writes, order independent) */\n  additive?: boolean;\n  /**\n   * The data was thinned to 1 point out of `thinned` (CPU backend): the\n   * drawn dots get denser to keep the look of the cloud\n   */\n  thinned?: number;\n}\n\n/** Lit triangles (surfaces, bars) */\nexport interface MeshItem extends ItemBase {\n  kind: \"mesh\";\n  vertices: ArrayBuffer;\n  vertexCount: number;\n  indices: Uint32Array;\n  /**\n   * Changes when only the order of the triangles changed (transparent meshes\n   * sorted back to front): the index buffer is rewritten, same length\n   */\n  order?: number;\n  /**\n   * Blended without writing depth whatever its `opacity` (merged transparent\n   * meshes: their opacity is baked into the vertex colors)\n   */\n  transparent?: boolean;\n}\n\n/** Screen-space wide segments (wireframes, contours, polylines) */\nexport interface LinesItem extends ItemBase {\n  kind: \"lines\";\n  data: ArrayBuffer;\n  count: number;\n  /** CSS pixels */\n  width: number;\n  /** Pulls the lines towards the camera (wireframes over their surface) */\n  bias: number;\n}\n\nexport type Item3D = PointsItem | MeshItem | LinesItem;\n\nexport interface Frame3D {\n  /** World -> clip (OpenGL convention) */\n  viewProj: Float32Array;\n  eye: Vec3;\n  /** Unit vector towards the light, in world space */\n  light: Vec3;\n  orthographic: boolean;\n  /** Distance of the camera to the box center (reference of the point sizes) */\n  distance: number;\n  /** Radius of the sphere around the box (depth cue range) */\n  radius: number;\n  /** Drawing buffer size in device pixels */\n  width: number;\n  height: number;\n  dpr: number;\n  /** ambient, diffuse, specular, shininess */\n  lighting: readonly [number, number, number, number];\n  /** Background color: far points fade towards it */\n  fog: Rgba;\n}\n\nexport interface Renderer3D {\n  readonly kind: ChartRendererKind;\n  readonly canvas: HTMLCanvasElement;\n  /** Drawing buffer size in device pixels */\n  resize(width: number, height: number): void;\n  render(items: readonly Item3D[], frame: Frame3D): void;\n  destroy(): void;\n}\n\n/** Whether an item writes the depth buffer (opaque items) */\nexport const writesDepth = (item: Item3D): boolean => {\n  if (item.opacity < 1) return false;\n  if (item.kind === \"mesh\") return !item.transparent;\n  if (item.kind === \"points\")\n    return !item.additive && item.style !== POINT_GLOW;\n  return true;\n};\n\n/**\n * Order of the draws: opaque meshes, opaque points, blended points,\n * transparent meshes, then lines (wireframes and contours stay visible over\n * transparent surfaces). Stable: items of a rank keep their order.\n */\nexport const drawOrder = (items: readonly Item3D[]): Item3D[] => {\n  const rank = (item: Item3D) =>\n    item.kind === \"mesh\"\n      ? writesDepth(item)\n        ? 0\n        : 3\n      : item.kind === \"points\"\n        ? writesDepth(item)\n          ? 1\n          : 2\n        : 4;\n  return items\n    .map((item, i) => ({ item, i, r: rank(item) }))\n    .sort((a, b) => a.r - b.r || a.i - b.i)\n    .map((e) => e.item);\n};\n"],"mappings":"AA2GA,IAAaA,KAAe,MACtBC,EAAK,UAAU,IAAU,KACzBA,EAAK,SAAS,SAAe,CAACA,EAAK,cACnCA,EAAK,SAAS,YACT,CAACA,EAAK,YAAYA,EAAK,UAAA,GASrBC,KAAa,MAAuC;CAC/D,IAAMC,KAAQ,MACZF,EAAK,SAAS,SACVD,EAAYC,CAAI,IACd,IACA,IACFA,EAAK,SAAS,WACZD,EAAYC,CAAI,IACd,IACA,IACF;CACR,OAAOG,EACJ,KAAK,GAAM,OAAO;EAAE;EAAM;EAAG,GAAGD,EAAKF,CAAI;CAAE,EAAE,CAAC,CAC9C,MAAM,GAAG,MAAMI,EAAE,IAAIC,EAAE,KAAKD,EAAE,IAAIC,EAAE,CAAC,CAAC,CACtC,KAAK,MAAM,EAAE,IAAI;AACtB"}