minerva-design 1.2.0 → 1.4.0

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=>{let t=e=>e.kind===`mesh`?e.opacity<1?2:0:e.kind===`points`?1:3;return e.map((e,n)=>({item:e,i:n,r:t(e)})).sort((e,t)=>e.r-t.r||e.i-t.i).map(e=>e.item)};exports.drawOrder=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":["drawOrder","rank","item","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/** Instanced billboards shaded as small spheres */\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}\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\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/**\n * Order of the draws: opaque meshes, points, transparent meshes, then lines\n * (wireframes and contours stay visible over transparent surfaces)\n */\nexport const drawOrder = (items: readonly Item3D[]): Item3D[] => {\n  const rank = (item: Item3D) =>\n    item.kind === \"mesh\"\n      ? item.opacity < 1\n        ? 2\n        : 0\n      : item.kind === \"points\"\n        ? 1\n        : 3;\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":"AA2FA,IAAaA,EAAa,GAAuC,CAC/D,IAAMC,EAAQ,GACZC,EAAK,OAAS,OACVA,EAAK,QAAU,EACb,EACA,EACFA,EAAK,OAAS,SACZ,EACA,EACR,OAAOC,EACJ,KAAK,EAAM,KAAO,CAAE,OAAM,IAAG,EAAGF,EAAKC,CAAI,CAAE,EAAE,CAAC,CAC9C,MAAM,EAAG,IAAME,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,82 @@
+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;
+}
+/** Instanced billboards shaded as small spheres */
+export interface PointsItem extends ItemBase {
+    kind: "points";
+    data: ArrayBuffer;
+    count: number;
+    /** Scales the dots with the distance (perspective) */
+    perspective: boolean;
+}
+/** 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;
+}
+/** 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;
+}
+/**
+ * Order of the draws: opaque meshes, points, transparent meshes, then lines
+ * (wireframes and contours stay visible over transparent surfaces)
+ */
+export declare const drawOrder: (items: readonly Item3D[]) => Item3D[];
+export {};

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

@@ -0,0 +1,82 @@
+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;
+}
+/** Instanced billboards shaded as small spheres */
+export interface PointsItem extends ItemBase {
+    kind: "points";
+    data: ArrayBuffer;
+    count: number;
+    /** Scales the dots with the distance (perspective) */
+    perspective: boolean;
+}
+/** 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;
+}
+/** 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;
+}
+/**
+ * Order of the draws: opaque meshes, points, transparent meshes, then lines
+ * (wireframes and contours stay visible over transparent surfaces)
+ */
+export declare const drawOrder: (items: readonly Item3D[]) => Item3D[];
+export {};

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

@@ -0,0 +1,13 @@
+//#region src/engine/three-d/render-types.ts
+var e = (e) => {
+	let t = (e) => e.kind === "mesh" ? e.opacity < 1 ? 2 : 0 : e.kind === "points" ? 1 : 3;
+	return e.map((e, n) => ({
+		item: e,
+		i: n,
+		r: t(e)
+	})).sort((e, t) => e.r - t.r || e.i - t.i).map((e) => e.item);
+};
+//#endregion
+export { e as drawOrder };
+
+//# 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":["drawOrder","rank","item","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/** Instanced billboards shaded as small spheres */\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}\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\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/**\n * Order of the draws: opaque meshes, points, transparent meshes, then lines\n * (wireframes and contours stay visible over transparent surfaces)\n */\nexport const drawOrder = (items: readonly Item3D[]): Item3D[] => {\n  const rank = (item: Item3D) =>\n    item.kind === \"mesh\"\n      ? item.opacity < 1\n        ? 2\n        : 0\n      : item.kind === \"points\"\n        ? 1\n        : 3;\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":";AA2FA,IAAaA,KAAa,MAAuC;CAC/D,IAAMC,KAAQ,MACZC,EAAK,SAAS,SACVA,EAAK,UAAU,IACb,IACA,IACFA,EAAK,SAAS,WACZ,IACA;CACR,OAAOC,EACJ,KAAK,GAAM,OAAO;EAAE;EAAM;EAAG,GAAGF,EAAKC,CAAI;CAAE,EAAE,CAAC,CAC9C,MAAM,GAAG,MAAME,EAAE,IAAIC,EAAE,KAAKD,EAAE,IAAIC,EAAE,CAAC,CAAC,CACtC,KAAK,MAAM,EAAE,IAAI;AACtB"}

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

@@ -0,0 +1,276 @@
+var e=(e,t,n,r,i,a,o,s)=>(e.set(t,0),e.set(n,16),e.set(r,20),e.set(i,24),e.set(a,28),e.set(o,32),e.set(s,36),e),t=(t,n,r)=>{let i=t.kind===`points`?+!!t.perspective:t.kind===`lines`?t.width:0;return e(r,n.viewProj,[n.width,n.height,n.dpr,+!!n.orthographic],[n.eye[0],n.eye[1],n.eye[2],t.kind===`lines`?t.bias:0],[n.light[0],n.light[1],n.light[2],0],n.lighting,[t.opacity,i,n.distance,n.radius],[n.fog[0],n.fog[1],n.fog[2],1])},n=e=>e.opacity>=1,r=`
+struct U {
+  viewProj: mat4x4f,
+  viewport: vec4f,
+  eye: vec4f,
+  light: vec4f,
+  material: vec4f,
+  params: vec4f,
+  fog: vec4f,
+};
+@group(0) @binding(0) var<uniform> u: U;
+
+fn toWebGpuDepth(p: vec4f) -> vec4f {
+  return vec4f(p.x, p.y, (p.z + p.w) * 0.5, p.w);
+}
+
+fn depthCue(world: vec3f) -> f32 {
+  let near = u.params.z - u.params.w;
+  return clamp((length(world - u.eye.xyz) - near) / (2.0 * u.params.w), 0.0, 1.0);
+}
+`,i=`${r}
+struct Out {
+  @builtin(position) position: vec4f,
+  @location(0) offset: vec2f,
+  @location(1) radius: f32,
+  @location(2) color: vec4f,
+  @location(3) fog: f32,
+};
+
+@vertex
+fn vs(
+  @builtin(vertex_index) vi: u32,
+  @location(0) pos: vec3f,
+  @location(1) size: f32,
+  @location(2) color: vec4f,
+) -> Out {
+  var out: Out;
+  let corner = vec2f(f32(vi & 1u), f32(vi >> 1u)) * 2.0 - 1.0;
+  let clip = u.viewProj * vec4f(pos, 1.0);
+  var factor = 1.0;
+  if (u.params.y > 0.5 && u.viewport.w < 0.5) {
+    factor = clamp(u.params.z / max(clip.w, 1e-6), 0.5, 2.0);
+  }
+  let radius = max(0.5, size * u.viewport.z * factor * 0.5);
+  let reach = radius + 1.0;
+  let shift = corner * reach * 2.0 / u.viewport.xy * clip.w;
+  out.position = toWebGpuDepth(vec4f(clip.xy + shift, clip.z, clip.w));
+  out.offset = corner * reach;
+  out.radius = radius;
+  out.color = color;
+  out.fog = depthCue(pos) * 0.45;
+  return out;
+}
+
+@fragment
+fn fs(in: Out) -> @location(0) vec4f {
+  let d = length(in.offset);
+  var alpha = clamp(in.radius + 0.5 - d, 0.0, 1.0);
+  if (alpha <= 0.0) { discard; }
+  let q = min(d / in.radius, 1.0);
+  let n = vec3f(in.offset.x / in.radius, in.offset.y / in.radius, sqrt(max(0.0, 1.0 - q * q)));
+  let l = normalize(vec3f(-0.45, 0.55, 0.7));
+  let lambert = max(dot(n, l), 0.0);
+  let shaded = in.color.rgb * (0.62 + 0.45 * lambert) + vec3f(pow(lambert, 18.0) * 0.28);
+  let sphere = smoothstep(1.5, 3.5, in.radius);
+  var rgb = mix(in.color.rgb, shaded, sphere);
+  rgb = mix(rgb, u.fog.rgb, in.fog);
+  alpha = alpha * in.color.a * u.params.x;
+  return vec4f(rgb * alpha, alpha);
+}
+`,a=`${r}
+struct Out {
+  @builtin(position) position: vec4f,
+  @location(0) world: vec3f,
+  @location(1) normal: vec3f,
+  @location(2) color: vec4f,
+};
+
+@vertex
+fn vs(
+  @location(0) pos: vec3f,
+  @location(1) normal: vec3f,
+  @location(2) color: vec4f,
+) -> Out {
+  var out: Out;
+  out.position = toWebGpuDepth(u.viewProj * vec4f(pos, 1.0));
+  out.world = pos;
+  out.normal = normal;
+  out.color = color;
+  return out;
+}
+
+@fragment
+fn fs(in: Out) -> @location(0) vec4f {
+  var n = normalize(in.normal);
+  let v = normalize(u.eye.xyz - in.world);
+  if (dot(n, v) < 0.0) { n = -n; }
+  let l = u.light.xyz;
+  let diffuse = max(dot(n, l), 0.0);
+  let h = normalize(l + v);
+  let specular = pow(max(dot(n, h), 0.0), u.material.w) * u.material.z;
+  let rgb = in.color.rgb * (u.material.x + u.material.y * diffuse) + vec3f(specular);
+  let alpha = in.color.a * u.params.x;
+  return vec4f(rgb * alpha, alpha);
+}
+`,o=`${r}
+struct Out {
+  @builtin(position) position: vec4f,
+  @location(0) across: f32,
+  @location(1) color: vec4f,
+};
+
+@vertex
+fn vs(
+  @builtin(vertex_index) vi: u32,
+  @location(0) a: vec3f,
+  @location(1) b: vec3f,
+  @location(2) color: vec4f,
+) -> Out {
+  var out: Out;
+  let corner = vec2f(f32(vi & 1u), f32(vi >> 1u));
+  let ca = u.viewProj * vec4f(a, 1.0);
+  let cb = u.viewProj * vec4f(b, 1.0);
+  let halfSize = u.viewport.xy * 0.5;
+  let sa = ca.xy / ca.w * halfSize;
+  let sb = cb.xy / cb.w * halfSize;
+  var dir = sb - sa;
+  let len = length(dir);
+  dir = select(vec2f(1.0, 0.0), dir / len, len > 1e-6);
+  let normal = vec2f(-dir.y, dir.x);
+  let w = max(0.5, u.params.y * u.viewport.z * 0.5) + 0.5;
+  let clip = select(ca, cb, corner.x > 0.5);
+  let side = corner.y * 2.0 - 1.0;
+  let pixel = select(sa, sb, corner.x > 0.5) + dir * (corner.x * 2.0 - 1.0) * w + normal * side * w;
+  let z = clip.z - u.eye.w * clip.w;
+  out.position = toWebGpuDepth(vec4f(pixel / halfSize * clip.w, z, clip.w));
+  out.across = side * w;
+  out.color = color;
+  return out;
+}
+
+@fragment
+fn fs(in: Out) -> @location(0) vec4f {
+  let core = u.params.y * u.viewport.z * 0.5;
+  let coverage = clamp(max(core, 0.5) + 0.5 - abs(in.across), 0.0, 1.0) * min(1.0, core * 2.0);
+  let alpha = coverage * in.color.a * u.params.x;
+  if (alpha <= 0.0) { discard; }
+  return vec4f(in.color.rgb * alpha, alpha);
+}
+`,s=`
+uniform mat4 u_viewProj;
+uniform vec4 u_viewport;
+uniform vec4 u_eye;
+uniform vec4 u_light;
+uniform vec4 u_material;
+uniform vec4 u_params;
+uniform vec4 u_fog;
+`,c=`
+attribute vec2 a_corner;
+attribute vec3 a_pos;
+attribute float a_size;
+attribute vec4 a_color;
+varying vec2 v_offset;
+varying float v_radius;
+varying vec4 v_color;
+varying float v_fog;
+void main() {
+  vec2 corner = a_corner * 2.0 - 1.0;
+  vec4 clip = u_viewProj * vec4(a_pos, 1.0);
+  float factor = 1.0;
+  if (u_params.y > 0.5 && u_viewport.w < 0.5) {
+    factor = clamp(u_params.z / max(clip.w, 1e-6), 0.5, 2.0);
+  }
+  float radius = max(0.5, a_size * u_viewport.z * factor * 0.5);
+  float reach = radius + 1.0;
+  vec2 shift = corner * reach * 2.0 / u_viewport.xy * clip.w;
+  gl_Position = vec4(clip.xy + shift, clip.z, clip.w);
+  v_offset = corner * reach;
+  v_radius = radius;
+  v_color = a_color;
+  float near = u_params.z - u_params.w;
+  v_fog = clamp((length(a_pos - u_eye.xyz) - near) / (2.0 * u_params.w), 0.0, 1.0) * 0.45;
+}
+`,l=`
+varying vec2 v_offset;
+varying float v_radius;
+varying vec4 v_color;
+varying float v_fog;
+void main() {
+  float d = length(v_offset);
+  float alpha = clamp(v_radius + 0.5 - d, 0.0, 1.0);
+  if (alpha <= 0.0) discard;
+  float q = min(d / v_radius, 1.0);
+  vec3 n = vec3(v_offset / v_radius, sqrt(max(0.0, 1.0 - q * q)));
+  vec3 l = normalize(vec3(-0.45, 0.55, 0.7));
+  float lambert = max(dot(n, l), 0.0);
+  vec3 shaded = v_color.rgb * (0.62 + 0.45 * lambert) + vec3(pow(lambert, 18.0) * 0.28);
+  float sphere = smoothstep(1.5, 3.5, v_radius);
+  vec3 rgb = mix(v_color.rgb, shaded, sphere);
+  rgb = mix(rgb, u_fog.rgb, v_fog);
+  alpha = alpha * v_color.a * u_params.x;
+  FRAG = vec4(rgb * alpha, alpha);
+}
+`,u=`
+attribute vec3 a_pos;
+attribute vec3 a_normal;
+attribute vec4 a_color;
+varying vec3 v_world;
+varying vec3 v_normal;
+varying vec4 v_color;
+void main() {
+  gl_Position = u_viewProj * vec4(a_pos, 1.0);
+  v_world = a_pos;
+  v_normal = a_normal;
+  v_color = a_color;
+}
+`,d=`
+varying vec3 v_world;
+varying vec3 v_normal;
+varying vec4 v_color;
+void main() {
+  vec3 n = normalize(v_normal);
+  vec3 v = normalize(u_eye.xyz - v_world);
+  if (dot(n, v) < 0.0) n = -n;
+  vec3 l = u_light.xyz;
+  float diffuse = max(dot(n, l), 0.0);
+  vec3 h = normalize(l + v);
+  float specular = pow(max(dot(n, h), 0.0), u_material.w) * u_material.z;
+  vec3 rgb = v_color.rgb * (u_material.x + u_material.y * diffuse) + vec3(specular);
+  float alpha = v_color.a * u_params.x;
+  FRAG = vec4(rgb * alpha, alpha);
+}
+`,f=`
+attribute vec2 a_corner;
+attribute vec3 a_a;
+attribute vec3 a_b;
+attribute vec4 a_color;
+varying float v_across;
+varying vec4 v_color;
+void main() {
+  vec4 ca = u_viewProj * vec4(a_a, 1.0);
+  vec4 cb = u_viewProj * vec4(a_b, 1.0);
+  vec2 halfSize = u_viewport.xy * 0.5;
+  vec2 sa = ca.xy / ca.w * halfSize;
+  vec2 sb = cb.xy / cb.w * halfSize;
+  vec2 dir = sb - sa;
+  float len = length(dir);
+  dir = len > 1e-6 ? dir / len : vec2(1.0, 0.0);
+  vec2 normal = vec2(-dir.y, dir.x);
+  float w = max(0.5, u_params.y * u_viewport.z * 0.5) + 0.5;
+  bool atEnd = a_corner.x > 0.5;
+  vec4 clip = atEnd ? cb : ca;
+  float side = a_corner.y * 2.0 - 1.0;
+  vec2 pixel = (atEnd ? sb : sa) + dir * (a_corner.x * 2.0 - 1.0) * w + normal * side * w;
+  gl_Position = vec4(pixel / halfSize * clip.w, clip.z - u_eye.w * clip.w, clip.w);
+  v_across = side * w;
+  v_color = a_color;
+}
+`,p=`
+varying float v_across;
+varying vec4 v_color;
+void main() {
+  float core = u_params.y * u_viewport.z * 0.5;
+  float coverage = clamp(max(core, 0.5) + 0.5 - abs(v_across), 0.0, 1.0) * min(1.0, core * 2.0);
+  float alpha = coverage * v_color.a * u_params.x;
+  if (alpha <= 0.0) discard;
+  FRAG = vec4(v_color.rgb * alpha, alpha);
+}
+`,m=`
+#ifdef GL_FRAGMENT_PRECISION_HIGH
+precision highp float;
+#else
+precision mediump float;
+#endif
+`,h=(e,t,n)=>n===2?{vertex:`#version 300 es\n#define attribute in\n#define varying out\n${s}${e}`,fragment:`#version 300 es\nprecision highp float;\n#define varying in\nout vec4 fragColor;\n#define FRAG fragColor\n${s}${t}`}:{vertex:`${s}${e}`,fragment:`${m}#define FRAG gl_FragColor\n${s}${t}`},g=e=>({points:h(c,l,e),mesh:h(u,d,e),lines:h(f,p,e)}),_={points:[`a_corner`,`a_pos`,`a_size`,`a_color`],mesh:[`a_pos`,`a_normal`,`a_color`],lines:[`a_corner`,`a_a`,`a_b`,`a_color`]};exports.GLSL_ATTRIBUTES=_,exports.WGSL_LINES=o,exports.WGSL_MESH=a,exports.WGSL_POINTS=i,exports.glslPrograms=g,exports.itemUniforms=t,exports.writesDepth=n;
+//# sourceMappingURL=shaders.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shaders.cjs","names":["writeUniforms","out","viewProj","viewport","eye","light","material","params","fog","itemUniforms","second","item","frame","writesDepth","WGSL_UNIFORMS","WGSL_POINTS","WGSL_MESH","WGSL_LINES","GLSL_UNIFORMS","GLSL_POINTS_VS","GLSL_POINTS_FS","GLSL_MESH_VS","GLSL_MESH_FS","GLSL_LINES_VS","GLSL_LINES_FS","PRECISION","glsl","version","vs","fs","glslPrograms","GLSL_ATTRIBUTES"],"sources":["../../../../../charts/src/engine/three-d/shaders.ts"],"sourcesContent":["// Shaders of the 3D data layer: instanced point billboards shaded as small\n// spheres, lit triangles (two-sided Lambert + Blinn-Phong) and screen-space\n// wide line segments. WGSL for WebGPU, GLSL ES 1.0 for WebGL (turned into\n// GLSL ES 3.0 for WebGL2 by a macro prefix). Outputs are premultiplied.\n//\n// Uniforms (WGSL struct, GLSL vec4 uniforms of the same names):\n//   viewProj  world -> clip (OpenGL depth convention)\n//   viewport  drawing buffer width, height (device px), dpr, orthographic\n//   eye       camera position, depth bias of the lines (NDC)\n//   light     unit vector towards the light\n//   material  ambient, diffuse, specular, shininess\n//   params    opacity, perspective sizes (0/1) | line width (CSS px), distance, radius\n//   fog       background color (far points fade towards it)\n\nimport type { Frame3D, Item3D } from \"./render-types\";\n\n/** Bytes of the WGSL uniform struct */\nexport const UNIFORM_BYTES = 160;\n\n/** Writes the uniforms of an item in the WGSL struct layout */\nconst writeUniforms = (\n  out: Float32Array,\n  viewProj: Float32Array,\n  viewport: readonly [number, number, number, number],\n  eye: readonly [number, number, number, number],\n  light: readonly [number, number, number, number],\n  material: readonly [number, number, number, number],\n  params: readonly [number, number, number, number],\n  fog: readonly [number, number, number, number],\n): Float32Array => {\n  out.set(viewProj, 0);\n  out.set(viewport, 16);\n  out.set(eye, 20);\n  out.set(light, 24);\n  out.set(material, 28);\n  out.set(params, 32);\n  out.set(fog, 36);\n  return out;\n};\n\n/** Uniform values of an item (40 floats, the WGSL struct layout) */\nexport const itemUniforms = (\n  item: Item3D,\n  frame: Frame3D,\n  out: Float32Array,\n): Float32Array => {\n  const second =\n    item.kind === \"points\"\n      ? item.perspective\n        ? 1\n        : 0\n      : item.kind === \"lines\"\n        ? item.width\n        : 0;\n  return writeUniforms(\n    out,\n    frame.viewProj,\n    [frame.width, frame.height, frame.dpr, frame.orthographic ? 1 : 0],\n    [\n      frame.eye[0],\n      frame.eye[1],\n      frame.eye[2],\n      item.kind === \"lines\" ? item.bias : 0,\n    ],\n    [frame.light[0], frame.light[1], frame.light[2], 0],\n    frame.lighting,\n    [item.opacity, second, frame.distance, frame.radius],\n    [frame.fog[0], frame.fog[1], frame.fog[2], 1],\n  );\n};\n\n/** Whether an item writes the depth buffer (opaque items) */\nexport const writesDepth = (item: Item3D): boolean => item.opacity >= 1;\n\n// ------------------------------------------------------------------- WGSL\n\nconst WGSL_UNIFORMS = /* wgsl */ `\nstruct U {\n  viewProj: mat4x4f,\n  viewport: vec4f,\n  eye: vec4f,\n  light: vec4f,\n  material: vec4f,\n  params: vec4f,\n  fog: vec4f,\n};\n@group(0) @binding(0) var<uniform> u: U;\n\nfn toWebGpuDepth(p: vec4f) -> vec4f {\n  return vec4f(p.x, p.y, (p.z + p.w) * 0.5, p.w);\n}\n\nfn depthCue(world: vec3f) -> f32 {\n  let near = u.params.z - u.params.w;\n  return clamp((length(world - u.eye.xyz) - near) / (2.0 * u.params.w), 0.0, 1.0);\n}\n`;\n\nexport const WGSL_POINTS = /* wgsl */ `${WGSL_UNIFORMS}\nstruct Out {\n  @builtin(position) position: vec4f,\n  @location(0) offset: vec2f,\n  @location(1) radius: f32,\n  @location(2) color: vec4f,\n  @location(3) fog: f32,\n};\n\n@vertex\nfn vs(\n  @builtin(vertex_index) vi: u32,\n  @location(0) pos: vec3f,\n  @location(1) size: f32,\n  @location(2) color: vec4f,\n) -> Out {\n  var out: Out;\n  let corner = vec2f(f32(vi & 1u), f32(vi >> 1u)) * 2.0 - 1.0;\n  let clip = u.viewProj * vec4f(pos, 1.0);\n  var factor = 1.0;\n  if (u.params.y > 0.5 && u.viewport.w < 0.5) {\n    factor = clamp(u.params.z / max(clip.w, 1e-6), 0.5, 2.0);\n  }\n  let radius = max(0.5, size * u.viewport.z * factor * 0.5);\n  let reach = radius + 1.0;\n  let shift = corner * reach * 2.0 / u.viewport.xy * clip.w;\n  out.position = toWebGpuDepth(vec4f(clip.xy + shift, clip.z, clip.w));\n  out.offset = corner * reach;\n  out.radius = radius;\n  out.color = color;\n  out.fog = depthCue(pos) * 0.45;\n  return out;\n}\n\n@fragment\nfn fs(in: Out) -> @location(0) vec4f {\n  let d = length(in.offset);\n  var alpha = clamp(in.radius + 0.5 - d, 0.0, 1.0);\n  if (alpha <= 0.0) { discard; }\n  let q = min(d / in.radius, 1.0);\n  let n = vec3f(in.offset.x / in.radius, in.offset.y / in.radius, sqrt(max(0.0, 1.0 - q * q)));\n  let l = normalize(vec3f(-0.45, 0.55, 0.7));\n  let lambert = max(dot(n, l), 0.0);\n  let shaded = in.color.rgb * (0.62 + 0.45 * lambert) + vec3f(pow(lambert, 18.0) * 0.28);\n  let sphere = smoothstep(1.5, 3.5, in.radius);\n  var rgb = mix(in.color.rgb, shaded, sphere);\n  rgb = mix(rgb, u.fog.rgb, in.fog);\n  alpha = alpha * in.color.a * u.params.x;\n  return vec4f(rgb * alpha, alpha);\n}\n`;\n\nexport const WGSL_MESH = /* wgsl */ `${WGSL_UNIFORMS}\nstruct Out {\n  @builtin(position) position: vec4f,\n  @location(0) world: vec3f,\n  @location(1) normal: vec3f,\n  @location(2) color: vec4f,\n};\n\n@vertex\nfn vs(\n  @location(0) pos: vec3f,\n  @location(1) normal: vec3f,\n  @location(2) color: vec4f,\n) -> Out {\n  var out: Out;\n  out.position = toWebGpuDepth(u.viewProj * vec4f(pos, 1.0));\n  out.world = pos;\n  out.normal = normal;\n  out.color = color;\n  return out;\n}\n\n@fragment\nfn fs(in: Out) -> @location(0) vec4f {\n  var n = normalize(in.normal);\n  let v = normalize(u.eye.xyz - in.world);\n  if (dot(n, v) < 0.0) { n = -n; }\n  let l = u.light.xyz;\n  let diffuse = max(dot(n, l), 0.0);\n  let h = normalize(l + v);\n  let specular = pow(max(dot(n, h), 0.0), u.material.w) * u.material.z;\n  let rgb = in.color.rgb * (u.material.x + u.material.y * diffuse) + vec3f(specular);\n  let alpha = in.color.a * u.params.x;\n  return vec4f(rgb * alpha, alpha);\n}\n`;\n\nexport const WGSL_LINES = /* wgsl */ `${WGSL_UNIFORMS}\nstruct Out {\n  @builtin(position) position: vec4f,\n  @location(0) across: f32,\n  @location(1) color: vec4f,\n};\n\n@vertex\nfn vs(\n  @builtin(vertex_index) vi: u32,\n  @location(0) a: vec3f,\n  @location(1) b: vec3f,\n  @location(2) color: vec4f,\n) -> Out {\n  var out: Out;\n  let corner = vec2f(f32(vi & 1u), f32(vi >> 1u));\n  let ca = u.viewProj * vec4f(a, 1.0);\n  let cb = u.viewProj * vec4f(b, 1.0);\n  let halfSize = u.viewport.xy * 0.5;\n  let sa = ca.xy / ca.w * halfSize;\n  let sb = cb.xy / cb.w * halfSize;\n  var dir = sb - sa;\n  let len = length(dir);\n  dir = select(vec2f(1.0, 0.0), dir / len, len > 1e-6);\n  let normal = vec2f(-dir.y, dir.x);\n  let w = max(0.5, u.params.y * u.viewport.z * 0.5) + 0.5;\n  let clip = select(ca, cb, corner.x > 0.5);\n  let side = corner.y * 2.0 - 1.0;\n  let pixel = select(sa, sb, corner.x > 0.5) + dir * (corner.x * 2.0 - 1.0) * w + normal * side * w;\n  let z = clip.z - u.eye.w * clip.w;\n  out.position = toWebGpuDepth(vec4f(pixel / halfSize * clip.w, z, clip.w));\n  out.across = side * w;\n  out.color = color;\n  return out;\n}\n\n@fragment\nfn fs(in: Out) -> @location(0) vec4f {\n  let core = u.params.y * u.viewport.z * 0.5;\n  let coverage = clamp(max(core, 0.5) + 0.5 - abs(in.across), 0.0, 1.0) * min(1.0, core * 2.0);\n  let alpha = coverage * in.color.a * u.params.x;\n  if (alpha <= 0.0) { discard; }\n  return vec4f(in.color.rgb * alpha, alpha);\n}\n`;\n\n// ------------------------------------------------------------------- GLSL\n\nconst GLSL_UNIFORMS = `\nuniform mat4 u_viewProj;\nuniform vec4 u_viewport;\nuniform vec4 u_eye;\nuniform vec4 u_light;\nuniform vec4 u_material;\nuniform vec4 u_params;\nuniform vec4 u_fog;\n`;\n\nconst GLSL_POINTS_VS = `\nattribute vec2 a_corner;\nattribute vec3 a_pos;\nattribute float a_size;\nattribute vec4 a_color;\nvarying vec2 v_offset;\nvarying float v_radius;\nvarying vec4 v_color;\nvarying float v_fog;\nvoid main() {\n  vec2 corner = a_corner * 2.0 - 1.0;\n  vec4 clip = u_viewProj * vec4(a_pos, 1.0);\n  float factor = 1.0;\n  if (u_params.y > 0.5 && u_viewport.w < 0.5) {\n    factor = clamp(u_params.z / max(clip.w, 1e-6), 0.5, 2.0);\n  }\n  float radius = max(0.5, a_size * u_viewport.z * factor * 0.5);\n  float reach = radius + 1.0;\n  vec2 shift = corner * reach * 2.0 / u_viewport.xy * clip.w;\n  gl_Position = vec4(clip.xy + shift, clip.z, clip.w);\n  v_offset = corner * reach;\n  v_radius = radius;\n  v_color = a_color;\n  float near = u_params.z - u_params.w;\n  v_fog = clamp((length(a_pos - u_eye.xyz) - near) / (2.0 * u_params.w), 0.0, 1.0) * 0.45;\n}\n`;\n\nconst GLSL_POINTS_FS = `\nvarying vec2 v_offset;\nvarying float v_radius;\nvarying vec4 v_color;\nvarying float v_fog;\nvoid main() {\n  float d = length(v_offset);\n  float alpha = clamp(v_radius + 0.5 - d, 0.0, 1.0);\n  if (alpha <= 0.0) discard;\n  float q = min(d / v_radius, 1.0);\n  vec3 n = vec3(v_offset / v_radius, sqrt(max(0.0, 1.0 - q * q)));\n  vec3 l = normalize(vec3(-0.45, 0.55, 0.7));\n  float lambert = max(dot(n, l), 0.0);\n  vec3 shaded = v_color.rgb * (0.62 + 0.45 * lambert) + vec3(pow(lambert, 18.0) * 0.28);\n  float sphere = smoothstep(1.5, 3.5, v_radius);\n  vec3 rgb = mix(v_color.rgb, shaded, sphere);\n  rgb = mix(rgb, u_fog.rgb, v_fog);\n  alpha = alpha * v_color.a * u_params.x;\n  FRAG = vec4(rgb * alpha, alpha);\n}\n`;\n\nconst GLSL_MESH_VS = `\nattribute vec3 a_pos;\nattribute vec3 a_normal;\nattribute vec4 a_color;\nvarying vec3 v_world;\nvarying vec3 v_normal;\nvarying vec4 v_color;\nvoid main() {\n  gl_Position = u_viewProj * vec4(a_pos, 1.0);\n  v_world = a_pos;\n  v_normal = a_normal;\n  v_color = a_color;\n}\n`;\n\nconst GLSL_MESH_FS = `\nvarying vec3 v_world;\nvarying vec3 v_normal;\nvarying vec4 v_color;\nvoid main() {\n  vec3 n = normalize(v_normal);\n  vec3 v = normalize(u_eye.xyz - v_world);\n  if (dot(n, v) < 0.0) n = -n;\n  vec3 l = u_light.xyz;\n  float diffuse = max(dot(n, l), 0.0);\n  vec3 h = normalize(l + v);\n  float specular = pow(max(dot(n, h), 0.0), u_material.w) * u_material.z;\n  vec3 rgb = v_color.rgb * (u_material.x + u_material.y * diffuse) + vec3(specular);\n  float alpha = v_color.a * u_params.x;\n  FRAG = vec4(rgb * alpha, alpha);\n}\n`;\n\nconst GLSL_LINES_VS = `\nattribute vec2 a_corner;\nattribute vec3 a_a;\nattribute vec3 a_b;\nattribute vec4 a_color;\nvarying float v_across;\nvarying vec4 v_color;\nvoid main() {\n  vec4 ca = u_viewProj * vec4(a_a, 1.0);\n  vec4 cb = u_viewProj * vec4(a_b, 1.0);\n  vec2 halfSize = u_viewport.xy * 0.5;\n  vec2 sa = ca.xy / ca.w * halfSize;\n  vec2 sb = cb.xy / cb.w * halfSize;\n  vec2 dir = sb - sa;\n  float len = length(dir);\n  dir = len > 1e-6 ? dir / len : vec2(1.0, 0.0);\n  vec2 normal = vec2(-dir.y, dir.x);\n  float w = max(0.5, u_params.y * u_viewport.z * 0.5) + 0.5;\n  bool atEnd = a_corner.x > 0.5;\n  vec4 clip = atEnd ? cb : ca;\n  float side = a_corner.y * 2.0 - 1.0;\n  vec2 pixel = (atEnd ? sb : sa) + dir * (a_corner.x * 2.0 - 1.0) * w + normal * side * w;\n  gl_Position = vec4(pixel / halfSize * clip.w, clip.z - u_eye.w * clip.w, clip.w);\n  v_across = side * w;\n  v_color = a_color;\n}\n`;\n\nconst GLSL_LINES_FS = `\nvarying float v_across;\nvarying vec4 v_color;\nvoid main() {\n  float core = u_params.y * u_viewport.z * 0.5;\n  float coverage = clamp(max(core, 0.5) + 0.5 - abs(v_across), 0.0, 1.0) * min(1.0, core * 2.0);\n  float alpha = coverage * v_color.a * u_params.x;\n  if (alpha <= 0.0) discard;\n  FRAG = vec4(v_color.rgb * alpha, alpha);\n}\n`;\n\nconst PRECISION = `\n#ifdef GL_FRAGMENT_PRECISION_HIGH\nprecision highp float;\n#else\nprecision mediump float;\n#endif\n`;\n\nexport interface GlslSource {\n  vertex: string;\n  fragment: string;\n}\n\nconst glsl = (vs: string, fs: string, version: 1 | 2): GlslSource =>\n  version === 2\n    ? {\n        vertex: `#version 300 es\\n#define attribute in\\n#define varying out\\n${GLSL_UNIFORMS}${vs}`,\n        fragment: `#version 300 es\\nprecision highp float;\\n#define varying in\\nout vec4 fragColor;\\n#define FRAG fragColor\\n${GLSL_UNIFORMS}${fs}`,\n      }\n    : {\n        vertex: `${GLSL_UNIFORMS}${vs}`,\n        fragment: `${PRECISION}#define FRAG gl_FragColor\\n${GLSL_UNIFORMS}${fs}`,\n      };\n\n/** GLSL programs of the three primitives for WebGL (1) or WebGL2 */\nexport const glslPrograms = (version: 1 | 2) => ({\n  points: glsl(GLSL_POINTS_VS, GLSL_POINTS_FS, version),\n  mesh: glsl(GLSL_MESH_VS, GLSL_MESH_FS, version),\n  lines: glsl(GLSL_LINES_VS, GLSL_LINES_FS, version),\n});\n\n/** Attribute names of every program, bound to locations 0, 1, ... */\nexport const GLSL_ATTRIBUTES = {\n  points: [\"a_corner\", \"a_pos\", \"a_size\", \"a_color\"],\n  mesh: [\"a_pos\", \"a_normal\", \"a_color\"],\n  lines: [\"a_corner\", \"a_a\", \"a_b\", \"a_color\"],\n} as const;\n"],"mappings":"AAoBA,IAAMA,GACJ,EACA,EACA,EACA,EACA,EACA,EACA,EACA,KAEAC,EAAI,IAAIC,EAAU,CAAC,EACnBD,EAAI,IAAIE,EAAU,EAAE,EACpBF,EAAI,IAAIG,EAAK,EAAE,EACfH,EAAI,IAAII,EAAO,EAAE,EACjBJ,EAAI,IAAIK,EAAU,EAAE,EACpBL,EAAI,IAAIM,EAAQ,EAAE,EAClBN,EAAI,IAAIO,EAAK,EAAE,EACRP,GAIIQ,GACX,EACA,EACA,IACiB,CACjB,IAAMC,EACJC,EAAK,OAAS,SACV,KAAK,YAGLA,EAAK,OAAS,QACZA,EAAK,MACL,EACR,OAAOX,EACLC,EACAW,EAAM,SACN,CAACA,EAAM,MAAOA,EAAM,OAAQA,EAAM,IAAK,KAAM,YAAoB,EACjE,CACEA,EAAM,IAAI,GACVA,EAAM,IAAI,GACVA,EAAM,IAAI,GACVD,EAAK,OAAS,QAAUA,EAAK,KAAO,CACtC,EACA,CAACC,EAAM,MAAM,GAAIA,EAAM,MAAM,GAAIA,EAAM,MAAM,GAAI,CAAC,EAClDA,EAAM,SACN,CAACD,EAAK,QAASD,EAAQE,EAAM,SAAUA,EAAM,MAAM,EACnD,CAACA,EAAM,IAAI,GAAIA,EAAM,IAAI,GAAIA,EAAM,IAAI,GAAI,CAAC,CAC9C,CACF,EAGaC,EAAe,GAA0BF,EAAK,SAAW,EAIhEG,EAA2B;;;;;;;;;;;;;;;;;;;;EAsBpBC,EAAyB,GAAGD,EAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoD1CE,EAAuB,GAAGF,EAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqCxCG,EAAwB,GAAGH,EAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgDhDI,EAAgB;;;;;;;;EAUhBC,EAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BjBC,EAAiB;;;;;;;;;;;;;;;;;;;;EAsBjBC,EAAe;;;;;;;;;;;;;EAefC,EAAe;;;;;;;;;;;;;;;;EAkBfC,EAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BhBC,EAAgB;;;;;;;;;;EAYhBC,EAAY;;;;;;EAaZC,GAAQ,EAAY,EAAY,IACpCC,IAAY,EACR,CACE,OAAQ,+DAA+DT,IAAgBU,IACvF,SAAU,6GAA6GV,IAAgBW,GACzI,EACA,CACE,OAAQ,GAAGX,IAAgBU,IAC3B,SAAU,GAAGH,EAAU,6BAA6BP,IAAgBW,GACtE,EAGOC,EAAgB,IAAoB,CAC/C,OAAQJ,EAAKP,EAAgBC,EAAgBO,CAAO,EACpD,KAAMD,EAAKL,EAAcC,EAAcK,CAAO,EAC9C,MAAOD,EAAKH,EAAeC,EAAeG,CAAO,CACnD,GAGaI,EAAkB,CAC7B,OAAQ,CAAC,WAAY,QAAS,SAAU,SAAS,EACjD,KAAM,CAAC,QAAS,WAAY,SAAS,EACrC,MAAO,CAAC,WAAY,MAAO,MAAO,SAAS,CAC7C"}

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

@@ -0,0 +1,26 @@
+import { Frame3D, Item3D } from './render-types.cjs';
+/** Bytes of the WGSL uniform struct */
+export declare const UNIFORM_BYTES = 160;
+/** Uniform values of an item (40 floats, the WGSL struct layout) */
+export declare const itemUniforms: (item: Item3D, frame: Frame3D, out: Float32Array) => Float32Array;
+/** Whether an item writes the depth buffer (opaque items) */
+export declare const writesDepth: (item: Item3D) => boolean;
+export declare const WGSL_POINTS = "\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\nstruct Out {\n  @builtin(position) position: vec4f,\n  @location(0) offset: vec2f,\n  @location(1) radius: f32,\n  @location(2) color: vec4f,\n  @location(3) fog: f32,\n};\n\n@vertex\nfn vs(\n  @builtin(vertex_index) vi: u32,\n  @location(0) pos: vec3f,\n  @location(1) size: f32,\n  @location(2) color: vec4f,\n) -> Out {\n  var out: Out;\n  let corner = vec2f(f32(vi & 1u), f32(vi >> 1u)) * 2.0 - 1.0;\n  let clip = u.viewProj * vec4f(pos, 1.0);\n  var factor = 1.0;\n  if (u.params.y > 0.5 && u.viewport.w < 0.5) {\n    factor = clamp(u.params.z / max(clip.w, 1e-6), 0.5, 2.0);\n  }\n  let radius = max(0.5, size * u.viewport.z * factor * 0.5);\n  let reach = radius + 1.0;\n  let shift = corner * reach * 2.0 / u.viewport.xy * clip.w;\n  out.position = toWebGpuDepth(vec4f(clip.xy + shift, clip.z, clip.w));\n  out.offset = corner * reach;\n  out.radius = radius;\n  out.color = color;\n  out.fog = depthCue(pos) * 0.45;\n  return out;\n}\n\n@fragment\nfn fs(in: Out) -> @location(0) vec4f {\n  let d = length(in.offset);\n  var alpha = clamp(in.radius + 0.5 - d, 0.0, 1.0);\n  if (alpha <= 0.0) { discard; }\n  let q = min(d / in.radius, 1.0);\n  let n = vec3f(in.offset.x / in.radius, in.offset.y / in.radius, sqrt(max(0.0, 1.0 - q * q)));\n  let l = normalize(vec3f(-0.45, 0.55, 0.7));\n  let lambert = max(dot(n, l), 0.0);\n  let shaded = in.color.rgb * (0.62 + 0.45 * lambert) + vec3f(pow(lambert, 18.0) * 0.28);\n  let sphere = smoothstep(1.5, 3.5, in.radius);\n  var rgb = mix(in.color.rgb, shaded, sphere);\n  rgb = mix(rgb, u.fog.rgb, in.fog);\n  alpha = alpha * in.color.a * u.params.x;\n  return vec4f(rgb * alpha, alpha);\n}\n";
+export declare const WGSL_MESH = "\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\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";
+export declare const WGSL_LINES = "\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\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";
+export interface GlslSource {
+    vertex: string;
+    fragment: string;
+}
+/** GLSL programs of the three primitives for WebGL (1) or WebGL2 */
+export declare const glslPrograms: (version: 1 | 2) => {
+    points: GlslSource;
+    mesh: GlslSource;
+    lines: GlslSource;
+};
+/** Attribute names of every program, bound to locations 0, 1, ... */
+export declare const GLSL_ATTRIBUTES: {
+    readonly points: readonly ["a_corner", "a_pos", "a_size", "a_color"];
+    readonly mesh: readonly ["a_pos", "a_normal", "a_color"];
+    readonly lines: readonly ["a_corner", "a_a", "a_b", "a_color"];
+};

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

@@ -0,0 +1,26 @@
+import { Frame3D, Item3D } from './render-types.js';
+/** Bytes of the WGSL uniform struct */
+export declare const UNIFORM_BYTES = 160;
+/** Uniform values of an item (40 floats, the WGSL struct layout) */
+export declare const itemUniforms: (item: Item3D, frame: Frame3D, out: Float32Array) => Float32Array;
+/** Whether an item writes the depth buffer (opaque items) */
+export declare const writesDepth: (item: Item3D) => boolean;
+export declare const WGSL_POINTS = "\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\nstruct Out {\n  @builtin(position) position: vec4f,\n  @location(0) offset: vec2f,\n  @location(1) radius: f32,\n  @location(2) color: vec4f,\n  @location(3) fog: f32,\n};\n\n@vertex\nfn vs(\n  @builtin(vertex_index) vi: u32,\n  @location(0) pos: vec3f,\n  @location(1) size: f32,\n  @location(2) color: vec4f,\n) -> Out {\n  var out: Out;\n  let corner = vec2f(f32(vi & 1u), f32(vi >> 1u)) * 2.0 - 1.0;\n  let clip = u.viewProj * vec4f(pos, 1.0);\n  var factor = 1.0;\n  if (u.params.y > 0.5 && u.viewport.w < 0.5) {\n    factor = clamp(u.params.z / max(clip.w, 1e-6), 0.5, 2.0);\n  }\n  let radius = max(0.5, size * u.viewport.z * factor * 0.5);\n  let reach = radius + 1.0;\n  let shift = corner * reach * 2.0 / u.viewport.xy * clip.w;\n  out.position = toWebGpuDepth(vec4f(clip.xy + shift, clip.z, clip.w));\n  out.offset = corner * reach;\n  out.radius = radius;\n  out.color = color;\n  out.fog = depthCue(pos) * 0.45;\n  return out;\n}\n\n@fragment\nfn fs(in: Out) -> @location(0) vec4f {\n  let d = length(in.offset);\n  var alpha = clamp(in.radius + 0.5 - d, 0.0, 1.0);\n  if (alpha <= 0.0) { discard; }\n  let q = min(d / in.radius, 1.0);\n  let n = vec3f(in.offset.x / in.radius, in.offset.y / in.radius, sqrt(max(0.0, 1.0 - q * q)));\n  let l = normalize(vec3f(-0.45, 0.55, 0.7));\n  let lambert = max(dot(n, l), 0.0);\n  let shaded = in.color.rgb * (0.62 + 0.45 * lambert) + vec3f(pow(lambert, 18.0) * 0.28);\n  let sphere = smoothstep(1.5, 3.5, in.radius);\n  var rgb = mix(in.color.rgb, shaded, sphere);\n  rgb = mix(rgb, u.fog.rgb, in.fog);\n  alpha = alpha * in.color.a * u.params.x;\n  return vec4f(rgb * alpha, alpha);\n}\n";
+export declare const WGSL_MESH = "\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\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";
+export declare const WGSL_LINES = "\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\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";
+export interface GlslSource {
+    vertex: string;
+    fragment: string;
+}
+/** GLSL programs of the three primitives for WebGL (1) or WebGL2 */
+export declare const glslPrograms: (version: 1 | 2) => {
+    points: GlslSource;
+    mesh: GlslSource;
+    lines: GlslSource;
+};
+/** Attribute names of every program, bound to locations 0, 1, ... */
+export declare const GLSL_ATTRIBUTES: {
+    readonly points: readonly ["a_corner", "a_pos", "a_size", "a_color"];
+    readonly mesh: readonly ["a_pos", "a_normal", "a_color"];
+    readonly lines: readonly ["a_corner", "a_a", "a_b", "a_color"];
+};