@fxi/zartigl 0.8.0 → 0.9.1

package/dist/engine.d.ts

@@ -181,6 +181,14 @@ export declare function fadeToOpacity(fade: number): number;
  */
 export declare function formatUnit(unit: string | undefined): string;
 
+/**
+ * `float geoVideoScalarValue(float r)`: a scalar-luma frame's red channel to
+ * its value, with the `u_code_range` / `u_value_range` uniforms it declares
+ * (geoVideoScalarUniforms); GLSL ES 1.0 and 3.0. The one scalar GeoVideo
+ * decoder: frames go to the GPU as images, never read back.
+ */
+export declare const GEOVIDEO_SCALAR_GLSL: string;
+
 /**
  * One immutable chunk of a GeoVideo archive, independent of the catalog: a
  * manifest and the range of its encoded samples.
@@ -315,8 +323,8 @@ export declare interface GeoVideoChunkSpan {
     end: number;
 }
 
-/** Scalar values (NaN invalid) or u/v components (NaN invalid). */
-export declare type GeoVideoFrameData = Float32Array | GeoVideoVectorFrame;
+/** A scalar frame image (decoded on the GPU) or u/v components (NaN invalid). */
+export declare type GeoVideoFrameData = GeoVideoScalarFrame | GeoVideoVectorFrame;
 
 /** The part of a frame source an archive reads. */
 export declare interface GeoVideoFrameReader<TFrame> {
@@ -332,11 +340,12 @@ export declare interface GeoVideoFrameRequest {
 
 /**
  * GeoVideo frames read one time step at a time (seek, no playback): video
- * and static mask loading, luma readback, a serial decode queue, and a small
- * LRU cache of decoded frames. Requests for the same step share one decode;
- * each can be abandoned with its own signal, and the decode is dropped once
- * no request waits for it. cancelAll() aborts every pending decode.
- * Subclasses turn the luma codes of a frame into values.
+ * and static mask loading, a serial decode queue, and a small LRU cache of
+ * decoded frames. Requests for the same step share one decode; each can be
+ * abandoned with its own signal, and the decode is dropped once no request
+ * waits for it. cancelAll() aborts every pending decode. Subclasses capture
+ * the presented frame: read back as luma codes (readCodes) or kept as an
+ * image for the GPU.
  */
 export declare abstract class GeoVideoFrameSource<TFrame> {
     /** Grid size; the video stacks `planes` grids vertically. */
@@ -348,7 +357,7 @@ export declare abstract class GeoVideoFrameSource<TFrame> {
     private readonly cacheSize;
     private readonly reader;
     private video;
-    private mask;
+    private maskCodes;
     private initPromise;
     private presented;
     private primed;
@@ -361,8 +370,17 @@ export declare abstract class GeoVideoFrameSource<TFrame> {
     constructor(manifest: GeoVideoManifest, planes: number, options?: {
         cacheSize?: number;
     });
-    /** Codes of the stacked planes and the per-cell mask to frame values. */
-    protected abstract decodeCodes(codes: Uint8Array, mask: Uint8Array, threshold: number): TFrame;
+    /**
+     * The presented frame (`rows` = stacked planes) and the per-cell mask to
+     * frame data; null when the decoder exposed no pixels yet.
+     */
+    protected abstract capture(video: HTMLVideoElement, rows: number, mask: Uint8Array): Promise<TFrame | null>;
+    /** Static validity, one 8-bit value per grid cell; null before init(). */
+    get mask(): Uint8Array | null;
+    /** Luma codes of the presented frame, or null when it is blank. */
+    protected readCodes(video: HTMLVideoElement, rows: number): Uint8Array | null;
+    /** True when the decoder exposed no pixels; reads back one row only. */
+    protected isBlank(video: HTMLVideoElement): boolean;
     init(): Promise<void>;
     /** Abort every pending frame decode; frames already decoded stay cached. */
     cancelAll(): void;
@@ -390,8 +408,8 @@ export declare abstract class GeoVideoFrameSource<TFrame> {
      */
     private primeDecoder;
     /**
-     * Seek, read back and decode one step. `signal` aborts it between steps;
-     * a seek already started completes first, keeping the queue serial.
+     * Seek and capture one step. `signal` aborts it between steps; a seek
+     * already started completes first, keeping the queue serial.
      */
     protected decode(index: number, signal: AbortSignal): Promise<TFrame>;
 }
@@ -514,18 +532,28 @@ export declare interface GeoVideoScalarEncoding {
     colorRange: "limited" | "full";
 }
 
+/** One scalar-luma frame, as decoded by the browser; GPU input only. */
+export declare type GeoVideoScalarFrame = ImageBitmap;
+
 /**
- * Scalar-luma GeoVideo read frame by frame (seek, no playback), for values
- * sampled on the GPU rather than the styled playback of GeoVideoLayer.
+ * Scalar-luma GeoVideo read frame by frame (seek, no playback). Frames stay
+ * images, uploaded as textures and decoded by GEOVIDEO_SCALAR_GLSL, the
+ * decoder GeoVideoLayer uses: never read back, so both renderers turn the
+ * same pixels into the same values.
  */
-export declare class GeoVideoScalarSource extends GeoVideoFrameSource<Float32Array> {
-    private readonly encoding;
+export declare class GeoVideoScalarSource extends GeoVideoFrameSource<GeoVideoScalarFrame> {
     constructor(manifest: GeoVideoManifest, options?: {
         cacheSize?: number;
     });
-    protected decodeCodes(codes: Uint8Array, mask: Uint8Array, threshold: number): Float32Array;
+    protected capture(video: HTMLVideoElement): Promise<GeoVideoScalarFrame | null>;
 }
 
+/** Uniforms of GEOVIDEO_SCALAR_GLSL for a scalar-luma encoding. */
+export declare function geoVideoScalarUniforms(encoding: Pick<GeoVideoScalarEncoding, "codeMin" | "codeMax" | "valueMin" | "valueMax">): {
+    codeRange: [number, number];
+    valueRange: [number, number];
+};
+
 declare interface GeoVideoSnapshotLoopTimeline {
     kind: "snapshot-loop";
     date: string;
@@ -592,7 +620,8 @@ export declare class GeoVideoVectorSource extends GeoVideoFrameSource<GeoVideoVe
     fetchSpatialChunkResult(variable: string, selection: {
         timeIndex: number;
     }): Promise<ZarrChunkFetchResult>;
-    protected decodeCodes(codes: Uint8Array, mask: Uint8Array, threshold: number): GeoVideoVectorFrame;
+    /** u/v codes are written into luma: read back, then decoded on the CPU. */
+    protected capture(video: HTMLVideoElement, rows: number, mask: Uint8Array): Promise<GeoVideoVectorFrame | null>;
 }
 
 export declare function getPalettes(): PaletteMeta[];

package/dist/engine.js

@@ -1,5 +1,5 @@
-import { E as d, F as i, H as l, G as m, T as u, I as v, b as x, J as g, c as p, K as f, L as G, l as V, x as C, C as b, M as S, N as R, q as _, y as O, z as h, B as A, m as L, A as F, O as T, P as k, Q as y, o as I, R as D, D as B, v as E } from "./geovideo-index-_qQ6iS2d.js";
-import { B as M, C as N, e as P, b as z, d as H, c as K, g as q, i as J, a as Q, r as U } from "./backdrop-DctkJ45Q.js";
+import { F as i, H as u, I as m, G as v, T as g, J as x, b as f, K as _, c as p, L as V, M as G, l as C, y as S, D as b, N as O, O as R, n as L, t as A, z as h, A as y, C as F, m as I, B as T, P as k, Q as D, R as E, p as B, S as w, E as M, v as N } from "./geovideo-index-CzQo6UIG.js";
+import { B as z, C as H, e as K, b as U, d as J, c as Q, g as j, i as q, a as W, r as X } from "./backdrop-DctkJ45Q.js";
 var e = `vec3 applyVibrance(vec3 c, float v) {
     float mx = max(c.r, max(c.g, c.b));
     float mn = min(c.r, min(c.g, c.b));
@@ -21,7 +21,13 @@ vec3 gradeColor(vec3 c, vec4 g) {
     
     c = mix(c, c * c * (3.0 - 2.0 * c), g.y);
     return clamp(applyVibrance(c, g.z), 0.0, 1.0);
-}`, a = `uint pcg(uint v) {
+}`, a = `uniform vec2 u_code_range;   
+uniform vec2 u_value_range;  
+
+float geoVideoScalarValue(float r) {
+    float code = clamp((r - u_code_range.x) / (u_code_range.y - u_code_range.x), 0.0, 1.0);
+    return mix(u_value_range.x, u_value_range.y, code);
+}`, o = `uint pcg(uint v) {
     uint state = v * 747796405u + 2891336453u;
     uint word = ((state >> ((state >> 28u) + 4u)) ^ state) * 277803737u;
     return (word >> 22u) ^ word;
@@ -29,55 +35,57 @@ vec3 gradeColor(vec3 c, vec4 g) {
 
 float random(uvec3 v) {
     return float(pcg(v.x ^ pcg(v.y ^ pcg(v.z))) >> 8u) * (1.0 / 16777216.0);
-}`, o = `vec3 applyVibrance(vec3 c, float v) {
+}`, r = `vec3 applyVibrance(vec3 c, float v) {
     float mx = max(c.r, max(c.g, c.b));
     float mn = min(c.r, min(c.g, c.b));
     float boost = v * (1.0 - (mx - mn));
     float luma = dot(c, vec3(0.299, 0.587, 0.114));
     return mix(vec3(luma), c, 1.0 + boost);
 }`;
-const r = o, n = e, c = a;
+const n = r, c = e, t = o, s = a;
 export {
-  M as BACKDROP_OFF,
-  n as COLOR_GRADE_GLSL,
-  N as COLOR_GRADE_OFF,
-  P as COLOR_GRADE_VIBRANT,
-  d as GeoVideoArchiveSource,
-  i as GeoVideoFrameSource,
-  l as GeoVideoScalarSource,
-  m as GeoVideoVectorSource,
-  c as RANDOM_GLSL,
-  u as TrailFade,
-  r as VIBRANCE_GLSL,
-  v as assertGeoVideoIndexIdentity,
-  z as backdropVec4,
-  H as colorGradeToGrade,
-  K as colorGradeVec4,
-  x as createColorRampTexture,
-  g as createGeoVideoFrameSource,
+  z as BACKDROP_OFF,
+  c as COLOR_GRADE_GLSL,
+  H as COLOR_GRADE_OFF,
+  K as COLOR_GRADE_VIBRANT,
+  s as GEOVIDEO_SCALAR_GLSL,
+  i as GeoVideoArchiveSource,
+  u as GeoVideoFrameSource,
+  m as GeoVideoScalarSource,
+  v as GeoVideoVectorSource,
+  t as RANDOM_GLSL,
+  g as TrailFade,
+  n as VIBRANCE_GLSL,
+  x as assertGeoVideoIndexIdentity,
+  U as backdropVec4,
+  J as colorGradeToGrade,
+  Q as colorGradeVec4,
+  f as createColorRampTexture,
+  _ as createGeoVideoFrameSource,
   p as createProgram,
-  f as createShader,
+  V as createShader,
   G as fadeToFrames,
-  V as fadeToOpacity,
-  C as formatUnit,
+  C as fadeToOpacity,
+  S as formatUnit,
   b as geoVideoChunkSources,
-  S as geoVideoGrid,
+  O as geoVideoGrid,
   R as geoVideoIndexChunks,
-  _ as geoVideoTimelineValues,
-  O as getPalettes,
-  q as gradeToColorGrade,
-  h as isGeoVideoArchiveSource,
-  J as isHexColor,
-  A as loadGeoVideoIndex,
-  L as loadGeoVideoManifest,
-  F as nextChunk,
-  T as nextChunkSpan,
-  k as pairChunk,
-  y as pairChunkSpan,
-  Q as resolveBackdrop,
-  U as resolveColorGrade,
-  I as resolveColorRamp,
-  D as validateGeoVideoIndex,
-  B as validateGeoVideoManifest,
-  E as validateScalarColorDomain
+  L as geoVideoScalarUniforms,
+  A as geoVideoTimelineValues,
+  h as getPalettes,
+  j as gradeToColorGrade,
+  y as isGeoVideoArchiveSource,
+  q as isHexColor,
+  F as loadGeoVideoIndex,
+  I as loadGeoVideoManifest,
+  T as nextChunk,
+  k as nextChunkSpan,
+  D as pairChunk,
+  E as pairChunkSpan,
+  W as resolveBackdrop,
+  X as resolveColorGrade,
+  B as resolveColorRamp,
+  w as validateGeoVideoIndex,
+  M as validateGeoVideoManifest,
+  N as validateScalarColorDomain
 };