talking-head-studio 0.4.10 → 0.4.11

package/dist/core/avatar/backends/gaussian.js

@@ -0,0 +1,291 @@
+"use strict";
+// src/core/avatar/backends/gaussian.ts
+// GaussianBackend — zero-prerequisite lip-sync for any GLB.
+//
+// Strategy: instead of relying on existing morph targets, we precompute
+// per-viseme deformation patches using approximate FLAME-to-skeleton transfer.
+// Each patch stores bone rotation deltas (for rigged models) and/or vertex
+// position deltas (for unrigged meshes). setControl() blends active patches
+// onto the model's base pose proportionally to ExpressionState weights.
+//
+// This is the "any model works" backend — no blend shapes, no rig requirements,
+// no artist work. Quality scales with skeleton completeness: humanoid rigs get
+// expressive results; static meshes get jaw + head motion only.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GaussianBackend = void 0;
+const visemes_1 = require("../visemes");
+const FLAME_VISEME_COEFFS = {
+    sil: [],
+    PP: [
+        { bone: 'LowerJaw', dx: 0.02, dy: 0, dz: 0 },
+        { bone: 'LowerLip', dx: 0.04, dy: 0, dz: 0 },
+    ],
+    FF: [
+        { bone: 'LowerJaw', dx: 0.06, dy: 0, dz: 0 },
+        { bone: 'UpperLip', dx: -0.05, dy: 0, dz: 0 },
+        { bone: 'LowerLip', dx: 0.08, dy: 0, dz: 0 },
+    ],
+    TH: [
+        { bone: 'LowerJaw', dx: 0.10, dy: 0, dz: 0 },
+        { bone: 'Tongue', dx: 0.12, dy: 0, dz: 0 },
+    ],
+    DD: [
+        { bone: 'LowerJaw', dx: 0.12, dy: 0, dz: 0 },
+        { bone: 'Tongue', dx: 0.08, dy: 0, dz: 0 },
+    ],
+    kk: [
+        { bone: 'LowerJaw', dx: 0.15, dy: 0, dz: 0 },
+    ],
+    CH: [
+        { bone: 'LowerJaw', dx: 0.16, dy: 0, dz: 0 },
+        { bone: 'LowerLip', dx: 0.06, dy: 0, dz: 0.03 },
+        { bone: 'UpperLip', dx: -0.03, dy: 0, dz: -0.03 },
+    ],
+    SS: [
+        { bone: 'LowerJaw', dx: 0.05, dy: 0, dz: 0 },
+        { bone: 'LowerLip', dx: 0.03, dy: 0, dz: 0.04 },
+    ],
+    nn: [
+        { bone: 'LowerJaw', dx: 0.08, dy: 0, dz: 0 },
+        { bone: 'Tongue', dx: 0.06, dy: 0, dz: 0 },
+    ],
+    RR: [
+        { bone: 'LowerJaw', dx: 0.10, dy: 0, dz: 0 },
+        { bone: 'LowerLip', dx: 0.05, dy: 0, dz: 0.02 },
+    ],
+    aa: [
+        { bone: 'LowerJaw', dx: 0.40, dy: 0, dz: 0 },
+        { bone: 'LowerLip', dx: 0.12, dy: 0, dz: 0 },
+    ],
+    ee: [
+        { bone: 'LowerJaw', dx: 0.22, dy: 0, dz: 0 },
+        { bone: 'LowerLip', dx: -0.05, dy: 0, dz: 0.08 },
+        { bone: 'UpperLip', dx: -0.04, dy: 0, dz: -0.06 },
+    ],
+    ih: [
+        { bone: 'LowerJaw', dx: 0.18, dy: 0, dz: 0 },
+        { bone: 'LowerLip', dx: -0.03, dy: 0, dz: 0.05 },
+    ],
+    oh: [
+        { bone: 'LowerJaw', dx: 0.28, dy: 0, dz: 0 },
+        { bone: 'LowerLip', dx: 0.10, dy: 0, dz: -0.05 },
+        { bone: 'UpperLip', dx: -0.06, dy: 0, dz: 0.04 },
+    ],
+    ou: [
+        { bone: 'LowerJaw', dx: 0.12, dy: 0, dz: 0 },
+        { bone: 'LowerLip', dx: 0.14, dy: 0, dz: -0.08 },
+        { bone: 'UpperLip', dx: -0.08, dy: 0, dz: 0.06 },
+    ],
+};
+// Standard Mixamo bone name aliases for jaw / lips / tongue / eyes.
+// We try each alias in order; the first found in the skeleton wins.
+const BONE_ALIASES = {
+    LowerJaw: ['lowerJaw', 'jaw', 'Jaw', 'mandible', 'Head'], // Head fallback for rigid jaw
+    UpperLip: ['upperLip', 'UpperLip', 'lip_upper', 'mouthTopLip'],
+    LowerLip: ['lowerLip', 'LowerLip', 'lip_lower', 'mouthBottomLip'],
+    Tongue: ['tongue', 'Tongue', 'tongue01'],
+    Head: ['Head', 'head', 'mixamorigHead'],
+    LeftEye: ['LeftEye', 'leftEye', 'mixamorigLeftEye', 'eye_l', 'Eye_L'],
+    RightEye: ['RightEye', 'rightEye', 'mixamorigRightEye', 'eye_r', 'Eye_R'],
+};
+// ─── Implementation ──────────────────────────────────────────────────────────
+class GaussianBackend {
+    constructor(config) {
+        /** Resolved skeleton bone map: canonical name → Three.js Bone */
+        this.boneMap = new Map();
+        /** Pre-computed deformation patches, one per Oculus viseme. */
+        this.patches = new Map();
+        /** Snapshot of bone rotations at attach() — restored on dispose(). */
+        this.basePose = [];
+        /** Last control applied — used in renderFrame() to avoid redundant writes. */
+        this.lastControl = null;
+        this.scene = config.scene;
+        this.schemaReport = config.schemaReport;
+        this.calibration = config.calibration ?? {
+            neutral: { pose: { yaw: 0, pitch: 0, roll: 0 }, expr: {} },
+        };
+        this.patchQuality = config.patchQuality ?? 'full';
+    }
+    // ── AvatarBackend.initialize ────────────────────────────────────────────
+    initialize() {
+        this._buildBoneMap();
+        this._captureBasePose();
+        this._buildPatches();
+    }
+    // ── AvatarBackend.attach ─────────────────────────────────────────────────
+    // Scene is passed in the constructor; attach is a no-op but can be used
+    // to re-initialize on scene swap.
+    attach(_target) {
+        this.initialize();
+    }
+    // ── AvatarBackend.setControl ─────────────────────────────────────────────
+    setControl(control) {
+        this.lastControl = control;
+    }
+    // ── AvatarBackend.renderFrame ────────────────────────────────────────────
+    // Writes blended bone deltas to the skeleton each render tick.
+    renderFrame() {
+        if (!this.lastControl)
+            return;
+        this._applyControl(this.lastControl);
+    }
+    // ── AvatarBackend.dispose ────────────────────────────────────────────────
+    dispose() {
+        this._restoreBasePose();
+        this.boneMap.clear();
+        this.patches.clear();
+        this.basePose = [];
+        this.lastControl = null;
+    }
+    // ── Internal: bone map ───────────────────────────────────────────────────
+    _buildBoneMap() {
+        this.boneMap.clear();
+        const allBones = new Map();
+        this.scene.traverse((obj) => {
+            if (obj.isBone)
+                allBones.set(obj.name, obj);
+            if (obj.isSkinnedMesh && obj.skeleton?.bones) {
+                for (const b of obj.skeleton.bones) {
+                    allBones.set(b.name, b);
+                }
+            }
+        });
+        for (const [canonical, aliases] of Object.entries(BONE_ALIASES)) {
+            for (const alias of aliases) {
+                // Case-insensitive match
+                const found = [...allBones.entries()].find(([name]) => name.toLowerCase() === alias.toLowerCase());
+                if (found) {
+                    this.boneMap.set(canonical, found[1]);
+                    break;
+                }
+            }
+        }
+    }
+    // ── Internal: base pose snapshot ─────────────────────────────────────────
+    _captureBasePose() {
+        this.basePose = [];
+        for (const bone of this.boneMap.values()) {
+            this.basePose.push({
+                bone,
+                rx: bone.rotation.x,
+                ry: bone.rotation.y,
+                rz: bone.rotation.z,
+            });
+        }
+    }
+    _restoreBasePose() {
+        for (const { bone, rx, ry, rz } of this.basePose) {
+            bone.rotation.set(rx, ry, rz);
+        }
+    }
+    // ── Internal: patch compilation ──────────────────────────────────────────
+    _buildPatches() {
+        this.patches.clear();
+        for (const viseme of visemes_1.OCULUS_VISEMES) {
+            const coeffs = FLAME_VISEME_COEFFS[viseme] ?? [];
+            const targets = this.patchQuality === 'fast'
+                ? coeffs.filter(c => c.bone === 'LowerJaw')
+                : coeffs;
+            const boneDeltas = [];
+            for (const coeff of targets) {
+                const bone = this.boneMap.get(coeff.bone);
+                if (bone) {
+                    boneDeltas.push({ bone, dx: coeff.dx, dy: coeff.dy, dz: coeff.dz });
+                }
+            }
+            // Always fall back to Head/LowerJaw if no lip bones found and viseme
+            // has any jaw motion — keeps jaw-only models animated.
+            if (boneDeltas.length === 0) {
+                const jawCoeff = coeffs.find(c => c.bone === 'LowerJaw');
+                if (jawCoeff) {
+                    const fallback = this.boneMap.get('LowerJaw') ?? this.boneMap.get('Head');
+                    if (fallback) {
+                        boneDeltas.push({ bone: fallback, dx: jawCoeff.dx * 0.6, dy: 0, dz: 0 });
+                    }
+                }
+            }
+            this.patches.set(viseme, { viseme, boneDeltas });
+        }
+    }
+    // ── Internal: apply FaceControl to skeleton ───────────────────────────────
+    _applyControl(control) {
+        const { expr, pose } = control;
+        const scale = 1.0;
+        // Reset to base pose each frame before accumulating deltas.
+        this._restoreBasePose();
+        // ── Expression channels → viseme patches ─────────────────────────────
+        // Map each ExpressionState channel to the closest Oculus viseme and
+        // accumulate the patch weighted by the channel value.
+        //
+        // Channel → viseme correspondence (loose phonetic mapping):
+        const CHANNEL_VISEME_MAP = [
+            ['jawOpen', 'aa', 1.0],
+            ['mouthFunnel', 'oh', 1.0],
+            ['mouthPucker', 'ou', 1.0],
+            ['mouthWide', 'ee', 0.8],
+            ['mouthSmile', 'ee', 0.4],
+            ['upperLipRaise', 'FF', 0.7],
+            ['lowerLipDepress', 'FF', 0.7],
+        ];
+        for (const [channel, viseme, gain] of CHANNEL_VISEME_MAP) {
+            const w = expr[channel] ?? 0;
+            if (w <= 0.001)
+                continue;
+            const patch = this.patches.get(viseme);
+            if (!patch)
+                continue;
+            const cal = this.calibration.ranges;
+            const range = cal?.[channel];
+            const remapped = range ? range.min + w * (range.max - range.min) : w;
+            const totalWeight = remapped * gain * scale;
+            for (const { bone, dx, dy, dz } of patch.boneDeltas) {
+                bone.rotation.x += dx * totalWeight;
+                bone.rotation.y += dy * totalWeight;
+                bone.rotation.z += dz * totalWeight;
+            }
+        }
+        // ── Head pose ────────────────────────────────────────────────────────
+        // Apply FaceControl head pose to the Head bone.
+        const headBone = this.boneMap.get('Head');
+        if (headBone) {
+            headBone.rotation.y += pose.yaw * 0.3; // radians, limited
+            headBone.rotation.x += pose.pitch * 0.2;
+            headBone.rotation.z += pose.roll * 0.15;
+        }
+        // ── Eye gaze ─────────────────────────────────────────────────────────
+        this._applyGaze(expr.eyeGazeLeft, 'LeftEye');
+        this._applyGaze(expr.eyeGazeRight, 'RightEye');
+    }
+    _applyGaze(gaze, canonicalBone) {
+        const bone = this.boneMap.get(canonicalBone);
+        if (!bone)
+            return;
+        const limits = this.calibration.gazeLimits;
+        const clamp = (v, axis) => {
+            const lim = limits?.[axis];
+            return lim ? Math.min(lim.max, Math.max(lim.min, v)) : v;
+        };
+        // x → yaw (left/right), y → pitch (down/up)
+        bone.rotation.y += clamp(gaze.x, 'x') * 0.25;
+        bone.rotation.x -= clamp(gaze.y, 'y') * 0.25; // negative: up = negative pitch
+    }
+    // ── Public diagnostics ───────────────────────────────────────────────────
+    /** Canonical bones resolved from the skeleton. Useful for debugging rig coverage. */
+    get resolvedBones() {
+        return Array.from(this.boneMap.keys());
+    }
+    /** Number of viseme patches with at least one resolved bone. */
+    get patchCoverage() {
+        let count = 0;
+        for (const patch of this.patches.values()) {
+            if (patch.boneDeltas.length > 0)
+                count++;
+        }
+        return count;
+    }
+    /** The schema report this backend was initialized with. */
+    get schema() {
+        return this.schemaReport;
+    }
+}
+exports.GaussianBackend = GaussianBackend;

package/dist/core/avatar/backends/index.d.ts

@@ -0,0 +1,3 @@
+export { MorphTargetBackend } from './morphTarget';
+export { GaussianBackend } from './gaussian';
+export type { GaussianBackendConfig } from './gaussian';

package/dist/core/avatar/backends/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GaussianBackend = exports.MorphTargetBackend = void 0;
+var morphTarget_1 = require("./morphTarget");
+Object.defineProperty(exports, "MorphTargetBackend", { enumerable: true, get: function () { return morphTarget_1.MorphTargetBackend; } });
+var gaussian_1 = require("./gaussian");
+Object.defineProperty(exports, "GaussianBackend", { enumerable: true, get: function () { return gaussian_1.GaussianBackend; } });

package/dist/core/avatar/backends/morphTarget.d.ts

@@ -0,0 +1,39 @@
+import type * as THREE from 'three';
+import type { AvatarBackend, AvatarRenderTarget, CalibrationProfile } from '../backend';
+import type { FaceControl } from '../faceControls';
+interface MorphTargetBackendConfig {
+    /** Optional calibration profile to remap control ranges per-avatar. */
+    calibration?: CalibrationProfile;
+    /** Optional mood name to layer over expressions (from MOOD_MORPHS). */
+    mood?: string;
+    /** Scale factor for expression morph weights (default 1.0). */
+    expressionScale?: number;
+}
+export declare class MorphTargetBackend implements AvatarBackend {
+    private scene;
+    private meshes;
+    private visemeCache;
+    private expressionCache;
+    private gazeCache;
+    private config;
+    constructor(scene: THREE.Object3D, config?: MorphTargetBackendConfig);
+    /** Scan the scene for meshes with morph targets and build lookup caches. */
+    private _buildCaches;
+    private _buildNamedCache;
+    private _setWeight;
+    private _zeroCache;
+    attach(_target: AvatarRenderTarget): void;
+    setControl(control: FaceControl): void;
+    renderFrame(): void;
+    setMood(mood: string): void;
+    dispose(): void;
+    /** Re-scan the scene after hot-swapping the GLB (e.g. wardrobe change). */
+    rebuildCaches(): void;
+    /** Read-only view of which morph channels were found on this model. */
+    get availableChannels(): {
+        visemes: string[];
+        expressions: string[];
+        gaze: string[];
+    };
+}
+export {};

package/dist/core/avatar/backends/morphTarget.js

@@ -0,0 +1,179 @@
+"use strict";
+// src/core/avatar/backends/morphTarget.ts
+// AvatarBackend implementation for Three.js GLB models with morph targets.
+//
+// Maps the canonical FaceControl (ExpressionState + HeadPose) to morph target
+// weights on a Three.js Object3D scene. Works with any GLB that has Oculus
+// viseme morphs, ARKit shapes, or the simpler fallback names from morphTables.ts.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MorphTargetBackend = void 0;
+const morphTables_1 = require("../../../wgpu/morphTables");
+// ─── ExpressionState → morph target name mapping ────────────────────────────
+//
+// Each ExpressionState channel maps to one or more morph target names to try,
+// in priority order. The first name found on any mesh wins.
+// This bridges the abstract FaceControl space to concrete GLB morph names.
+const EXPRESSION_MORPH_ALIASES = {
+    jawOpen: ['jawOpen', 'jaw_open', 'viseme_aa', 'mouthOpen'],
+    mouthSmile: ['mouthSmileLeft', 'mouthSmile', 'mouth_smile'],
+    mouthFunnel: ['mouthFunnel', 'mouth_funnel', 'viseme_O', 'viseme_oh'],
+    mouthPucker: ['mouthPucker', 'mouth_pucker', 'viseme_U', 'viseme_ou'],
+    mouthWide: ['mouthStretchLeft', 'mouthWide', 'mouth_wide'],
+    upperLipRaise: ['mouthUpperUpLeft', 'mouthUpperUpRight', 'upperLipRaiser'],
+    lowerLipDepress: ['mouthLowerDownLeft', 'mouthLowerDownRight', 'lowerLipDepressor'],
+    cheekRaise: ['cheekSquintLeft', 'cheekSquintRight', 'cheekRaiser'],
+    blinkLeft: ['eyeBlinkLeft', 'blink_left', 'eyesClosed'],
+    blinkRight: ['eyeBlinkRight', 'blink_right', 'eyesClosed'],
+    browInnerUp: ['browInnerUp', 'brow_inner_up', 'innerBrowRaiser'],
+    browDownLeft: ['browDownLeft', 'brow_down_left', 'browLowererLeft'],
+    browDownRight: ['browDownRight', 'brow_down_right', 'browLowererRight'],
+};
+// Eye gaze morph names (separate from scalar channels)
+const EYE_GAZE_MORPHS = {
+    lookLeft: ['eyeLookOutLeft', 'eyeLookLeft', 'eye_look_left'],
+    lookRight: ['eyeLookOutRight', 'eyeLookRight', 'eye_look_right'],
+    lookUp: ['eyeLookUpLeft', 'eyeLookUpRight', 'eyeLookUp', 'eye_look_up'],
+    lookDown: ['eyeLookDownLeft', 'eyeLookDownRight', 'eyeLookDown', 'eye_look_down'],
+};
+// ─── Implementation ──────────────────────────────────────────────────────────
+class MorphTargetBackend {
+    constructor(scene, config = {}) {
+        this.scene = null;
+        this.meshes = [];
+        this.visemeCache = {};
+        this.expressionCache = {};
+        this.gazeCache = {};
+        this.scene = scene;
+        this.config = {
+            calibration: config.calibration ?? { neutral: { pose: { yaw: 0, pitch: 0, roll: 0 }, expr: {} } },
+            mood: config.mood ?? 'neutral',
+            expressionScale: config.expressionScale ?? 1.0,
+        };
+        this._buildCaches();
+    }
+    /** Scan the scene for meshes with morph targets and build lookup caches. */
+    _buildCaches() {
+        if (!this.scene)
+            return;
+        this.meshes = [];
+        this.scene.traverse((child) => {
+            const mesh = child;
+            if (mesh.isMesh && mesh.morphTargetDictionary && mesh.morphTargetInfluences) {
+                this.meshes.push(mesh);
+            }
+        });
+        this.visemeCache = this._buildNamedCache(morphTables_1.VISEME_MORPH_ALIASES);
+        this.expressionCache = this._buildNamedCache(EXPRESSION_MORPH_ALIASES);
+        this.gazeCache = this._buildNamedCache(EYE_GAZE_MORPHS);
+    }
+    _buildNamedCache(aliasMap) {
+        const cache = {};
+        for (const [key, aliases] of Object.entries(aliasMap)) {
+            const entries = [];
+            for (const mesh of this.meshes) {
+                const dict = mesh.morphTargetDictionary;
+                const dictLower = Object.fromEntries(Object.keys(dict).map(k => [k.toLowerCase(), k]));
+                for (const alias of aliases) {
+                    const found = dictLower[alias.toLowerCase()];
+                    if (found !== undefined) {
+                        entries.push({ influences: mesh.morphTargetInfluences, idx: dict[found] });
+                        break; // first alias match per mesh
+                    }
+                }
+            }
+            if (entries.length > 0)
+                cache[key] = entries;
+        }
+        return cache;
+    }
+    _setWeight(cache, key, weight) {
+        const entries = cache[key];
+        if (!entries)
+            return;
+        const w = Math.min(1, Math.max(0, weight));
+        for (const e of entries)
+            e.influences[e.idx] = w;
+    }
+    _zeroCache(cache) {
+        for (const entries of Object.values(cache)) {
+            for (const e of entries)
+                e.influences[e.idx] = 0;
+        }
+    }
+    // AvatarBackend.attach — this backend takes an Object3D directly in the
+    // constructor, so attach is a no-op (scene already set).
+    attach(_target) { }
+    setControl(control) {
+        if (!this.scene)
+            return;
+        const { expr } = control;
+        const scale = this.config.expressionScale;
+        const cal = this.config.calibration.ranges ?? {};
+        // Zero all managed channels before applying new values
+        this._zeroCache(this.visemeCache);
+        this._zeroCache(this.expressionCache);
+        this._zeroCache(this.gazeCache);
+        // Apply mood morphs as a base layer (low-weight persistent shapes)
+        const moodMorphs = morphTables_1.MOOD_MORPHS[this.config.mood] ?? {};
+        for (const [morphName, weight] of Object.entries(moodMorphs)) {
+            this._setWeight(this.visemeCache, morphName, weight);
+            this._setWeight(this.expressionCache, morphName, weight);
+        }
+        // Apply ExpressionState channels
+        for (const [channel, aliases] of Object.entries(EXPRESSION_MORPH_ALIASES)) {
+            const key = channel;
+            const raw = expr[key] ?? 0;
+            const range = cal[key];
+            const remapped = range ? range.min + raw * (range.max - range.min) : raw;
+            void aliases; // alias lookup happens via cache
+            this._setWeight(this.expressionCache, key, remapped * scale);
+        }
+        // Apply eye gaze — split x/y into directional morph targets
+        const gl = expr.eyeGazeLeft;
+        const gr = expr.eyeGazeRight;
+        const gazeX = (gl.x + gr.x) / 2;
+        const gazeY = (gl.y + gr.y) / 2;
+        const gazeLimits = this.config.calibration.gazeLimits;
+        const clampGaze = (v, axis) => {
+            const lim = gazeLimits?.[axis];
+            return lim ? Math.min(lim.max, Math.max(lim.min, v)) : v;
+        };
+        const cx = clampGaze(gazeX, 'x');
+        const cy = clampGaze(gazeY, 'y');
+        if (cx < 0)
+            this._setWeight(this.gazeCache, 'lookLeft', -cx);
+        if (cx > 0)
+            this._setWeight(this.gazeCache, 'lookRight', cx);
+        if (cy > 0)
+            this._setWeight(this.gazeCache, 'lookUp', cy);
+        if (cy < 0)
+            this._setWeight(this.gazeCache, 'lookDown', -cy);
+    }
+    renderFrame() {
+        // Three.js applies morph target influences automatically each render loop.
+        // Nothing to do here — weights set in setControl are live on the mesh.
+    }
+    setMood(mood) {
+        this.config.mood = mood;
+    }
+    dispose() {
+        this._zeroCache(this.visemeCache);
+        this._zeroCache(this.expressionCache);
+        this._zeroCache(this.gazeCache);
+        this.meshes = [];
+        this.scene = null;
+    }
+    /** Re-scan the scene after hot-swapping the GLB (e.g. wardrobe change). */
+    rebuildCaches() {
+        this._buildCaches();
+    }
+    /** Read-only view of which morph channels were found on this model. */
+    get availableChannels() {
+        return {
+            visemes: Object.keys(this.visemeCache),
+            expressions: Object.keys(this.expressionCache),
+            gaze: Object.keys(this.gazeCache),
+        };
+    }
+}
+exports.MorphTargetBackend = MorphTargetBackend;

package/dist/core/avatar/faceControls.d.ts

@@ -0,0 +1,40 @@
+import type { OculusViseme } from './visemes';
+export type HeadPose = {
+    /** -1..1, left..right */
+    yaw: number;
+    /** -1..1, down..up */
+    pitch: number;
+    /** -1..1, left-ear-down..right-ear-down */
+    roll: number;
+};
+export type EyeGaze = {
+    /** -1..1, left..right */
+    x: number;
+    /** -1..1, down..up */
+    y: number;
+};
+export type ExpressionState = {
+    jawOpen: number;
+    mouthSmile: number;
+    mouthFunnel: number;
+    mouthPucker: number;
+    mouthWide: number;
+    upperLipRaise: number;
+    lowerLipDepress: number;
+    cheekRaise: number;
+    blinkLeft: number;
+    blinkRight: number;
+    browInnerUp: number;
+    browDownLeft: number;
+    browDownRight: number;
+    eyeGazeLeft: EyeGaze;
+    eyeGazeRight: EyeGaze;
+};
+export type FaceControl = {
+    pose: HeadPose;
+    expr: ExpressionState;
+};
+export type Viseme = OculusViseme;
+export declare function createNeutralExpression(): ExpressionState;
+export declare function visemeToExpression(viseme: Viseme, weight?: number): Partial<ExpressionState>;
+export declare function applyVisemeToExpression(base: ExpressionState, viseme: Viseme, weight?: number): ExpressionState;