@jbrowse/render-core 4.3.0

package/src/shaders/coverageBand.slang

@@ -0,0 +1,276 @@
+// Shared coverage-band primitive: the uniform block, the band geometry and the
+// depth-normalizer every mark in a coverage histogram is placed by.
+//
+// Two displays draw exactly this band — the alignments pileup's depth/SNP/
+// modification/interbase strip and the MAF display's depth/SNP/interbase strip
+// — off the same worker-packed buffers (`@jbrowse/alignments-core`'s
+// `packCoverageBinsForGpu`, `computeSNPCoverage`, `computeInterbaseCoverage`).
+// The five entry-point shaders beside this file are the only copy of each pass,
+// so a change to a bar's height rule lands in both displays by construction.
+//
+// It shipped as the alignments plugin's own passes over its plugin-wide
+// `Uniforms` struct, with the MAF band on Canvas2D only. Lifting them here cost
+// the alignments renderer one extra UBO write per band per block (it already
+// does the same for its arc band) and bought a second consumer that cannot
+// drift: MAF's band is now the same five draws, not a second reading of them.
+//
+// Colors arrive as packed u32 ABGR (one slot each, no std140 vec3 padding) and
+// are read with `unpackRGBA(u.colorX).xyz` from colorPack.
+//! export-consts: TRIANGLE_HW, TRIANGLE_H
+// The band's px-space decisions, lifted for the Canvas2D and SVG painters that
+// have to land on the same pixels (adr-051). They live in
+// @jbrowse/alignments-core because that is where those painters are, and it
+// cannot depend on a plugin — nor, being upstream of it, on this package.
+//! js-export: covEffectiveHeightPx, covBottomOffsetPx, normalizeDepthScalar
+//! js-export-out: packages/alignments-core/src/coverageBandLayout.generated.ts
+//! consts-out: packages/alignments-core/src/indicatorTriangle.generated.ts
+//! js-skip: covExpandMinWidthX — a 1 CSS px floor over hpmath's expandToMinWidthX, which is where the rule and the reason it has no Canvas2D twin are recorded
+module coverageBand;
+
+import colorPack;
+import hpmath;
+import scoreScale;
+
+public struct CoverageBandUniforms {
+  // HP-split bp range: hi = base-pair offset (high 20 bits), lo = fractional
+  // low 12 bits, len = visible span in bp. See hpmath.slang.
+  public float bpHi;
+  public float bpLo;
+  public float bpLen;
+  // Runtime 0.0 sentinel. HP math uses 1/hpZero to materialize +inf without the
+  // compiler folding the hi/lo combination. MUST always be uploaded as 0.0.
+  public float hpZero;
+
+  public float canvasW;
+  public float canvasH;
+
+  // The band box. `covTop` is the screen-pixel Y of the band's top edge: 0 for
+  // a band pinned to the canvas top, a scrolled offset for one that travels
+  // with a stacked section. `covYOffset` is the scalebar-label inset, reserved
+  // at BOTH ends — see covEffectiveHeightPx.
+  public float covHeight;
+  public float covYOffset;
+  public float covTop;
+
+  // The depth axis. `regionMaxDepth` is what the buffer's `relDepth` is a
+  // fraction of, so it is what recovers a raw depth; the domain is the display's
+  // autoscaled one, so a rescale needs no repack.
+  public float regionMaxDepth;
+  public float depthDomainMax;
+  public float depthDomainMin;
+  // symlog's linear-region width, already resolved from the domain on the JS
+  // side (see resolveSymlogConstant). Unread by the other two scales.
+  public float coverageSymlogConstant;
+
+  // Bin width in bp for the depth bars: 1 for per-bp coverage, wider once the
+  // producer downsamples.
+  public float binSize;
+  // Full-scale height in px of the interbase histogram — see
+  // `interbaseBarHeightPx`, which is the one rule the draw, the hit test and
+  // this uniform share.
+  public float interbaseHeight;
+  // Allele-fraction floor for the SNP segments: a segment whose `segHeight`
+  // (its share of THIS position's depth) is below this is folded away. 0 draws
+  // every mismatch. The depth bar underneath is not gated, so a hidden segment
+  // reads as reference rather than as a gap.
+  public float snpMinFreq;
+  public float reversed;
+
+  public int coverageScaleType; // 0 = linear, 1 = log2, 2 = symlog
+
+  public uint colorCoverage;
+  public uint colorBaseA;
+  public uint colorBaseC;
+  public uint colorBaseG;
+  public uint colorBaseT;
+  // Also what a non-A/C/G/T base takes, and the muted grey a palette collapse
+  // writes into all five. Resolved on the CPU so the shader has one lookup and
+  // no mode to branch on.
+  public uint colorBaseN;
+  // The band's own indicator variants (lightened in dark mode), distinct from
+  // the pileup's insertion/clip fills; see covClipKindColor.
+  public uint colorInsertionIndicator;
+  public uint colorSoftclipIndicator;
+  public uint colorHardclipIndicator;
+};
+
+// Coverage-band clip indicator triangle, in CSS px: half-width and height.
+// Four consumers depend on this one number: coverageIndicator.slang draws the
+// triangle, coverageInterbase.slang hangs its bars directly below one, and the
+// Canvas2D painter + hit test read it from `@jbrowse/alignments-core` — which
+// the `consts-out` directive above generates from these declarations, so the
+// cross-package copy can't drift either.
+public static const float TRIANGLE_HW = 3.5;
+public static const float TRIANGLE_H  = 4.5;
+
+// Shared vertex output for the band's four solid-fill passes. The indicator
+// pass carries a barycentric varying as well and declares its own.
+public struct CoverageVsOut {
+  public float4 position : SV_Position;
+  public float4 color    : COLOR0;
+};
+
+// Fold a vertex to the origin (degenerate, invisible), for an instance a gate
+// dropped. Folding rather than shrinking is what leaves the rest of the stack
+// where it was.
+public CoverageVsOut covDiscardVertex() {
+  CoverageVsOut o;
+  o.position = float4(0.0);
+  o.color = float4(0.0);
+  return o;
+}
+
+public float covBpToClipX(uint bp, CoverageBandUniforms u) {
+  return hpToClipX(hpSplitUint(bp), float3(u.bpHi, u.bpLo, u.bpLen), u.hpZero);
+}
+
+public float covFlipX(float x, CoverageBandUniforms u) {
+  return lerp(x, -x, u.reversed);
+}
+
+// Widen a [x1,x2] clip-space span to a minimum of 1 CSS pixel about its
+// MIDPOINT, so sub-pixel-narrow marks (a coverage bin, a 1bp SNP slice) stay
+// visible without sliding off the coordinate they report. The 1.0 is this
+// band's floor; hpmath's `expandToMinWidthX` is the rule.
+public float2 covExpandMinWidthX(float x1, float x2, float canvasWidth) {
+  return expandToMinWidthX(x1, x2, 1.0, canvasWidth);
+}
+
+// Clip-space position of one corner of a box mark: interpolate the
+// [x0,x1] x [yBot,yTop] clip box by the quadLocal() corner and apply the
+// reverse-strand X flip. Y args are (bottom, top) to match quadLocal's Y-up
+// local.y.
+public float4 covFlippedQuad(float x0, float x1, float yBot, float yTop,
+                             float2 local, CoverageBandUniforms u) {
+  return float4(covFlipX(lerp(x0, x1, local.x), u), lerp(yBot, yTop, local.y),
+                0.0, 1.0);
+}
+
+// The band's two px-space numbers, factored out of the clip-space conversions
+// below so `//! js-export` can lift them. `covYOffset` is the scalebar-label
+// inset, reserved at BOTH ends — hence the drawable height losing two of them
+// while the baseline loses one.
+//
+// `coverageLayout` in @jbrowse/alignments-core's coverageBandBox.ts is the
+// generated twin, read by the coverage bars, the SNP segments, the modification
+// segments and the y-axis ticks. Both backends measure every mark from these,
+// so disagreeing shifts the whole band rather than one glyph — visible only
+// against the other backend.
+//
+// Floored at 0 here, at the declaration, because a band shorter than its two
+// insets otherwise INVERTS rather than degrades: every mark is
+// `baseline - fraction * effectiveH`, so a negative height grows the depth
+// bars, the SNP segments stacked in them and the interbase bars DOWNWARD from a
+// baseline sitting near the band's top edge. `covHeight` reaches here unclamped
+// — a resize handle floors at 20 but a config slot declaring less is left where
+// it is — and 2 * covYOffset is 10, so any band under 10px drew upside down on
+// both backends.
+public float covEffectiveHeightPx(float covHeight, float covYOffset) {
+  return max(covHeight - 2.0 * covYOffset, 0.0);
+}
+
+// Distance from the band's top edge down to the bars' baseline.
+public float covBottomOffsetPx(float covHeight, float covYOffset) {
+  return covHeight - covYOffset;
+}
+
+public float covEffHeight(CoverageBandUniforms u) {
+  return covEffectiveHeightPx(u.covHeight, u.covYOffset);
+}
+
+// Clip-space Y of the band's top edge. Single source for where every
+// top-anchored mark (bars, SNP/mod segments, indicators, interbase histogram)
+// starts. covTop == 0 → clip-top (1.0), the pinned-band behavior; a stacked
+// section passes its scrolled top.
+public float covAreaTop(CoverageBandUniforms u) {
+  return yPxToClipY(u.covTop, u.canvasH);
+}
+
+public float covBottom(CoverageBandUniforms u) {
+  return covAreaTop(u)
+    - (covBottomOffsetPx(u.covHeight, u.covYOffset) / u.canvasH) * 2.0;
+}
+
+// Normalize a raw coverage depth to [0,1] over the domain [min, max], on the
+// current scale type — `scoreScale.slang`'s normalizer under the coverage
+// band's name for it.
+//
+// The name is what the alignments coverage reads it by: it is the scalar twin
+// of makeScoreNormalizer in packages/wiggle-core/src/normalize.ts, which is
+// what the Canvas2D coverage draws and the y-axis ticks go through, and
+// `coverageNormalizeParity.test.ts` pins all of those against each other. The
+// three branches themselves are no longer here — this band and the wiggle
+// renderer had a copy each and they had drifted (see scoreScale.slang).
+public float normalizeDepthScalar(float rawDepth, float domainMin, float domainMax, int scaleType, float symlogConstant) {
+  return normalizeScore(rawDepth, domainMin, domainMax, scaleType, symlogConstant);
+}
+
+// The uniform-block wrapper every pass calls. Recovers the raw depth from the
+// packed `relDepth` (= rawDepth / regionMaxDepth) and hands it to the scalar
+// above — the same product Canvas2D forms, rather than a round trip through the
+// domain. Multiplying by `regionMaxDepth / domainMax` and then by `domainMax`
+// cancels algebraically and does not cancel in floats: a domainMax of 0, which
+// `getNiceDomain` returns verbatim for a typed `Set max score` of 0, made the
+// first factor +inf and the product NaN, reaching `clamp(NaN, 0, 1)`.
+// Split in two so the scalar half can be `//! js-export`ed — the twin emitter
+// cannot carry a uniform struct across.
+public float covNormalizeDepth(float relDepth, CoverageBandUniforms u) {
+  float rawDepth = relDepth * u.regionMaxDepth;
+  return normalizeDepthScalar(
+    rawDepth, u.depthDomainMin, u.depthDomainMax, u.coverageScaleType,
+    u.coverageSymlogConstant);
+}
+
+// Bar height scale: maps relDepth to a clip-space height multiplier. Shared by
+// every stacked-segment pass so the formula can't drift between them.
+public float covBarScale(float relDepth, CoverageBandUniforms u) {
+  return covNormalizeDepth(relDepth, u) * covEffHeight(u) / u.canvasH * 2.0;
+}
+
+// Stacked-segment quad — the geometry of EVERY bar in the band. A `widthBp`-wide
+// rect whose bottom/top are the yOffset / yOffset+segHeight fractions of this
+// position's coverage bar (covBarScale(relDepth)).
+//
+// The three passes differ only in what they put in those parameters. The SNP and
+// modification segments are 1bp slices of a bar (widthBp 1, a partial y span);
+// the depth bar itself is the whole bar (widthBp = u.binSize, y span 0..1), and
+// coverageBar.slang open-coded it once — the same four calls in the same order,
+// so the band could shift under its own segments without anything catching it.
+// Passing `0.0, 1.0` is not a special case here, it is what "the whole bar"
+// spells.
+public float4 covSegQuad(uint position, uint widthBp, float yOffset,
+                         float segHeight, float relDepth, float2 local,
+                         CoverageBandUniforms u) {
+  float2 xx = covExpandMinWidthX(
+    covBpToClipX(position, u), covBpToClipX(position + widthBp, u), u.canvasW);
+  float bottom = covBottom(u);
+  float k = covBarScale(relDepth, u);
+  float segBot = bottom + yOffset * k;
+  float segTop = segBot + segHeight * k;
+  return covFlippedQuad(xx.x, xx.y, segBot, segTop, local, u);
+}
+
+// SNP segment fill. colorType encodes 1=A 2=C 3=G 4=T 5=N; 5 and any other type
+// take the dedicated N color. `snpColorForType` in @jbrowse/alignments-core is
+// the Canvas2D twin.
+public float3 covSnpColor(float ct, CoverageBandUniforms u) {
+  switch (int(ct)) {
+    case 1:  return unpackRGBA(u.colorBaseA).xyz;
+    case 2:  return unpackRGBA(u.colorBaseC).xyz;
+    case 3:  return unpackRGBA(u.colorBaseG).xyz;
+    case 4:  return unpackRGBA(u.colorBaseT).xyz;
+    default: return unpackRGBA(u.colorBaseN).xyz;
+  }
+}
+
+// Interbase mark fill, for both the histogram bars and the indicator triangles:
+// 1=insertion 2=softclip 3=hardclip, with anything else taking the insertion
+// color — the same fallback `drawIndicators`' lut takes for an out-of-range
+// kind. Nothing reaches that arm today (the interbase compute only ever emits
+// 1..3), which is exactly why the two spellings disagreeing would be invisible.
+public float3 covClipKindColor(float ct, CoverageBandUniforms u) {
+  int ci = int(ct);
+  if (ci == 2) { return unpackRGBA(u.colorSoftclipIndicator).xyz; }
+  if (ci == 3) { return unpackRGBA(u.colorHardclipIndicator).xyz; }
+  return unpackRGBA(u.colorInsertionIndicator).xyz;
+}

package/src/shaders/coverageBar.generated.ts

@@ -0,0 +1,10 @@
+// AUTO-GENERATED by packages/shader-tools/src/shader-codegen from coverageBar.slang.
+// Do not edit. Run `pnpm gen:shaders` to regenerate.
+
+export const WGSL_SOURCE = "struct CoverageBandUniforms_std140_0\n{\n    @align(16) bpHi_0 : f32,\n    @align(4) bpLo_0 : f32,\n    @align(8) bpLen_0 : f32,\n    @align(4) hpZero_0 : f32,\n    @align(16) canvasW_0 : f32,\n    @align(4) canvasH_0 : f32,\n    @align(8) covHeight_0 : f32,\n    @align(4) covYOffset_0 : f32,\n    @align(16) covTop_0 : f32,\n    @align(4) regionMaxDepth_0 : f32,\n    @align(8) depthDomainMax_0 : f32,\n    @align(4) depthDomainMin_0 : f32,\n    @align(16) coverageSymlogConstant_0 : f32,\n    @align(4) binSize_0 : f32,\n    @align(8) interbaseHeight_0 : f32,\n    @align(4) snpMinFreq_0 : f32,\n    @align(16) reversed_0 : f32,\n    @align(4) coverageScaleType_0 : i32,\n    @align(8) colorCoverage_0 : u32,\n    @align(4) colorBaseA_0 : u32,\n    @align(16) colorBaseC_0 : u32,\n    @align(4) colorBaseG_0 : u32,\n    @align(8) colorBaseT_0 : u32,\n    @align(4) colorBaseN_0 : u32,\n    @align(16) colorInsertionIndicator_0 : u32,\n    @align(4) colorSoftclipIndicator_0 : u32,\n    @align(8) colorHardclipIndicator_0 : u32,\n};\n\n@binding(1) @group(0) var<uniform> u_0 : CoverageBandUniforms_std140_0;\nfn quadLocal_0( vid_0 : u32) -> vec2<f32>\n{\n    var v_0 : u32 = vid_0 % u32(6);\n    var _S1 : bool = v_0 == u32(0);\n    var _S2 : bool;\n    if(_S1)\n    {\n        _S2 = true;\n    }\n    else\n    {\n        _S2 = v_0 == u32(2);\n    }\n    if(_S2)\n    {\n        _S2 = true;\n    }\n    else\n    {\n        _S2 = v_0 == u32(3);\n    }\n    var _S3 : f32;\n    if(_S2)\n    {\n        _S3 = 0.0f;\n    }\n    else\n    {\n        _S3 = 1.0f;\n    }\n    if(_S1)\n    {\n        _S2 = true;\n    }\n    else\n    {\n        _S2 = v_0 == u32(1);\n    }\n    if(_S2)\n    {\n        _S2 = true;\n    }\n    else\n    {\n        _S2 = v_0 == u32(4);\n    }\n    var _S4 : f32;\n    if(_S2)\n    {\n        _S4 = 0.0f;\n    }\n    else\n    {\n        _S4 = 1.0f;\n    }\n    return vec2<f32>(_S3, _S4);\n}\n\nfn hpSplitUint_0( value_0 : u32) -> vec2<f32>\n{\n    var lo_0 : u32 = (value_0 & (u32(4095)));\n    return vec2<f32>(f32(value_0 - lo_0), f32(lo_0));\n}\n\nfn hpToClipX_0( splitPos_0 : vec2<f32>,  bpRange_0 : vec3<f32>,  hpZero_1 : f32) -> f32\n{\n    var step_0 : f32 = 2.0f / bpRange_0.z;\n    var _S5 : f32 = - (1.0f / hpZero_1);\n    return dot(vec3<f32>(-1.0f, max(splitPos_0.x - bpRange_0.x, _S5), max(splitPos_0.y - bpRange_0.y, _S5)), vec3<f32>(1.0f, step_0, step_0));\n}\n\nfn covBpToClipX_0( bp_0 : u32,  u_1 : ptr<function, CoverageBandUniforms_std140_0>) -> f32\n{\n    return hpToClipX_0(hpSplitUint_0(bp_0), vec3<f32>((*u_1).bpHi_0, (*u_1).bpLo_0, (*u_1).bpLen_0), (*u_1).hpZero_0);\n}\n\nfn expandToMinWidthPx_0( x1_0 : f32,  x2_0 : f32,  minWidth_0 : f32) -> vec2<f32>\n{\n    if((x2_0 - x1_0) < minWidth_0)\n    {\n        var mid_0 : f32 = (x1_0 + x2_0) * 0.5f;\n        var _S6 : f32 = minWidth_0 * 0.5f;\n        return vec2<f32>(mid_0 - _S6, mid_0 + _S6);\n    }\n    return vec2<f32>(x1_0, x2_0);\n}\n\nfn expandToMinWidthX_0( x1_1 : f32,  x2_1 : f32,  minWidthPx_0 : f32,  canvasWidth_0 : f32) -> vec2<f32>\n{\n    return expandToMinWidthPx_0(x1_1, x2_1, minWidthPx_0 * 2.0f / canvasWidth_0);\n}\n\nfn covExpandMinWidthX_0( x1_2 : f32,  x2_2 : f32,  canvasWidth_1 : f32) -> vec2<f32>\n{\n    return expandToMinWidthX_0(x1_2, x2_2, 1.0f, canvasWidth_1);\n}\n\nfn yPxToClipY_0( yPx_0 : f32,  canvasHeight_0 : f32) -> f32\n{\n    return 1.0f - yPx_0 / canvasHeight_0 * 2.0f;\n}\n\nfn covAreaTop_0( u_2 : ptr<function, CoverageBandUniforms_std140_0>) -> f32\n{\n    return yPxToClipY_0((*u_2).covTop_0, (*u_2).canvasH_0);\n}\n\nfn covBottomOffsetPx_0( covHeight_1 : f32,  covYOffset_1 : f32) -> f32\n{\n    return covHeight_1 - covYOffset_1;\n}\n\nfn covBottom_0( u_3 : ptr<function, CoverageBandUniforms_std140_0>) -> f32\n{\n    var _S7 : f32 = covAreaTop_0(&((*u_3)));\n    return _S7 - covBottomOffsetPx_0((*u_3).covHeight_0, (*u_3).covYOffset_0) / (*u_3).canvasH_0 * 2.0f;\n}\n\nfn symlogTransform_0( x_0 : f32,  c_0 : f32) -> f32\n{\n    return f32((i32(sign((x_0))))) * log(1.0f + abs(x_0 / c_0));\n}\n\nfn normalizeScore_0( score_0 : f32,  domainMin_0 : f32,  domainMax_0 : f32,  scaleType_0 : i32,  symlogConstant_0 : f32) -> f32\n{\n    if(scaleType_0 == i32(2))\n    {\n        var tMin_0 : f32 = symlogTransform_0(domainMin_0, symlogConstant_0);\n        var tRange_0 : f32 = symlogTransform_0(domainMax_0, symlogConstant_0) - tMin_0;\n        if(tRange_0 <= 0.0f)\n        {\n            return 0.0f;\n        }\n        return clamp((symlogTransform_0(score_0, symlogConstant_0) - tMin_0) / tRange_0, 0.0f, 1.0f);\n    }\n    if(scaleType_0 == i32(1))\n    {\n        var floorV_0 : f32;\n        if(domainMin_0 > 0.0f)\n        {\n            floorV_0 = domainMin_0;\n        }\n        else\n        {\n            floorV_0 = 1.0f;\n        }\n        var logMin_0 : f32 = log2(floorV_0);\n        var logRange_0 : f32 = log2(max(domainMax_0, floorV_0)) - logMin_0;\n        if(logRange_0 <= 0.0f)\n        {\n            return 0.0f;\n        }\n        return clamp((log2(max(score_0, floorV_0)) - logMin_0) / logRange_0, 0.0f, 1.0f);\n    }\n    var range_0 : f32 = domainMax_0 - domainMin_0;\n    if(range_0 <= 0.0f)\n    {\n        return 0.0f;\n    }\n    return clamp((score_0 - domainMin_0) / range_0, 0.0f, 1.0f);\n}\n\nfn normalizeDepthScalar_0( rawDepth_0 : f32,  domainMin_1 : f32,  domainMax_1 : f32,  scaleType_1 : i32,  symlogConstant_1 : f32) -> f32\n{\n    return normalizeScore_0(rawDepth_0, domainMin_1, domainMax_1, scaleType_1, symlogConstant_1);\n}\n\nfn covNormalizeDepth_0( relDepth_0 : f32,  u_4 : ptr<function, CoverageBandUniforms_std140_0>) -> f32\n{\n    return normalizeDepthScalar_0(relDepth_0 * (*u_4).regionMaxDepth_0, (*u_4).depthDomainMin_0, (*u_4).depthDomainMax_0, (*u_4).coverageScaleType_0, (*u_4).coverageSymlogConstant_0);\n}\n\nfn covEffectiveHeightPx_0( covHeight_2 : f32,  covYOffset_2 : f32) -> f32\n{\n    return max(covHeight_2 - 2.0f * covYOffset_2, 0.0f);\n}\n\nfn covEffHeight_0( u_5 : ptr<function, CoverageBandUniforms_std140_0>) -> f32\n{\n    return covEffectiveHeightPx_0((*u_5).covHeight_0, (*u_5).covYOffset_0);\n}\n\nfn covBarScale_0( relDepth_1 : f32,  u_6 : ptr<function, CoverageBandUniforms_std140_0>) -> f32\n{\n    var _S8 : f32 = covNormalizeDepth_0(relDepth_1, &((*u_6)));\n    var _S9 : f32 = covEffHeight_0(&((*u_6)));\n    return _S8 * _S9 / (*u_6).canvasH_0 * 2.0f;\n}\n\nfn covFlipX_0( x_1 : f32,  u_7 : ptr<function, CoverageBandUniforms_std140_0>) -> f32\n{\n    return mix(x_1, - x_1, (*u_7).reversed_0);\n}\n\nfn covFlippedQuad_0( x0_0 : f32,  x1_3 : f32,  yBot_0 : f32,  yTop_0 : f32,  local_0 : vec2<f32>,  u_8 : ptr<function, CoverageBandUniforms_std140_0>) -> vec4<f32>\n{\n    var _S10 : f32 = covFlipX_0(mix(x0_0, x1_3, local_0.x), &((*u_8)));\n    return vec4<f32>(_S10, mix(yBot_0, yTop_0, local_0.y), 0.0f, 1.0f);\n}\n\nfn covSegQuad_0( position_0 : u32,  widthBp_0 : u32,  yOffset_0 : f32,  segHeight_0 : f32,  relDepth_2 : f32,  local_1 : vec2<f32>,  u_9 : ptr<function, CoverageBandUniforms_std140_0>) -> vec4<f32>\n{\n    var _S11 : f32 = covBpToClipX_0(position_0, &((*u_9)));\n    var _S12 : f32 = covBpToClipX_0(position_0 + widthBp_0, &((*u_9)));\n    var xx_0 : vec2<f32> = covExpandMinWidthX_0(_S11, _S12, (*u_9).canvasW_0);\n    var _S13 : f32 = covBottom_0(&((*u_9)));\n    var _S14 : f32 = covBarScale_0(relDepth_2, &((*u_9)));\n    var segBot_0 : f32 = _S13 + yOffset_0 * _S14;\n    var _S15 : vec4<f32> = covFlippedQuad_0(xx_0.x, xx_0.y, segBot_0, segBot_0 + segHeight_0 * _S14, local_1, &((*u_9)));\n    return _S15;\n}\n\nfn unpackRGBA_0( c_1 : u32) -> vec4<f32>\n{\n    return vec4<f32>(f32((((c_1 >> (u32(0)))) & (u32(255)))), f32((((c_1 >> (u32(8)))) & (u32(255)))), f32((((c_1 >> (u32(16)))) & (u32(255)))), f32((((c_1 >> (u32(24)))) & (u32(255))))) / vec4<f32>(255.0f);\n}\n\nstruct CoverageVsOut_0\n{\n    @builtin(position) position_1 : vec4<f32>,\n    @location(0) color_0 : vec4<f32>,\n};\n\nstruct vertexInput_0\n{\n    @location(0) position_2 : u32,\n    @location(1) relDepth_3 : f32,\n};\n\n@vertex\nfn vs_main( _S16 : vertexInput_0, @builtin(vertex_index) vid_1 : u32) -> CoverageVsOut_0\n{\n    var o_0 : CoverageVsOut_0;\n    var _S17 : u32 = u32(u_0.binSize_0);\n    var _S18 : vec2<f32> = quadLocal_0(vid_1);\n    var _S19 : CoverageBandUniforms_std140_0 = u_0;\n    var _S20 : vec4<f32> = covSegQuad_0(_S16.position_2, _S17, 0.0f, 1.0f, _S16.relDepth_3, _S18, &(_S19));\n    o_0.position_1 = _S20;\n    o_0.color_0 = vec4<f32>(unpackRGBA_0(u_0.colorCoverage_0).xyz, 1.0f);\n    return o_0;\n}\n\nstruct pixelOutput_0\n{\n    @location(0) output_0 : vec4<f32>,\n};\n\nstruct pixelInput_0\n{\n    @location(0) color_1 : vec4<f32>,\n};\n\n@fragment\nfn fs_main( _S21 : pixelInput_0, @builtin(position) position_3 : vec4<f32>) -> pixelOutput_0\n{\n    var _S22 : pixelOutput_0 = pixelOutput_0( _S21.color_1 );\n    return _S22;\n}\n\n"
+
+export const GLSL_VERTEX = "#version 300 es\nprecision highp float;\nprecision highp int;\nstruct CoverageBandUniforms_0\n{\n    float bpHi_0;\n    float bpLo_0;\n    float bpLen_0;\n    float hpZero_0;\n    float canvasW_0;\n    float canvasH_0;\n    float covHeight_0;\n    float covYOffset_0;\n    float covTop_0;\n    float regionMaxDepth_0;\n    float depthDomainMax_0;\n    float depthDomainMin_0;\n    float coverageSymlogConstant_0;\n    float binSize_0;\n    float interbaseHeight_0;\n    float snpMinFreq_0;\n    float reversed_0;\n    int coverageScaleType_0;\n    uint colorCoverage_0;\n    uint colorBaseA_0;\n    uint colorBaseC_0;\n    uint colorBaseG_0;\n    uint colorBaseT_0;\n    uint colorBaseN_0;\n    uint colorInsertionIndicator_0;\n    uint colorSoftclipIndicator_0;\n    uint colorHardclipIndicator_0;\n};\n\n\nlayout(std140) uniform Uniforms\n{\n    float bpHi_0;\n    float bpLo_0;\n    float bpLen_0;\n    float hpZero_0;\n    float canvasW_0;\n    float canvasH_0;\n    float covHeight_0;\n    float covYOffset_0;\n    float covTop_0;\n    float regionMaxDepth_0;\n    float depthDomainMax_0;\n    float depthDomainMin_0;\n    float coverageSymlogConstant_0;\n    float binSize_0;\n    float interbaseHeight_0;\n    float snpMinFreq_0;\n    float reversed_0;\n    int coverageScaleType_0;\n    uint colorCoverage_0;\n    uint colorBaseA_0;\n    uint colorBaseC_0;\n    uint colorBaseG_0;\n    uint colorBaseT_0;\n    uint colorBaseN_0;\n    uint colorInsertionIndicator_0;\n    uint colorSoftclipIndicator_0;\n    uint colorHardclipIndicator_0;\n}u_0;\n\nvec2 quadLocal_0(uint vid_0)\n{\n\n    uint v_0 = vid_0 % 6U;\n\n    bool _S1 = v_0 == 0U;\n\n    bool _S2;\n\n    if(_S1)\n    {\n\n        _S2 = true;\n\n    }\n    else\n    {\n\n        _S2 = v_0 == 2U;\n\n    }\n\n    if(_S2)\n    {\n\n        _S2 = true;\n\n    }\n    else\n    {\n\n        _S2 = v_0 == 3U;\n\n    }\n\n    float _S3;\n\n    if(_S2)\n    {\n\n        _S3 = 0.0;\n\n    }\n    else\n    {\n\n        _S3 = 1.0;\n\n    }\n    if(_S1)\n    {\n\n        _S2 = true;\n\n    }\n    else\n    {\n\n        _S2 = v_0 == 1U;\n\n    }\n\n    if(_S2)\n    {\n\n        _S2 = true;\n\n    }\n    else\n    {\n\n        _S2 = v_0 == 4U;\n\n    }\n\n    float _S4;\n\n    if(_S2)\n    {\n\n        _S4 = 0.0;\n\n    }\n    else\n    {\n\n        _S4 = 1.0;\n\n    }\n\n    return vec2(_S3, _S4);\n}\n\n\nvec2 hpSplitUint_0(uint value_0)\n{\n\n    uint lo_0 = value_0 & 4095U;\n\n    return vec2(float(value_0 - lo_0), float(lo_0));\n}\n\n\nfloat hpToClipX_0(vec2 splitPos_0, vec3 bpRange_0, float hpZero_1)\n{\n    float step_0 = 2.0 / bpRange_0.z;\n    float _S5 = - (1.0 / hpZero_1);\n\n    return dot(vec3(-1.0, max(splitPos_0.x - bpRange_0.x, _S5), max(splitPos_0.y - bpRange_0.y, _S5)), vec3(1.0, step_0, step_0));\n}\n\n\nfloat covBpToClipX_0(uint bp_0, CoverageBandUniforms_0 u_1)\n{\n\n    return hpToClipX_0(hpSplitUint_0(bp_0), vec3(u_1.bpHi_0, u_1.bpLo_0, u_1.bpLen_0), u_1.hpZero_0);\n}\n\n\nvec2 expandToMinWidthPx_0(float x1_0, float x2_0, float minWidth_0)\n{\n\n    if((x2_0 - x1_0) < minWidth_0)\n    {\n\n        float mid_0 = (x1_0 + x2_0) * 0.5;\n        float _S6 = minWidth_0 * 0.5;\n\n        return vec2(mid_0 - _S6, mid_0 + _S6);\n    }\n    return vec2(x1_0, x2_0);\n}\n\nvec2 expandToMinWidthX_0(float x1_1, float x2_1, float minWidthPx_0, float canvasWidth_0)\n{\n\n    return expandToMinWidthPx_0(x1_1, x2_1, minWidthPx_0 * 2.0 / canvasWidth_0);\n}\n\n\nvec2 covExpandMinWidthX_0(float x1_2, float x2_2, float canvasWidth_1)\n{\n\n    return expandToMinWidthX_0(x1_2, x2_2, 1.0, canvasWidth_1);\n}\n\n\nfloat yPxToClipY_0(float yPx_0, float canvasHeight_0)\n{\n\n    return 1.0 - yPx_0 / canvasHeight_0 * 2.0;\n}\n\n\nfloat covAreaTop_0(CoverageBandUniforms_0 u_2)\n{\n\n    return yPxToClipY_0(u_2.covTop_0, u_2.canvasH_0);\n}\n\n\nfloat covBottomOffsetPx_0(float covHeight_1, float covYOffset_1)\n{\n\n    return covHeight_1 - covYOffset_1;\n}\n\n\nfloat covBottom_0(CoverageBandUniforms_0 u_3)\n{\n\n    return covAreaTop_0(u_3) - covBottomOffsetPx_0(u_3.covHeight_0, u_3.covYOffset_0) / u_3.canvasH_0 * 2.0;\n}\n\n\nfloat symlogTransform_0(float x_0, float c_0)\n{\n\n    return float((int(sign((x_0))))) * log(1.0 + abs(x_0 / c_0));\n}\n\nfloat normalizeScore_0(float score_0, float domainMin_0, float domainMax_0, int scaleType_0, float symlogConstant_0)\n{\n\n    if(scaleType_0 == 2)\n    {\n\n        float tMin_0 = symlogTransform_0(domainMin_0, symlogConstant_0);\n\n        float tRange_0 = symlogTransform_0(domainMax_0, symlogConstant_0) - tMin_0;\n        if(tRange_0 <= 0.0)\n        {\n\n            return 0.0;\n        }\n        return clamp((symlogTransform_0(score_0, symlogConstant_0) - tMin_0) / tRange_0, 0.0, 1.0);\n    }\n    if(scaleType_0 == 1)\n    {\n\n        float floorV_0;\n\n        if(domainMin_0 > 0.0)\n        {\n\n            floorV_0 = domainMin_0;\n\n        }\n        else\n        {\n\n            floorV_0 = 1.0;\n\n        }\n        float logMin_0 = log2(floorV_0);\n\n        float logRange_0 = log2(max(domainMax_0, floorV_0)) - logMin_0;\n        if(logRange_0 <= 0.0)\n        {\n\n            return 0.0;\n        }\n        return clamp((log2(max(score_0, floorV_0)) - logMin_0) / logRange_0, 0.0, 1.0);\n    }\n    float range_0 = domainMax_0 - domainMin_0;\n    if(range_0 <= 0.0)\n    {\n\n        return 0.0;\n    }\n\n    return clamp((score_0 - domainMin_0) / range_0, 0.0, 1.0);\n}\n\n\nfloat normalizeDepthScalar_0(float rawDepth_0, float domainMin_1, float domainMax_1, int scaleType_1, float symlogConstant_1)\n{\n\n    return normalizeScore_0(rawDepth_0, domainMin_1, domainMax_1, scaleType_1, symlogConstant_1);\n}\n\n\nfloat covNormalizeDepth_0(float relDepth_0, CoverageBandUniforms_0 u_4)\n{\n    return normalizeDepthScalar_0(relDepth_0 * u_4.regionMaxDepth_0, u_4.depthDomainMin_0, u_4.depthDomainMax_0, u_4.coverageScaleType_0, u_4.coverageSymlogConstant_0);\n}\n\n\nfloat covEffectiveHeightPx_0(float covHeight_2, float covYOffset_2)\n{\n\n    return max(covHeight_2 - 2.0 * covYOffset_2, 0.0);\n}\n\n\nfloat covEffHeight_0(CoverageBandUniforms_0 u_5)\n{\n\n    return covEffectiveHeightPx_0(u_5.covHeight_0, u_5.covYOffset_0);\n}\n\n\nfloat covBarScale_0(float relDepth_1, CoverageBandUniforms_0 u_6)\n{\n\n    return covNormalizeDepth_0(relDepth_1, u_6) * covEffHeight_0(u_6) / u_6.canvasH_0 * 2.0;\n}\n\n\nfloat covFlipX_0(float x_1, CoverageBandUniforms_0 u_7)\n{\n\n    return mix(x_1, - x_1, u_7.reversed_0);\n}\n\n\nvec4 covFlippedQuad_0(float x0_0, float x1_3, float yBot_0, float yTop_0, vec2 local_0, CoverageBandUniforms_0 u_8)\n{\n    return vec4(covFlipX_0(mix(x0_0, x1_3, local_0.x), u_8), mix(yBot_0, yTop_0, local_0.y), 0.0, 1.0);\n}\n\n\nvec4 covSegQuad_0(uint position_0, uint widthBp_0, float yOffset_0, float segHeight_0, float relDepth_2, vec2 local_1, CoverageBandUniforms_0 u_9)\n{\n\n    vec2 xx_0 = covExpandMinWidthX_0(covBpToClipX_0(position_0, u_9), covBpToClipX_0(position_0 + widthBp_0, u_9), u_9.canvasW_0);\n\n\n    float k_0 = covBarScale_0(relDepth_2, u_9);\n    float segBot_0 = covBottom_0(u_9) + yOffset_0 * k_0;\n\n    return covFlippedQuad_0(xx_0.x, xx_0.y, segBot_0, segBot_0 + segHeight_0 * k_0, local_1, u_9);\n}\n\n\nvec4 unpackRGBA_0(uint c_1)\n{\n\n    return vec4(float((c_1 >> 0U) & 255U), float((c_1 >> 8U) & 255U), float((c_1 >> 16U) & 255U), float((c_1 >> 24U) & 255U)) / 255.0;\n}\n\n\nout vec4 v_color;\n\n\nlayout(location = 0)\nin uint a_position;\n\n\nlayout(location = 1)\nin float a_relDepth;\n\n\nstruct CoverageVsOut_0\n{\n    vec4 position_1;\n    vec4 color_0;\n};\n\n\nvoid main()\n{\n\n    CoverageVsOut_0 o_0;\n\n    CoverageBandUniforms_0 _S7 = CoverageBandUniforms_0(u_0.bpHi_0, u_0.bpLo_0, u_0.bpLen_0, u_0.hpZero_0, u_0.canvasW_0, u_0.canvasH_0, u_0.covHeight_0, u_0.covYOffset_0, u_0.covTop_0, u_0.regionMaxDepth_0, u_0.depthDomainMax_0, u_0.depthDomainMin_0, u_0.coverageSymlogConstant_0, u_0.binSize_0, u_0.interbaseHeight_0, u_0.snpMinFreq_0, u_0.reversed_0, u_0.coverageScaleType_0, u_0.colorCoverage_0, u_0.colorBaseA_0, u_0.colorBaseC_0, u_0.colorBaseG_0, u_0.colorBaseT_0, u_0.colorBaseN_0, u_0.colorInsertionIndicator_0, u_0.colorSoftclipIndicator_0, u_0.colorHardclipIndicator_0);\n\n    o_0.position_1 = covSegQuad_0(a_position, uint(u_0.binSize_0), 0.0, 1.0, a_relDepth, quadLocal_0(uint(gl_VertexID)), _S7);\n\n    o_0.color_0 = vec4(unpackRGBA_0(u_0.colorCoverage_0).xyz, 1.0);\n    CoverageVsOut_0 _S8 = o_0;\n\n    gl_Position = o_0.position_1;\n\n    v_color = _S8.color_0;\n\n    return;\n}\n\n"
+
+export const GLSL_FRAGMENT = "#version 300 es\nprecision highp float;\nprecision highp int;\nlayout(location = 0)\nout vec4 entryPointParam_fs_main_0;\n\n\nin vec4 v_color;\n\n\nvoid main()\n{\n\n    entryPointParam_fs_main_0 = v_color;\n\n    return;\n}\n\n"
+
+export * from './coverageBar.iface.generated.ts'

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

@@ -0,0 +1,172 @@
+// AUTO-GENERATED by packages/shader-tools/src/shader-codegen from coverageBar.slang.
+// Do not edit. Run `pnpm gen:shaders` to regenerate.
+
+import type { VertexAttributeLayout, ShaderBinding } from '@jbrowse/render-core/hal'
+
+export const BINDINGS: readonly ShaderBinding[] = [
+  { index: 1, kind: 'uniform', name: 'u' },
+]
+
+export const VERTS_PER_INSTANCE = 6
+
+export const UNIFORMS_SIZE_BYTES = 112
+
+// Word indices into a Float32Array view over the uniform buffer.
+export const UNIFORM_OFFSET_F32 = {
+  bpHi: 0,
+  bpLo: 1,
+  bpLen: 2,
+  hpZero: 3,
+  canvasW: 4,
+  canvasH: 5,
+  covHeight: 6,
+  covYOffset: 7,
+  covTop: 8,
+  regionMaxDepth: 9,
+  depthDomainMax: 10,
+  depthDomainMin: 11,
+  coverageSymlogConstant: 12,
+  binSize: 13,
+  interbaseHeight: 14,
+  snpMinFreq: 15,
+  reversed: 16,
+} as const
+
+// Word indices into a Uint32Array view over the uniform buffer.
+export const UNIFORM_OFFSET_U32 = {
+  colorCoverage: 18,
+  colorBaseA: 19,
+  colorBaseC: 20,
+  colorBaseG: 21,
+  colorBaseT: 22,
+  colorBaseN: 23,
+  colorInsertionIndicator: 24,
+  colorSoftclipIndicator: 25,
+  colorHardclipIndicator: 26,
+} as const
+
+// Word indices into a Int32Array view over the uniform buffer.
+export const UNIFORM_OFFSET_I32 = {
+  coverageScaleType: 17,
+} as const
+
+
+export interface Uniforms {
+  bpHi: number
+  bpLo: number
+  bpLen: number
+  hpZero: number
+  canvasW: number
+  canvasH: number
+  covHeight: number
+  covYOffset: number
+  covTop: number
+  regionMaxDepth: number
+  depthDomainMax: number
+  depthDomainMin: number
+  coverageSymlogConstant: number
+  binSize: number
+  interbaseHeight: number
+  snpMinFreq: number
+  reversed: number
+  coverageScaleType: number
+  colorCoverage: number
+  colorBaseA: number
+  colorBaseC: number
+  colorBaseG: number
+  colorBaseT: number
+  colorBaseN: number
+  colorInsertionIndicator: number
+  colorSoftclipIndicator: number
+  colorHardclipIndicator: number
+}
+
+export function writeUniforms(buf: ArrayBuffer, uniforms: Uniforms) {
+  const f32 = new Float32Array(buf)
+  const u32 = new Uint32Array(buf)
+  const i32 = new Int32Array(buf)
+  f32[0] = uniforms.bpHi
+  f32[1] = uniforms.bpLo
+  f32[2] = uniforms.bpLen
+  f32[3] = uniforms.hpZero
+  f32[4] = uniforms.canvasW
+  f32[5] = uniforms.canvasH
+  f32[6] = uniforms.covHeight
+  f32[7] = uniforms.covYOffset
+  f32[8] = uniforms.covTop
+  f32[9] = uniforms.regionMaxDepth
+  f32[10] = uniforms.depthDomainMax
+  f32[11] = uniforms.depthDomainMin
+  f32[12] = uniforms.coverageSymlogConstant
+  f32[13] = uniforms.binSize
+  f32[14] = uniforms.interbaseHeight
+  f32[15] = uniforms.snpMinFreq
+  f32[16] = uniforms.reversed
+  i32[17] = uniforms.coverageScaleType
+  u32[18] = uniforms.colorCoverage
+  u32[19] = uniforms.colorBaseA
+  u32[20] = uniforms.colorBaseC
+  u32[21] = uniforms.colorBaseG
+  u32[22] = uniforms.colorBaseT
+  u32[23] = uniforms.colorBaseN
+  u32[24] = uniforms.colorInsertionIndicator
+  u32[25] = uniforms.colorSoftclipIndicator
+  u32[26] = uniforms.colorHardclipIndicator
+}
+
+export const INSTANCE_STRIDE_BYTES = 8
+export const INSTANCE_STRIDE_WORDS = 2
+
+// Word indices into a Float32Array view over the instance buffer.
+export const INSTANCE_OFFSET_F32 = {
+  relDepth: 1,
+} as const
+
+// Word indices into a Uint32Array view over the instance buffer.
+export const INSTANCE_OFFSET_U32 = {
+  position: 0,
+} as const
+
+export const VERTEX_ATTRIBUTES: readonly VertexAttributeLayout[] = [
+  { name: 'a_position', components: 1, type: 'uint', offsetBytes: 0, integer: true },
+  { name: 'a_relDepth', components: 1, type: 'float', offsetBytes: 4, integer: false },
+]
+
+export interface InstanceArrays {
+  position: ArrayLike<number>
+  relDepth: ArrayLike<number>
+}
+
+export function packInstances(
+  arrays: InstanceArrays,
+  numInstances: number,
+  buf: ArrayBuffer = new ArrayBuffer(numInstances * INSTANCE_STRIDE_BYTES),
+) {
+  const f32 = new Float32Array(buf)
+  const u32 = new Uint32Array(buf)
+  const { position, relDepth } = arrays
+  for (let i = 0; i < numInstances; i++) {
+    const o = i * INSTANCE_STRIDE_WORDS
+    u32[o + 0] = position[i]!
+    f32[o + 1] = relDepth[i]!
+  }
+  return buf
+}
+
+// Instance `i`'s `position`.
+export function getInstancePosition(u32: Uint32Array, i: number) {
+  return u32[i * INSTANCE_STRIDE_WORDS]!
+}
+
+export function setInstancePosition(u32: Uint32Array, i: number, v: number) {
+  u32[i * INSTANCE_STRIDE_WORDS] = v
+}
+
+// Instance `i`'s `relDepth`.
+export function getInstanceRelDepth(f32: Float32Array, i: number) {
+  return f32[i * INSTANCE_STRIDE_WORDS + 1]!
+}
+
+export function setInstanceRelDepth(f32: Float32Array, i: number, v: number) {
+  f32[i * INSTANCE_STRIDE_WORDS + 1] = v
+}

package/src/shaders/coverageBar.slang

@@ -0,0 +1,37 @@
+// Coverage-band depth bars: one bar per coverage bin, filled with the palette's
+// coverage color. Bar height is covNormalizeDepth(relDepth) * the band's
+// drawable height. Shared by the alignments pileup band and the MAF band — see
+// coverageBand.slang.
+//! targets: wgsl, glsl
+//! layout-out: packages/alignments-core/src/coverageLayout.generated.ts
+
+import coverageBand;
+import colorPack;
+import hpmath;
+
+public static const uint VERTS_PER_INSTANCE = 6u;
+[[vk::binding(1, 0)]] ConstantBuffer<CoverageBandUniforms> u;
+
+// `relDepth` is depths[bin] / regionMaxDepth, the same packing the SNP and
+// modification segments carry (see coverageSnp.slang) — covNormalizeDepth
+// recovers the raw depth from it. The bin spans `u.binSize` bp: 1 for per-bp
+// coverage, wider once the producer downsamples.
+struct Instance {
+  uint  position : ATTR0;
+  float relDepth : ATTR1;
+};
+
+[shader("vertex")]
+CoverageVsOut vs_main(Instance inst, uint vid : SV_VertexID) {
+  CoverageVsOut o;
+  // The whole bar: y span 0..1 of itself. Same quad the segments stack inside.
+  o.position = covSegQuad(inst.position, uint(u.binSize), 0.0, 1.0,
+                          inst.relDepth, quadLocal(vid), u);
+  o.color = float4(unpackRGBA(u.colorCoverage).xyz, 1.0);
+  return o;
+}
+
+[shader("fragment")]
+float4 fs_main(CoverageVsOut fragIn) : SV_Target {
+  return fragIn.color;
+}

package/src/shaders/coverageIndicator.generated.ts

@@ -0,0 +1,10 @@
+// AUTO-GENERATED by packages/shader-tools/src/shader-codegen from coverageIndicator.slang.
+// Do not edit. Run `pnpm gen:shaders` to regenerate.
+
+export const WGSL_SOURCE = "struct CoverageBandUniforms_std140_0\n{\n    @align(16) bpHi_0 : f32,\n    @align(4) bpLo_0 : f32,\n    @align(8) bpLen_0 : f32,\n    @align(4) hpZero_0 : f32,\n    @align(16) canvasW_0 : f32,\n    @align(4) canvasH_0 : f32,\n    @align(8) covHeight_0 : f32,\n    @align(4) covYOffset_0 : f32,\n    @align(16) covTop_0 : f32,\n    @align(4) regionMaxDepth_0 : f32,\n    @align(8) depthDomainMax_0 : f32,\n    @align(4) depthDomainMin_0 : f32,\n    @align(16) coverageSymlogConstant_0 : f32,\n    @align(4) binSize_0 : f32,\n    @align(8) interbaseHeight_0 : f32,\n    @align(4) snpMinFreq_0 : f32,\n    @align(16) reversed_0 : f32,\n    @align(4) coverageScaleType_0 : i32,\n    @align(8) colorCoverage_0 : u32,\n    @align(4) colorBaseA_0 : u32,\n    @align(16) colorBaseC_0 : u32,\n    @align(4) colorBaseG_0 : u32,\n    @align(8) colorBaseT_0 : u32,\n    @align(4) colorBaseN_0 : u32,\n    @align(16) colorInsertionIndicator_0 : u32,\n    @align(4) colorSoftclipIndicator_0 : u32,\n    @align(8) colorHardclipIndicator_0 : u32,\n};\n\n@binding(1) @group(0) var<uniform> u_0 : CoverageBandUniforms_std140_0;\nfn hpSplitUint_0( value_0 : u32) -> vec2<f32>\n{\n    var lo_0 : u32 = (value_0 & (u32(4095)));\n    return vec2<f32>(f32(value_0 - lo_0), f32(lo_0));\n}\n\nfn hpToClipX_0( splitPos_0 : vec2<f32>,  bpRange_0 : vec3<f32>,  hpZero_1 : f32) -> f32\n{\n    var step_0 : f32 = 2.0f / bpRange_0.z;\n    var _S1 : f32 = - (1.0f / hpZero_1);\n    return dot(vec3<f32>(-1.0f, max(splitPos_0.x - bpRange_0.x, _S1), max(splitPos_0.y - bpRange_0.y, _S1)), vec3<f32>(1.0f, step_0, step_0));\n}\n\nfn covBpToClipX_0( bp_0 : u32,  u_1 : ptr<function, CoverageBandUniforms_std140_0>) -> f32\n{\n    return hpToClipX_0(hpSplitUint_0(bp_0), vec3<f32>((*u_1).bpHi_0, (*u_1).bpLo_0, (*u_1).bpLen_0), (*u_1).hpZero_0);\n}\n\nfn pxToClipLen_0( px_0 : f32,  size_0 : f32) -> f32\n{\n    return px_0 * 2.0f / size_0;\n}\n\nfn yPxToClipY_0( yPx_0 : f32,  canvasHeight_0 : f32) -> f32\n{\n    return 1.0f - yPx_0 / canvasHeight_0 * 2.0f;\n}\n\nfn covAreaTop_0( u_2 : ptr<function, CoverageBandUniforms_std140_0>) -> f32\n{\n    return yPxToClipY_0((*u_2).covTop_0, (*u_2).canvasH_0);\n}\n\nfn covFlipX_0( x_0 : f32,  u_3 : ptr<function, CoverageBandUniforms_std140_0>) -> f32\n{\n    return mix(x_0, - x_0, (*u_3).reversed_0);\n}\n\nfn unpackRGBA_0( c_0 : u32) -> vec4<f32>\n{\n    return vec4<f32>(f32((((c_0 >> (u32(0)))) & (u32(255)))), f32((((c_0 >> (u32(8)))) & (u32(255)))), f32((((c_0 >> (u32(16)))) & (u32(255)))), f32((((c_0 >> (u32(24)))) & (u32(255))))) / vec4<f32>(255.0f);\n}\n\nfn covClipKindColor_0( ct_0 : f32,  u_4 : ptr<function, CoverageBandUniforms_std140_0>) -> vec3<f32>\n{\n    var ci_0 : i32 = i32(ct_0);\n    if(ci_0 == i32(2))\n    {\n        return unpackRGBA_0((*u_4).colorSoftclipIndicator_0).xyz;\n    }\n    if(ci_0 == i32(3))\n    {\n        return unpackRGBA_0((*u_4).colorHardclipIndicator_0).xyz;\n    }\n    return unpackRGBA_0((*u_4).colorInsertionIndicator_0).xyz;\n}\n\nstruct VsOut_0\n{\n    @builtin(position) position_0 : vec4<f32>,\n    @location(0) color_0 : vec4<f32>,\n    @location(1) bary_0 : vec3<f32>,\n};\n\nstruct vertexInput_0\n{\n    @location(0) position_1 : u32,\n    @location(1) colorType_0 : f32,\n};\n\n@vertex\nfn vs_main( _S2 : vertexInput_0, @builtin(vertex_index) vid_0 : u32) -> VsOut_0\n{\n    var o_0 : VsOut_0;\n    var v_0 : u32 = vid_0 % u32(3);\n    var _S3 : CoverageBandUniforms_std140_0 = u_0;\n    var _S4 : f32 = covBpToClipX_0(_S2.position_1, &(_S3));\n    var tw_0 : f32 = pxToClipLen_0(7.0f, u_0.canvasW_0);\n    var th_0 : f32 = pxToClipLen_0(4.5f, u_0.canvasH_0);\n    var _S5 : f32 = covAreaTop_0(&(_S3));\n    var sx_0 : f32;\n    var sy_0 : f32;\n    if(v_0 == u32(0))\n    {\n        var _S6 : f32 = _S4 - tw_0 * 0.5f;\n        o_0.bary_0 = vec3<f32>(1.0f, 0.0f, 0.0f);\n        sx_0 = _S6;\n        sy_0 = _S5;\n    }\n    else\n    {\n        if(v_0 == u32(1))\n        {\n            var _S7 : f32 = _S4 + tw_0 * 0.5f;\n            o_0.bary_0 = vec3<f32>(0.0f, 1.0f, 0.0f);\n            sx_0 = _S7;\n            sy_0 = _S5;\n        }\n        else\n        {\n            var _S8 : f32 = _S5 - th_0;\n            o_0.bary_0 = vec3<f32>(0.0f, 0.0f, 1.0f);\n            sx_0 = _S4;\n            sy_0 = _S8;\n        }\n    }\n    var _S9 : f32 = covFlipX_0(sx_0, &(_S3));\n    o_0.position_0 = vec4<f32>(_S9, sy_0, 0.0f, 1.0f);\n    var _S10 : vec3<f32> = covClipKindColor_0(_S2.colorType_0, &(_S3));\n    o_0.color_0 = vec4<f32>(_S10, 1.0f);\n    return o_0;\n}\n\nstruct pixelOutput_0\n{\n    @location(0) output_0 : vec4<f32>,\n};\n\nstruct pixelInput_0\n{\n    @location(0) color_1 : vec4<f32>,\n    @location(1) bary_1 : vec3<f32>,\n};\n\n@fragment\nfn fs_main( _S11 : pixelInput_0, @builtin(position) position_2 : vec4<f32>) -> pixelOutput_0\n{\n    var _S12 : pixelOutput_0 = pixelOutput_0( vec4<f32>(_S11.color_1.xyz, _S11.color_1.w * smoothstep(0.0f, 1.0f, min(_S11.bary_1.y * 3.70000004768371582f, _S11.bary_1.x * 3.70000004768371582f))) );\n    return _S12;\n}\n\n"
+
+export const GLSL_VERTEX = "#version 300 es\nprecision highp float;\nprecision highp int;\nstruct CoverageBandUniforms_0\n{\n    float bpHi_0;\n    float bpLo_0;\n    float bpLen_0;\n    float hpZero_0;\n    float canvasW_0;\n    float canvasH_0;\n    float covHeight_0;\n    float covYOffset_0;\n    float covTop_0;\n    float regionMaxDepth_0;\n    float depthDomainMax_0;\n    float depthDomainMin_0;\n    float coverageSymlogConstant_0;\n    float binSize_0;\n    float interbaseHeight_0;\n    float snpMinFreq_0;\n    float reversed_0;\n    int coverageScaleType_0;\n    uint colorCoverage_0;\n    uint colorBaseA_0;\n    uint colorBaseC_0;\n    uint colorBaseG_0;\n    uint colorBaseT_0;\n    uint colorBaseN_0;\n    uint colorInsertionIndicator_0;\n    uint colorSoftclipIndicator_0;\n    uint colorHardclipIndicator_0;\n};\n\n\nlayout(std140) uniform Uniforms\n{\n    float bpHi_0;\n    float bpLo_0;\n    float bpLen_0;\n    float hpZero_0;\n    float canvasW_0;\n    float canvasH_0;\n    float covHeight_0;\n    float covYOffset_0;\n    float covTop_0;\n    float regionMaxDepth_0;\n    float depthDomainMax_0;\n    float depthDomainMin_0;\n    float coverageSymlogConstant_0;\n    float binSize_0;\n    float interbaseHeight_0;\n    float snpMinFreq_0;\n    float reversed_0;\n    int coverageScaleType_0;\n    uint colorCoverage_0;\n    uint colorBaseA_0;\n    uint colorBaseC_0;\n    uint colorBaseG_0;\n    uint colorBaseT_0;\n    uint colorBaseN_0;\n    uint colorInsertionIndicator_0;\n    uint colorSoftclipIndicator_0;\n    uint colorHardclipIndicator_0;\n}u_0;\n\nvec2 hpSplitUint_0(uint value_0)\n{\n\n    uint lo_0 = value_0 & 4095U;\n\n    return vec2(float(value_0 - lo_0), float(lo_0));\n}\n\n\nfloat hpToClipX_0(vec2 splitPos_0, vec3 bpRange_0, float hpZero_1)\n{\n    float step_0 = 2.0 / bpRange_0.z;\n    float _S1 = - (1.0 / hpZero_1);\n\n    return dot(vec3(-1.0, max(splitPos_0.x - bpRange_0.x, _S1), max(splitPos_0.y - bpRange_0.y, _S1)), vec3(1.0, step_0, step_0));\n}\n\n\nfloat covBpToClipX_0(uint bp_0, CoverageBandUniforms_0 u_1)\n{\n\n    return hpToClipX_0(hpSplitUint_0(bp_0), vec3(u_1.bpHi_0, u_1.bpLo_0, u_1.bpLen_0), u_1.hpZero_0);\n}\n\n\nfloat pxToClipLen_0(float px_0, float size_0)\n{\n\n    return px_0 * 2.0 / size_0;\n}\n\n\nfloat yPxToClipY_0(float yPx_0, float canvasHeight_0)\n{\n\n    return 1.0 - yPx_0 / canvasHeight_0 * 2.0;\n}\n\n\nfloat covAreaTop_0(CoverageBandUniforms_0 u_2)\n{\n\n    return yPxToClipY_0(u_2.covTop_0, u_2.canvasH_0);\n}\n\n\nfloat covFlipX_0(float x_0, CoverageBandUniforms_0 u_3)\n{\n\n    return mix(x_0, - x_0, u_3.reversed_0);\n}\n\n\nvec4 unpackRGBA_0(uint c_0)\n{\n\n    return vec4(float((c_0 >> 0U) & 255U), float((c_0 >> 8U) & 255U), float((c_0 >> 16U) & 255U), float((c_0 >> 24U) & 255U)) / 255.0;\n}\n\n\nvec3 covClipKindColor_0(float ct_0, CoverageBandUniforms_0 u_4)\n{\n\n    int ci_0 = int(ct_0);\n    if(ci_0 == 2)\n    {\n\n        return unpackRGBA_0(u_4.colorSoftclipIndicator_0).xyz;\n    }\n\n    if(ci_0 == 3)\n    {\n\n        return unpackRGBA_0(u_4.colorHardclipIndicator_0).xyz;\n    }\n\n    return unpackRGBA_0(u_4.colorInsertionIndicator_0).xyz;\n}\n\n\nout vec4 v_color;\n\n\nout vec3 v_bary;\n\n\nlayout(location = 0)\nin uint a_position;\n\n\nlayout(location = 1)\nin float a_colorType;\n\n\nstruct VsOut_0\n{\n    vec4 position_0;\n    vec4 color_0;\n    vec3 bary_0;\n};\n\nvoid main()\n{\n\n    VsOut_0 o_0;\n    uint v_0 = uint(gl_VertexID) % 3U;\n\n    CoverageBandUniforms_0 _S2 = CoverageBandUniforms_0(u_0.bpHi_0, u_0.bpLo_0, u_0.bpLen_0, u_0.hpZero_0, u_0.canvasW_0, u_0.canvasH_0, u_0.covHeight_0, u_0.covYOffset_0, u_0.covTop_0, u_0.regionMaxDepth_0, u_0.depthDomainMax_0, u_0.depthDomainMin_0, u_0.coverageSymlogConstant_0, u_0.binSize_0, u_0.interbaseHeight_0, u_0.snpMinFreq_0, u_0.reversed_0, u_0.coverageScaleType_0, u_0.colorCoverage_0, u_0.colorBaseA_0, u_0.colorBaseC_0, u_0.colorBaseG_0, u_0.colorBaseT_0, u_0.colorBaseN_0, u_0.colorInsertionIndicator_0, u_0.colorSoftclipIndicator_0, u_0.colorHardclipIndicator_0);\n\n    float cx_0 = covBpToClipX_0(a_position, _S2);\n    float tw_0 = pxToClipLen_0(7.0, u_0.canvasW_0);\n    float th_0 = pxToClipLen_0(4.5, u_0.canvasH_0);\n\n    float top_0 = covAreaTop_0(_S2);\n\n    float sx_0;\n\n    float sy_0;\n\n    if(v_0 == 0U)\n    {\n\n        float _S3 = cx_0 - tw_0 * 0.5;\n\n        o_0.bary_0 = vec3(1.0, 0.0, 0.0);\n\n        sx_0 = _S3;\n\n        sy_0 = top_0;\n\n    }\n    else\n    {\n\n        if(v_0 == 1U)\n        {\n\n            float _S4 = cx_0 + tw_0 * 0.5;\n\n            o_0.bary_0 = vec3(0.0, 1.0, 0.0);\n\n            sx_0 = _S4;\n\n            sy_0 = top_0;\n\n        }\n        else\n        {\n\n            float _S5 = top_0 - th_0;\n\n            o_0.bary_0 = vec3(0.0, 0.0, 1.0);\n\n            sx_0 = cx_0;\n\n            sy_0 = _S5;\n\n        }\n\n    }\n\n\n\n    o_0.position_0 = vec4(covFlipX_0(sx_0, _S2), sy_0, 0.0, 1.0);\n    o_0.color_0 = vec4(covClipKindColor_0(a_colorType, _S2), 1.0);\n    VsOut_0 _S6 = o_0;\n\n    gl_Position = o_0.position_0;\n\n    v_color = _S6.color_0;\n\n    v_bary = _S6.bary_0;\n\n    return;\n}\n\n"
+
+export const GLSL_FRAGMENT = "#version 300 es\nprecision highp float;\nprecision highp int;\nlayout(location = 0)\nout vec4 entryPointParam_fs_main_0;\n\n\nin vec4 v_color;\n\n\nin vec3 v_bary;\n\n\nvoid main()\n{\n\n    entryPointParam_fs_main_0 = vec4(v_color.xyz, v_color.w * smoothstep(0.0, 1.0, min(v_bary.y * 3.70000004768371582, v_bary.x * 3.70000004768371582)));\n\n    return;\n}\n\n"
+
+export * from './coverageIndicator.iface.generated.ts'