minerva-design 1.3.0 → 1.5.0

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

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

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

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

@@ -0,0 +1,25 @@
+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;
+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 {
+    vertex: string;
+    fragment: string;
+}
+/** GLSL programs of the three primitives for WebGL (1) or WebGL2 */
+export declare const glslPrograms: (version: 1 | 2) => {
+    points: GlslSource;
+    mesh: GlslSource;
+    lines: GlslSource;
+};
+/** Attribute names of every program, bound to locations 0, 1, ... */
+export declare const GLSL_ATTRIBUTES: {
+    readonly points: readonly ["a_corner", "a_pos", "a_size", "a_color"];
+    readonly mesh: readonly ["a_pos", "a_normal", "a_color"];
+    readonly lines: readonly ["a_corner", "a_a", "a_b", "a_color"];
+};

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

@@ -0,0 +1,25 @@
+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;
+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 {
+    vertex: string;
+    fragment: string;
+}
+/** GLSL programs of the three primitives for WebGL (1) or WebGL2 */
+export declare const glslPrograms: (version: 1 | 2) => {
+    points: GlslSource;
+    mesh: GlslSource;
+    lines: GlslSource;
+};
+/** Attribute names of every program, bound to locations 0, 1, ... */
+export declare const GLSL_ATTRIBUTES: {
+    readonly points: readonly ["a_corner", "a_pos", "a_size", "a_color"];
+    readonly mesh: readonly ["a_pos", "a_normal", "a_color"];
+    readonly lines: readonly ["a_corner", "a_a", "a_b", "a_color"];
+};

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

@@ -0,0 +1,210 @@
+import { writesDepth as e } from "./render-types.js";
+//#region src/engine/three-d/shaders.ts
+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 = "\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", i = `${r}
+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
+fn vs(
+  @builtin(vertex_index) vi: u32,
+  @location(0) pos: vec3f,
+  @location(1) size: f32,
+  @location(2) color: vec4f,
+) -> Out {
+  var out: Out;
+  let corner = vec2f(f32(vi & 1u), f32(vi >> 1u)) * 2.0 - 1.0;
+  let clip = u.viewProj * vec4f(pos, 1.0);
+  var factor = 1.0;
+  if (u.params.y > 0.5 && u.viewport.w < 0.5) {
+    factor = clamp(u.params.z / max(clip.w, 1e-6), 0.5, 2.0);
+  }
+  let 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);
+  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}
+struct Out {
+  @builtin(position) position: vec4f,
+  @location(0) world: vec3f,
+  @location(1) normal: vec3f,
+  @location(2) color: vec4f,
+};
+
+@vertex
+fn vs(
+  @location(0) pos: vec3f,
+  @location(1) normal: vec3f,
+  @location(2) color: vec4f,
+) -> Out {
+  var out: Out;
+  out.position = toWebGpuDepth(u.viewProj * vec4f(pos, 1.0));
+  out.world = pos;
+  out.normal = normal;
+  out.color = color;
+  return out;
+}
+
+@fragment
+fn fs(in: Out) -> @location(0) vec4f {
+  var n = normalize(in.normal);
+  let v = normalize(u.eye.xyz - in.world);
+  if (dot(n, v) < 0.0) { n = -n; }
+  let l = u.light.xyz;
+  let diffuse = max(dot(n, l), 0.0);
+  let h = normalize(l + v);
+  let specular = pow(max(dot(n, h), 0.0), u.material.w) * u.material.z;
+  let rgb = in.color.rgb * (u.material.x + u.material.y * diffuse) + vec3f(specular);
+  let alpha = in.color.a * u.params.x;
+  return vec4f(rgb * alpha, alpha);
+}
+`, o = `${r}
+struct Out {
+  @builtin(position) position: vec4f,
+  @location(0) across: f32,
+  @location(1) color: vec4f,
+};
+
+@vertex
+fn vs(
+  @builtin(vertex_index) vi: u32,
+  @location(0) a: vec3f,
+  @location(1) b: vec3f,
+  @location(2) color: vec4f,
+) -> Out {
+  var out: Out;
+  let corner = vec2f(f32(vi & 1u), f32(vi >> 1u));
+  let ca = u.viewProj * vec4f(a, 1.0);
+  let cb = u.viewProj * vec4f(b, 1.0);
+  let halfSize = u.viewport.xy * 0.5;
+  let sa = ca.xy / ca.w * halfSize;
+  let sb = cb.xy / cb.w * halfSize;
+  var dir = sb - sa;
+  let len = length(dir);
+  dir = select(vec2f(1.0, 0.0), dir / len, len > 1e-6);
+  let normal = vec2f(-dir.y, dir.x);
+  let w = max(0.5, u.params.y * u.viewport.z * 0.5) + 0.5;
+  let clip = select(ca, cb, corner.x > 0.5);
+  let side = corner.y * 2.0 - 1.0;
+  let pixel = select(sa, sb, corner.x > 0.5) + dir * (corner.x * 2.0 - 1.0) * w + normal * side * w;
+  let z = clip.z - u.eye.w * clip.w;
+  out.position = toWebGpuDepth(vec4f(pixel / halfSize * clip.w, z, clip.w));
+  out.across = side * w;
+  out.color = color;
+  return out;
+}
+
+@fragment
+fn fs(in: Out) -> @location(0) vec4f {
+  let core = u.params.y * u.viewport.z * 0.5;
+  let coverage = clamp(max(core, 0.5) + 0.5 - abs(in.across), 0.0, 1.0) * min(1.0, core * 2.0);
+  let alpha = coverage * in.color.a * u.params.x;
+  if (alpha <= 0.0) { discard; }
+  return vec4f(in.color.rgb * alpha, alpha);
+}
+`, s = "\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", c = "\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", l = "\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", u = "\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", d = "\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", f = "\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", p = "\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", m = "\n#ifdef GL_FRAGMENT_PRECISION_HIGH\nprecision highp float;\n#else\nprecision mediump float;\n#endif\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"
+	]
+};
+//#endregion
+export { _ as GLSL_ATTRIBUTES, o as WGSL_LINES, a as WGSL_MESH, i as WGSL_POINTS, g as glslPrograms, n as itemUniforms, e as writesDepth };
+
+//# sourceMappingURL=shaders.js.map