minerva-design 1.4.0 → 1.5.0

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

@@ -1 +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"}
+{"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

@@ -15,13 +15,26 @@ interface ItemBase {
     /** 0-1; below 1 the item is drawn without writing depth */
     opacity: number;
 }
-/** Instanced billboards shaded as small spheres */
+/** 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 {
@@ -34,6 +47,11 @@ export interface MeshItem extends ItemBase {
      * 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 {
@@ -74,9 +92,12 @@ export interface Renderer3D {
     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, points, transparent meshes, then lines
- * (wireframes and contours stay visible over transparent surfaces)
+ * 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

@@ -15,13 +15,26 @@ interface ItemBase {
     /** 0-1; below 1 the item is drawn without writing depth */
     opacity: number;
 }
-/** Instanced billboards shaded as small spheres */
+/** 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 {
@@ -34,6 +47,11 @@ export interface MeshItem extends ItemBase {
      * 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 {
@@ -74,9 +92,12 @@ export interface Renderer3D {
     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, points, transparent meshes, then lines
- * (wireframes and contours stay visible over transparent surfaces)
+ * 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

@@ -1,13 +1,12 @@
-//#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) => ({
+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: n,
-		r: t(e)
+		i: t,
+		r: n(e)
 	})).sort((e, t) => e.r - t.r || e.i - t.i).map((e) => e.item);
 };
 //#endregion
-export { e as drawOrder };
+export { t as drawOrder, e as writesDepth };
 
 //# sourceMappingURL=render-types.js.map

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

@@ -1 +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"}
+{"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"}

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

@@ -1,4 +1,4 @@
-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=`
+const e=require("./render-types.cjs");var t=(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),n=(e,n,r)=>{let i=e.kind===`points`?+!!e.perspective:e.kind===`lines`?e.width:0;return t(r,n.viewProj,[n.width,n.height,n.dpr,+!!n.orthographic],[n.eye[0],n.eye[1],n.eye[2],e.kind===`lines`?e.bias:e.kind===`points`?e.style??0:0],[n.light[0],n.light[1],n.light[2],e.kind===`points`&&e.additive?1:0],n.lighting,[e.opacity,i,n.distance,n.radius],[n.fog[0],n.fog[1],n.fog[2],1])},r=`
 struct U {
   viewProj: mat4x4f,
   viewport: vec4f,
@@ -25,6 +25,7 @@ struct Out {
   @location(1) radius: f32,
   @location(2) color: vec4f,
   @location(3) fog: f32,
+  @location(4) coverage: f32,
 };
 
 @vertex
@@ -41,31 +42,48 @@ fn vs(
   if (u.params.y > 0.5 && u.viewport.w < 0.5) {
     factor = clamp(u.params.z / max(clip.w, 1e-6), 0.5, 2.0);
   }
-  let radius = max(0.5, size * u.viewport.z * factor * 0.5);
-  let reach = radius + 1.0;
+  let glow = u.eye.w > 1.5;
+  let raw = max(size, 0.0) * u.viewport.z * factor * 0.5;
+  let radius = max(raw, select(0.5, 0.75, glow));
+  let reach = select(radius + 1.0, radius * 2.2 + 1.0, glow);
   let shift = corner * reach * 2.0 / u.viewport.xy * clip.w;
   out.position = toWebGpuDepth(vec4f(clip.xy + shift, clip.z, clip.w));
   out.offset = corner * reach;
   out.radius = radius;
   out.color = color;
   out.fog = depthCue(pos) * 0.45;
+  out.coverage = min(1.0, raw * raw / (radius * radius));
   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;
+  let r = in.radius;
+  var alpha = clamp(r + 0.5 - d, 0.0, 1.0);
+  var rgb = in.color.rgb;
+  if (u.eye.w > 1.5) {
+    // glow: an anti-aliased core and a gaussian halo
+    let core = clamp(r * 0.6 + 0.5 - d, 0.0, 1.0);
+    let q = d / r;
+    alpha = core + (1.0 - core) * exp(-1.2 * q * q);
+    rgb = rgb + (vec3f(1.0) - rgb) * (0.2 * core);
+  } else if (u.eye.w < 0.5) {
+    let q = min(d / r, 1.0);
+    let n = vec3f(in.offset.x / r, in.offset.y / r, sqrt(max(0.0, 1.0 - q * q)));
+    let l = normalize(vec3f(-0.45, 0.55, 0.7));
+    let lambert = max(dot(n, l), 0.0);
+    let shaded = rgb * (0.62 + 0.45 * lambert) + vec3f(pow(lambert, 18.0) * 0.28);
+    rgb = mix(rgb, shaded, smoothstep(1.5, 3.5, r));
+  }
+  if (alpha <= 0.004) { discard; }
+  if (u.light.w > 0.5) {
+    // additive light fades with the distance
+    alpha = alpha * (1.0 - in.fog);
+  } else {
+    rgb = mix(rgb, u.fog.rgb, in.fog);
+  }
+  alpha = alpha * in.coverage * in.color.a * u.params.x;
   return vec4f(rgb * alpha, alpha);
 }
 `,a=`${r}
@@ -164,6 +182,7 @@ varying vec2 v_offset;
 varying float v_radius;
 varying vec4 v_color;
 varying float v_fog;
+varying float v_coverage;
 void main() {
   vec2 corner = a_corner * 2.0 - 1.0;
   vec4 clip = u_viewProj * vec4(a_pos, 1.0);
@@ -171,8 +190,10 @@ void main() {
   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;
+  bool glow = u_eye.w > 1.5;
+  float raw = max(a_size, 0.0) * u_viewport.z * factor * 0.5;
+  float radius = max(raw, glow ? 0.75 : 0.5);
+  float reach = glow ? radius * 2.2 + 1.0 : 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;
@@ -180,25 +201,39 @@ void main() {
   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;
+  v_coverage = min(1.0, raw * raw / (radius * radius));
 }
 `,l=`
 varying vec2 v_offset;
 varying float v_radius;
 varying vec4 v_color;
 varying float v_fog;
+varying float v_coverage;
 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;
+  float r = v_radius;
+  float alpha = clamp(r + 0.5 - d, 0.0, 1.0);
+  vec3 rgb = v_color.rgb;
+  if (u_eye.w > 1.5) {
+    float core = clamp(r * 0.6 + 0.5 - d, 0.0, 1.0);
+    float q = d / r;
+    alpha = core + (1.0 - core) * exp(-1.2 * q * q);
+    rgb = rgb + (vec3(1.0) - rgb) * (0.2 * core);
+  } else if (u_eye.w < 0.5) {
+    float q = min(d / r, 1.0);
+    vec3 n = vec3(v_offset / r, 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 = rgb * (0.62 + 0.45 * lambert) + vec3(pow(lambert, 18.0) * 0.28);
+    rgb = mix(rgb, shaded, smoothstep(1.5, 3.5, r));
+  }
+  if (alpha <= 0.004) discard;
+  if (u_light.w > 0.5) {
+    alpha = alpha * (1.0 - v_fog);
+  } else {
+    rgb = mix(rgb, u_fog.rgb, v_fog);
+  }
+  alpha = alpha * v_coverage * v_color.a * u_params.x;
   FRAG = vec4(rgb * alpha, alpha);
 }
 `,u=`
@@ -272,5 +307,5 @@ 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;
+`,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=n,exports.writesDepth=e.writesDepth;
 //# sourceMappingURL=shaders.cjs.map

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

@@ -1 +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"}
+{"version":3,"file":"shaders.cjs","names":["require_render_types","writeUniforms","out","viewProj","viewport","eye","light","material","params","fog","itemUniforms","second","item","frame","WGSL_UNIFORMS","WGSL_POINTS","WGSL_MESH","WGSL_LINES","GLSL_UNIFORMS","GLSL_POINTS_VS","GLSL_POINTS_FS","GLSL_MESH_VS","GLSL_MESH_FS","GLSL_LINES_VS","GLSL_LINES_FS","PRECISION","glsl","version","vs","fs","glslPrograms","GLSL_ATTRIBUTES"],"sources":["../../../../../charts/src/engine/three-d/shaders.ts"],"sourcesContent":["// Shaders of the 3D data layer: instanced point billboards (shaded spheres,\n// flat discs or glowing discs), lit triangles (two-sided Lambert +\n// Blinn-Phong) and screen-space wide line segments. WGSL for WebGPU, GLSL ES\n// 1.0 for WebGL (turned into GLSL ES 3.0 for WebGL2 by a macro prefix).\n// Outputs are premultiplied.\n//\n// Uniforms (WGSL struct, GLSL vec4 uniforms of the same names):\n//   viewProj  world -> clip (OpenGL depth convention)\n//   viewport  drawing buffer width, height (device px), dpr, orthographic\n//   eye       camera position, depth bias of the lines (NDC) | point style\n//   light     unit vector towards the light, additive points (0/1)\n//   material  ambient, diffuse, specular, shininess\n//   params    opacity, perspective sizes (0/1) | line width (CSS px), distance, radius\n//   fog       background color (far points fade towards it)\n//\n// Point sizes are CSS pixels times the device pixel ratio (billboards: no\n// point size limit). Dots thinner than the smallest drawn radius keep their\n// energy: their alpha scales with the area they would cover.\n\nimport { POINT_SPHERE, type Frame3D, type Item3D } from \"./render-types\";\n\nexport { writesDepth } from \"./render-types\";\n\n/** Bytes of the WGSL uniform struct */\nexport const UNIFORM_BYTES = 160;\n\n/** Writes the uniforms of an item in the WGSL struct layout */\nconst writeUniforms = (\n  out: Float32Array,\n  viewProj: Float32Array,\n  viewport: readonly [number, number, number, number],\n  eye: readonly [number, number, number, number],\n  light: readonly [number, number, number, number],\n  material: readonly [number, number, number, number],\n  params: readonly [number, number, number, number],\n  fog: readonly [number, number, number, number],\n): Float32Array => {\n  out.set(viewProj, 0);\n  out.set(viewport, 16);\n  out.set(eye, 20);\n  out.set(light, 24);\n  out.set(material, 28);\n  out.set(params, 32);\n  out.set(fog, 36);\n  return out;\n};\n\n/** Uniform values of an item (40 floats, the WGSL struct layout) */\nexport const itemUniforms = (\n  item: Item3D,\n  frame: Frame3D,\n  out: Float32Array,\n): Float32Array => {\n  const second =\n    item.kind === \"points\"\n      ? item.perspective\n        ? 1\n        : 0\n      : item.kind === \"lines\"\n        ? item.width\n        : 0;\n  return writeUniforms(\n    out,\n    frame.viewProj,\n    [frame.width, frame.height, frame.dpr, frame.orthographic ? 1 : 0],\n    [\n      frame.eye[0],\n      frame.eye[1],\n      frame.eye[2],\n      item.kind === \"lines\"\n        ? item.bias\n        : item.kind === \"points\"\n          ? (item.style ?? POINT_SPHERE)\n          : 0,\n    ],\n    [\n      frame.light[0],\n      frame.light[1],\n      frame.light[2],\n      item.kind === \"points\" && item.additive ? 1 : 0,\n    ],\n    frame.lighting,\n    [item.opacity, second, frame.distance, frame.radius],\n    [frame.fog[0], frame.fog[1], frame.fog[2], 1],\n  );\n};\n\n// ------------------------------------------------------------------- WGSL\n\nconst WGSL_UNIFORMS = /* wgsl */ `\nstruct U {\n  viewProj: mat4x4f,\n  viewport: vec4f,\n  eye: vec4f,\n  light: vec4f,\n  material: vec4f,\n  params: vec4f,\n  fog: vec4f,\n};\n@group(0) @binding(0) var<uniform> u: U;\n\nfn toWebGpuDepth(p: vec4f) -> vec4f {\n  return vec4f(p.x, p.y, (p.z + p.w) * 0.5, p.w);\n}\n\nfn depthCue(world: vec3f) -> f32 {\n  let near = u.params.z - u.params.w;\n  return clamp((length(world - u.eye.xyz) - near) / (2.0 * u.params.w), 0.0, 1.0);\n}\n`;\n\nexport const WGSL_POINTS = /* wgsl */ `${WGSL_UNIFORMS}\nstruct Out {\n  @builtin(position) position: vec4f,\n  @location(0) offset: vec2f,\n  @location(1) radius: f32,\n  @location(2) color: vec4f,\n  @location(3) fog: f32,\n  @location(4) coverage: f32,\n};\n\n@vertex\nfn vs(\n  @builtin(vertex_index) vi: u32,\n  @location(0) pos: vec3f,\n  @location(1) size: f32,\n  @location(2) color: vec4f,\n) -> Out {\n  var out: Out;\n  let corner = vec2f(f32(vi & 1u), f32(vi >> 1u)) * 2.0 - 1.0;\n  let clip = u.viewProj * vec4f(pos, 1.0);\n  var factor = 1.0;\n  if (u.params.y > 0.5 && u.viewport.w < 0.5) {\n    factor = clamp(u.params.z / max(clip.w, 1e-6), 0.5, 2.0);\n  }\n  let glow = u.eye.w > 1.5;\n  let raw = max(size, 0.0) * u.viewport.z * factor * 0.5;\n  let radius = max(raw, select(0.5, 0.75, glow));\n  let reach = select(radius + 1.0, radius * 2.2 + 1.0, glow);\n  let shift = corner * reach * 2.0 / u.viewport.xy * clip.w;\n  out.position = toWebGpuDepth(vec4f(clip.xy + shift, clip.z, clip.w));\n  out.offset = corner * reach;\n  out.radius = radius;\n  out.color = color;\n  out.fog = depthCue(pos) * 0.45;\n  out.coverage = min(1.0, raw * raw / (radius * radius));\n  return out;\n}\n\n@fragment\nfn fs(in: Out) -> @location(0) vec4f {\n  let d = length(in.offset);\n  let r = in.radius;\n  var alpha = clamp(r + 0.5 - d, 0.0, 1.0);\n  var rgb = in.color.rgb;\n  if (u.eye.w > 1.5) {\n    // glow: an anti-aliased core and a gaussian halo\n    let core = clamp(r * 0.6 + 0.5 - d, 0.0, 1.0);\n    let q = d / r;\n    alpha = core + (1.0 - core) * exp(-1.2 * q * q);\n    rgb = rgb + (vec3f(1.0) - rgb) * (0.2 * core);\n  } else if (u.eye.w < 0.5) {\n    let q = min(d / r, 1.0);\n    let n = vec3f(in.offset.x / r, in.offset.y / r, sqrt(max(0.0, 1.0 - q * q)));\n    let l = normalize(vec3f(-0.45, 0.55, 0.7));\n    let lambert = max(dot(n, l), 0.0);\n    let shaded = rgb * (0.62 + 0.45 * lambert) + vec3f(pow(lambert, 18.0) * 0.28);\n    rgb = mix(rgb, shaded, smoothstep(1.5, 3.5, r));\n  }\n  if (alpha <= 0.004) { discard; }\n  if (u.light.w > 0.5) {\n    // additive light fades with the distance\n    alpha = alpha * (1.0 - in.fog);\n  } else {\n    rgb = mix(rgb, u.fog.rgb, in.fog);\n  }\n  alpha = alpha * in.coverage * in.color.a * u.params.x;\n  return vec4f(rgb * alpha, alpha);\n}\n`;\n\nexport const WGSL_MESH = /* wgsl */ `${WGSL_UNIFORMS}\nstruct Out {\n  @builtin(position) position: vec4f,\n  @location(0) world: vec3f,\n  @location(1) normal: vec3f,\n  @location(2) color: vec4f,\n};\n\n@vertex\nfn vs(\n  @location(0) pos: vec3f,\n  @location(1) normal: vec3f,\n  @location(2) color: vec4f,\n) -> Out {\n  var out: Out;\n  out.position = toWebGpuDepth(u.viewProj * vec4f(pos, 1.0));\n  out.world = pos;\n  out.normal = normal;\n  out.color = color;\n  return out;\n}\n\n@fragment\nfn fs(in: Out) -> @location(0) vec4f {\n  var n = normalize(in.normal);\n  let v = normalize(u.eye.xyz - in.world);\n  if (dot(n, v) < 0.0) { n = -n; }\n  let l = u.light.xyz;\n  let diffuse = max(dot(n, l), 0.0);\n  let h = normalize(l + v);\n  let specular = pow(max(dot(n, h), 0.0), u.material.w) * u.material.z;\n  let rgb = in.color.rgb * (u.material.x + u.material.y * diffuse) + vec3f(specular);\n  let alpha = in.color.a * u.params.x;\n  return vec4f(rgb * alpha, alpha);\n}\n`;\n\nexport const WGSL_LINES = /* wgsl */ `${WGSL_UNIFORMS}\nstruct Out {\n  @builtin(position) position: vec4f,\n  @location(0) across: f32,\n  @location(1) color: vec4f,\n};\n\n@vertex\nfn vs(\n  @builtin(vertex_index) vi: u32,\n  @location(0) a: vec3f,\n  @location(1) b: vec3f,\n  @location(2) color: vec4f,\n) -> Out {\n  var out: Out;\n  let corner = vec2f(f32(vi & 1u), f32(vi >> 1u));\n  let ca = u.viewProj * vec4f(a, 1.0);\n  let cb = u.viewProj * vec4f(b, 1.0);\n  let halfSize = u.viewport.xy * 0.5;\n  let sa = ca.xy / ca.w * halfSize;\n  let sb = cb.xy / cb.w * halfSize;\n  var dir = sb - sa;\n  let len = length(dir);\n  dir = select(vec2f(1.0, 0.0), dir / len, len > 1e-6);\n  let normal = vec2f(-dir.y, dir.x);\n  let w = max(0.5, u.params.y * u.viewport.z * 0.5) + 0.5;\n  let clip = select(ca, cb, corner.x > 0.5);\n  let side = corner.y * 2.0 - 1.0;\n  let pixel = select(sa, sb, corner.x > 0.5) + dir * (corner.x * 2.0 - 1.0) * w + normal * side * w;\n  let z = clip.z - u.eye.w * clip.w;\n  out.position = toWebGpuDepth(vec4f(pixel / halfSize * clip.w, z, clip.w));\n  out.across = side * w;\n  out.color = color;\n  return out;\n}\n\n@fragment\nfn fs(in: Out) -> @location(0) vec4f {\n  let core = u.params.y * u.viewport.z * 0.5;\n  let coverage = clamp(max(core, 0.5) + 0.5 - abs(in.across), 0.0, 1.0) * min(1.0, core * 2.0);\n  let alpha = coverage * in.color.a * u.params.x;\n  if (alpha <= 0.0) { discard; }\n  return vec4f(in.color.rgb * alpha, alpha);\n}\n`;\n\n// ------------------------------------------------------------------- GLSL\n\nconst GLSL_UNIFORMS = `\nuniform mat4 u_viewProj;\nuniform vec4 u_viewport;\nuniform vec4 u_eye;\nuniform vec4 u_light;\nuniform vec4 u_material;\nuniform vec4 u_params;\nuniform vec4 u_fog;\n`;\n\nconst GLSL_POINTS_VS = `\nattribute vec2 a_corner;\nattribute vec3 a_pos;\nattribute float a_size;\nattribute vec4 a_color;\nvarying vec2 v_offset;\nvarying float v_radius;\nvarying vec4 v_color;\nvarying float v_fog;\nvarying float v_coverage;\nvoid main() {\n  vec2 corner = a_corner * 2.0 - 1.0;\n  vec4 clip = u_viewProj * vec4(a_pos, 1.0);\n  float factor = 1.0;\n  if (u_params.y > 0.5 && u_viewport.w < 0.5) {\n    factor = clamp(u_params.z / max(clip.w, 1e-6), 0.5, 2.0);\n  }\n  bool glow = u_eye.w > 1.5;\n  float raw = max(a_size, 0.0) * u_viewport.z * factor * 0.5;\n  float radius = max(raw, glow ? 0.75 : 0.5);\n  float reach = glow ? radius * 2.2 + 1.0 : radius + 1.0;\n  vec2 shift = corner * reach * 2.0 / u_viewport.xy * clip.w;\n  gl_Position = vec4(clip.xy + shift, clip.z, clip.w);\n  v_offset = corner * reach;\n  v_radius = radius;\n  v_color = a_color;\n  float near = u_params.z - u_params.w;\n  v_fog = clamp((length(a_pos - u_eye.xyz) - near) / (2.0 * u_params.w), 0.0, 1.0) * 0.45;\n  v_coverage = min(1.0, raw * raw / (radius * radius));\n}\n`;\n\nconst GLSL_POINTS_FS = `\nvarying vec2 v_offset;\nvarying float v_radius;\nvarying vec4 v_color;\nvarying float v_fog;\nvarying float v_coverage;\nvoid main() {\n  float d = length(v_offset);\n  float r = v_radius;\n  float alpha = clamp(r + 0.5 - d, 0.0, 1.0);\n  vec3 rgb = v_color.rgb;\n  if (u_eye.w > 1.5) {\n    float core = clamp(r * 0.6 + 0.5 - d, 0.0, 1.0);\n    float q = d / r;\n    alpha = core + (1.0 - core) * exp(-1.2 * q * q);\n    rgb = rgb + (vec3(1.0) - rgb) * (0.2 * core);\n  } else if (u_eye.w < 0.5) {\n    float q = min(d / r, 1.0);\n    vec3 n = vec3(v_offset / r, sqrt(max(0.0, 1.0 - q * q)));\n    vec3 l = normalize(vec3(-0.45, 0.55, 0.7));\n    float lambert = max(dot(n, l), 0.0);\n    vec3 shaded = rgb * (0.62 + 0.45 * lambert) + vec3(pow(lambert, 18.0) * 0.28);\n    rgb = mix(rgb, shaded, smoothstep(1.5, 3.5, r));\n  }\n  if (alpha <= 0.004) discard;\n  if (u_light.w > 0.5) {\n    alpha = alpha * (1.0 - v_fog);\n  } else {\n    rgb = mix(rgb, u_fog.rgb, v_fog);\n  }\n  alpha = alpha * v_coverage * v_color.a * u_params.x;\n  FRAG = vec4(rgb * alpha, alpha);\n}\n`;\n\nconst GLSL_MESH_VS = `\nattribute vec3 a_pos;\nattribute vec3 a_normal;\nattribute vec4 a_color;\nvarying vec3 v_world;\nvarying vec3 v_normal;\nvarying vec4 v_color;\nvoid main() {\n  gl_Position = u_viewProj * vec4(a_pos, 1.0);\n  v_world = a_pos;\n  v_normal = a_normal;\n  v_color = a_color;\n}\n`;\n\nconst GLSL_MESH_FS = `\nvarying vec3 v_world;\nvarying vec3 v_normal;\nvarying vec4 v_color;\nvoid main() {\n  vec3 n = normalize(v_normal);\n  vec3 v = normalize(u_eye.xyz - v_world);\n  if (dot(n, v) < 0.0) n = -n;\n  vec3 l = u_light.xyz;\n  float diffuse = max(dot(n, l), 0.0);\n  vec3 h = normalize(l + v);\n  float specular = pow(max(dot(n, h), 0.0), u_material.w) * u_material.z;\n  vec3 rgb = v_color.rgb * (u_material.x + u_material.y * diffuse) + vec3(specular);\n  float alpha = v_color.a * u_params.x;\n  FRAG = vec4(rgb * alpha, alpha);\n}\n`;\n\nconst GLSL_LINES_VS = `\nattribute vec2 a_corner;\nattribute vec3 a_a;\nattribute vec3 a_b;\nattribute vec4 a_color;\nvarying float v_across;\nvarying vec4 v_color;\nvoid main() {\n  vec4 ca = u_viewProj * vec4(a_a, 1.0);\n  vec4 cb = u_viewProj * vec4(a_b, 1.0);\n  vec2 halfSize = u_viewport.xy * 0.5;\n  vec2 sa = ca.xy / ca.w * halfSize;\n  vec2 sb = cb.xy / cb.w * halfSize;\n  vec2 dir = sb - sa;\n  float len = length(dir);\n  dir = len > 1e-6 ? dir / len : vec2(1.0, 0.0);\n  vec2 normal = vec2(-dir.y, dir.x);\n  float w = max(0.5, u_params.y * u_viewport.z * 0.5) + 0.5;\n  bool atEnd = a_corner.x > 0.5;\n  vec4 clip = atEnd ? cb : ca;\n  float side = a_corner.y * 2.0 - 1.0;\n  vec2 pixel = (atEnd ? sb : sa) + dir * (a_corner.x * 2.0 - 1.0) * w + normal * side * w;\n  gl_Position = vec4(pixel / halfSize * clip.w, clip.z - u_eye.w * clip.w, clip.w);\n  v_across = side * w;\n  v_color = a_color;\n}\n`;\n\nconst GLSL_LINES_FS = `\nvarying float v_across;\nvarying vec4 v_color;\nvoid main() {\n  float core = u_params.y * u_viewport.z * 0.5;\n  float coverage = clamp(max(core, 0.5) + 0.5 - abs(v_across), 0.0, 1.0) * min(1.0, core * 2.0);\n  float alpha = coverage * v_color.a * u_params.x;\n  if (alpha <= 0.0) discard;\n  FRAG = vec4(v_color.rgb * alpha, alpha);\n}\n`;\n\nconst PRECISION = `\n#ifdef GL_FRAGMENT_PRECISION_HIGH\nprecision highp float;\n#else\nprecision mediump float;\n#endif\n`;\n\nexport interface GlslSource {\n  vertex: string;\n  fragment: string;\n}\n\nconst glsl = (vs: string, fs: string, version: 1 | 2): GlslSource =>\n  version === 2\n    ? {\n        vertex: `#version 300 es\\n#define attribute in\\n#define varying out\\n${GLSL_UNIFORMS}${vs}`,\n        fragment: `#version 300 es\\nprecision highp float;\\n#define varying in\\nout vec4 fragColor;\\n#define FRAG fragColor\\n${GLSL_UNIFORMS}${fs}`,\n      }\n    : {\n        vertex: `${GLSL_UNIFORMS}${vs}`,\n        fragment: `${PRECISION}#define FRAG gl_FragColor\\n${GLSL_UNIFORMS}${fs}`,\n      };\n\n/** GLSL programs of the three primitives for WebGL (1) or WebGL2 */\nexport const glslPrograms = (version: 1 | 2) => ({\n  points: glsl(GLSL_POINTS_VS, GLSL_POINTS_FS, version),\n  mesh: glsl(GLSL_MESH_VS, GLSL_MESH_FS, version),\n  lines: glsl(GLSL_LINES_VS, GLSL_LINES_FS, version),\n});\n\n/** Attribute names of every program, bound to locations 0, 1, ... */\nexport const GLSL_ATTRIBUTES = {\n  points: [\"a_corner\", \"a_pos\", \"a_size\", \"a_color\"],\n  mesh: [\"a_pos\", \"a_normal\", \"a_color\"],\n  lines: [\"a_corner\", \"a_a\", \"a_b\", \"a_color\"],\n} as const;\n"],"mappings":"sCA2BA,IAAMC,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,QACVA,EAAK,KACLA,EAAK,OAAS,SACXA,EAAK,OAAA,EACN,CACR,EACA,CACEC,EAAM,MAAM,GACZA,EAAM,MAAM,GACZA,EAAM,MAAM,GACZD,EAAK,OAAS,UAAYA,EAAK,SAAW,EAAI,CAChD,EACAC,EAAM,SACN,CAACD,EAAK,QAASD,EAAQE,EAAM,SAAUA,EAAM,MAAM,EACnD,CAACA,EAAM,IAAI,GAAIA,EAAM,IAAI,GAAIA,EAAM,IAAI,GAAI,CAAC,CAC9C,CACF,EAIMC,EAA2B;;;;;;;;;;;;;;;;;;;;EAsBpBC,EAAyB,GAAGD,EAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsE1CE,EAAuB,GAAGF,EAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqCxCG,EAAwB,GAAGH,EAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgDhDI,EAAgB;;;;;;;;EAUhBC,EAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgCjBC,EAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmCjBC,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

@@ -1,11 +1,10 @@
 import { Frame3D, Item3D } from './render-types.cjs';
+export { writesDepth } 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_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  @location(4) coverage: f32,\n};\n\n@vertex\nfn vs(\n  @builtin(vertex_index) vi: u32,\n  @location(0) pos: vec3f,\n  @location(1) size: f32,\n  @location(2) color: vec4f,\n) -> Out {\n  var out: Out;\n  let corner = vec2f(f32(vi & 1u), f32(vi >> 1u)) * 2.0 - 1.0;\n  let clip = u.viewProj * vec4f(pos, 1.0);\n  var factor = 1.0;\n  if (u.params.y > 0.5 && u.viewport.w < 0.5) {\n    factor = clamp(u.params.z / max(clip.w, 1e-6), 0.5, 2.0);\n  }\n  let glow = u.eye.w > 1.5;\n  let raw = max(size, 0.0) * u.viewport.z * factor * 0.5;\n  let radius = max(raw, select(0.5, 0.75, glow));\n  let reach = select(radius + 1.0, radius * 2.2 + 1.0, glow);\n  let shift = corner * reach * 2.0 / u.viewport.xy * clip.w;\n  out.position = toWebGpuDepth(vec4f(clip.xy + shift, clip.z, clip.w));\n  out.offset = corner * reach;\n  out.radius = radius;\n  out.color = color;\n  out.fog = depthCue(pos) * 0.45;\n  out.coverage = min(1.0, raw * raw / (radius * radius));\n  return out;\n}\n\n@fragment\nfn fs(in: Out) -> @location(0) vec4f {\n  let d = length(in.offset);\n  let r = in.radius;\n  var alpha = clamp(r + 0.5 - d, 0.0, 1.0);\n  var rgb = in.color.rgb;\n  if (u.eye.w > 1.5) {\n    // glow: an anti-aliased core and a gaussian halo\n    let core = clamp(r * 0.6 + 0.5 - d, 0.0, 1.0);\n    let q = d / r;\n    alpha = core + (1.0 - core) * exp(-1.2 * q * q);\n    rgb = rgb + (vec3f(1.0) - rgb) * (0.2 * core);\n  } else if (u.eye.w < 0.5) {\n    let q = min(d / r, 1.0);\n    let n = vec3f(in.offset.x / r, in.offset.y / r, sqrt(max(0.0, 1.0 - q * q)));\n    let l = normalize(vec3f(-0.45, 0.55, 0.7));\n    let lambert = max(dot(n, l), 0.0);\n    let shaded = rgb * (0.62 + 0.45 * lambert) + vec3f(pow(lambert, 18.0) * 0.28);\n    rgb = mix(rgb, shaded, smoothstep(1.5, 3.5, r));\n  }\n  if (alpha <= 0.004) { discard; }\n  if (u.light.w > 0.5) {\n    // additive light fades with the distance\n    alpha = alpha * (1.0 - in.fog);\n  } else {\n    rgb = mix(rgb, u.fog.rgb, in.fog);\n  }\n  alpha = alpha * in.coverage * in.color.a * u.params.x;\n  return vec4f(rgb * alpha, alpha);\n}\n";
 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 {

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

@@ -1,11 +1,10 @@
 import { Frame3D, Item3D } from './render-types.js';
+export { writesDepth } 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_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  @location(4) coverage: f32,\n};\n\n@vertex\nfn vs(\n  @builtin(vertex_index) vi: u32,\n  @location(0) pos: vec3f,\n  @location(1) size: f32,\n  @location(2) color: vec4f,\n) -> Out {\n  var out: Out;\n  let corner = vec2f(f32(vi & 1u), f32(vi >> 1u)) * 2.0 - 1.0;\n  let clip = u.viewProj * vec4f(pos, 1.0);\n  var factor = 1.0;\n  if (u.params.y > 0.5 && u.viewport.w < 0.5) {\n    factor = clamp(u.params.z / max(clip.w, 1e-6), 0.5, 2.0);\n  }\n  let glow = u.eye.w > 1.5;\n  let raw = max(size, 0.0) * u.viewport.z * factor * 0.5;\n  let radius = max(raw, select(0.5, 0.75, glow));\n  let reach = select(radius + 1.0, radius * 2.2 + 1.0, glow);\n  let shift = corner * reach * 2.0 / u.viewport.xy * clip.w;\n  out.position = toWebGpuDepth(vec4f(clip.xy + shift, clip.z, clip.w));\n  out.offset = corner * reach;\n  out.radius = radius;\n  out.color = color;\n  out.fog = depthCue(pos) * 0.45;\n  out.coverage = min(1.0, raw * raw / (radius * radius));\n  return out;\n}\n\n@fragment\nfn fs(in: Out) -> @location(0) vec4f {\n  let d = length(in.offset);\n  let r = in.radius;\n  var alpha = clamp(r + 0.5 - d, 0.0, 1.0);\n  var rgb = in.color.rgb;\n  if (u.eye.w > 1.5) {\n    // glow: an anti-aliased core and a gaussian halo\n    let core = clamp(r * 0.6 + 0.5 - d, 0.0, 1.0);\n    let q = d / r;\n    alpha = core + (1.0 - core) * exp(-1.2 * q * q);\n    rgb = rgb + (vec3f(1.0) - rgb) * (0.2 * core);\n  } else if (u.eye.w < 0.5) {\n    let q = min(d / r, 1.0);\n    let n = vec3f(in.offset.x / r, in.offset.y / r, sqrt(max(0.0, 1.0 - q * q)));\n    let l = normalize(vec3f(-0.45, 0.55, 0.7));\n    let lambert = max(dot(n, l), 0.0);\n    let shaded = rgb * (0.62 + 0.45 * lambert) + vec3f(pow(lambert, 18.0) * 0.28);\n    rgb = mix(rgb, shaded, smoothstep(1.5, 3.5, r));\n  }\n  if (alpha <= 0.004) { discard; }\n  if (u.light.w > 0.5) {\n    // additive light fades with the distance\n    alpha = alpha * (1.0 - in.fog);\n  } else {\n    rgb = mix(rgb, u.fog.rgb, in.fog);\n  }\n  alpha = alpha * in.coverage * in.color.a * u.params.x;\n  return vec4f(rgb * alpha, alpha);\n}\n";
 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 {