@norbert_bodziony/bloub 0.3.0 → 0.6.0

package/dist/package/types/plush/motion.d.ts

@@ -0,0 +1,236 @@
+import { type Look } from '../bot/engine.js';
+import { type BotExpression } from '../bot/expressions.js';
+import { type StateId } from '../bot/states.js';
+import type { GazeScript } from '../ui/gaze.js';
+import type { PlushPad, PlushState } from './catalogue.js';
+/**
+ * L'etat du moteur sous un etat de peluche. `thinking`, `asleep` et `failed` gardent le
+ * corps au repos : le moteur reste sur `idle`, la peluche ne change que le visage et le decor.
+ */
+export declare const engineState: (state: PlushState) => StateId;
+/**
+ * Duree d'arrivee dans un etat : le `morph` de l'etat du moteur du meme nom. `asleep` prend
+ * celui de `sleep` (l'endormissement de la video), `failed` celui du repos, qu'il garde.
+ */
+export declare const morphOf: (state: PlushState) => number;
+/**
+ * La derive du regard au repos, reduite : c'est celle que les six personnages ont eue
+ * pendant tout l'essai, celle que l'utilisateur a validee. `mix` nul : le regard reste
+ * celui de la pose (le visage au repos, le regard releve d'un clin d'oeil).
+ */
+export declare const REST_LOOK: Look;
+/**
+ * Le regard pendant `thinking` : en haut, du cote des points. CHOISI, pas releve — la video
+ * n'a pas de peluche qui reflechit. Sous le tangage du visage `neutre` (28,6°), donc aucun
+ * oeil ne passe le limbe.
+ */
+export declare const THINK_LOOK: Look;
+/**
+ * Le regard endormi : la derive presque eteinte (les yeux fermes ne cherchent rien) et plus
+ * aucun clignement : des yeux fermes ne clignent pas. CHOISI.
+ */
+export declare const ASLEEP_LOOK: Look;
+/** Le regard d'un etat : `thinking` vise les points, `asleep` dort, les autres sont au repos. */
+export declare const lookOf: (state: PlushState) => Look;
+/**
+ * Un regard qui glisse de `from` a `to` en `duration`, avec la courbe des morphs du moteur.
+ * Le composant applique un script image par image (rattrapage d'1/60 s) : c'est donc au
+ * script d'etre continu, et il l'est parce que `from` est le dernier regard rendu.
+ */
+export declare const glide: (from: Look, to: Look, duration: number) => GazeScript;
+/** amplitude du « non », en degres de lacet */
+export declare const SHAKE_YAW = 12;
+/** duree du « non » : deux allers-retours */
+export declare const SHAKE = 0.8;
+export declare const shake: (t: number) => number;
+/**
+ * Le script de regard a l'entree dans un etat, depuis le dernier regard rendu : un glissement
+ * vers le regard de l'etat, et le « non » de `failed` par-dessus. Le « non » passe par `spin`,
+ * qui s'ajoute au lacet quel que soit `mix` : il secoue le regard de la pose, pas une cible.
+ */
+export declare function enter(from: Look, state: PlushState): GazeScript;
+/**
+ * Endormi : les deux yeux fermes, avec le regard tombant et l'ecart de `somnolent`, le
+ * visage d'avant le sommeil. Pas au catalogue des expressions, comme les visages des
+ * personnages.
+ */
+export declare const ASLEEP_FACE: BotExpression;
+/** largeur/hauteur d'un oeil rond aplati par `failed` : juste au-dela de la bande ou une pente se perd */
+export declare const FAILED_ASPECT = 1.8;
+/** l'oeil le plus ouvert d'un visage (aire de la gelule), que `failed` donne aux deux yeux */
+export declare const openEye: (face: BotExpression) => 0 | 1;
+export declare function failedFace(base: BotExpression): BotExpression;
+/** Les patins de `failed` : celui de l'oeil le plus ouvert, chacun a sa place (`dx`, `dy`). */
+export declare function failedPads(pads: readonly [PlushPad, PlushPad], base: BotExpression): readonly [PlushPad, PlushPad];
+/**
+ * Le passage d'un patin a l'autre en entrant dans `failed` ou en en sortant : un fondu, sur
+ * la duree et la courbe du changement de visage du moteur (`SHAPE_MORPH`, easeOutQuint),
+ * pendant que la gelule glisse. Une photo ne se deforme pas en une autre ; sans fondu,
+ * l'oeil plisse de Vita doublait de largeur d'une image a l'autre. `start` est le niveau
+ * d'ou part le nouveau patin : un aller-retour en plein fondu repart de ce qu'on voit.
+ */
+export interface PadFade {
+    from: readonly [PlushPad, PlushPad] | null;
+    at: number;
+    start: number;
+}
+export declare const NO_PAD_FADE: PadFade;
+/** opacite des patins courants ; ceux de `from` ont le complement */
+export declare const padFadeLevel: (fade: PadFade, t: number) => number;
+export declare const padFadeToggle: (fade: PadFade, from: readonly [PlushPad, PlushPad], t: number) => PadFade;
+/**
+ * Agrandir les yeux (`eyeScale`) sans les pousser hors du corps ni les souder. Grandir chacun
+ * autour de son centre ne va pas : le regard au repos du moteur porte les yeux contre le bord,
+ * en haut a droite, et l'oeil agrandi le traverse ; et des yeux deja proches (`wide`,
+ * `notify`, Fred) se touchent. C'est donc le VISAGE entier qui grandit — tailles et ecart
+ * ensemble, aucun oeil ne gagne sur l'autre — autour de son point le plus exterieur : le
+ * point du visage le plus loin du centre du corps, dans la direction centre -> visage. Ce
+ * point reste la ou le moteur l'a pose, avec la marge que le moteur lui a laissee, et le
+ * visage gagne sa taille vers l'interieur.
+ *
+ * `eyes` : la matrice de chaque oeil (a, b, c, d, e, f, e et f deja decales du patin) et la
+ * taille de sa gelule. Rend, par oeil, le deplacement de son centre a l'ecran ; sa taille,
+ * elle, est multipliee par `scale` dans son repere. Une fonction continue de l'image
+ * courante (un `max` de fonctions continues), sans choix ni recherche : rien a faire
+ * trembler (cf. `eyefit.ts`).
+ */
+export declare function faceGrowth(eyes: readonly {
+    m: readonly number[];
+    w: number;
+    h: number;
+}[], scale: number): {
+    x: number;
+    y: number;
+}[];
+/** les six nombres d'une chaine `matrix(a,b,c,d,e,f)` */
+export declare const matrixOf: (transform: string) => number[];
+/**
+ * La frange du feutre, hors de la gelule, en petits cotes : `dehors` (30 px) sur la gelule de
+ * reference (205 px de petit cote) de `tools/peluche/fit/feutre.py`. Les paupieres se posent
+ * au-dela : le patin garde son bord de fibres, qui fait la douceur de la paupiere.
+ */
+export declare const LID_FRANGE: number;
+/**
+ * Douceur du bord des paupieres, au-dela de la frange, en petits cotes (CHOISI, juge a 4x sur
+ * Yoshi `curieux`, `fier` et `somnolent`) : ce qui reste de l'ombre portee s'y eteint. A 0,25,
+ * c'etait un halo translucide autour du patin.
+ */
+export declare const LID_SOFT = 0.1;
+/** le bord doux en paliers : autant de gelules imbriquees (CHOISI) */
+export declare const LID_BANDS = 4;
+/**
+ * L'ouverture s'elargit de la gelule a toute l'image (ombre portee) en `l^LID_MARGE` (CHOISI) :
+ * a l'ouvert tout est visible, sans saut au debut d'un clignement, mais des que l'oeil se ferme
+ * un peu, les paupieres suivent la gelule, comme le trou du moteur. A 4, la marge tenait encore
+ * a mi-clignement : une gelule bien plus large que le patin, dont les arcs le coupaient presque
+ * a plat, un patin rond (Fred) se fermait en carre.
+ */
+export declare const LID_MARGE = 8;
+/** les paupieres d'un oeil qui cligne */
+export interface LidMask {
+    /** le centre de l'oeil (avant le decalage du patin) et l'ecrasement vertical, a l'ecran, autour de lui */
+    x: number;
+    y: number;
+    s: number;
+    /**
+     * des gelules imbriquees, dans le repere du patin (sous sa correction), de la plus large a
+     * l'ouverture elle-meme : demi-largeur, demi-hauteur, rayon et opacite. Peintes l'une sur
+     * l'autre, elles montent par paliers egaux de 0 au bord a 1 dans l'ouverture.
+     */
+    bands: {
+        w: number;
+        h: number;
+        r: number;
+        alpha: number;
+    }[];
+}
+/**
+ * Le moteur ferme un oeil en l'ecrasant verticalement A L'ECRAN (`open`, compose en dernier
+ * dans la matrice `L = ecrasement . L0`) : c'est la mesure pour le trou du masque plat, mais
+ * ecraser une photo de feutre en fait un baton. Le patin est donc pose avec `L0` : cette
+ * matrice, `L^-1 . L0`, se met SOUS celle de l'oeil et lui retire l'ecrasement. Oeil
+ * ouvert, `undefined` : rien a retirer.
+ */
+export declare function unsquash(m: readonly number[], open: number): string | undefined;
+/**
+ * La gelule d'un oeil mi-clos AU REPOS (`rest` < 1 : `somnolent`, « paupieres a moitie
+ * tombees »), posee sous `L0` : chacun de ses axes est raccourci de ce que l'ecrasement de
+ * repos raccourcit son image a l'ecran. C'est une gelule plus courte, recomposee en morceaux
+ * comme celle de toute expression, jamais une image ecrasee. Des paupieres qui la coupaient au
+ * repos en laissaient un carre, les cotes droits et le haut et le bas fondus.
+ */
+export declare function restCapsule(m: readonly number[], open: number, rest: number, w: number, h: number): {
+    w: number;
+    h: number;
+};
+/**
+ * Un patin qui cligne garde sa forme : la fourrure du corps se ferme dessus, comme des paupieres.
+ * Amincir le patin en gelule faisait une autre gelule, pas un oeil qui se ferme ; c'est bon pour
+ * une expression au repos (`restCapsule`), pas pour le geste.
+ *
+ * L'ouverture est la gelule de l'oeil, ecrasee verticalement A L'ECRAN autour de son centre,
+ * comme le moteur ecrase le trou du masque plat : ses paupieres sont courbes et suivent
+ * l'inclinaison de l'oeil. Une bande horizontale coupait un oeil incline (`curieux`) en
+ * parallelogramme flou. L'ecrasement `s` va de 1 (`open` = `rest`, l'oeil de l'expression) a 0
+ * (`open` = `blinkScale(0)`) : le moteur garde un trait a l'oeil ferme, une fente de feutre s'y
+ * lisait comme un oeil ouvert. La gelule est elargie de la frange du feutre (`LID_FRANGE`) ; a
+ * l'ouvert, jusqu'a couvrir toute l'image, ombre comprise, une marge qui part en `l^LID_MARGE`.
+ * Bord doux sur `LID_SOFT` petit cote, au-dela. `m` : la matrice de l'oeil ; `gelule` : la demi-taille de la gelule dessinee
+ * (`restCapsule`) ; `image` : la demi-etendue de ses morceaux (`padExtent`). Hors clignement,
+ * `null` : pas de masque.
+ */
+export declare function lidMask(m: readonly number[], open: number, rest: number, gelule: {
+    x: number;
+    y: number;
+}, image: {
+    x: number;
+    y: number;
+}): LidMask | null;
+/**
+ * Le visage qu'impose un etat, ou `null` quand il laisse celui de la peluche. `base` est le
+ * visage propre de la peluche (celui du personnage, `neutre` pour une forme).
+ */
+export declare const faceOf: (state: PlushState, base: BotExpression) => BotExpression | null;
+export declare const THINK_X = 0.62;
+export declare const THINK_Y = -1.3;
+export declare const THINK_SCALE = 0.6;
+/** emergence des points, celle de l'etat `thinking` */
+export declare const EMERGE = 0.3;
+/**
+ * Histoire des points, datee sur l'horloge du bot. Les fondus repartent du niveau atteint,
+ * et la pulsation n'est pas remise a zero tant que les points sont encore visibles : un
+ * aller-retour rapide ne fait sauter ni l'opacite ni les rayons.
+ */
+export interface DotsTrack {
+    /** origine de la pulsation */
+    phase: number;
+    /** entree (ou sortie) la plus recente, et la visibilite d'ou elle part */
+    at: number;
+    from: number;
+    on: boolean;
+    /** duree de la sortie : le morph de l'etat d'arrivee */
+    exit: number;
+}
+export declare const NO_DOTS: DotsTrack;
+export declare function dotsVisibility(track: DotsTrack, t: number): number;
+/** Entree dans `thinking` (`on`) ou sortie vers `next`, a l'instant `t`. */
+export declare function dotsToggle(track: DotsTrack, on: boolean, t: number, next: PlushState): DotsTrack;
+export interface PlushDot {
+    x: number;
+    y: number;
+    r: number;
+    opacity: number;
+}
+/** Les trois points a l'instant `t`, en unites de rayon. Vide quand ils sont invisibles. */
+export declare function thinkingDots(track: DotsTrack, t: number): PlushDot[];
+/** vie d'un « z », en secondes */
+export declare const Z_LIFE = 3;
+export interface PlushZ {
+    x: number;
+    y: number;
+    /** cote du « z », en unites de rayon */
+    size: number;
+    opacity: number;
+}
+/** Les « z » a l'instant `t`, en unites de rayon. Vide quand ils sont invisibles. */
+export declare function sleepZs(track: DotsTrack, t: number): PlushZ[];

package/dist/package/types/plush/slices.d.ts

@@ -0,0 +1,49 @@
+import type { PlushPad } from './catalogue.js';
+/**
+ * Le patin sur une gelule de `w` x `h` px : des morceaux d'une gelule de feutre, jamais etiree.
+ *
+ * Le feutre (`tools/peluche/fit/feutre.py`) a un grain et une frange : etire, chaque fibre
+ * devenait une raie. Chaque patin est donc cuit en gelule, couchee (`x`) et debout (`y`) : le
+ * patin rond (la gelule ajustee sans sa partie droite) allonge d'une partie droite de
+ * `2 BARRE` petits cotes, le feutre lu sur le patin rond et prolonge dans la partie droite. Les
+ * deux bouts sont le patin rond tel quel ; la partie droite est SYMETRIQUE (et a la meme
+ * lumiere partout). Sur une gelule longue de `2 e` de plus que large, a l'echelle `u` du
+ * petit cote, chaque moitie montre son bout et `e` de partie droite :
+ * - jusqu'a `BARRE`, d'un seul morceau. Les deux moities se rejoignent au centre sur deux
+ *   colonnes symetriques de l'image : la meme matiere ;
+ * - au-dela, par troncons de `BARRE` : l'image lue jusqu'a son milieu, puis au-dela de son
+ *   milieu (le reflet de ce qui precede), et ainsi de suite. Jusqu'a `BARRES` troncons ; plus
+ *   loin, ils s'etirent (aucun oeil du catalogue n'y va).
+ *
+ * Aucune coupe ne tombe sur le bord d'une image (le bord d'un `<image>` est antialiase en plus
+ * de la coupe : un liseré). Toutes sont paralleles, et les morceaux s'additionnent
+ * (`plus-lighter`) dans un groupe isole : leurs couvertures antialiasees se completent a 1.
+ * Tout est continu en `w`, `h`, l'image elle-meme comprise quand l'oeil passe de couche a
+ * debout : sur une gelule ronde, les deux images montrent le MEME patin rond (`matiere.py`).
+ */
+export interface PadPiece {
+    /** l'image : la gelule couchee (`x`) ou debout (`y`) */
+    src: 'x' | 'y';
+    /** le rectangle ou le morceau est pose, centre sur l'oeil */
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    /** ce qu'il montre de son image (0 a 1) : le `viewBox` de l'`<svg>` imbrique */
+    viewBox: string;
+}
+/** un troncon de partie droite, en petits cotes : la moitie de celle de l'image (`barre` de `matiere.py`) */
+export declare const BARRE = 0.5;
+/**
+ * Au-dela de ce nombre de troncons de chaque cote, ils s'etirent plutot que de se multiplier
+ * (CHOISI) : aucun oeil du catalogue ne va si loin ; le plus long (Vita, 3,8 fois plus long que
+ * large) en demande trois.
+ */
+export declare const BARRES = 3;
+/** Les morceaux du patin `pad` pose sur une gelule de `w` x `h` px. */
+export declare function padPieces(pad: PlushPad, w: number, h: number): PadPiece[];
+/** La demi-etendue des morceaux, centres sur l'oeil : ce que couvrent les images, frange et ombre comprises. */
+export declare function padExtent(pieces: readonly PadPiece[]): {
+    x: number;
+    y: number;
+};

package/dist/package/types/plush/tint.d.ts

@@ -0,0 +1,27 @@
+/** la mediane de l'interieur d'un corps gris (`GRIS_CIBLE` de `forme.py`) */
+export declare const GRIS = 0.55;
+/**
+ * Courbe de la teinte, ajustee (`tools/peluche/mesure/teinte.py`) sur les quantiles des
+ * corps cuits de Nexo, Malu, Yoshi, Vita et Fred, chaque forme grise teinte de l'encre du
+ * personnage : ecart moyen par canal 14,3 sur 255, contre 18,8 pour la courbe d'avant.
+ * `gamma` creuse les ombres, `sheen` blanchit les fibres au-dessus de la mediane.
+ * La mediane reste la couleur demandee : un facteur d'exposition gagnait encore un peu,
+ * mais seulement parce que le corps cuit de Malu est plus sombre que son encre, ce qui
+ * tient a sa generation et pas a la matiere (celui de Yoshi est plus clair que la sienne).
+ */
+export declare const TINT: {
+    gamma: number;
+    sheen: number;
+};
+export declare function parseHex(hex: string): [number, number, number];
+/**
+ * La table : pour chaque gris 0..255, la couleur RGB 0..255. Pure, donc testable, et
+ * c'est elle qu'on etalonne. En lumiere lineaire : la couleur, multipliee par l'ecart de
+ * luminance a la mediane (puissance `gamma`), puis melangee vers le blanc au-dessus.
+ */
+export declare function tintRamp(hex: string, { gamma, sheen }?: {
+    gamma: number;
+    sheen: number;
+}): Uint8ClampedArray;
+/** L'URL d'objet du corps `url` teint en `hex`, calculee une fois. Navigateur seulement. */
+export declare function tinted(url: string, hex: string): Promise<string>;

package/dist/package/types/plush/transition.d.ts

@@ -0,0 +1,33 @@
+export declare const PLUSH_TRANSITIONS: readonly ["flip", "pop", "warp", "dissolve", "cut"];
+export type PlushTransition = (typeof PLUSH_TRANSITIONS)[number];
+export declare const DEFAULT_TRANSITION: PlushTransition;
+export declare const popCourbe: (t: number) => number;
+export declare const POP: number;
+/** le rapetissement avant le pop : la moitie du morph de forme */
+export declare const RETRAIT: number;
+export declare const DUREE: Record<PlushTransition, number>;
+/** Ce qu'une transition dessine a un instant donne. */
+export interface Rendu {
+    /** quel(s) corps : l'ancien, le nouveau, ou les deux melanges */
+    corps: 'avant' | 'apres' | 'deux';
+    /** poids du nouveau corps quand il y en a deux (fondu, seuil de dissolution) */
+    melange: number;
+    /** echelle du groupe corps + yeux, autour du centre */
+    sx: number;
+    sy: number;
+    /** la forme que le moteur doit avoir : il y place les yeux */
+    bascule: boolean;
+    fini: boolean;
+}
+export declare const REPOS_AVANT: Rendu;
+export declare const REPOS_APRES: Rendu;
+/**
+ * `s` : secondes depuis le changement. Avant (s < 0) on dessine l'ancien corps ; une fois
+ * la duree passee, le nouveau, a l'echelle 1.
+ */
+export declare function rendu(transition: PlushTransition, s: number): Rendu;
+/**
+ * Les rayons du contour pendant `warp`, a `s` secondes du changement : exactement ceux
+ * que le moteur donne au corps (`shapeAtTime`), pour que le feutre reste sous les yeux.
+ */
+export declare function rayonsWarp(avant: readonly number[], apres: readonly number[], s: number): number[];

package/dist/package/types/plush/warp.d.ts

@@ -0,0 +1,10 @@
+export interface Warp {
+    /** charge les deux corps ; la promesse se resout quand ils sont prets */
+    corps(avant: string, apres: string): Promise<void>;
+    dessine(ra: readonly number[], rb: readonly number[], rc: readonly number[], melange: number): void;
+    detruit(): void;
+}
+/** `null` sans WebGL 2 : la peluche retombe alors sur `cut`. */
+export declare function creeWarp(canvas: HTMLCanvasElement): Warp | null;
+/** le canvas couvre le viewBox du bot : `DEMI_VIEWBOX` de chaque cote du centre */
+export declare const COTE_VIEWBOX: number;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@norbert_bodziony/bloub",
   "private": false,
-  "version": "0.3.0",
+  "version": "0.6.0",
   "type": "module",
   "description": "SVG recreation of the x.ai bot avatar. One shape morphing through 14 states, measured off the reference video frame by frame.",
   "license": "MIT",
@@ -19,12 +19,17 @@
     "animation",
     "avatar",
     "solid-js",
-    "morphing"
+    "morphing",
+    "plush"
   ],
   "packageManager": "bun@1.4.0",
   "files": [
     "dist/package/index.js",
     "dist/package/server.js",
+    "dist/package/plush.js",
+    "dist/package/plush-server.js",
+    "dist/package/chunks",
+    "dist/package/assets",
     "dist/package/types"
   ],
   "types": "./dist/package/types/index.d.ts",
@@ -34,6 +39,12 @@
       "browser": "./dist/package/index.js",
       "import": "./dist/package/server.js",
       "default": "./dist/package/server.js"
+    },
+    "./plush": {
+      "types": "./dist/package/types/plush/index.d.ts",
+      "browser": "./dist/package/plush.js",
+      "import": "./dist/package/plush-server.js",
+      "default": "./dist/package/plush-server.js"
     }
   },
   "sideEffects": false,