@jbrowse/render-core 5.0.0-beta.3 → 5.0.0-beta.7

package/src/shaders/pointMark.slang

@@ -7,12 +7,16 @@
 // All four are a 6-vertex quad; the fragment shader carves the shape.
 //! targets: wgsl, glsl
 //! export-consts: DIAMOND_GLYPH_SCALE, GLYPH_DISC, GLYPH_TRIANGLE, GLYPH_DIAMOND
-//! js-export: valueToYPx
+//! js-export: valueToYPx, valueToYPxScaled, pointDrawsBar
+// `valueToYPx` is `valueScale`'s; it is lifted here, once, for every consumer
+// of the scale — the bar shape's painter and hit test import this twin too.
 
 import antialias;
 import hpmath;
 import colorPack;
+import markColor;
 import pointGlyph;
+import valueScale;
 
 public static const uint VERTS_PER_INSTANCE = 6u;
 
@@ -29,6 +33,13 @@ struct Uniforms {
   float  canvasHeight;
   float  domainMin;
   float  domainMax;
+  // `scoreScale`'s scale-type vocabulary, for the declared y scale.
+  int    valueScaleType;
+  // `markColor`'s: 0 packs the instance's colour, 1 and 2 read its slot as a
+  // value through the ramp below.
+  int    rampMode;
+  float  rampMin;
+  float  rampMax;
   float  zero;
   float  viewportWidth;
   float  radiusPx;
@@ -36,32 +47,23 @@ struct Uniforms {
   float  devicePixelRatio;
 };
 [[vk::binding(1, 0)]] ConstantBuffer<Uniforms> u;
+[[vk::binding(2, 0)]] Sampler2D<float4> colorRamp;
 
 float bpToClipX(uint bp, Uniforms u) {
   return hpToClipX(hpSplitUint(bp), u.bpRangeX, u.zero);
 }
 
-// The shape's y scale: clamp into the domain, invert (a bigger value sits
-// higher), scale to the canvas. Linear only — a consumer that wants log
-// pre-transforms its values, which is what GWAS -log10 p already is.
+// Whether an instance draws as an extent bar rather than a glyph: its span has
+// to beat the glyph it would otherwise be, so a datum wider than its own marker
+// stops pretending to be a point.
 //
-// `//! js-export`ed because the Canvas2D painter AND the hit test run the JS
-// twin: a drift would move the grab target off the drawn glyph on the no-GPU
-// path only.
-//
-// max(range, 1e-6) guards a degenerate (min == max) domain from dividing by
-// zero. JS spelled that guard `|| 1`, and the two are NOT the same: `|| 1`
-// invents a phantom unit-wide domain, so with bounds pinned to a single value
-// a value half a unit above it drew half-way up the Canvas2D canvas while the
-// GPU clamped it to the top. Pinning a degenerate domain means everything above
-// it is off the top, which is what this does; the parity test pins the case.
-float valueToYPx(float value, float domainMin, float domainMax, float h) {
-  float norm = clamp(
-    (value - domainMin) / max(domainMax - domainMin, 1e-6),
-    0.0,
-    1.0,
-  );
-  return (1.0 - norm) * h;
+// `//! js-export`ed because this one decision is read in three places — the
+// vertex branch below, the painter's rect-vs-glyph fork and the hit test's
+// rect-vs-centre fork — and a display whose hit test took the other branch from
+// the draw would grab a bar at its midpoint. `rectDrawsOutline` and `arrowDraws`
+// are the same lift for the same reason.
+bool pointDrawsBar(float spanPx, float radiusPx) {
+  return spanPx > radiusPx * 2.0;
 }
 
 struct VsOut {
@@ -73,10 +75,6 @@ struct VsOut {
   nointerpolation float shape : TEXCOORD1;
 };
 
-// Solid ink each side of a bar's genomic span, in CSS px, so a run of adjacent
-// bars abuts. SHAPE_BAR's fragment coverage is a constant 1.
-static const float BAR_OVERDRAW_PX = 1.0;
-
 // Shape discriminators for the fragment shader. SMALL_POINT_MAX_DIAMETER and
 // the disc SDF come from the shared pointGlyph module so they stay in lockstep
 // with wiggle.slang.
@@ -112,24 +110,28 @@ VsOut vs_main(PointMarkInstance inst, uint vid : SV_VertexID) {
 
   float startClipX = bpToClipX(inst.x, u);
   float endClipX = bpToClipX(inst.x2, u);
-  float yPx = valueToYPx(inst.y, u.domainMin, u.domainMax, u.canvasHeight);
+  float yPx = valueToYPxScaled(inst.y, u.domainMin, u.domainMax, u.canvasHeight, u.valueScaleType);
   float centerClipY = yPxToClipY(yPx, u.canvasHeight);
 
   // Genomic span in CSS px (clip width spans -1..1 across viewportWidth).
   // abs() because reversal is baked into bpRangeX (negated length), so
   // endClipX < startClipX on reversed regions — matches wiggle.slang.
   float spanPx = clipLenToPx(abs(endClipX - startClipX), u.viewportWidth);
-  bool isBar = spanPx > u.radiusPx * 2.0;
+  bool isBar = pointDrawsBar(spanPx, u.radiusPx);
 
   VsOut o;
-  o.color = unpackRGBA(inst.color);
+  o.color = markInstanceColor(colorRamp, inst.color, u.rampMode, u.rampMin, u.rampMax);
   if (isBar) {
     // Horizontal bar from x→x2, height 2*radiusPx px, centered on the value.
-    float overdrawClipX = pxToClipLen(BAR_OVERDRAW_PX, u.viewportWidth);
-    // min/max so a reversed region (endClipX < startClipX) still spans the full
-    // bar extent instead of drawing an inverted quad — matches wiggle.slang.
-    float x = xZero ? (min(startClipX, endClipX) - overdrawClipX)
-                    : (max(startClipX, endClipX) + overdrawClipX);
+    //
+    // NO SEAM PAD, and this reverses a deliberate one: `c7ff9d459d` kept the
+    // 1 px overdraw on the claim that abutting bars leave hairline gaps without
+    // it (the claim is that commit's, not the ADR-098 document's).
+    // Measured against a fixture built to test that (38 of 39 boundaries on a
+    // shared pixel row), padded and unpadded have the same interior gap
+    // columns — none opens. A hairline at a fractional `fillRect` edge is a
+    // Canvas2D problem and takes a Canvas2D pad; see `spanMark`'s `seamPx`.
+    float x = xZero ? min(startClipX, endClipX) : max(startClipX, endClipX);
     float halfBandPx = u.radiusPx;
     float y = centerClipY + pxToClipLen(local.y * halfBandPx, u.canvasHeight);
     o.position = float4(x, y, 0.0, 1.0);

package/src/shaders/scoreScale.generated.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED by packages/shader-tools/src/shader-codegen from scoreScale.slang.
+// Do not edit. Run `pnpm gen:shaders` to regenerate.
+
+export const SCALE_TYPE_LOG = 1
+
+export const SCALE_TYPE_SYMLOG = 2

package/src/shaders/scoreScale.slang

@@ -16,6 +16,7 @@
 //
 // `SCALE_TYPE_LINEAR` is deliberately absent: it is "neither of these", and a
 // third constant would be a value nothing compares against.
+//! export-consts: SCALE_TYPE_LOG, SCALE_TYPE_SYMLOG
 //! js-export: normalizeScore
 //! js-skip: symlogTransform — the JS twin (wiggle-core normalize.ts) spells it Math.log1p, which is accurate near zero where the shader's log(1.0 + x) is not; a generated twin would be a faithful copy of the worse of the two. What both backends must agree on is normalizeScore, which is exported and swept by normalizeScoreParity.test.ts
 module scoreScale;

package/src/shaders/valueScale.slang

@@ -0,0 +1,52 @@
+// The linear value → canvas-y scale a quantitative mark places its datum
+// through: clamp into the domain, invert (a bigger value sits higher), scale to
+// the canvas. `valueToYPx` is the linear scale on its own, which is what a
+// consumer with no scale type of its own reads (Manhattan pins linear, and its
+// -log10 p is already a pre-transform); `valueToYPxScaled` below takes a
+// declared one.
+//
+// Two shapes compose it (ADR-095): `pointMark` reads it for a glyph centre and
+// `barMark` for both cuts of a bar. Each keeps its own anchor (ADR-097) — a
+// point centres on the value, a bar grows from `origin` to it — so only the
+// scale lives here.
+//
+// max(range, 1e-6) guards a degenerate (min == max) domain from dividing by
+// zero. JS spelled that guard `|| 1`, and the two are NOT the same: `|| 1`
+// invents a phantom unit-wide domain, so with bounds pinned to a single value
+// a value half a unit above it drew half-way up the Canvas2D canvas while the
+// GPU clamped it to the top. Pinning a degenerate domain means everything above
+// it is off the top, which is what this does; the parity test pins the case.
+//
+// A declared log scale takes the log arm of `scoreScale`'s `normalizeScore`,
+// the normalizer wiggle and the coverage band are already placed by, so a mark
+// display's axis ticks and its shader agree by construction. The linear arm
+// stays this module's own: `normalizeScore` answers 0 on a degenerate domain
+// and this answers 1, and that difference is a pinned cross-backend value
+// (ADR-097).
+//
+// The JS twin is lifted by `pointMark.slang`'s `//! js-export` rather than
+// here, the way hpmath's `expandToMinWidthPx` reaches JS through
+// `coverageBar.slang`: one twin, in the generated module every consumer of the
+// scale already imports.
+module valueScale;
+
+import scoreScale;
+
+public float valueToYPx(float value, float domainMin, float domainMax, float h) {
+  float norm = clamp(
+    (value - domainMin) / max(domainMax - domainMin, 1e-6),
+    0.0,
+    1.0,
+  );
+  return (1.0 - norm) * h;
+}
+
+// The same placement under a declared scale type: `SCALE_TYPE_LOG` reads the
+// value through `scoreScale`'s log arm, anything else through the linear one
+// above.
+public float valueToYPxScaled(float value, float domainMin, float domainMax, float h, int scaleType) {
+  if (scaleType == SCALE_TYPE_LOG) {
+    return (1.0 - normalizeScore(value, domainMin, domainMax, SCALE_TYPE_LOG, 1.0)) * h;
+  }
+  return valueToYPx(value, domainMin, domainMax, h);
+}