@backbay/glia 0.2.0-alpha.1

package/dist/primitives/three/Glyph/GlyphObject.js

@@ -0,0 +1,311 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { PointMaterial, Points, useAnimations, useGLTF } from "@react-three/drei";
+import { useFrame } from "@react-three/fiber";
+import { useLayoutEffect, useMemo, useRef } from "react";
+import * as THREE from "three";
+import { Color, Mesh, Vector3 } from "three";
+import { useGlyphController } from "./useGlyphController";
+import { useGlyphEmotion } from "./useGlyphEmotion";
+/** Maximum particle count for buffer allocation */
+const MAX_PARTICLES = 100;
+/** Minimum radius particles spawn at */
+const PARTICLE_MIN_RADIUS = 1.2;
+/** Maximum radius particles spawn at */
+const PARTICLE_MAX_RADIUS = 1.7;
+/** Radius at which particles reset (too far) */
+const PARTICLE_OUTER_BOUND = 2.5;
+/** Radius at which particles reset (too close) */
+const PARTICLE_INNER_BOUND = 0.8;
+/** Linear interpolation helper */
+const lerp = (a, b, t) => a + (b - a) * t;
+const DEFAULT_GLYPH_URL = "/models/glyph.glb";
+const GLYPH_COLORS = {
+    core: "#f2c96b",
+    coreEmissive: "#d4a84b",
+    ring: "#6b8cbe",
+    ringEmissive: "#9bb4e3",
+    face: "#8a8f98",
+    faceEmissive: "#dc143c",
+};
+export function GlyphObject({ state = "idle", anchor, dimensions, visualState: directVisualState, scale = 1, position = [0, 0, 0], variant = "sentinel", modelUrl, enableBlending = false, oneShot, oneShotNonce, enableParticles, onClick, }) {
+    const showParticles = enableParticles ?? variant === "sentinel";
+    const rootRef = useRef(null);
+    const timeOffset = useRef(Math.random() * Math.PI * 2);
+    const ringPhase = useRef(Math.random() * Math.PI * 2);
+    const ringTiltRadiansRef = useRef(0);
+    const coreMaterialsRef = useRef([]);
+    const ringMeshesRef = useRef([]);
+    const tmpBaseQuat = useMemo(() => new THREE.Quaternion(), []);
+    const tmpOffsetQuat = useMemo(() => new THREE.Quaternion(), []);
+    const tmpEuler = useMemo(() => new THREE.Euler(), []);
+    const particlesRef = useRef(null);
+    // Face mesh refs for expression animation
+    const browRef = useRef(null);
+    const eyeLeftRef = useRef(null);
+    const eyeRightRef = useRef(null);
+    // Store original positions so expression offsets are additive
+    const browOriginalY = useRef(0);
+    const eyeLeftOriginalPos = useRef(new Vector3());
+    const eyeRightOriginalPos = useRef(new Vector3());
+    const eyeLeftOriginalScale = useRef(1);
+    const eyeRightOriginalScale = useRef(1);
+    const { scene, animations } = useGLTF(modelUrl ?? DEFAULT_GLYPH_URL);
+    const { actions } = useAnimations(animations, scene);
+    const { dimensions: emotionDimensions, visualState } = useGlyphEmotion({
+        state,
+        anchor,
+        dimensions,
+        visualState: directVisualState,
+    });
+    const actionsMap = useMemo(() => {
+        if (!actions)
+            return {};
+        return Object.fromEntries(Object.entries(actions).map(([key, value]) => [key, value ?? undefined]));
+    }, [actions]);
+    useGlyphController(state, actionsMap, {
+        arousal: emotionDimensions.arousal,
+        dimensions: emotionDimensions,
+        enableBlending,
+        oneShot,
+        oneShotNonce,
+    });
+    const coreColor = useMemo(() => {
+        const hue = visualState.coreHue / 360;
+        const saturation = visualState.coreSaturation;
+        const lightness = 0.55;
+        return new Color().setHSL(hue, saturation, lightness);
+    }, [visualState.coreHue, visualState.coreSaturation]);
+    const coreEmissiveColor = useMemo(() => {
+        const hue = visualState.coreHue / 360;
+        const saturation = visualState.coreSaturation * 0.9;
+        const lightness = 0.4;
+        return new Color().setHSL(hue, saturation, lightness);
+    }, [visualState.coreHue, visualState.coreSaturation]);
+    const emissiveBoost = variant === "sentinel" ? 0.7 : variant === "graph" ? 0.5 : variant === "minimal" ? 0.35 : 0.4;
+    const haloOpacity = variant === "sentinel" ? 0.22 : variant === "graph" ? 0.18 : variant === "minimal" ? 0.12 : 0.16;
+    useLayoutEffect(() => {
+        if (!scene.userData.__glyphFlipped) {
+            scene.rotation.y += Math.PI;
+            scene.userData.__glyphFlipped = true;
+        }
+        const coreMaterials = [];
+        const ringMeshes = [];
+        scene.traverse((obj) => {
+            if (!(obj instanceof Mesh))
+                return;
+            const mesh = obj;
+            mesh.castShadow = false;
+            mesh.receiveShadow = false;
+            const meshName = (mesh.name || "").toLowerCase();
+            const geometryName = (mesh.geometry?.name || "").toLowerCase();
+            // Collect orbital ring meshes (nodes are `ol_glyph_ring_*`, geometry is often `Torus.*`)
+            if (meshName.includes("ring") || meshName.includes("torus") || geometryName.includes("torus")) {
+                ringMeshes.push(mesh);
+            }
+            // Collect face meshes for expression animation (ol_glyph_brow, ol_glyph_eye_l, ol_glyph_eye_r)
+            if (meshName.includes("brow")) {
+                browRef.current = mesh;
+                browOriginalY.current = mesh.position.y;
+                if (mesh.userData.__glyphDeltaY === undefined)
+                    mesh.userData.__glyphDeltaY = 0;
+            }
+            if (meshName.includes("eye_l")) {
+                eyeLeftRef.current = mesh;
+                eyeLeftOriginalPos.current.copy(mesh.position);
+                eyeLeftOriginalScale.current = mesh.scale.x; // assume uniform scale
+                if (mesh.userData.__glyphDeltaX === undefined)
+                    mesh.userData.__glyphDeltaX = 0;
+                if (mesh.userData.__glyphScaleMul === undefined)
+                    mesh.userData.__glyphScaleMul = 1;
+            }
+            if (meshName.includes("eye_r")) {
+                eyeRightRef.current = mesh;
+                eyeRightOriginalPos.current.copy(mesh.position);
+                eyeRightOriginalScale.current = mesh.scale.x; // assume uniform scale
+                if (mesh.userData.__glyphDeltaX === undefined)
+                    mesh.userData.__glyphDeltaX = 0;
+                if (mesh.userData.__glyphScaleMul === undefined)
+                    mesh.userData.__glyphScaleMul = 1;
+            }
+            const mats = Array.isArray(mesh.material)
+                ? mesh.material
+                : [mesh.material];
+            mats.forEach((m) => {
+                if (!m)
+                    return;
+                const name = (m.name || "").toLowerCase();
+                const isCore = name.includes("core") || meshName.includes("core") || name.includes("body");
+                const isFace = name.includes("eye") ||
+                    name.includes("brow") ||
+                    meshName.includes("eye") ||
+                    meshName.includes("face");
+                const isRingLike = name.includes("ring") || name.includes("orbit") || meshName.includes("ring") || meshName.includes("orbit");
+                m.flatShading = false;
+                m.metalness = 0.2;
+                m.roughness = 0.55;
+                m.emissive.set("#000000");
+                m.emissiveIntensity = 0;
+                if (isCore) {
+                    coreMaterials.push(m);
+                    m.color.set(GLYPH_COLORS.core);
+                    m.emissive.set(GLYPH_COLORS.coreEmissive);
+                    m.emissiveIntensity = 0.35 * emissiveBoost + 0.15;
+                    m.roughness = 0.45;
+                }
+                else if (isRingLike) {
+                    m.color.set(GLYPH_COLORS.ring);
+                    m.emissive.set(GLYPH_COLORS.ringEmissive);
+                    m.emissiveIntensity = 0.9 * emissiveBoost + 0.2;
+                    m.roughness = 0.25;
+                    m.toneMapped = false;
+                    m.side = THREE.DoubleSide;
+                    m.needsUpdate = true;
+                }
+                else if (isFace) {
+                    m.color.set(GLYPH_COLORS.face);
+                    m.emissive.set(GLYPH_COLORS.faceEmissive);
+                    m.emissiveIntensity = 0.25 * emissiveBoost + 0.15;
+                    m.roughness = 0.7;
+                }
+            });
+        });
+        coreMaterialsRef.current = coreMaterials;
+        ringMeshesRef.current = ringMeshes;
+    }, [scene, emissiveBoost]);
+    useFrame(({ clock }, delta) => {
+        const t = clock.getElapsedTime() + timeOffset.current;
+        if (!rootRef.current)
+            return;
+        // Apply breathing animation scaled by visualState.breathingRate
+        const breathingSpeed = visualState.breathingRate * 0.5;
+        const breathingAmplitude = visualState.breathingAmplitude * 1.5;
+        rootRef.current.rotation.x = (0.04 + breathingAmplitude) * Math.sin(t * breathingSpeed);
+        rootRef.current.rotation.y = 0.03 * Math.cos(t * 0.25);
+        // Apply emotion-driven colors and emissive to core materials
+        coreMaterialsRef.current.forEach((m) => {
+            m.color.copy(coreColor);
+            m.emissive.copy(coreEmissiveColor);
+            m.emissiveIntensity = visualState.emissiveIntensity * emissiveBoost + 0.15;
+        });
+        // Apply per-ring rotation and tilt from visualState
+        // Integrate ring phase so changes in `ringRotationSpeed` don't cause pops.
+        ringPhase.current = (ringPhase.current + delta * visualState.ringRotationSpeed) % (Math.PI * 2);
+        const ringCount = ringMeshesRef.current.length;
+        const targetTiltRadians = (visualState.ringTilt * Math.PI) / 180; // degrees -> radians
+        const tiltLerpT = 1 - Math.exp(-delta * 10);
+        ringTiltRadiansRef.current = lerp(ringTiltRadiansRef.current, targetTiltRadians, tiltLerpT);
+        const tiltRadians = ringTiltRadiansRef.current;
+        ringMeshesRef.current.forEach((ring, i) => {
+            const phaseOffset = ringCount > 0 ? (i / ringCount) * Math.PI * 2 : 0;
+            tmpBaseQuat.copy(ring.quaternion);
+            tmpEuler.set(tiltRadians, ringPhase.current + phaseOffset, 0);
+            tmpOffsetQuat.setFromEuler(tmpEuler);
+            ring.quaternion.copy(tmpBaseQuat.multiply(tmpOffsetQuat));
+        });
+        // Face expressions: drive eye/brow meshes from AVO dimensions
+        const { arousal, valence, openness } = emotionDimensions;
+        // Brow Y: low valence -> down, high valence -> up
+        if (browRef.current) {
+            const browDeltaY = lerp(-0.05, 0.05, valence);
+            const prevDeltaY = browRef.current.userData.__glyphDeltaY ?? 0;
+            const baseY = browRef.current.position.y - prevDeltaY;
+            browRef.current.position.y = baseY + browDeltaY;
+            browRef.current.userData.__glyphDeltaY = browDeltaY;
+        }
+        // Eye scale: low arousal -> smaller, high arousal -> wider
+        // Eye X: low openness -> converge inward, high openness -> look outward
+        if (eyeLeftRef.current) {
+            const scaleMul = lerp(0.9, 1.1, arousal);
+            const prevScaleMul = eyeLeftRef.current.userData.__glyphScaleMul ?? 1;
+            const baseScaleX = eyeLeftRef.current.scale.x / prevScaleMul;
+            const baseScaleY = eyeLeftRef.current.scale.y / prevScaleMul;
+            const baseScaleZ = eyeLeftRef.current.scale.z / prevScaleMul;
+            eyeLeftRef.current.scale.set(baseScaleX * scaleMul, baseScaleY * scaleMul, baseScaleZ * scaleMul);
+            eyeLeftRef.current.userData.__glyphScaleMul = scaleMul;
+            const deltaX = lerp(0.02, -0.02, openness);
+            const prevDeltaX = eyeLeftRef.current.userData.__glyphDeltaX ?? 0;
+            const baseX = eyeLeftRef.current.position.x - prevDeltaX;
+            eyeLeftRef.current.position.x = baseX + deltaX;
+            eyeLeftRef.current.userData.__glyphDeltaX = deltaX;
+        }
+        if (eyeRightRef.current) {
+            const scaleMul = lerp(0.9, 1.1, arousal);
+            const prevScaleMul = eyeRightRef.current.userData.__glyphScaleMul ?? 1;
+            const baseScaleX = eyeRightRef.current.scale.x / prevScaleMul;
+            const baseScaleY = eyeRightRef.current.scale.y / prevScaleMul;
+            const baseScaleZ = eyeRightRef.current.scale.z / prevScaleMul;
+            eyeRightRef.current.scale.set(baseScaleX * scaleMul, baseScaleY * scaleMul, baseScaleZ * scaleMul);
+            eyeRightRef.current.userData.__glyphScaleMul = scaleMul;
+            const deltaX = lerp(-0.02, 0.02, openness);
+            const prevDeltaX = eyeRightRef.current.userData.__glyphDeltaX ?? 0;
+            const baseX = eyeRightRef.current.position.x - prevDeltaX;
+            eyeRightRef.current.position.x = baseX + deltaX;
+            eyeRightRef.current.userData.__glyphDeltaX = deltaX;
+        }
+    });
+    const emotionScale = scale * visualState.scaleFactor;
+    const glowColor = useMemo(() => {
+        const hue = visualState.coreHue / 360;
+        return new Color().setHSL(hue, 0.6, 0.5);
+    }, [visualState.coreHue]);
+    const particlePositions = useMemo(() => {
+        const positions = new Float32Array(MAX_PARTICLES * 3);
+        for (let i = 0; i < MAX_PARTICLES; i++) {
+            const theta = Math.random() * Math.PI * 2;
+            const phi = Math.acos(2 * Math.random() - 1);
+            const r = PARTICLE_MIN_RADIUS + Math.random() * (PARTICLE_MAX_RADIUS - PARTICLE_MIN_RADIUS);
+            positions[i * 3] = r * Math.sin(phi) * Math.cos(theta);
+            positions[i * 3 + 1] = r * Math.sin(phi) * Math.sin(theta);
+            positions[i * 3 + 2] = r * Math.cos(phi);
+        }
+        return positions;
+    }, []);
+    // Animate particles: radial flow based on openness, velocity based on arousal
+    useFrame(() => {
+        if (!showParticles || !particlesRef.current)
+            return;
+        const posAttr = particlesRef.current.geometry.attributes.position;
+        const positions = posAttr.array;
+        const flowDir = visualState.particleFlowDirection; // -1 inward -> +1 outward
+        const velocity = visualState.particleVelocity;
+        const activeCount = visualState.particleCount;
+        for (let i = 0; i < MAX_PARTICLES; i++) {
+            const idx = i * 3;
+            const x = positions[idx];
+            const y = positions[idx + 1];
+            const z = positions[idx + 2];
+            const r = Math.sqrt(x * x + y * y + z * z);
+            if (r < 0.001)
+                continue;
+            const nx = x / r;
+            const ny = y / r;
+            const nz = z / r;
+            const movement = flowDir * velocity * 0.08;
+            const newR = r + movement;
+            positions[idx] = nx * newR;
+            positions[idx + 1] = ny * newR;
+            positions[idx + 2] = nz * newR;
+            const shouldReset = newR > PARTICLE_OUTER_BOUND || newR < PARTICLE_INNER_BOUND || i >= activeCount;
+            if (shouldReset) {
+                const theta = Math.random() * Math.PI * 2;
+                const phi = Math.acos(2 * Math.random() - 1);
+                const spawnR = PARTICLE_MIN_RADIUS + Math.random() * (PARTICLE_MAX_RADIUS - PARTICLE_MIN_RADIUS);
+                positions[idx] = spawnR * Math.sin(phi) * Math.cos(theta);
+                positions[idx + 1] = spawnR * Math.sin(phi) * Math.sin(theta);
+                positions[idx + 2] = spawnR * Math.cos(phi);
+                if (i >= activeCount) {
+                    positions[idx] = 0;
+                    positions[idx + 1] = 0;
+                    positions[idx + 2] = 1000;
+                }
+            }
+        }
+        posAttr.needsUpdate = true;
+    });
+    return (_jsxs("group", { ref: rootRef, position: position, scale: emotionScale, onClick: (e) => {
+            e.stopPropagation();
+            onClick?.();
+        }, children: [_jsx("pointLight", { position: [0, 0, 0.4], intensity: (variant === "sentinel" ? 0.9 : 0.6) * visualState.overallIntensity, distance: variant === "sentinel" ? 4 : 3, decay: 2, color: glowColor }), _jsx("primitive", { object: scene }), _jsxs("mesh", { scale: 1.08 * visualState.auraExpansion, children: [_jsx("sphereGeometry", { args: [1, 64, 32] }), _jsx("meshStandardMaterial", { transparent: true, opacity: haloOpacity * visualState.overallIntensity, color: coreColor, emissive: coreEmissiveColor, emissiveIntensity: 0.2 * emissiveBoost * visualState.emissiveIntensity, roughness: 0.85, metalness: 0 })] }), showParticles && (_jsx(Points, { ref: particlesRef, positions: particlePositions, stride: 3, frustumCulled: false, children: _jsx(PointMaterial, { transparent: true, color: glowColor, size: 0.035, sizeAttenuation: true, depthWrite: false, opacity: 0.65 * visualState.overallIntensity, toneMapped: false }) }))] }));
+}
+useGLTF.preload(DEFAULT_GLYPH_URL);

package/dist/primitives/three/Glyph/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Glyph
+ *
+ * GLB-backed Glyph avatar with baked animations + AVO emotion system modulation.
+ */
+export * from "./types";
+export { useGlyphEmotion } from "./useGlyphEmotion";
+export { useGlyphController } from "./useGlyphController";
+export { GlyphObject } from "./GlyphObject";
+//# sourceMappingURL=index.d.ts.map

package/dist/primitives/three/Glyph/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/primitives/three/Glyph/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,SAAS,CAAC;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC"}

package/dist/primitives/three/Glyph/index.js

@@ -0,0 +1,9 @@
+/**
+ * Glyph
+ *
+ * GLB-backed Glyph avatar with baked animations + AVO emotion system modulation.
+ */
+export * from "./types";
+export { useGlyphEmotion } from "./useGlyphEmotion";
+export { useGlyphController } from "./useGlyphController";
+export { GlyphObject } from "./GlyphObject";

package/dist/primitives/three/Glyph/types.d.ts

@@ -0,0 +1,33 @@
+import type { AnchorState, AVO, LegacyGlyphState, VisualState } from "../../../emotion/types";
+export type GlyphState = LegacyGlyphState;
+export type GlyphVariant = "sentinel" | "console" | "graph" | "minimal";
+export type GlyphOneShot = Extract<LegacyGlyphState, "responding" | "success" | "error">;
+export interface GlyphObjectProps {
+    /** Legacy state (maps to baked animation + AVO transition) */
+    state?: GlyphState;
+    /** Named AVO anchor state (overrides `state`) */
+    anchor?: AnchorState;
+    /** Direct AVO dimensions (overrides `anchor` + `state`) */
+    dimensions?: AVO;
+    /** Pre-computed visual state (overrides everything) */
+    visualState?: VisualState;
+    /** Scale factor */
+    scale?: number;
+    /** Position in 3D space */
+    position?: [number, number, number];
+    /** Visual variant (material intensity + optional particles) */
+    variant?: GlyphVariant;
+    /** Custom model URL (defaults to `/models/glyph.glb`) */
+    modelUrl?: string;
+    /** Enable AVO-based animation blending (weights multiple baked animations by proximity) */
+    enableBlending?: boolean;
+    /** Trigger a one-shot baked animation clip (responding/success/error) */
+    oneShot?: GlyphOneShot;
+    /** Change this value to retrigger `oneShot` even if it stays the same */
+    oneShotNonce?: number;
+    /** Enable particle system around the glyph (default: true for `sentinel`) */
+    enableParticles?: boolean;
+    /** Click handler */
+    onClick?: () => void;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/primitives/three/Glyph/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/primitives/three/Glyph/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,GAAG,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAE9F,MAAM,MAAM,UAAU,GAAG,gBAAgB,CAAC;AAE1C,MAAM,MAAM,YAAY,GAAG,UAAU,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,CAAC;AAExE,MAAM,MAAM,YAAY,GAAG,OAAO,CAAC,gBAAgB,EAAE,YAAY,GAAG,SAAS,GAAG,OAAO,CAAC,CAAC;AAEzF,MAAM,WAAW,gBAAgB;IAC/B,8DAA8D;IAC9D,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,iDAAiD;IACjD,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,2DAA2D;IAC3D,UAAU,CAAC,EAAE,GAAG,CAAC;IACjB,uDAAuD;IACvD,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,mBAAmB;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,2BAA2B;IAC3B,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,+DAA+D;IAC/D,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB,yDAAyD;IACzD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,2FAA2F;IAC3F,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,yEAAyE;IACzE,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB,yEAAyE;IACzE,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,6EAA6E;IAC7E,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,oBAAoB;IACpB,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;CACtB"}

package/dist/primitives/three/Glyph/types.js

@@ -0,0 +1 @@
+export {};

package/dist/primitives/three/Glyph/useGlyphController.d.ts

@@ -0,0 +1,24 @@
+import * as THREE from "three";
+import type { AVO, LegacyGlyphState } from "../../../emotion/types";
+import type { GlyphOneShot } from "./types";
+type ActionsMap = Record<string, THREE.AnimationAction | undefined>;
+export interface UseGlyphControllerOptions {
+    /** Arousal value for timeScale modulation (0-1) */
+    arousal?: number;
+    /** Current AVO dimensions for proximity-based blending */
+    dimensions?: AVO;
+    /** Enable blending mode (default: false for backward compatibility) */
+    enableBlending?: boolean;
+    /** Trigger a one-shot clip (responding/success/error) */
+    oneShot?: GlyphOneShot;
+    /** Change this value to retrigger `oneShot` even if it stays the same */
+    oneShotNonce?: number;
+}
+/**
+ * Controls glyph baked animations, supporting either:
+ * 1) Legacy mode: hard transitions between states based on LegacyGlyphState
+ * 2) Blending mode: weighted blending of multiple animations based on AVO proximity
+ */
+export declare function useGlyphController(state: LegacyGlyphState, actions: ActionsMap, options?: UseGlyphControllerOptions): void;
+export {};
+//# sourceMappingURL=useGlyphController.d.ts.map

package/dist/primitives/three/Glyph/useGlyphController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useGlyphController.d.ts","sourceRoot":"","sources":["../../../../src/primitives/three/Glyph/useGlyphController.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,KAAK,EAAE,GAAG,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AACpE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE5C,KAAK,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,eAAe,GAAG,SAAS,CAAC,CAAC;AA8BpE,MAAM,WAAW,yBAAyB;IACxC,mDAAmD;IACnD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,0DAA0D;IAC1D,UAAU,CAAC,EAAE,GAAG,CAAC;IACjB,uEAAuE;IACvE,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,yDAAyD;IACzD,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB,yEAAyE;IACzE,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,gBAAgB,EACvB,OAAO,EAAE,UAAU,EACnB,OAAO,GAAE,yBAA8B,QA6KxC"}

package/dist/primitives/three/Glyph/useGlyphController.js

@@ -0,0 +1,182 @@
+import { useEffect, useMemo, useRef } from "react";
+import * as THREE from "three";
+import { getAnimationWeights } from "../../../emotion";
+const LOOP_STATES = ["idle", "listening", "thinking", "sleep"];
+const ONE_SHOT_STATES = ["responding", "success", "error"];
+// TimeScale modulation constants
+const BASE_TIME_SCALE = 1.0;
+const AROUSAL_INFLUENCE = 0.5; // Arousal 0..1 => timeScale ~0.75..1.25
+function isOneShotState(state) {
+    return ONE_SHOT_STATES.includes(state);
+}
+function getPrefixForState(state) {
+    const capitalized = state.charAt(0).toUpperCase() + state.slice(1);
+    return `Glyph_${capitalized}_`;
+}
+function getActionsForState(state, actions) {
+    const prefix = getPrefixForState(state);
+    return Object.entries(actions)
+        .filter(([name]) => name.startsWith(prefix))
+        .map(([, action]) => action)
+        .filter((a) => !!a);
+}
+function calculateTimeScale(arousal) {
+    return BASE_TIME_SCALE + (arousal - 0.5) * AROUSAL_INFLUENCE;
+}
+/**
+ * Controls glyph baked animations, supporting either:
+ * 1) Legacy mode: hard transitions between states based on LegacyGlyphState
+ * 2) Blending mode: weighted blending of multiple animations based on AVO proximity
+ */
+export function useGlyphController(state, actions, options = {}) {
+    const { arousal, dimensions, enableBlending = false, oneShot, oneShotNonce } = options;
+    const actionsSignature = useMemo(() => Object.keys(actions).sort().join("|"), [actions]);
+    // Track whether we've initialized play() for blending mode.
+    const initializedRef = useRef(false);
+    const lastSignatureRef = useRef(null);
+    const overlayActiveRef = useRef(false);
+    const overlayEndTimeoutRef = useRef(null);
+    const overlayStopTimeoutRef = useRef(null);
+    const clearOverlayTimers = () => {
+        if (overlayEndTimeoutRef.current)
+            clearTimeout(overlayEndTimeoutRef.current);
+        if (overlayStopTimeoutRef.current)
+            clearTimeout(overlayStopTimeoutRef.current);
+        overlayEndTimeoutRef.current = null;
+        overlayStopTimeoutRef.current = null;
+    };
+    // Reset initialization if the underlying actions set changes (e.g., modelUrl swap).
+    if (lastSignatureRef.current !== actionsSignature) {
+        lastSignatureRef.current = actionsSignature;
+        initializedRef.current = false;
+        overlayActiveRef.current = false;
+        clearOverlayTimers();
+    }
+    // Blending mode: weight multiple animations by AVO proximity.
+    useEffect(() => {
+        if (!enableBlending || !dimensions)
+            return;
+        const weights = getAnimationWeights(dimensions);
+        const timeScale = calculateTimeScale(dimensions.arousal);
+        const loopTotal = LOOP_STATES.reduce((sum, loopState) => sum + (weights[loopState] ?? 0), 0);
+        const loopAttenuation = overlayActiveRef.current ? 0.15 : 1;
+        // Initialize all animations on first run.
+        if (!initializedRef.current) {
+            LOOP_STATES.forEach((loopState) => {
+                const stateActions = getActionsForState(loopState, actions);
+                stateActions.forEach((action) => {
+                    action.reset();
+                    action.setEffectiveTimeScale(timeScale);
+                    action.setEffectiveWeight(0);
+                    action.loop = THREE.LoopRepeat;
+                    action.clampWhenFinished = false;
+                    action.play();
+                });
+            });
+            initializedRef.current = true;
+        }
+        // Apply weights + timeScale to loop animations only.
+        LOOP_STATES.forEach((loopState) => {
+            const stateActions = getActionsForState(loopState, actions);
+            const weight = loopTotal > 0 ? (weights[loopState] ?? 0) / loopTotal : loopState === "idle" ? 1 : 0;
+            stateActions.forEach((action) => {
+                action.setEffectiveWeight(weight * loopAttenuation);
+                action.setEffectiveTimeScale(timeScale);
+            });
+        });
+    }, [actions, dimensions, enableBlending, oneShotNonce]);
+    // One-shot clips: play once on request (either explicit oneShot or when state is a one-shot).
+    useEffect(() => {
+        if (!enableBlending)
+            return;
+        const requestedOneShot = oneShot ?? (isOneShotState(state) ? state : null);
+        if (!requestedOneShot)
+            return;
+        clearOverlayTimers();
+        const timeScale = calculateTimeScale(dimensions?.arousal ?? arousal ?? 0.5);
+        const targetActions = getActionsForState(requestedOneShot, actions);
+        if (targetActions.length === 0)
+            return;
+        // Fade/stop any currently running one-shot actions.
+        ONE_SHOT_STATES.forEach((oneShotState) => {
+            if (oneShotState === requestedOneShot)
+                return;
+            const running = getActionsForState(oneShotState, actions);
+            running.forEach((action) => {
+                if (!action.isRunning())
+                    return;
+                action.fadeOut(0.12);
+                action.stop();
+                action.reset();
+                action.setEffectiveWeight(0);
+            });
+        });
+        // Start the new one-shot.
+        targetActions.forEach((action) => {
+            action.reset();
+            action.setEffectiveTimeScale(timeScale);
+            action.setEffectiveWeight(1);
+            action.loop = THREE.LoopOnce;
+            action.clampWhenFinished = true;
+            action.fadeIn(0.12).play();
+        });
+        overlayActiveRef.current = true;
+        const maxDurationSec = targetActions.reduce((max, action) => Math.max(max, action.getClip().duration), 0);
+        const durationMs = Math.max(1, Math.floor((maxDurationSec * 1000) / Math.max(0.001, timeScale)));
+        overlayEndTimeoutRef.current = setTimeout(() => {
+            targetActions.forEach((action) => action.fadeOut(0.18));
+            overlayActiveRef.current = false;
+            overlayStopTimeoutRef.current = setTimeout(() => {
+                targetActions.forEach((action) => {
+                    action.stop();
+                    action.reset();
+                    action.setEffectiveWeight(0);
+                });
+            }, 220);
+        }, durationMs);
+        return () => {
+            clearOverlayTimers();
+        };
+    }, [actionsSignature, state, oneShot, oneShotNonce, enableBlending, dimensions, arousal]);
+    // Legacy mode: hard transitions between states.
+    useEffect(() => {
+        if (enableBlending && dimensions)
+            return;
+        const prefix = getPrefixForState(state);
+        const loop = LOOP_STATES.includes(state);
+        const targetActions = Object.entries(actions)
+            .filter(([name]) => name.startsWith(prefix))
+            .map(([, action]) => action)
+            .filter((a) => !!a);
+        if (targetActions.length === 0)
+            return;
+        Object.values(actions).forEach((action) => {
+            if (!action || !action.isRunning())
+                return;
+            action.fadeOut(0.3);
+        });
+        const timeScale = calculateTimeScale(arousal ?? 0.5);
+        targetActions.forEach((action) => {
+            action.reset();
+            action.setEffectiveTimeScale(timeScale);
+            action.setEffectiveWeight(1);
+            action.clampWhenFinished = !loop;
+            action.loop = loop ? THREE.LoopRepeat : THREE.LoopOnce;
+            action.fadeIn(0.3).play();
+        });
+        initializedRef.current = false; // reset for potential switch to blending mode
+    }, [state, actions, arousal, enableBlending, dimensions]);
+    // Continuous timeScale modulation based on arousal (legacy mode only).
+    useEffect(() => {
+        if (enableBlending && dimensions)
+            return;
+        if (arousal === undefined)
+            return;
+        const timeScale = calculateTimeScale(arousal);
+        Object.values(actions).forEach((action) => {
+            if (!action?.isRunning())
+                return;
+            action.setEffectiveTimeScale(timeScale);
+        });
+    }, [arousal, actions, enableBlending, dimensions]);
+}

package/dist/primitives/three/Glyph/useGlyphEmotion.d.ts

@@ -0,0 +1,26 @@
+import type { AnchorState, AVO, LegacyGlyphState, VisualState } from "../../../emotion/types";
+export interface UseGlyphEmotionOptions {
+    /** Legacy state */
+    state?: LegacyGlyphState;
+    /** Named AVO anchor state (overrides `state`) */
+    anchor?: AnchorState;
+    /** Direct AVO dimensions (overrides `anchor` + `state`) */
+    dimensions?: AVO;
+    /** Pre-computed visual state (overrides everything) */
+    visualState?: VisualState;
+}
+export interface UseGlyphEmotionResult {
+    dimensions: AVO;
+    visualState: VisualState;
+}
+/**
+ * Hook that bridges Glyph state/anchor inputs to animated AVO + VisualState.
+ *
+ * Priority order:
+ * 1. If `visualState` provided, use it directly
+ * 2. If `dimensions` provided, compute visual state from them
+ * 3. If `anchor` provided, drive useEmotion() toward that anchor
+ * 4. If legacy `state` provided, convert via LEGACY_STATE_MAP and drive useEmotion()
+ */
+export declare function useGlyphEmotion(options: UseGlyphEmotionOptions): UseGlyphEmotionResult;
+//# sourceMappingURL=useGlyphEmotion.d.ts.map

package/dist/primitives/three/Glyph/useGlyphEmotion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useGlyphEmotion.d.ts","sourceRoot":"","sources":["../../../../src/primitives/three/Glyph/useGlyphEmotion.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,GAAG,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAE9F,MAAM,WAAW,sBAAsB;IACrC,mBAAmB;IACnB,KAAK,CAAC,EAAE,gBAAgB,CAAC;IACzB,iDAAiD;IACjD,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,2DAA2D;IAC3D,UAAU,CAAC,EAAE,GAAG,CAAC;IACjB,uDAAuD;IACvD,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B;AAED,MAAM,WAAW,qBAAqB;IACpC,UAAU,EAAE,GAAG,CAAC;IAChB,WAAW,EAAE,WAAW,CAAC;CAC1B;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,sBAAsB,GAAG,qBAAqB,CAqCtF"}

package/dist/primitives/three/Glyph/useGlyphEmotion.js

@@ -0,0 +1,44 @@
+"use client";
+import { useEffect, useMemo } from "react";
+import { ANCHOR_STATES, computeVisualState, LEGACY_STATE_MAP, useEmotion } from "../../../emotion";
+/**
+ * Hook that bridges Glyph state/anchor inputs to animated AVO + VisualState.
+ *
+ * Priority order:
+ * 1. If `visualState` provided, use it directly
+ * 2. If `dimensions` provided, compute visual state from them
+ * 3. If `anchor` provided, drive useEmotion() toward that anchor
+ * 4. If legacy `state` provided, convert via LEGACY_STATE_MAP and drive useEmotion()
+ */
+export function useGlyphEmotion(options) {
+    const { state, anchor, dimensions: directDimensions, visualState: directVisualState } = options;
+    const targetAnchor = anchor ?? (state ? LEGACY_STATE_MAP[state] : "idle");
+    const shouldAutoTick = !directDimensions && !directVisualState;
+    const { goTo, dimensions, visualState } = useEmotion({
+        initialAnchor: targetAnchor,
+        microExpressions: true,
+        autoTick: shouldAutoTick,
+    });
+    // Transition when legacy state / anchor changes (only when controller is active).
+    useEffect(() => {
+        if (!shouldAutoTick)
+            return;
+        goTo(targetAnchor);
+    }, [targetAnchor, shouldAutoTick, goTo]);
+    const result = useMemo(() => {
+        if (directVisualState) {
+            return {
+                dimensions: directDimensions ?? ANCHOR_STATES.idle,
+                visualState: directVisualState,
+            };
+        }
+        if (directDimensions) {
+            return {
+                dimensions: directDimensions,
+                visualState: computeVisualState(directDimensions),
+            };
+        }
+        return { dimensions, visualState };
+    }, [directVisualState, directDimensions, dimensions, visualState]);
+    return result;
+}