plushies 0.1.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Patrick Rathje
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,195 @@
+# plushies
+
+Soft 3D plush characters for [three.js](https://threejs.org). A flat silhouette
+(circle, heart, star, … 17 kinds) is inflated into a stuffed pillow with a
+rolled seam and covered in real shell-textured fur. Eyes, mouth, moustache,
+glasses, hats (top hat to fez to halo), pins and neckwear float in front of the
+body as separate pieces. Everything that
+moves — eye direction, blink, squash & stretch, hop, lean, turn — is a plain
+number you can set every frame.
+
+**Demo and editor:** run `bun install` at the repo root, then `bun run site:dev` in `packages/plushies`, and open
+<http://localhost:4517> — configure a plushie and copy the code.
+
+## Install
+
+Three builds, depending on what your page already has:
+
+| you have | use | size (gzip) |
+|---|---|---|
+| a bundler and three.js | `plushies` / `plushies/viewer` (three is a peer dependency) | ~22 kB (`index.js` ~19.8 + `viewer.js` ~2.5) |
+| a bundler, no three.js | `plushies/bundled` (three included) | ~200 kB |
+| a plain HTML page | `dist/plushies.global.js` → `window.Plushies` (three included) | ~200 kB |
+
+```sh
+npm i plushies three
+```
+
+The CDN snippets below and on the site work once the package is published to
+npm.
+
+```html
+<!-- no build step, three bundled in -->
+<script src="https://cdn.jsdelivr.net/npm/plushies@0.1/dist/plushies.global.js"></script>
+<script>
+  Plushies.mountPlushie(document.getElementById('hero'), {kind: 'heart', idle: true});
+</script>
+```
+
+Only use one copy of three per page: if your app already imports three, use the
+small build and pass your copy in.
+
+## Drop-in viewer
+
+```html
+<div id="hero" style="width: 360px; height: 360px"></div>
+<script type="module">
+  import * as THREE from 'three';
+  import {mountPlushie} from 'plushies/viewer';
+
+  const view = mountPlushie(document.querySelector('#hero'), THREE, {
+    kind: 'heart',
+    color: '#f47c9a',
+    mouth: 'smile',
+    glasses: 'round',
+    idle: true,          // blink, breathe, glance around
+    followPointer: true, // eyes follow the mouse
+  });
+  view.canvas.addEventListener('click', () => view.hop());
+</script>
+```
+
+The canvas is transparent and fills its container. The viewer only renders
+while something changes, and stops painting while it is scrolled off-screen
+(tweens keep running, so their promises still resolve; it repaints when it
+scrolls back in). Every viewer on the page draws through one shared,
+hidden WebGL context, so you can mount dozens without hitting the browser's
+limit of about 16 contexts.
+
+| method | |
+|---|---|
+| `view.set(pose)` | set pose fields right away |
+| `view.to(pose, seconds, ease)` | tween numeric pose fields; resolves when done |
+| `view.look(x, y)` · `view.blink()` · `view.hop(height)` · `view.squish(amount)` | little performances, all promises; `hop()` defaults to a height that fits the container: min(90, 20% of its height) px |
+| `view.stop()` | halt everything where it is: running tweens, `hop`/`squish`/`blink` sequences and the idle loop's current gesture. All their promises resolve; the idle loop, if on, carries on after its next pause (use `setIdle(false)` to end it) |
+| `view.restyle(options)` | change the look in place, keeping the pose. `options` is **merged** into the current look (pass `undefined` to reset a key); only the fur length resets, to the new fabric's, unless you give `fur` |
+| `view.options` | the current look: the mount options merged with every `restyle` |
+| `view.setIdle(on)` · `view.setFollowPointer(on)` | toggle the idle loop / pointer following |
+| `view.dispose()` | remove the canvas and free its GPU resources (the shared context goes with the last viewer); pending promises resolve, and calling it twice is fine |
+
+With `plushies/bundled` or the global build, drop the `THREE` argument:
+`mountPlushie(element, options)` / `createPlushie(options)`.
+
+## In your own three.js scene
+
+```ts
+import * as THREE from 'three';
+import {createPlushie} from 'plushies';
+
+const plush = createPlushie(THREE, {kind: 'star', fabric: 'felt', finish: 'felt', hat: 'party', renderer});
+// The object is laid out in pixels (fits width × height, centred, y up):
+const world = new THREE.Group();
+world.scale.setScalar(1 / 100);
+world.add(plush.object);
+scene.add(world);
+
+// every frame, or whenever something changes:
+plush.set({lookX: 0.5, blink: 0, squash: 0.2, width: 600, height: 600});
+```
+
+`createPlushie` never imports `three` itself — you pass your copy of the module,
+so it works with any build from r160 on. Pass `renderer` so beads, glasses and
+the crown get their studio reflections. Pass `lights: false` to light it
+yourself (the fur is lit by its own built-in rig either way).
+
+Also exported: `DEFAULT_OPTIONS`, `DEFAULT_POSE`, the `PLUSHIE_*` value lists,
+`fabricFur(fabric)` and `plushieOutline(kind, options)` (the flat silhouette as
+points, e.g. for icons).
+
+## Options (the look)
+
+| option | values | default |
+|---|---|---|
+| `kind` | circle, square, triangle, heart, star, pill, cloud, polygon, blob, egg, drop, ghost, bean, flower, diamond, squircle, arch | circle |
+| `roundness` | 0..1 corner softness | 0.6 |
+| `sides` | corners of `polygon`, points of `star`, petals of `flower` | 6 / 5 / 6 |
+| `starInner` | star inner radius 0.2..0.9 | 0.55 |
+| `seed` | shape of `blob` | 1 |
+| `thickness` | stuffing, relative to half-width | 0.42 |
+| `fabric` | plush, felt, velvet, shaggy, fleece | plush |
+| `furGrain` | strand size, replacing the fabric's own (smaller is finer, denser fur) | from fabric: plush 1, felt 0.8, velvet 0.9, shaggy 1.7, fleece 2.8 |
+| `finish` | surface of eyes, mouth, moustache, glasses, neckwear, pins: gloss, satin, matte, felt | satin |
+| `eyes` | dot, oval, googly, ring, happy, sleepy, none | dot |
+| `eyeSize`, `eyeSpacing` | multipliers | 1 |
+| `faceY` | face up (+) / down (−) | 0 |
+| `mouth` | none, smile, grin, open, flat, cat | none |
+| `cheeks` | boolean | false |
+| `moustache` | none, curly, walrus, pencil | none |
+| `glasses` | none, round, square, monocle, shades | none |
+| `hat` | none, top, beanie, party, crown, cowboy, cap, hardhat, fireman, santa, graduation, fez, halo — worn on a tip when the top has a dip (heart) | none |
+| `hatSize` | multiplier | 1 |
+| `neck` | none, bowtie, necktie (`bowtie: true` is shorthand) | none |
+| `pin` | none, flower, bow, heart (on the head), star, badge (on the chest) | none |
+| `featureColor`, `moustacheColor`, `glassesColor`, `hatColor`, `neckColor`, `pinColor`, `accentColor`, `cheekColor` | CSS colours (`ACCESSORY_COLORS` lists the per-item defaults) | |
+| `headroom` | free space above for hops, fraction of body height | 0.22 |
+| `shadow` | contact shadow | true |
+
+Colours accept any CSS colour: hex, names, `rgb()`/`hsl()` in comma or space
+syntax, and `oklch()`/`lab()` and friends (resolved through the browser). An
+unknown colour warns once in the console and falls back to the default; any
+other invalid option does the same (booleans included: `shadow: 'false'`
+warns and keeps the default).
+
+## Pose (per frame)
+
+| field | meaning | default |
+|---|---|---|
+| `width`, `height` | box to fit into, px | 600 |
+| `pixelRatio` | device pixels per px (picks the fur shell count) | 1 |
+| `lookX`, `lookY` | eye direction −1..1 (y down) | 0 |
+| `blink` | 0 open .. 1 closed | 0 |
+| `squash` | +1 squashed .. −1 stretched, volume preserving | 0 |
+| `hop` | jump height, px | 0 |
+| `lean`, `turn` | degrees | 0 |
+| `float` | how far accessories float off the body | 1 |
+| `fur` | fur length, fraction of half-width | from fabric |
+| `color` | fur colour, any CSS colour or sRGB `[r, g, b]` 0..1 | #f2b33d |
+
+## Performance
+
+The fur is up to 16 shells of the body mesh with per-vertex lighting and a
+cheap fragment shader; the shell count adapts to the on-screen fur length, so
+small plushies are cheap. A handful of hero-size plushies is fine on any GPU.
+
+## Development
+
+This package lives in the `plushies` monorepo next to [`@plushies/cursors`](../cursors). Run `bun install` once at the repo root; the commands below run in `packages/plushies`.
+
+```sh
+bun run typecheck   # tsc over src, tests and site
+bun run test        # unit tests (bun:test, headless three)
+bun run build       # dist/: ESM + CJS (three external), bundled ESM + global (three included), d.ts
+bun run site:dev    # the demo/editor site with live reload on http://localhost:4517
+bun run site:build  # _site/ (the repo root's site:build also adds the cursor demo at _site/cursors/)
+bun run test:e2e    # Playwright: the three builds and the site in Chromium (needs build + the root's site:build)
+bun run check       # typecheck + test + build + site:build
+```
+
+CI (`.github/workflows/ci.yml` at the repo root) runs all of the above for both packages on every push and pull
+request and deploys `_site/` to GitHub Pages from `main` (Settings → Pages →
+Source: GitHub Actions).
+
+`examples/index.html` is a minimal page using the ESM build (`bun run build`
+first, then serve the repo root).
+
+### VideoZero
+
+This is the same code that renders the `Plushie` / `PlushLibrary` components in
+VideoZero. PlushLibrary loads the CommonJS core at runtime; refresh the engine's
+copy from the repo root (with the engine checked out next to this repo) with
+
+```sh
+bun run vendor
+```
+
+(restart the engine after adding the file for the first time).

package/dist/bundled.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Batteries included: the same API with three.js bundled in, so there is
+ * nothing to wire up. Use this when your page doesn't already load three.
+ *
+ *   import {mountPlushie} from 'plushies/bundled';
+ *   mountPlushie(document.querySelector('#hero'), {kind: 'star', idle: true});
+ *
+ * If your app already uses three, import 'plushies' / 'plushies/viewer'
+ * instead and pass your copy — two copies of three on one page don't mix.
+ */
+import * as THREE from 'three';
+import { type Plushie, type PlushieOptions, type PlushiePose } from './index.js';
+import { type PlushieViewer, type ViewerOptions } from './viewer.js';
+export { ACCESSORY_COLORS, DEFAULT_OPTIONS, DEFAULT_POSE, MAX_FUR_SHELLS, PLUSHIE_EYES, PLUSHIE_FABRICS, PLUSHIE_FINISHES, PLUSHIE_GLASSES, PLUSHIE_HATS, PLUSHIE_KINDS, PLUSHIE_MOUSTACHES, PLUSHIE_MOUTHS, PLUSHIE_NECKS, PLUSHIE_PINS, fabricFur, fabricGrain, plushieOutline, } from './index.js';
+export type * from './index.js';
+export { easeIn, easeInOut, easeOut } from './viewer.js';
+export type { Easing, PlushieViewer, ViewerLook, ViewerOptions } from './viewer.js';
+export { THREE };
+/** Build a plushie for your own scene (uses the bundled three). */
+export declare function createPlushie(options?: PlushieOptions & Partial<PlushiePose>): Plushie;
+/** Mount a plushie filling `container`. */
+export declare function mountPlushie(container: HTMLElement, options?: ViewerOptions): PlushieViewer;

package/dist/index.d.ts

@@ -0,0 +1,224 @@
+/**
+ * plushies — soft 3D plush characters for three.js.
+ *
+ * A body is a 2D silhouette (circle, heart, star, …) inflated into a stuffed
+ * pillow with a rolled seam and covered in shell-textured fur. Eyes, mouth,
+ * moustache, glasses, hat, pin and neckwear are separate objects floating just
+ * in front of / above the body.
+ *
+ * The library never imports `three` itself: pass your copy of the module to
+ * `createPlushie(THREE, options)`. That keeps it working with whatever
+ * three.js build (r160+) the page already loads.
+ *
+ * Units: the returned `object` is laid out in pixels — it fits itself into a
+ * `width` × `height` box (default 600 × 600) centred on its origin, y up. Put
+ * it in a group scaled by 1/100 for a 100 px = 1 unit world, or use
+ * `mountPlushie` (./viewer) which sets up renderer, camera and loop for you.
+ */
+import type * as ThreeNamespace from 'three';
+/** The `three` module namespace, as passed to `createPlushie`. */
+export type ThreeModule = typeof ThreeNamespace;
+type T3 = ThreeModule;
+type TGroup = InstanceType<T3['Group']>;
+type TRenderer = InstanceType<T3['WebGLRenderer']>;
+/** sRGB colour, each channel 0..1. */
+export type Rgb = [number, number, number];
+/** A CSS colour string (`#rgb`, `#rrggbb`, `rgb(…)`, `hsl(…)`, names) or an sRGB 0..1 triple. */
+export type PlushieColor = string | Rgb | readonly number[];
+/** Body silhouettes. */
+export type PlushieKind = 'circle' | 'square' | 'triangle' | 'heart' | 'star' | 'pill' | 'cloud' | 'polygon' | 'blob' | 'egg' | 'drop' | 'ghost' | 'bean' | 'flower' | 'diamond' | 'squircle' | 'arch';
+/** Body fabric: fur length, fibre size, sheen and mottling presets. */
+export type PlushieFabric = 'plush' | 'felt' | 'velvet' | 'shaggy' | 'fleece';
+/** Surface of the eyes, mouth, glasses and bow tie. */
+export type PlushieFinish = 'gloss' | 'satin' | 'matte' | 'felt';
+export type PlushieEyes = 'dot' | 'oval' | 'googly' | 'ring' | 'happy' | 'sleepy' | 'none';
+export type PlushieMouth = 'none' | 'smile' | 'grin' | 'open' | 'flat' | 'cat';
+export type PlushieGlasses = 'none' | 'round' | 'square' | 'monocle' | 'shades';
+export type PlushieHat = 'none' | 'top' | 'beanie' | 'party' | 'crown' | 'cowboy' | 'cap' | 'hardhat' | 'fireman' | 'santa' | 'graduation' | 'fez' | 'halo';
+/** Worn below the mouth. */
+export type PlushieNeck = 'none' | 'bowtie' | 'necktie';
+/** A small piece pinned to the body: flower, bow and heart sit on the head, badge and star on the chest. */
+export type PlushiePin = 'none' | 'flower' | 'bow' | 'heart' | 'star' | 'badge';
+export type PlushieMoustache = 'none' | 'curly' | 'walrus' | 'pencil';
+/** Forget the baked environment map of `renderer` (after its WebGL context was lost and restored). */
+export declare function resetEnvironment(renderer: TRenderer): void;
+/** Default colour of each hat, neck piece and pin when its colour option is left out (missing ones use `accentColor`; the bow tie uses `featureColor`). */
+export declare const ACCESSORY_COLORS: {
+    hat: Partial<Record<PlushieHat, string>>;
+    neck: Partial<Record<PlushieNeck, string>>;
+    pin: Partial<Record<PlushiePin, string>>;
+};
+/** Build-time options: the character's look. Changing them means a new plushie. */
+export interface PlushieOptions {
+    /** Body silhouette. (default: 'circle') */
+    kind?: PlushieKind;
+    /** How soft the silhouette's corners are, 0..1. (default: 0.6) */
+    roundness?: number;
+    /** Corner count for `polygon` (default 6), points of a `star` (default 5), petals of a `flower` (default 6). */
+    sides?: number;
+    /** Inner radius of a `star` relative to its points, 0.2..0.9. (default: 0.55) */
+    starInner?: number;
+    /** Seed for the `blob` silhouette — each seed is a different lump. (default: 1) */
+    seed?: number;
+    /** Stuffing: how thick the pillow is relative to its half-width. (default: 0.42) */
+    thickness?: number;
+    /** Body fabric preset: plush, felt, velvet, shaggy, fleece. (default: 'plush') */
+    fabric?: PlushieFabric;
+    /** Size of one fur strand; smaller is finer, denser fur. (default: from `fabric`) */
+    furGrain?: number;
+    /** Surface of eyes, mouth, moustache, glasses, neckwear and pins: gloss, satin, matte, felt. (default: 'satin') */
+    finish?: PlushieFinish;
+    /** Eye style. (default: 'dot') */
+    eyes?: PlushieEyes;
+    /** Eye size multiplier. (default: 1) */
+    eyeSize?: number;
+    /** Distance between the eyes, multiplier. (default: 1) */
+    eyeSpacing?: number;
+    /** Shift the face up (+) or down (−), as a fraction of the body's half-height. (default: 0) */
+    faceY?: number;
+    /** Mouth style. (default: 'none') */
+    mouth?: PlushieMouth;
+    /** Blush discs under the eyes. (default: false) */
+    cheeks?: boolean;
+    /** Moustache over the mouth. (default: 'none') */
+    moustache?: PlushieMoustache;
+    /** Glasses. (default: 'none') */
+    glasses?: PlushieGlasses;
+    /** Hat. Silhouettes without a top in the middle (a heart) wear it on a tip. (default: 'none') */
+    hat?: PlushieHat;
+    /** Hat size multiplier. (default: 1) */
+    hatSize?: number;
+    /** Neckwear: a bow tie at the bottom edge, or a necktie under the mouth. (default: 'none') */
+    neck?: PlushieNeck;
+    /** Shorthand for `neck: 'bowtie'`. */
+    bowtie?: boolean;
+    /** A pin: flower, bow and heart on the head, star and badge on the chest. (default: 'none') */
+    pin?: PlushiePin;
+    /** Eyes / mouth / eyebrows colour. (default: '#18130f') */
+    featureColor?: string;
+    /** Moustache colour. (default: featureColor) */
+    moustacheColor?: string;
+    /** Glasses frame colour. (default: featureColor) */
+    glassesColor?: string;
+    /** Hat colour; each hat has a sensible default (see `ACCESSORY_COLORS`). */
+    hatColor?: string;
+    /** Neckwear colour. (default: featureColor for the bow tie, otherwise from `ACCESSORY_COLORS`) */
+    neckColor?: string;
+    /** Older name for `neckColor`. */
+    bowtieColor?: string;
+    /** Pin colour; each pin has a sensible default (the badge uses accentColor). */
+    pinColor?: string;
+    /** Second colour for hat bands and tassels, party-hat stripes, jewels and necktie stripes. (default: '#5b6cff') */
+    accentColor?: string;
+    /** Blush colour. (default: '#f08a9b') */
+    cheekColor?: string;
+    /** Empty space kept above the character for hops and accessories, fraction of body height. (default: 0.22) */
+    headroom?: number;
+    /** Soft contact shadow under the body. (default: true) */
+    shadow?: boolean;
+    /** Add the built-in light rig to `object`. Turn off to light it yourself. (default: true) */
+    lights?: boolean;
+    /**
+     * The renderer that will draw the plushie. Used once to bake a small studio
+     * environment map that gives beads, glasses and the crown their reflections;
+     * without it those render without reflections.
+     */
+    renderer?: TRenderer;
+}
+/** Everything that can change every frame. All fields are cheap to update. */
+export interface PlushiePose {
+    /** Box the character fits into, in pixels. (default: 600) */
+    width: number;
+    /** (default: 600) */
+    height: number;
+    /** Device pixels per pixel — picks how many fur shells are worth drawing. (default: 1) */
+    pixelRatio: number;
+    /** Eye direction, −1 left .. 1 right. */
+    lookX: number;
+    /** Eye direction, −1 up .. 1 down. */
+    lookY: number;
+    /** 0 open .. 1 closed. */
+    blink: number;
+    /** +1 squashed .. −1 stretched, volume preserving, pivoting on the bottom. */
+    squash: number;
+    /** Jump height in pixels. */
+    hop: number;
+    /** Lean in degrees, clockwise, about the bottom. */
+    lean: number;
+    /** Turn about the vertical axis in degrees. */
+    turn: number;
+    /** Accessory float multiplier (1 = rest). */
+    float: number;
+    /** Fur length as a fraction of the half-width. (default: from `fabric`) */
+    fur: number;
+    /** Fur colour. (default: '#f2b33d') */
+    color: PlushieColor;
+}
+export interface Plushie {
+    /** Add this to your scene. Laid out in pixels, y up, centred on the origin. */
+    readonly object: TGroup;
+    /** The current pose. */
+    readonly pose: Readonly<PlushiePose>;
+    /** Merge `pose` into the current pose and apply it. */
+    set(pose: Partial<PlushiePose>): void;
+    /** Free geometries, materials and textures (not the shared environment map). */
+    dispose(): void;
+}
+export declare const DEFAULT_POSE: Readonly<Omit<PlushiePose, 'fur'>>;
+/** The defaults `createPlushie` fills in for options you leave out (colours that follow other options are omitted). */
+export declare const DEFAULT_OPTIONS: {
+    readonly kind: "circle";
+    readonly roundness: 0.6;
+    readonly starInner: 0.55;
+    readonly seed: 1;
+    readonly thickness: 0.42;
+    readonly fabric: "plush";
+    readonly finish: "satin";
+    readonly eyes: "dot";
+    readonly eyeSize: 1;
+    readonly eyeSpacing: 1;
+    readonly faceY: 0;
+    readonly mouth: "none";
+    readonly cheeks: false;
+    readonly glasses: "none";
+    readonly moustache: "none";
+    readonly hat: "none";
+    readonly hatSize: 1;
+    readonly neck: "none";
+    readonly pin: "none";
+    readonly featureColor: "#18130f";
+    readonly accentColor: "#5b6cff";
+    readonly cheekColor: "#f08a9b";
+    readonly headroom: 0.22;
+    readonly shadow: true;
+    readonly lights: true;
+};
+/** Every body silhouette, in display order. */
+export declare const PLUSHIE_KINDS: readonly PlushieKind[];
+export declare const PLUSHIE_FABRICS: readonly PlushieFabric[];
+export declare const PLUSHIE_FINISHES: readonly PlushieFinish[];
+export declare const PLUSHIE_EYES: readonly PlushieEyes[];
+export declare const PLUSHIE_MOUTHS: readonly PlushieMouth[];
+export declare const PLUSHIE_GLASSES: readonly PlushieGlasses[];
+export declare const PLUSHIE_HATS: readonly PlushieHat[];
+export declare const PLUSHIE_NECKS: readonly PlushieNeck[];
+export declare const PLUSHIE_PINS: readonly PlushiePin[];
+export declare const PLUSHIE_MOUSTACHES: readonly PlushieMoustache[];
+/** The default fur length of a fabric preset. */
+export declare function fabricFur(fabric?: PlushieFabric): number;
+/** The default strand size (`furGrain`) of a fabric preset. */
+export declare function fabricGrain(fabric?: PlushieFabric): number;
+/**
+ * The flat silhouette a plushie is inflated from, as a closed counter-clockwise
+ * polyline fitted into [-1, 1] (y up). Handy for icons and hit areas.
+ */
+export declare function plushieOutline(kind?: PlushieKind, options?: Pick<PlushieOptions, 'roundness' | 'sides' | 'starInner' | 'seed'>): [number, number][];
+/** Number of fur shells drawn at most (each is one pass over the body). */
+export declare const MAX_FUR_SHELLS = 16;
+/**
+ * Build a plushie. `three` is your `three` module (`import * as THREE from 'three'`).
+ * The second argument takes the look (`PlushieOptions`) and, optionally, the
+ * initial pose.
+ */
+export declare function createPlushie(three: ThreeModule, options?: PlushieOptions & Partial<PlushiePose>): Plushie;
+export {};