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

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

@@ -0,0 +1,168 @@
+// AUTO-GENERATED by packages/shader-tools/src/shader-codegen from spanMark.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 = 48
+
+// Word indices into a Float32Array view over the uniform buffer.
+export const UNIFORM_OFFSET_F32 = {
+  bpRangeX: 0,
+  canvasHeight: 3,
+  minCellDenomPx: 4,
+  minCellPx: 5,
+  zero: 6,
+  rowHeight: 7,
+  rowProportion: 8,
+  scrollTop: 9,
+} as const
+
+
+export interface Uniforms {
+  bpRangeX: [number, number, number]
+  canvasHeight: number
+  minCellDenomPx: number
+  minCellPx: number
+  zero: number
+  rowHeight: number
+  rowProportion: number
+  scrollTop: number
+}
+
+export function writeUniforms(buf: ArrayBuffer, uniforms: Uniforms) {
+  const f32 = new Float32Array(buf)
+  f32[0] = uniforms.bpRangeX[0]
+  f32[1] = uniforms.bpRangeX[1]
+  f32[2] = uniforms.bpRangeX[2]
+  f32[3] = uniforms.canvasHeight
+  f32[4] = uniforms.minCellDenomPx
+  f32[5] = uniforms.minCellPx
+  f32[6] = uniforms.zero
+  f32[7] = uniforms.rowHeight
+  f32[8] = uniforms.rowProportion
+  f32[9] = uniforms.scrollTop
+}
+
+export const INSTANCE_STRIDE_BYTES = 16
+export const INSTANCE_STRIDE_WORDS = 4
+
+// Word indices into a Uint32Array view over the instance buffer.
+export const INSTANCE_OFFSET_U32 = {
+  x: 0,
+  x2: 1,
+  row: 2,
+  color: 3,
+} as const
+
+export const VERTEX_ATTRIBUTES: readonly VertexAttributeLayout[] = [
+  { name: 'a_x', components: 1, type: 'uint', offsetBytes: 0, integer: true },
+  { name: 'a_x2', components: 1, type: 'uint', offsetBytes: 4, integer: true },
+  { name: 'a_row', components: 1, type: 'uint', offsetBytes: 8, integer: true },
+  { name: 'a_color', components: 1, type: 'uint', offsetBytes: 12, integer: true },
+]
+
+export interface InstanceArrays {
+  x: ArrayLike<number>
+  x2: ArrayLike<number>
+  row: ArrayLike<number>
+  color: ArrayLike<number>
+}
+
+export function packInstances(
+  arrays: InstanceArrays,
+  numInstances: number,
+  buf: ArrayBuffer = new ArrayBuffer(numInstances * INSTANCE_STRIDE_BYTES),
+) {
+  const u32 = new Uint32Array(buf)
+  const { x, x2, row, color } = arrays
+  for (let i = 0; i < numInstances; i++) {
+    const o = i * INSTANCE_STRIDE_WORDS
+    u32[o + 0] = x[i]!
+    u32[o + 1] = x2[i]!
+    u32[o + 2] = row[i]!
+    u32[o + 3] = color[i]!
+  }
+  return buf
+}
+
+// Instance `i`'s `x`.
+export function getInstanceX(u32: Uint32Array, i: number) {
+  return u32[i * INSTANCE_STRIDE_WORDS]!
+}
+
+export function setInstanceX(u32: Uint32Array, i: number, v: number) {
+  u32[i * INSTANCE_STRIDE_WORDS] = v
+}
+
+// Instance `i`'s `x2`.
+export function getInstanceX2(u32: Uint32Array, i: number) {
+  return u32[i * INSTANCE_STRIDE_WORDS + 1]!
+}
+
+export function setInstanceX2(u32: Uint32Array, i: number, v: number) {
+  u32[i * INSTANCE_STRIDE_WORDS + 1] = v
+}
+
+// Instance `i`'s `row`.
+export function getInstanceRow(u32: Uint32Array, i: number) {
+  return u32[i * INSTANCE_STRIDE_WORDS + 2]!
+}
+
+export function setInstanceRow(u32: Uint32Array, i: number, v: number) {
+  u32[i * INSTANCE_STRIDE_WORDS + 2] = v
+}
+
+// Instance `i`'s `color`.
+export function getInstanceColor(u32: Uint32Array, i: number) {
+  return u32[i * INSTANCE_STRIDE_WORDS + 3]!
+}
+
+export function setInstanceColor(u32: Uint32Array, i: number, v: number) {
+  u32[i * INSTANCE_STRIDE_WORDS + 3] = v
+}
+
+// Appends instances one at a time, for an encoder that cannot say up front
+// how many it will emit. Seed the constructor with an upper bound and the
+// common path allocates exactly once; the doubling is a correctness
+// backstop, not the expected route.
+export class InstanceWriter {
+  private buf: ArrayBuffer
+  private u32: Uint32Array
+  private capacity: number
+  count = 0
+
+  constructor(capacity: number) {
+    this.capacity = Math.max(1, capacity)
+    this.buf = new ArrayBuffer(this.capacity * INSTANCE_STRIDE_BYTES)
+    this.u32 = new Uint32Array(this.buf)
+  }
+
+  push(x: number, x2: number, row: number, color: number) {
+    if (this.count === this.capacity) {
+      this.capacity *= 2
+      const grown = new ArrayBuffer(this.capacity * INSTANCE_STRIDE_BYTES)
+      new Uint8Array(grown).set(new Uint8Array(this.buf))
+      this.buf = grown
+      this.u32 = new Uint32Array(grown)
+    }
+    const o = this.count * INSTANCE_STRIDE_WORDS
+    this.u32[o] = x
+    this.u32[o + 1] = x2
+    this.u32[o + 2] = row
+    this.u32[o + 3] = color
+    this.count++
+  }
+
+  // A right-sized COPY, not a subarray view — see the class comment. Skipped
+  // entirely when the seed turned out to be exact, which is the common path.
+  finish() {
+    const used = this.count * INSTANCE_STRIDE_BYTES
+    return used === this.buf.byteLength ? this.buf : this.buf.slice(0, used)
+  }
+}

package/src/shaders/spanMark.slang

@@ -0,0 +1,22 @@
+// The `span` mark shape: one instance is a coloured rectangle spanning
+// [x, x2) in absolute genomic coords, on the row band given by the `row`
+// channel. The geometry — row band, hp clip-x span, min-width widening — is
+// `rowRect`'s; this is the entry point that makes it a pass a mark can draw.
+//! targets: wgsl, glsl
+//! instance-writer
+
+import rowRect;
+
+public static const uint VERTS_PER_INSTANCE = 6u;
+
+[[vk::binding(1, 0)]] ConstantBuffer<RowRectUniforms> u;
+
+[shader("vertex")]
+RowRectVsOut vs_main(RowRectInstance inst, uint vid : SV_VertexID) {
+  return rowRectVertex(inst, vid, u);
+}
+
+[shader("fragment")]
+float4 fs_main(RowRectVsOut v) : SV_Target {
+  return v.color;
+}

package/esm/globalRenderingBackend.d.ts

@@ -1,90 +0,0 @@
-import { Canvas2DRenderingBackendBase, GpuRenderingBackendBase } from './renderingBackendBase.ts';
-import type { FrameDimensions, RenderingBackend } from './renderingBackendBase.ts';
-/**
- * Shared contract for monolithic GPU backends (HiC, LD, multi-variant
- * matrix) — displays with no region partitioning. One payload under the
- * `data` key, one draw per frame. Render receives the data directly so
- * Canvas2D backends stay stateless; GPU backends use `upload` to push bytes
- * into a HAL buffer and ignore the `data` arg at render time.
- *
- * A display with a second upload beside the payload — HiC's and LD's colour
- * ramp texture, derived from a setting rather than the fetch — widens `Key`
- * and `Cell` so `upload` takes both cells and tells them apart, while `render`
- * is still handed the payload alone.
- */
-export interface GlobalRenderingBackend<UploadData, RenderState, Key extends string = 'data', Cell = UploadData> extends RenderingBackend {
-    upload(key: Key, data: Cell): void;
-    release(key: Key): void;
-    /**
-     * Paint one frame and report whether real content reached the canvas — the
-     * monolithic twin of `PerRegionRenderingBackend.renderBlocks`, and it answers
-     * for the same reason. `RenderLifecycleMixin` flips `canvasDrawn` (the loading
-     * scrim, `data-display-drawn`, every browser test's wait) only on `true`, so a
-     * tick that drew nothing must say so.
-     *
-     * **This used to return `void`, and the answer was the display's to give.**
-     * Each of the three wrote the same six lines — "data is here, so return
-     * `true`" — beside a renderer whose own guard was strictly narrower: a color
-     * ramp that had not arrived, a zero instance count, an empty HAL buffer. Two
-     * expressions of one fact, and the one that could see what actually happened
-     * was not the one being asked. LD's model even carried a comment explaining
-     * the workaround, which is the usual sign that a signature is wrong rather
-     * than a caller.
-     */
-    render(data: UploadData | null, state: RenderState): boolean;
-}
-/**
- * Canvas2D-side base for `GlobalRenderingBackend` implementations. Inherits the
- * `canvas` + 2D context (and no-op `dispose`) from
- * `Canvas2DRenderingBackendBase`; stubs `upload` (no-op — data flows through
- * `render`).
- *
- * `render` is concrete and runs `prepareCanvas` (DPR-aware backing-store sizing)
- * before handing off to the abstract `draw`, exactly as
- * `Canvas2DPerRegionRenderingBackend` does — so a renderer here can no more
- * forget it and paint blurry on hi-DPI than one over there can. All three
- * subclasses opened with that same call and none of them had to.
- *
- * A null payload still prepares (and so clears) the canvas, then skips the
- * draw: that is the frame where a refetch is in flight and the old picture must
- * not stay up.
- */
-export declare abstract class Canvas2DGlobalRenderingBackend<UploadData, RenderState extends FrameDimensions, Key extends string = 'data', Cell = UploadData> extends Canvas2DRenderingBackendBase implements GlobalRenderingBackend<UploadData, RenderState, Key, Cell> {
-    upload(_key: Key, _cell: Cell): void;
-    release(_key: Key): void;
-    render(data: UploadData | null, state: RenderState): boolean;
-    /**
-     * Paint `data` into `this.ctx` (already DPR-prepared) and answer whether
-     * anything reached it. Delegates to the plugin's pure `drawXxxBlocks`
-     * function, the one SVG export shares.
-     */
-    protected abstract draw(data: UploadData, state: RenderState): boolean;
-}
-/**
- * GPU-side base for `GlobalRenderingBackend` implementations. Inherits the
- * `hal` reference, the pre-allocated uniform scratch buffer, and the
- * HAL-delegating `dispose` from `GpuRenderingBackendBase`. Subclasses implement
- * `upload` and `draw`.
- *
- * `render` is the frame scaffold the per-region base has always had and this
- * one did not: resize the backing store, `beginFrame`/`endFrame`, and hand the
- * middle to `draw`. **The pairing is the point.** `beginFrame` is what clears
- * the canvas, so a frame that draws nothing still has to open and close one or
- * the last picture stays up — and with each subclass writing its own scaffold,
- * that invariant held three times by hand.
- *
- * `release` is a no-op by default: a payload leaving the map is answered by
- * `render` being handed `null`, and `beginFrame` clears the last picture. A
- * subclass whose buffers are worth freeing early overrides it.
- */
-export declare abstract class GpuGlobalRenderingBackend<UploadData, RenderState extends FrameDimensions, Key extends string = 'data', Cell = UploadData> extends GpuRenderingBackendBase implements GlobalRenderingBackend<UploadData, RenderState, Key, Cell> {
-    abstract upload(key: Key, data: Cell): void;
-    release(): void;
-    render(data: UploadData | null, state: RenderState): boolean;
-    /**
-     * Write uniforms and issue the draw passes for one frame, inside an already-
-     * open `beginFrame`/`endFrame`. Return whether anything was drawn — a buffer
-     * the upload has not filled yet is the ordinary reason not to.
-     */
-    protected abstract draw(data: UploadData, state: RenderState): boolean;
-}

package/esm/globalRenderingBackend.js

@@ -1,53 +0,0 @@
-import { prepareCanvas } from './canvas2dUtils.js';
-import { Canvas2DRenderingBackendBase, GpuRenderingBackendBase, } from './renderingBackendBase.js';
-/**
- * Canvas2D-side base for `GlobalRenderingBackend` implementations. Inherits the
- * `canvas` + 2D context (and no-op `dispose`) from
- * `Canvas2DRenderingBackendBase`; stubs `upload` (no-op — data flows through
- * `render`).
- *
- * `render` is concrete and runs `prepareCanvas` (DPR-aware backing-store sizing)
- * before handing off to the abstract `draw`, exactly as
- * `Canvas2DPerRegionRenderingBackend` does — so a renderer here can no more
- * forget it and paint blurry on hi-DPI than one over there can. All three
- * subclasses opened with that same call and none of them had to.
- *
- * A null payload still prepares (and so clears) the canvas, then skips the
- * draw: that is the frame where a refetch is in flight and the old picture must
- * not stay up.
- */
-export class Canvas2DGlobalRenderingBackend extends Canvas2DRenderingBackendBase {
-    upload(_key, _cell) { }
-    release(_key) { }
-    render(data, state) {
-        prepareCanvas(this.canvas, this.ctx, state.canvasWidth, state.canvasHeight);
-        return data !== null && this.draw(data, state);
-    }
-}
-/**
- * GPU-side base for `GlobalRenderingBackend` implementations. Inherits the
- * `hal` reference, the pre-allocated uniform scratch buffer, and the
- * HAL-delegating `dispose` from `GpuRenderingBackendBase`. Subclasses implement
- * `upload` and `draw`.
- *
- * `render` is the frame scaffold the per-region base has always had and this
- * one did not: resize the backing store, `beginFrame`/`endFrame`, and hand the
- * middle to `draw`. **The pairing is the point.** `beginFrame` is what clears
- * the canvas, so a frame that draws nothing still has to open and close one or
- * the last picture stays up — and with each subclass writing its own scaffold,
- * that invariant held three times by hand.
- *
- * `release` is a no-op by default: a payload leaving the map is answered by
- * `render` being handed `null`, and `beginFrame` clears the last picture. A
- * subclass whose buffers are worth freeing early overrides it.
- */
-export class GpuGlobalRenderingBackend extends GpuRenderingBackendBase {
-    release() { }
-    render(data, state) {
-        this.hal.resize(state.canvasWidth, state.canvasHeight);
-        this.hal.beginFrame(0, 0, 0, 0);
-        const painted = data !== null && this.draw(data, state);
-        this.hal.endFrame();
-        return painted;
-    }
-}

package/esm/keyedRenderingBackend.d.ts

@@ -1,41 +0,0 @@
-import type { RenderingBackend } from './renderingBackendBase.ts';
-/**
- * Shared contract for **keyed shared-canvas** backends — one canvas painting
- * several displays at once, each holding its own uploaded buffer under its own
- * key. Dotplot (a key per display in the view) and multi-LGV synteny (a key per
- * track level) are the two.
- *
- * The third shape beside per-region and monolithic, and genuinely neither:
- * per-region drives off `renderBlocks(blocks, regions, state)` with the model's
- * data map handed back each frame, and monolithic is one payload under the `data` key
- * with no key at all. These key their uploads and render every key in one
- * frame from state the caller assembled, so they own the map.
- *
- * Unlike the other two this is an interface with no abstract class under it:
- * the shared *state* (`hal` + uniform scratch, or `canvas` + 2D context) is
- * `GpuRenderingBackendBase` / `Canvas2DRenderingBackendBase`, which every keyed
- * backend extends, and there is no shared *behavior* on top — the render loops
- * genuinely differ. An empty abstract class between them would only be a place
- * to look.
- */
-export interface KeyedRenderingBackend<UploadData, RenderState> extends RenderingBackend {
-    /** CSS-pixel size of the shared canvas. */
-    resize(width: number, height: number): void;
-    upload(key: number, data: UploadData): void;
-    release(key: number): void;
-    /** Paint every key the state names. */
-    render(state: RenderState): void;
-}
-/**
- * Stable 32-bit slot for a display on a backend it shares with siblings, hashed
- * from its MST node id (djb2). Collisions are vanishingly rare at display
- * cardinalities, and the alternative — coordinating integer slots between
- * displays that don't know about each other — is worse.
- *
- * Key by this, never by the display's index in its parent's list. An index
- * renumbers when a sibling is hidden or reordered, which hands the survivor a
- * slot holding another display's bytes: the keyed diff sees a changed
- * reference and re-uploads every later display's whole buffer, and any frame
- * drawn between the two mistakes one display's geometry for another's.
- */
-export declare function sharedBackendKey(id: string): number;