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

package/src/shaders/pointMark.iface.generated.ts

@@ -1,15 +1,17 @@
 // AUTO-GENERATED by packages/shader-tools/src/shader-codegen from pointMark.slang.
 // Do not edit. Run `pnpm gen:shaders` to regenerate.
 
-import type { VertexAttributeLayout, ShaderBinding } from '@jbrowse/render-core/hal'
+import type { VertexAttributeLayout, ShaderBinding, TextureBinding } from '@jbrowse/render-core/hal'
 
 export const BINDINGS: readonly ShaderBinding[] = [
   { index: 1, kind: 'uniform', name: 'u' },
+  { index: 2, kind: 'texture', name: 'colorRamp' },
+  { index: 3, kind: 'sampler', name: 'colorRamp' },
 ]
 
 export const VERTS_PER_INSTANCE = 6
 
-export const UNIFORMS_SIZE_BYTES = 48
+export const UNIFORMS_SIZE_BYTES = 64
 
 // Word indices into a Float32Array view over the uniform buffer.
 export const UNIFORM_OFFSET_F32 = {
@@ -17,10 +19,18 @@ export const UNIFORM_OFFSET_F32 = {
   canvasHeight: 3,
   domainMin: 4,
   domainMax: 5,
-  zero: 6,
-  viewportWidth: 7,
-  radiusPx: 8,
-  devicePixelRatio: 9,
+  rampMin: 8,
+  rampMax: 9,
+  zero: 10,
+  viewportWidth: 11,
+  radiusPx: 12,
+  devicePixelRatio: 13,
+} as const
+
+// Word indices into a Int32Array view over the uniform buffer.
+export const UNIFORM_OFFSET_I32 = {
+  valueScaleType: 6,
+  rampMode: 7,
 } as const
 
 
@@ -29,6 +39,10 @@ export interface Uniforms {
   canvasHeight: number
   domainMin: number
   domainMax: number
+  valueScaleType: number
+  rampMode: number
+  rampMin: number
+  rampMax: number
   zero: number
   viewportWidth: number
   radiusPx: number
@@ -37,16 +51,21 @@ export interface Uniforms {
 
 export function writeUniforms(buf: ArrayBuffer, uniforms: Uniforms) {
   const f32 = new Float32Array(buf)
+  const i32 = new Int32Array(buf)
   f32[0] = uniforms.bpRangeX[0]
   f32[1] = uniforms.bpRangeX[1]
   f32[2] = uniforms.bpRangeX[2]
   f32[3] = uniforms.canvasHeight
   f32[4] = uniforms.domainMin
   f32[5] = uniforms.domainMax
-  f32[6] = uniforms.zero
-  f32[7] = uniforms.viewportWidth
-  f32[8] = uniforms.radiusPx
-  f32[9] = uniforms.devicePixelRatio
+  i32[6] = uniforms.valueScaleType
+  i32[7] = uniforms.rampMode
+  f32[8] = uniforms.rampMin
+  f32[9] = uniforms.rampMax
+  f32[10] = uniforms.zero
+  f32[11] = uniforms.viewportWidth
+  f32[12] = uniforms.radiusPx
+  f32[13] = uniforms.devicePixelRatio
 }
 
 export const INSTANCE_STRIDE_BYTES = 20
@@ -144,3 +163,8 @@ export function getInstanceGlyph(u32: Uint32Array, i: number) {
 export function setInstanceGlyph(u32: Uint32Array, i: number, v: number) {
   u32[i * INSTANCE_STRIDE_WORDS + 4] = v
 }
+
+// Combined `Sampler2D` bindings. Texture unit indices start at 0.
+export const TEXTURES: readonly [TextureBinding, ...TextureBinding[]] = [
+  { textureBinding: 2, samplerBinding: 3, glTextureUnit: 0, glUniformName: 'u_colorRamp', filter: 'linear' },
+]

package/src/shaders/pointMark.js.generated.ts

@@ -16,10 +16,51 @@ function _min(a: number, b: number) {
   return b < a || Number.isNaN(a) ? b : a
 }
 
+function symlogTransform(x: number, c: number): number {
+  return ((((Math.sign(x)) | 0)) * Math.log((1.0 + Math.abs((x / c)))))
+}
+
+function normalizeScore(score: number, domainMin: number, domainMax: number, scaleType: number, symlogConstant: number): number {
+  if ((scaleType == 2)) {
+    let tMin = symlogTransform(domainMin, symlogConstant)
+    let tRange = (symlogTransform(domainMax, symlogConstant) - tMin)
+    if ((tRange <= 0.0)) {
+      return 0.0
+    }
+    return _clamp(((symlogTransform(score, symlogConstant) - tMin) / tRange), 0.0, 1.0)
+  }
+  if ((scaleType == 1)) {
+    let floorV: number
+    if ((domainMin > 0.0)) {
+      floorV = domainMin
+    } else {
+      floorV = 1.0
+    }
+    let logMin = Math.log2(floorV)
+    let logRange = (Math.log2(_max(domainMax, floorV)) - logMin)
+    if ((logRange <= 0.0)) {
+      return 0.0
+    }
+    return _clamp(((Math.log2(_max(score, floorV)) - logMin) / logRange), 0.0, 1.0)
+  }
+  let range = (domainMax - domainMin)
+  if ((range <= 0.0)) {
+    return 0.0
+  }
+  return _clamp(((score - domainMin) / range), 0.0, 1.0)
+}
+
 export function valueToYPx(value: number, domainMin: number, domainMax: number, h: number): number {
   return ((1.0 - _clamp(((value - domainMin) / _max((domainMax - domainMin), 9.99999997475242708e-07)), 0.0, 1.0)) * h)
 }
 
+export function valueToYPxScaled(value: number, domainMin: number, domainMax: number, h: number, scaleType: number): number {
+  if ((scaleType == 1)) {
+    return ((1.0 - normalizeScore(value, domainMin, domainMax, 1, 1.0)) * h)
+  }
+  return valueToYPx(value, domainMin, domainMax, h)
+}
+
 export function pointDrawsBar(spanPx: number, radiusPx: number): boolean {
   return (spanPx > (radiusPx * 2.0))
 }

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, pointDrawsBar
+//! 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,34 +47,12 @@ 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.
-//
-// `//! 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;
-}
-
 // 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.
@@ -121,7 +110,7 @@ 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).
@@ -131,7 +120,7 @@ VsOut vs_main(PointMarkInstance inst, uint vid : SV_VertexID) {
   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.
     //

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);
+}