minerva-design 1.4.0 → 1.6.0

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","drawRank","drawOrder","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  /** Scale of the light of the additive points (tone mapped when possible) */\n  exposure: number;\n}\n\nexport interface Renderer3D {\n  readonly kind: ChartRendererKind;\n  readonly canvas: HTMLCanvasElement;\n  /**\n   * Blends the transparent items in any order (weighted blended\n   * order-independent transparency): they need no depth sorting\n   */\n  readonly orderIndependent?: boolean;\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 * Draw passes of the items: 0 opaque meshes, 1 opaque points, 2 blended\n * items (transparent meshes and points: order independent, or sorted back to\n * front together), 3 lines (wireframes and contours stay visible over\n * transparent surfaces)\n */\nexport const drawRank = (item: Item3D): number =>\n  item.kind === \"lines\"\n    ? 3\n    : !writesDepth(item)\n      ? 2\n      : item.kind === \"mesh\"\n        ? 0\n        : 1;\n\n/**\n * Order of the draws (`drawRank`). Stable: items of a rank keep their order\n * (the back-to-front order of the depth sorter for the blended items).\n */\nexport const drawOrder = (items: readonly Item3D[]): Item3D[] =>\n  items\n    .map((item, i) => ({ item, i, r: drawRank(item) }))\n    .sort((a, b) => a.r - b.r || a.i - b.i)\n    .map((e) => e.item);\n"],"mappings":"AAkHA,IAAaA,KAAe,MACtBC,EAAK,UAAU,IAAU,KACzBA,EAAK,SAAS,SAAe,CAACA,EAAK,cACnCA,EAAK,SAAS,YACT,CAACA,EAAK,YAAYA,EAAK,UAAA,GAUrBC,KAAY,MACvBD,EAAK,SAAS,UACV,IACCD,EAAYC,CAAI,IAEfA,EAAK,SAAS,SACZ,IACA,IAHF,GASKE,KAAa,MACxBC,EACG,KAAK,GAAM,OAAO;CAAE;CAAM;CAAG,GAAGF,EAASD,CAAI;AAAE,EAAE,CAAC,CAClD,MAAM,GAAG,MAAMI,EAAE,IAAIC,EAAE,KAAKD,EAAE,IAAIC,EAAE,CAAC,CAAC,CACtC,KAAK,MAAM,EAAE,IAAI"}

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"),t=require("./oit.cjs");var n=(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),r=(e,t,r)=>{let i=e.kind===`points`?+!!e.perspective:e.kind===`lines`?e.width:0;return n(r,t.viewProj,[t.width,t.height,t.dpr,+!!t.orthographic],[t.eye[0],t.eye[1],t.eye[2],e.kind===`lines`?e.bias:e.kind===`points`?e.style??0:0],[t.light[0],t.light[1],t.light[2],e.kind===`points`&&e.additive?1:0],t.lighting,[e.opacity,i,t.distance,t.radius],[t.fog[0],t.fog[1],t.fog[2],t.exposure])},i=`
 struct U {
   viewProj: mat4x4f,
   viewport: vec4f,
@@ -18,13 +18,14 @@ 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}
+${t.WGSL_OIT}`,a=`${i}
 struct Out {
   @builtin(position) position: vec4f,
   @location(0) offset: vec2f,
   @location(1) radius: f32,
   @location(2) color: vec4f,
   @location(3) fog: f32,
+  @location(4) coverage: f32,
 };
 
 @vertex
@@ -41,34 +42,62 @@ 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.fog = depthCue(pos);
+  out.coverage = min(1.0, raw * raw / (radius * radius));
   return out;
 }
 
-@fragment
-fn fs(in: Out) -> @location(0) vec4f {
+fn shade(in: Out) -> 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; }
+  let fog = in.fog * 0.45;
+  if (u.light.w > 0.5) {
+    // additive light fades with the distance
+    alpha = alpha * (1.0 - fog);
+    rgb = rgb * u.fog.w;
+  } else {
+    rgb = mix(rgb, u.fog.rgb, fog);
+  }
+  alpha = alpha * in.coverage * in.color.a * u.params.x;
   return vec4f(rgb * alpha, alpha);
 }
-`,a=`${r}
+
+@fragment
+fn fs(in: Out) -> @location(0) vec4f {
+  return shade(in);
+}
+
+@fragment
+fn fsOit(in: Out) -> Oit {
+  return oit(shade(in), in.fog);
+}
+`,o=`${i}
 struct Out {
   @builtin(position) position: vec4f,
   @location(0) world: vec3f,
@@ -90,8 +119,7 @@ fn vs(
   return out;
 }
 
-@fragment
-fn fs(in: Out) -> @location(0) vec4f {
+fn shade(in: Out) -> vec4f {
   var n = normalize(in.normal);
   let v = normalize(u.eye.xyz - in.world);
   if (dot(n, v) < 0.0) { n = -n; }
@@ -103,7 +131,17 @@ fn fs(in: Out) -> @location(0) vec4f {
   let alpha = in.color.a * u.params.x;
   return vec4f(rgb * alpha, alpha);
 }
-`,o=`${r}
+
+@fragment
+fn fs(in: Out) -> @location(0) vec4f {
+  return shade(in);
+}
+
+@fragment
+fn fsOit(in: Out) -> Oit {
+  return oit(shade(in), depthCue(in.world));
+}
+`,s=`${i}
 struct Out {
   @builtin(position) position: vec4f,
   @location(0) across: f32,
@@ -147,7 +185,7 @@ fn fs(in: Out) -> @location(0) vec4f {
   if (alpha <= 0.0) { discard; }
   return vec4f(in.color.rgb * alpha, alpha);
 }
-`,s=`
+`,c=`
 uniform mat4 u_viewProj;
 uniform vec4 u_viewport;
 uniform vec4 u_eye;
@@ -155,7 +193,7 @@ uniform vec4 u_light;
 uniform vec4 u_material;
 uniform vec4 u_params;
 uniform vec4 u_fog;
-`,c=`
+`,l=`
 attribute vec2 a_corner;
 attribute vec3 a_pos;
 attribute float a_size;
@@ -164,6 +202,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,37 +210,55 @@ 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;
   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;
+  v_fog = clamp((length(a_pos - u_eye.xyz) - near) / (2.0 * u_params.w), 0.0, 1.0);
+  v_coverage = min(1.0, raw * raw / (radius * radius));
 }
-`,l=`
+`,u=`
 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;
-  FRAG = vec4(rgb * alpha, alpha);
+  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;
+  float fog = v_fog * 0.45;
+  if (u_light.w > 0.5) {
+    alpha = alpha * (1.0 - fog);
+    rgb = rgb * u_fog.w;
+  } else {
+    rgb = mix(rgb, u_fog.rgb, fog);
+  }
+  alpha = alpha * v_coverage * v_color.a * u_params.x;
+  EMIT(vec4(rgb * alpha, alpha), v_fog);
 }
-`,u=`
+`,d=`
 attribute vec3 a_pos;
 attribute vec3 a_normal;
 attribute vec4 a_color;
@@ -214,7 +271,7 @@ void main() {
   v_normal = a_normal;
   v_color = a_color;
 }
-`,d=`
+`,f=`
 varying vec3 v_world;
 varying vec3 v_normal;
 varying vec4 v_color;
@@ -228,9 +285,11 @@ void main() {
   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);
+  float near = u_params.z - u_params.w;
+  float depth = (length(v_world - u_eye.xyz) - near) / (2.0 * u_params.w);
+  EMIT(vec4(rgb * alpha, alpha), depth);
 }
-`,f=`
+`,p=`
 attribute vec2 a_corner;
 attribute vec3 a_a;
 attribute vec3 a_b;
@@ -256,7 +315,7 @@ void main() {
   v_across = side * w;
   v_color = a_color;
 }
-`,p=`
+`,m=`
 varying float v_across;
 varying vec4 v_color;
 void main() {
@@ -264,13 +323,15 @@ void main() {
   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);
+  EMIT(vec4(v_color.rgb * alpha, alpha), 0.0);
 }
-`,m=`
+`,h=`
 #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;
+`,g=(e,n,r,i=!1)=>r===2?{vertex:`#version 300 es\n#define attribute in\n#define varying out\n${c}${e}`,fragment:`#version 300 es\nprecision highp float;\n#define varying in\n${c}${i?t.GLSL_OIT:`out vec4 fragColor;
+#define EMIT(c, d) fragColor = (c)
+`}${n}`}:{vertex:`${c}${e}`,fragment:`${h}#define EMIT(c, d) gl_FragColor = (c)\n${c}${n}`},_=e=>({points:g(l,u,e),mesh:g(d,f,e),lines:g(p,m,e)}),v=()=>({points:g(l,u,2,!0),mesh:g(d,f,2,!0)}),y={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=y,exports.WGSL_LINES=s,exports.WGSL_MESH=o,exports.WGSL_POINTS=a,exports.glslOitPrograms=v,exports.glslPrograms=_,exports.itemUniforms=r,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":["WGSL_OIT","GLSL_OIT","require_render_types","require_oit","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","oit","fs","glslPrograms","glslOitPrograms","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), exposure of the\n//             additive light\n//\n// Points and meshes have a second fragment entry point writing the targets\n// of the order-independent transparency (`oit.ts`): `fsOit` in WGSL, the\n// `oit` variant of the GLSL programs (WebGL2).\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 { GLSL_OIT, WGSL_OIT } from \"./oit\";\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], frame.exposure],\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${WGSL_OIT}`;\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);\n  out.coverage = min(1.0, raw * raw / (radius * radius));\n  return out;\n}\n\nfn shade(in: Out) -> 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  let fog = in.fog * 0.45;\n  if (u.light.w > 0.5) {\n    // additive light fades with the distance\n    alpha = alpha * (1.0 - fog);\n    rgb = rgb * u.fog.w;\n  } else {\n    rgb = mix(rgb, u.fog.rgb, fog);\n  }\n  alpha = alpha * in.coverage * in.color.a * u.params.x;\n  return vec4f(rgb * alpha, alpha);\n}\n\n@fragment\nfn fs(in: Out) -> @location(0) vec4f {\n  return shade(in);\n}\n\n@fragment\nfn fsOit(in: Out) -> Oit {\n  return oit(shade(in), in.fog);\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\nfn shade(in: Out) -> 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@fragment\nfn fs(in: Out) -> @location(0) vec4f {\n  return shade(in);\n}\n\n@fragment\nfn fsOit(in: Out) -> Oit {\n  return oit(shade(in), depthCue(in.world));\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);\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  float fog = v_fog * 0.45;\n  if (u_light.w > 0.5) {\n    alpha = alpha * (1.0 - fog);\n    rgb = rgb * u_fog.w;\n  } else {\n    rgb = mix(rgb, u_fog.rgb, fog);\n  }\n  alpha = alpha * v_coverage * v_color.a * u_params.x;\n  EMIT(vec4(rgb * alpha, alpha), v_fog);\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  float near = u_params.z - u_params.w;\n  float depth = (length(v_world - u_eye.xyz) - near) / (2.0 * u_params.w);\n  EMIT(vec4(rgb * alpha, alpha), depth);\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  EMIT(vec4(v_color.rgb * alpha, alpha), 0.0);\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 = (\n  vs: string,\n  fs: string,\n  version: 1 | 2,\n  oit = false,\n): 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\\n${GLSL_UNIFORMS}${\n          oit\n            ? GLSL_OIT\n            : \"out vec4 fragColor;\\n#define EMIT(c, d) fragColor = (c)\\n\"\n        }${fs}`,\n      }\n    : {\n        vertex: `${GLSL_UNIFORMS}${vs}`,\n        fragment: `${PRECISION}#define EMIT(c, d) gl_FragColor = (c)\\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/**\n * Variants of the points and meshes writing the targets of the\n * order-independent transparency (WebGL2)\n */\nexport const glslOitPrograms = () => ({\n  points: glsl(GLSL_POINTS_VS, GLSL_POINTS_FS, 2, true),\n  mesh: glsl(GLSL_MESH_VS, GLSL_MESH_FS, 2, true),\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":"6DAiCA,IAAMI,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,GAAIA,EAAM,QAAQ,CAC3D,CACF,EAIMC,EAA2B;;;;;;;;;;;;;;;;;;;;EAoB/BjB,EAAAA,WAEWkB,EAAyB,GAAGD,EAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiF1CE,EAAuB,GAAGF,EAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8CxCG,EAAwB,GAAGH,EAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgDhDI,EAAgB;;;;;;;;EAUhBC,EAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgCjBC,EAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqCjBC,EAAe;;;;;;;;;;;;;EAefC,EAAe;;;;;;;;;;;;;;;;;;EAoBfC,EAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BhBC,EAAgB;;;;;;;;;;EAYhBC,EAAY;;;;;;EAaZC,GACJ,EACA,EACA,EACA,EAAM,KAENC,IAAY,EACR,CACE,OAAQ,+DAA+DT,IAAgBU,IACvF,SAAU,gEAAgEV,IACxEW,EACI/B,EAAAA,SACA;;IACHgC,GACL,EACA,CACE,OAAQ,GAAGZ,IAAgBU,IAC3B,SAAU,GAAGH,EAAU,yCAAyCP,IAAgBY,GAClF,EAGOC,EAAgB,IAAoB,CAC/C,OAAQL,EAAKP,EAAgBC,EAAgBO,CAAO,EACpD,KAAMD,EAAKL,EAAcC,EAAcK,CAAO,EAC9C,MAAOD,EAAKH,EAAeC,EAAeG,CAAO,CACnD,GAMaK,OAAyB,CACpC,OAAQN,EAAKP,EAAgBC,EAAgB,EAAG,EAAI,EACpD,KAAMM,EAAKL,EAAcC,EAAc,EAAG,EAAI,CAChD,GAGaW,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,13 +1,12 @@
 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_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 declare const WGSL_POINTS: string;
+export declare const WGSL_MESH: string;
+export declare const WGSL_LINES: string;
 export interface GlslSource {
     vertex: string;
     fragment: string;
@@ -18,6 +17,14 @@ export declare const glslPrograms: (version: 1 | 2) => {
     mesh: GlslSource;
     lines: GlslSource;
 };
+/**
+ * Variants of the points and meshes writing the targets of the
+ * order-independent transparency (WebGL2)
+ */
+export declare const glslOitPrograms: () => {
+    points: GlslSource;
+    mesh: 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"];

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

@@ -1,13 +1,12 @@
 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_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 declare const WGSL_POINTS: string;
+export declare const WGSL_MESH: string;
+export declare const WGSL_LINES: string;
 export interface GlslSource {
     vertex: string;
     fragment: string;
@@ -18,6 +17,14 @@ export declare const glslPrograms: (version: 1 | 2) => {
     mesh: GlslSource;
     lines: GlslSource;
 };
+/**
+ * Variants of the points and meshes writing the targets of the
+ * order-independent transparency (WebGL2)
+ */
+export declare const glslOitPrograms: () => {
+    points: GlslSource;
+    mesh: 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"];