@vectoriox/iox-ui 5.75.3 → 5.76.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vectoriox/iox-ui",
-  "version": "5.75.3",
+  "version": "5.76.0",
   "peerDependencies": {
     "@angular/common": ">=20.0.0",
     "@angular/core": ">=20.0.0",

package/src/media-core/frames.ts

@@ -111,23 +111,6 @@ export function framePosition(played: number, count: number): number {
 /** On a Video whose pictures are drawing: the poster has done its job and steps aside. */
 export const FRAMES_SHOWING_ATTRIBUTE = 'data-iox-frames-showing';
 
-/**
- * Below this many pictures a second the film stops following the scroll exactly and lands on its own. A landing scroll
- * slows exponentially, so the last picture or two would take most of a second as one slow dissolve between two places:
- * the subject showing twice, and then settling. Landing at least this fast keeps the end of the move a move.
- */
-export const FILM_LANDING_SPEED = 10;
-/** With no word from the driver on where the scroll is going, how fast a landing scroll is assumed to slow (per second). */
-const FILM_LANDING_DECAY = 5;
-/** How quickly the film catches up with a scroll that turned back while it was landing ahead of it (per second). */
-const FILM_CATCH_RATE = 25;
-/** How quickly the film's reading of the scroll's speed follows it (per second). */
-const FILM_SPEED_RATE = 30;
-/** A step this short is the same frame asked twice: it moves nothing and reads no speed. */
-const FILM_SAME_FRAME_SECONDS = 0.002;
-const FILM_MAX_STEP_SECONDS = 0.1;
-const FILM_EPSILON = 1e-6;
-
 /** How finely two neighbours mix. Finer than the eye reads, and a scroll that moves less than a step draws nothing. */
 export const FRAME_BLEND_STEPS = 32;
 
@@ -152,59 +135,6 @@ export function frameBlendAt(loaded: ReadonlyArray<unknown>, position: number):
     return nearest < 0 ? null : { from: nearest, to: nearest, mix: 0 };
 }
 
-/** Where the film stands and how the scroll under it moves: what one landing step reads and writes. */
-export interface FilmMotion {
-    /** The moment drawn, in pictures (2.5 = half way from the third to the fourth). */
-    position: number;
-    /** The moment the scroll asks for. */
-    wanted: number;
-    /** The scroll's speed, in pictures a second, smoothed. */
-    speed: number;
-    /** The way the scroll last moved: 1 onward, -1 back. */
-    direction: 1 | -1;
-}
-
-/** Where a film stands before its first step: on the moment asked for, still. */
-export function filmAt(wanted: number): FilmMotion {
-    return { position: wanted, wanted, speed: 0, direction: 1 };
-}
-
-/**
- * One step of the film. Moving fast, it stands exactly where the scroll asks. Landing (slower than FILM_LANDING_SPEED
- * pictures a second) it runs on at that speed to the whole picture nearest where the scroll will stop, and stands there:
- * it never crawls through a dissolve, never stops between two pictures, and never steps back over a picture it reached
- * unless the scroll turns. `aim` is where the scroll is heading, when the driver knows it (its undamped target); without it, it is guessed.
- */
-export function stepFilm(motion: FilmMotion, wanted: number, seconds: number, last: number, aim?: number): FilmMotion {
-    const sameFrame = seconds < FILM_SAME_FRAME_SECONDS;
-    const step = Math.min(FILM_MAX_STEP_SECONDS, seconds);
-    const moved = wanted - motion.wanted;
-    const speed = sameFrame ? motion.speed : motion.speed + (moved / step - motion.speed) * (1 - Math.exp(-FILM_SPEED_RATE * step));
-    const heading = aim === undefined ? moved : aim - wanted;
-    const direction: 1 | -1 = Math.abs(heading) > FILM_EPSILON ? (heading > 0 ? 1 : -1) : Math.abs(moved) > FILM_EPSILON ? (moved > 0 ? 1 : -1) : motion.direction;
-    // Moving: with the scroll, but never back over a picture a landing already reached unless the scroll turned.
-    if (Math.abs(speed) >= FILM_LANDING_SPEED) {
-        const position = direction > 0 ? Math.max(wanted, Math.min(motion.position, Math.ceil(wanted))) : Math.min(wanted, Math.max(motion.position, Math.floor(wanted)));
-        return { position, wanted, speed, direction };
-    }
-    if (sameFrame) return { ...motion, wanted, direction };
-    const clamp = (value: number): number => Math.min(last, Math.max(0, value));
-    const stop = aim ?? wanted + speed / FILM_LANDING_DECAY;
-    // The picture nearest the stop, unless reaching it would show a step back: then the next whole one on the way.
-    const nearest = Math.round(stop);
-    const back = (motion.position - nearest) * direction > 1 / FRAME_BLEND_STEPS;
-    const goal = clamp(back ? (direction > 0 ? Math.ceil(motion.position) : Math.floor(motion.position)) : nearest);
-    const behind = (wanted - motion.position) * direction;
-    const reach = Math.max(FILM_LANDING_SPEED * step, behind > 0 ? behind * (1 - Math.exp(-FILM_CATCH_RATE * step)) : 0);
-    const position = direction > 0 ? Math.min(goal, motion.position + reach) : Math.max(goal, motion.position - reach);
-    return { position, wanted, speed, direction };
-}
-
-/** Whether a film has landed: still, on a whole picture beside where the scroll stands. */
-export function filmLanded(motion: FilmMotion): boolean {
-    return Math.abs(motion.speed) < 0.01 && Number.isInteger(motion.position) && Math.abs(motion.position - motion.wanted) < 1;
-}
-
 /** The picture at `played` % of a set of `count`. */
 export function frameIndexAt(played: number, count: number): number {
     if (count <= 1) return 0;
@@ -321,10 +251,6 @@ export interface FramePlayerOptions {
  */
 export class FramePlayer {
     private played: number | null = null;
-    private aim: number | undefined;
-    private motion: FilmMotion | null = null;
-    private steppedAt = 0;
-    private landingFrame: number | null = null;
     private readonly set: FrameSet;
     private readonly info: FrameSetInfo;
     private readonly images: Array<HTMLImageElement | null>;
@@ -360,33 +286,13 @@ export class FramePlayer {
     }
 
     /**
-     * Stand at `played` %, on the way to `aim` % when the caller knows where the scroll is going. `now` is the caller's
-     * frame time: the player keeps time by frames, so a frame asked twice moves once however long the page took.
+     * Stand at `played` %, exactly. The film keeps no motion of its own: the scroll's glide, and the slowing at its end,
+     * are the caller's, so the film slows with the page and stops when it stops. Between two pictures it blends them.
      */
-    seek(played: number, aim?: number, now?: number): void {
-        if (played === this.played && aim === this.aim) return;
+    seek(played: number): void {
+        if (played === this.played) return;
         this.played = played;
-        this.aim = aim;
-        this.step(now ?? this.host.performance?.now() ?? 0);
-    }
-
-    /** One step toward the moment asked for, drawn now; a landing goes on by itself until it stands on a whole picture. */
-    private step(now: number): void {
-        if (this.destroyed || this.played === null) return;
-        const wanted = framePosition(this.played, this.info.count);
-        const aim = this.aim === undefined ? undefined : framePosition(this.aim, this.info.count);
-        this.motion = this.motion ? stepFilm(this.motion, wanted, (now - this.steppedAt) / 1000, this.info.count - 1, aim) : filmAt(wanted);
-        this.steppedAt = now;
         this.draw();
-        if (!filmLanded(this.motion) && this.landingFrame === null) this.landingFrame = this.host.requestAnimationFrame(time => {
-            this.landingFrame = null;
-            this.step(time);
-        });
-    }
-
-    private stopLanding(): void {
-        if (this.landingFrame !== null) this.host.cancelAnimationFrame?.(this.landingFrame);
-        this.landingFrame = null;
     }
 
     /** Whether a re-render took the canvas away with the markup it sat in. */
@@ -396,7 +302,6 @@ export class FramePlayer {
 
     destroy(): void {
         this.destroyed = true;
-        this.stopLanding();
         this.el.removeAttribute(FRAMES_SHOWING_ATTRIBUTE);
         this.observer?.disconnect();
         this.observer = null;
@@ -457,8 +362,8 @@ export class FramePlayer {
     }
 
     private draw(): void {
-        if (!this.motion) return;
-        const blend = frameBlendAt(this.images, this.motion.position);
+        if (this.destroyed || this.played === null) return;
+        const blend = frameBlendAt(this.images, framePosition(this.played, this.info.count));
         const last = this.drawn;
         if (!blend || (last && last.from === blend.from && last.to === blend.to && last.mix === blend.mix)) return;
         const image = this.images[blend.from]!;
@@ -466,11 +371,19 @@ export class FramePlayer {
         const context = this.context!;
         const { width, height } = this.canvas!;
         context.clearRect(0, 0, width, height);
-        context.drawImage(image, 0, 0, width, height);
         if (blend.mix > 0) {
+            // A true mix, (1 − mix)·from + mix·to, even where a see-through film has nothing on one side. Drawing `to` over
+            // an opaque `from` kept `from`'s outline whole until the next picture, so the subject's edge jumped a picture at
+            // a time instead of moving.
+            context.globalCompositeOperation = 'lighter';
+            context.globalAlpha = 1 - blend.mix;
+            context.drawImage(image, 0, 0, width, height);
             context.globalAlpha = blend.mix;
             context.drawImage(this.images[blend.to]!, 0, 0, width, height);
             context.globalAlpha = 1;
+            context.globalCompositeOperation = 'source-over';
+        } else {
+            context.drawImage(image, 0, 0, width, height);
         }
         // Over a transparent film the poster would show through: a second, stiller subject behind the moving one.
         if (!this.drawn) this.el.setAttribute(FRAMES_SHOWING_ATTRIBUTE, '');

package/src/scene-core/scroll-driver.ts

@@ -19,7 +19,8 @@ import { LIGHT_UP_PIECE_CAP, SplitText, splitText } from './split-text';
  */
 
 export const SCENE_DAMPING = 9;
-const SETTLED = 0.0005;
+/** Page px from the scroll at which the damping stops and stands exactly on it: a step this small never shows. */
+const SETTLED_PX = 0.25;
 const MAX_FRAME_SECONDS = 0.1;
 /** The first frame after a sleep has no previous one to measure from: it counts as one frame, or a scroll would lose it. */
 const WAKING_FRAME_SECONDS = 1 / 60;
@@ -263,11 +264,12 @@ export class ScrollDriver {
         for (const { scene, local, target } of reads) {
             if (this.options.pin && scene.stage) scene.stage.style.setProperty('translate', `0 ${local}px`);
             const next = scene.fresh ? target : dampToward(scene.progress, target, seconds, this.options.damping);
-            const settled = Math.abs(next - target) < SETTLED;
+            // The step onto the scroll is what is left: taken once it is under SETTLED_PX, so it never shows.
+            const settled = scene.fresh || Math.abs(target - scene.progress) * Math.max(1, scene.travel) < SETTLED_PX;
             scene.progress = settled ? target : next;
             scene.target = target;
             scene.fresh = false;
-            this.write(scene, now);
+            this.write(scene);
             this.options.onFrame?.(scene.root, { target, progress: scene.progress });
             moving = moving || !settled;
         }
@@ -283,11 +285,11 @@ export class ScrollDriver {
         return { scene, local, target: progress };
     }
 
-    private write(scene: Scene, now: number): void {
+    private write(scene: Scene): void {
         for (const layer of scene.layers) {
             const tracks = scene.phone && layer.phoneTracks.length ? layer.phoneTracks : layer.tracks;
             this.writeWords(layer, sceneWordsLit(tracks, scene.progress));
-            this.writePlayed(layer, scene, scenePlayed(tracks, scene.progress), scenePlayed(tracks, scene.target), now);
+            this.writePlayed(layer, scene, scenePlayed(tracks, scene.progress));
             const frame = sceneFrame(tracks, scene.progress, { inlineSign: scene.inlineSign });
             for (const key of Object.keys(frame) as (keyof SceneFrame)[]) {
                 if (layer.stale || frame[key] !== layer.last[key]) layer.el.style[key] = frame[key] ?? '';
@@ -305,7 +307,7 @@ export class ScrollDriver {
      * The picture this moment asks for. The attribute sits on the Video's own root, which is the layer on the string path
      * and inside it on the component path. A layer with no pictures, or no Play track, holds its poster.
      */
-    private writePlayed(layer: Layer, scene: Scene, played: number | null, aim: number | null, now: number): void {
+    private writePlayed(layer: Layer, scene: Scene, played: number | null): void {
         const target = played === null ? null : (layer.el.hasAttribute(VideoAttribute.Frames) ? layer.el : layer.el.querySelector<HTMLElement>(`[${VideoAttribute.Frames}]`));
         const raw = target?.getAttribute(VideoAttribute.Frames) ?? '';
         const sequence = raw ? normalizeFrameSequence(raw) : null;
@@ -319,8 +321,8 @@ export class ScrollDriver {
             layer.player = new FramePlayer(target, sequence, { phone: scene.phone, near: scene.root, host: this.host });
             layer.playerKey = key;
         }
-        // Where the damping is heading, so a landing film stops on the picture the scroll stops on, not one past it.
-        layer.player.seek(played!, aim ?? undefined, now);
+        // The damped moment, like every other layer: the film slows with the page and stops when it stops.
+        layer.player.seek(played!);
     }
 
     /** One opacity per word, and a write only for the few the scroll actually changed. */