@fxi/zartigl 0.10.4 → 0.11.1

package/dist/engine.d.ts

@@ -178,7 +178,10 @@ export declare function createColorRampTexture(gl: WebGL2RenderingContext, ramp?
     alphaFade?: AlphaFade;
 }): WebGLTexture;
 
-/** The frame source decoding `manifest`: scalar or vector by its encoding. */
+/**
+ * The frame source decoding `manifest`: scalar or vector by its encoding.
+ * Scalar frames decode through WebCodecs where the browser supports it.
+ */
 export declare function createGeoVideoFrameSource(manifest: GeoVideoManifest, options?: {
     cacheSize?: number;
 }): GeoVideoScalarSource | GeoVideoVectorSource;
@@ -366,6 +369,8 @@ export declare class GeoVideoClock {
     /** Playhead, epoch ms. Assigning it also resets a terminal step's hold. */
     get ms(): number;
     set ms(value: number);
+    /** Progress through the final sample's held step, 0 elsewhere. */
+    get holdFraction(): number;
     /** Playback held, e.g. while a timeline thumb is held. */
     held: boolean;
     private playingValue;
@@ -381,6 +386,49 @@ export declare class GeoVideoClock {
     advance(dt: number, times: ArrayLike<number>, stepsPerSecond: number, range?: readonly [number, number], loop?: boolean, holdLastStep?: boolean): boolean;
 }
 
+/**
+ * Scalar-luma GeoVideo decoded with WebCodecs, in decode order: playback
+ * feeds the decoder sample after sample instead of seeking a video element,
+ * which redecodes from the previous keyframe at every step. A step behind
+ * the last one taken, or past a later keyframe, restarts at its keyframe.
+ * Frames stay images, decoded on the GPU by GEOVIDEO_SCALAR_GLSL like those
+ * of GeoVideoScalarSource, which serves browsers without WebCodecs for the
+ * codec.
+ */
+export declare class GeoVideoCodecScalarSource extends GeoVideoScalarSource {
+    private track;
+    private data;
+    /** Decode-order sample presenting each video frame. */
+    private sampleOfFrame;
+    private decoder;
+    /** Next sample (decode order) to feed; -1 when the decoder needs a reset. */
+    private fed;
+    /** Last video frame handed out; later frames can still be reached. */
+    private taken;
+    /** Decoded frames not taken yet, by video frame. */
+    private readonly outputs;
+    private progress;
+    private failure;
+    /** Aborts the media download of the current load on release. */
+    private loading;
+    /** True once the media decodes through WebCodecs. */
+    get usesWebCodecs(): boolean;
+    protected loadMedia(): Promise<void>;
+    release(): void;
+    protected decode(index: number, signal: AbortSignal): Promise<GeoVideoScalarFrame>;
+    private config;
+    /** Video frame `frame`, owned by the caller. */
+    private decodeFrame;
+    private dropOutputsBefore;
+    private keySample;
+    private restart;
+    private feed;
+    /** Next output, dequeue or error; a timer for decoders without events. */
+    private waitProgress;
+    private notify;
+    private closeDecoder;
+}
+
 /**
  * GeoVideo frames as textures, decoded ahead of the playhead: vector frames
  * as float (u, v, validity, 0), scalar frames as the browser decodes them,
@@ -416,6 +464,8 @@ export declare class GeoVideoField {
     get maxSpeed(): number;
     /** Resolves once the step at `ms` is uploaded. */
     prime(ms: number): Promise<void>;
+    /** The uploaded texture of the step at `ms`, or null. */
+    texture(ms: number): WebGLTexture | null;
     /** True once the frames interpolated at `ms` are uploaded. */
     ready(ms: number): boolean;
     /**
@@ -530,7 +580,8 @@ export declare abstract class GeoVideoFrameSource<TFrame> {
     private drop;
     private load;
     private loadMask;
-    private loadVideo;
+    /** Open the media; the default reads frames by seeking a video element. */
+    protected loadMedia(): Promise<void>;
     /** Seek to a frame and wait until it is presented. */
     private presentFrame;
     /**
@@ -539,6 +590,8 @@ export declare abstract class GeoVideoFrameSource<TFrame> {
      * playback would otherwise buffer far beyond the requested frame.
      */
     private primeDecoder;
+    /** Media time inside the video frame showing step `index`. */
+    protected stepSeconds(index: number): number;
     /**
      * Seek and capture one step. `signal` aborts it between steps; a seek
      * already started completes first, keeping the queue serial.
@@ -667,6 +720,12 @@ export declare class GeoVideoPlayback {
     constructor(options: GeoVideoPlaybackOptions, repaint: () => void, emit: <K extends keyof GeoVideoPlaybackEvents>(event: K, ...args: Parameters<GeoVideoPlaybackEvents[K]>) => void);
     load(gl: WebGL2RenderingContext, manifest: GeoVideoManifest): Promise<void>;
     sample(now: number): readonly [WebGLTexture, WebGLTexture, number] | null;
+    /**
+     * Through the final step of a chunk followed by a decoded one, the last
+     * frame blends into the next chunk's first, as steps do within a chunk:
+     * the chunk swap then lands on the frame already shown.
+     */
+    private handoff;
     get time(): number;
     get preloadedMediaUrl(): string | undefined;
     setStepsPerSecond(value: number): void;
@@ -861,6 +920,23 @@ export declare function getPalettes(options?: {
     includeDeprecated?: boolean;
 }): PaletteMeta[];
 
+/**
+ * Glow gain at glow = 1. A thin trail covers about a quarter of its glow
+ * texel, so this keeps the halo faint even over dense trails.
+ */
+export declare const GLOW_GAIN = 1.2;
+
+/**
+ * Particle glow, `vec4 glowGather(sampler2D trails, ivec2 texel)` and
+ * `vec4 addGlow(vec4 trail, sampler2D glowTex, vec2 uv, float gain)`; GLSL
+ * ES 3.0. Gather the trails into a texture GLOW_SCALE× smaller, then add it
+ * under them at GLOW_GAIN × the style's glow.
+ */
+export declare const GLOW_GLSL: string;
+
+/** Trail texels per glow texel along each axis: the chunk's GLOW_SCALE. */
+export declare const GLOW_SCALE = 4;
+
 /** Color grade of a style `particles.grade`; an object tunes the vibrant one. */
 export declare function gradeToColorGrade(grade: ParticleGrade | undefined): ColorGrade;
 

package/dist/engine.js

@@ -1,116 +1,63 @@
-import { I as u, J as v, K as f, L as x, G as g, M as _, N as V, T as p, O as G, P as C, b as S, Q as b, c as y, R as L, S as R, l as O, z as h, D as A, U as T, V as k, n as I, u as D, q as F, A as B, C as E, m as w, B as N, W as P, X as z, Y as M, Z as U, o as H, _ as K, $ as Y, a0 as q, E as J, a1 as Q, a2 as W, H as X, v as Z, a3 as $ } from "./geovideo-index-BqOLqzgA.js";
-import { B as ee, C as ae, e as oe, b as ne, d as re, c as ce, g as te, i as se, a as ie, r as le } from "./backdrop-DctkJ45Q.js";
-var e = `vec3 velocityValue(vec4 texel, vec2 minimum, vec2 maximum, float physical) {
-    if (physical > 0.5) return texel.xyz;
-    return vec3(mix(minimum, maximum, texel.rg), texel.a);
-}
-
-vec3 blendVelocity(vec3 a, vec3 b, float fraction) {
-    if (fraction <= 0.0) return a;
-    return mix(a, b, fraction);
-}`, a = `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);
-}
-
-vec3 gradeColor(vec3 c, vec4 g) {
-    float m = max(c.r, max(c.g, c.b));
-    if (m > 0.0) {
-        
-        
-        float e = g.x > 1e-3 ? (1.0 - exp(-g.x * m)) / (1.0 - exp(-g.x)) : m;
-        
-        e += g.w * smoothstep(0.5, 1.0, e) * (1.0 - e);
-        c *= e / m;
-    }
-    
-    c = mix(c, c * c * (3.0 - 2.0 * c), g.y);
-    return clamp(applyVibrance(c, g.z), 0.0, 1.0);
-}`, o = `uniform vec2 u_code_range;       
-uniform vec2 u_value_range;      
-uniform float u_scalar_transfer; 
-
-float geoVideoScalarCode(float r) {
-    return clamp((r - u_code_range.x) / (u_code_range.y - u_code_range.x), 0.0, 1.0);
-}
-
-float geoVideoScalarValue(float r) {
-    float code = geoVideoScalarCode(r);
-    float t = mix(code, (pow(10.0, code) - 1.0) / 9.0, u_scalar_transfer);
-    return mix(u_value_range.x, u_value_range.y, t);
-}`, n = `uint pcg(uint v) {
-    uint state = v * 747796405u + 2891336453u;
-    uint word = ((state >> ((state >> 28u) + 4u)) ^ state) * 277803737u;
-    return (word >> 22u) ^ word;
-}
-
-float random(uvec3 v) {
-    return float(pcg(v.x ^ pcg(v.y ^ pcg(v.z))) >> 8u) * (1.0 / 16777216.0);
-}`, 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 c = r, t = a, s = n, i = o, l = e;
+import { K as o, L as s, G as r, M as i, j as d, N as G, O as c, P as t, Q as l, R as V, m as n, S, U as C, V as L, T as u, W as m, X as O, Y as _, Z as p, b as R, _ as A, c as T, $ as x, a0 as g, n as k, B as F, F as I, a1 as h, a2 as v, p as D, x as E, u as f, C as B, E as b, o as N, D as P, a3 as y, a4 as M, a5 as W, a6 as U, q as H, a7 as K, a8 as Y, a9 as j, H as q, aa as J, ab as Q, J as X, v as Z, ac as $ } from "./engine-BBxJ6x3s.js";
+import { B as z, a as aa, f as ea, b as oa, e as sa, c as ra, g as ia, i as da, r as Ga, d as ca } from "./backdrop-Dceb4d8E.js";
 export {
-  ee as BACKDROP_OFF,
-  t as COLOR_GRADE_GLSL,
-  ae as COLOR_GRADE_OFF,
-  oe as COLOR_GRADE_VIBRANT,
-  i as GEOVIDEO_SCALAR_GLSL,
-  u as GeoVideoArchiveSource,
-  v as GeoVideoClock,
-  f as GeoVideoField,
-  x as GeoVideoFrameSource,
-  g as GeoVideoPlayback,
-  _ as GeoVideoScalarSource,
-  V as GeoVideoVectorSource,
-  s as RANDOM_GLSL,
-  p as TrailFade,
-  l as VELOCITY_BLEND_GLSL,
-  c as VIBRANCE_GLSL,
-  G as alphaFadeAt,
-  C as assertGeoVideoIndexIdentity,
-  ne as backdropVec4,
-  re as colorGradeToGrade,
-  ce as colorGradeVec4,
-  S as createColorRampTexture,
-  b as createGeoVideoFrameSource,
-  y as createProgram,
-  L as createShader,
-  R as fadeToFrames,
-  O as fadeToOpacity,
-  h as formatUnit,
-  A as geoVideoChunkSources,
-  T as geoVideoGrid,
-  k as geoVideoIndexChunks,
-  I as geoVideoScalarUniforms,
-  D as geoVideoTimelineValues,
-  F as getPalettes,
-  te as gradeToColorGrade,
+  z as BACKDROP_OFF,
+  o as COLOR_GRADE_GLSL,
+  aa as COLOR_GRADE_OFF,
+  ea as COLOR_GRADE_VIBRANT,
+  s as GEOVIDEO_SCALAR_GLSL,
+  r as GLOW_GAIN,
+  i as GLOW_GLSL,
+  d as GLOW_SCALE,
+  G as GeoVideoArchiveSource,
+  c as GeoVideoClock,
+  t as GeoVideoCodecScalarSource,
+  l as GeoVideoField,
+  V as GeoVideoFrameSource,
+  n as GeoVideoPlayback,
+  S as GeoVideoScalarSource,
+  C as GeoVideoVectorSource,
+  L as RANDOM_GLSL,
+  u as TrailFade,
+  m as VELOCITY_BLEND_GLSL,
+  O as VIBRANCE_GLSL,
+  _ as alphaFadeAt,
+  p as assertGeoVideoIndexIdentity,
+  oa as backdropVec4,
+  sa as colorGradeToGrade,
+  ra as colorGradeVec4,
+  R as createColorRampTexture,
+  A as createGeoVideoFrameSource,
+  T as createProgram,
+  x as createShader,
+  g as fadeToFrames,
+  k as fadeToOpacity,
+  F as formatUnit,
+  I as geoVideoChunkSources,
+  h as geoVideoGrid,
+  v as geoVideoIndexChunks,
+  D as geoVideoScalarUniforms,
+  E as geoVideoTimelineValues,
+  f as getPalettes,
+  ia as gradeToColorGrade,
   B as isGeoVideoArchiveSource,
-  se as isHexColor,
-  E as loadGeoVideoIndex,
-  w as loadGeoVideoManifest,
-  N as nextChunk,
-  P as nextChunkSpan,
-  z as pairChunk,
-  M as pairChunkSpan,
+  da as isHexColor,
+  b as loadGeoVideoIndex,
+  N as loadGeoVideoManifest,
+  P as nextChunk,
+  y as nextChunkSpan,
+  M as pairChunk,
+  W as pairChunkSpan,
   U as parseTimeRange,
-  ie as resolveBackdrop,
-  le as resolveColorGrade,
+  Ga as resolveBackdrop,
+  ca as resolveColorGrade,
   H as resolveColorRamp,
   K as stepTime,
   Y as subtractIsoDuration,
-  q as timeBracket,
-  J as timeRangeBounds,
-  Q as timeStep,
-  W as validateGeoVideoIndex,
+  j as timeBracket,
+  q as timeRangeBounds,
+  J as timeStep,
+  Q as validateGeoVideoIndex,
   X as validateGeoVideoManifest,
   Z as validateScalarColorDomain,
   $ as velocityTexels