@oeave/bakery3 0.0.0-stage → 0.1.0

package/dist/session-YCQS4MRH.js

@@ -0,0 +1,9 @@
+export { LIVE, createBakeSession } from './chunk-TGFNQBKC.js';
+import './chunk-HQTUFVMM.js';
+import './chunk-4E5VV4QY.js';
+import './chunk-W6WQ5UP7.js';
+import './chunk-6NYR73Y7.js';
+import './chunk-MD2U6S4N.js';
+import './chunk-3G5QL4F4.js';
+//# sourceMappingURL=session-YCQS4MRH.js.map
+//# sourceMappingURL=session-YCQS4MRH.js.map

package/dist/session-YCQS4MRH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"session-YCQS4MRH.js"}

package/dist/shapes/index.d.ts

@@ -0,0 +1,222 @@
+import * as THREE from 'three';
+import { WebGPURenderer } from 'three/webgpu';
+import { T as Timeline } from '../timeline-ChwgD7bT.js';
+import '../animation-B1h0Ryvj.js';
+
+/**
+ * The implementation behind `@oeave/bakery3/shapes`. `index.ts` lists what
+ * is public; the rest is shared with the SDK's own tests and tools.
+ */
+
+type Vec3 = [number, number, number];
+declare const SHAPE_KINDS: readonly ["sphere", "blob", "pebble", "torus", "ring", "knot", "capsule", "box"];
+type ShapeKind = (typeof SHAPE_KINDS)[number];
+/**
+ * `glow` emits its color (a real light in the render); `glass` refracts what
+ * is behind it; `matte`, `satin` and `metal` are lit surfaces; `rim` is a
+ * fresnel emission written in TSL (bright at the silhouette, dark in the
+ * middle); `nebula` is emission driven by fractal noise in TSL; `beacon` is a
+ * dark body that emits at a handful of fixed points, in TSL.
+ *
+ * The rest are TSL graphs too. `iris` is a metal whose color turns through
+ * the spectrum with the angle it is seen from, like oil on water. `scan` is a
+ * dark body crossed by bands of light that are fixed in the WORLD, so a shape
+ * that bobs, tumbles or orbits moves through them. `magma` is dark plates
+ * with glowing seams (cellular noise). `holo` is a globe's grid of glowing
+ * meridians and parallels. `aurora` is soft emission in two colors, folded
+ * by sines. `topo` is glowing contour lines at even heights of the shape, so
+ * on a blob they map its lumps. `spiral` is a lit surface in two-tone
+ * stripes that wind round the shape.
+ */
+declare const SHAPE_FINISHES: readonly ["glow", "glass", "matte", "satin", "metal", "rim", "nebula", "beacon", "iris", "scan", "magma", "holo", "aurora", "topo", "spiral"];
+type ShapeFinish = (typeof SHAPE_FINISHES)[number];
+declare const MOTION_KINDS: readonly ["spin", "tumble", "pulse", "bob", "orbit", "drift", "glow", "tint", "frost"];
+type MotionKind = (typeof MOTION_KINDS)[number];
+/**
+ * A motion runs for the whole clip. The cyclic ones (`spin`, `tumble`,
+ * `pulse`, `bob`, `orbit`, `glow`) complete whole turns or cycles so the
+ * clip loops; the one-way ones (`drift`, `tint`, `frost`) ease from the
+ * shape's own value to the one given.
+ */
+type Motion = 
+/** Whole turns about one axis. Default y, one turn. */
+{
+    kind: 'spin';
+    axis?: 'x' | 'y' | 'z';
+    turns?: number;
+}
+/** Whole turns about x and z at once. Default one turn. */
+ | {
+    kind: 'tumble';
+    turns?: number;
+}
+/** Scale breathing by ±amount (fraction of size). Default 0.12, two cycles. */
+ | {
+    kind: 'pulse';
+    amount?: number;
+    cycles?: number;
+}
+/** Vertical drift by ±amount meters. Default 0.12, one cycle. */
+ | {
+    kind: 'bob';
+    amount?: number;
+    cycles?: number;
+}
+/** Circle the composition's center at the shape's own distance (or `radius`). Default one turn. */
+ | {
+    kind: 'orbit';
+    radius?: number;
+    turns?: number;
+}
+/** Ease to another point, meters. */
+ | {
+    kind: 'drift';
+    to: Vec3;
+}
+/** Emission breathing by ±amount (fraction of strength); glow shapes only. Default 0.6, two cycles. */
+ | {
+    kind: 'glow';
+    amount?: number;
+    cycles?: number;
+}
+/** Ease the color to another hex. */
+ | {
+    kind: 'tint';
+    to: string;
+}
+/** Ease the roughness to `to` (default 0.6): glass frosts over, metal dulls. */
+ | {
+    kind: 'frost';
+    to?: number;
+};
+type Shape = {
+    id: string;
+    kind: ShapeKind;
+    finish: ShapeFinish;
+    /** CSS hex. The emission color of a glow, the tint of a glass, the albedo of the rest. */
+    color: string;
+    /** Center, meters; y up from the floor (y = 0). */
+    position: Vec3;
+    /** Longest extent, meters. */
+    size: number;
+    /** Degrees. */
+    rotation?: Vec3;
+    /** 0–1: how far the surface is pushed by noise. Blobs and pebbles have their own default; the rest none. */
+    noise?: number;
+    /** Emission strength for the finishes that emit. Default per finish. */
+    strength?: number;
+    motion?: Motion[];
+};
+type Composition = {
+    kind: 'composition';
+    shapes: Shape[];
+    /** Seeds the noise lattice, so a blob is the same blob in every capture. */
+    seed?: number;
+};
+type BuiltShape = {
+    spec: Shape;
+    mesh: THREE.Mesh;
+    /**
+     * The viewport-only light inside a glow shape.
+     * @internal Driven by `followGlow`; may change without notice.
+     */
+    light?: THREE.PointLight;
+    /**
+     * The viewport-only halo round an emitter in fog.
+     * @internal May change without notice.
+     */
+    halo?: THREE.Sprite;
+    /**
+     * The values the motions start from.
+     * @internal What the timeline animates from; may change without notice.
+     */
+    base: {
+        position: Vec3;
+        rotation: Vec3;
+        strength: number;
+        roughness: number;
+        color: THREE.Color;
+    };
+};
+type BuiltComposition = {
+    group: THREE.Group;
+    shapes: BuiltShape[];
+};
+/**
+ * Build a composition at `at` (the floor point the shapes' y is measured
+ * from). Returns the group to add to the scene and the built shapes the
+ * timeline and the glow follower work on.
+ */
+declare function createComposition(spec: Composition, at?: Vec3): BuiltComposition;
+/** Each frame: the stand-in light follows the emission the timeline is driving, and the loop's fade. */
+declare function followGlow(built: BuiltComposition): void;
+type Reflections = {
+    /** How many shapes took the snapshot. Zero when the scene has its own environment map, or nothing reflects. */
+    shapes: number;
+    /** Take the snapshot again now (after the setting changed, say). */
+    refresh(): Promise<void>;
+    /** Once a frame: takes the snapshot again when an emitter has moved or changed its glow since the last one. */
+    follow(): void;
+    /**
+     * True while a snapshot is being taken. The reflective shapes are hidden
+     * for that long (they must not reflect themselves), across an await, so a
+     * frame drawn meanwhile shows the composition without them: a render loop
+     * should keep its last frame up instead of drawing one.
+     */
+    readonly busy: boolean;
+    /**
+     * For filming frame by frame: resolves once no snapshot is in flight and
+     * the last one is of the emitters where they are now, with every shape
+     * visible again. Await it after a seek and before the shot, or the shot
+     * catches the glass hidden.
+     */
+    settle(): Promise<void>;
+    /** Free the render target. The materials keep no map after this. */
+    dispose(): void;
+};
+/**
+ * Give the reflective shapes something to reflect in the viewport: the
+ * scene as seen from the composition's center (the setting and the
+ * composition's own emitters, without the reflective shapes themselves),
+ * filtered into a PMREM. Called once after the setting is built; a scene
+ * that already has an environment map needs nothing. Call `follow()` on the
+ * handle every frame so a moving or breathing emitter is reflected where it
+ * is.
+ */
+declare function snapshotReflections(renderer: WebGPURenderer, scene: THREE.Scene, built: BuiltComposition, center: Vec3): Promise<Reflections>;
+/**
+ * How a clip loops. `fade` is seconds of fade-out at the end and fade-in at
+ * the start (0: the clip loops by itself); `start` is the frame the cut opens
+ * on, the first one after the fade-in, so the loop never opens on an empty
+ * stage.
+ */
+type Loop = {
+    fade: number;
+    start: number;
+};
+/**
+ * How a clip of `spec` loops: by itself when the camera move (in the
+ * timeline's own terms: `orbitY`, `orbitX`, `dolly`) comes back to its start
+ * and every motion the shapes actually run is cyclic; otherwise with a fade.
+ */
+declare function compositionLoop(spec: Composition, clip: {
+    seconds: number;
+    fps: number;
+    camera?: {
+        orbitY?: number;
+        orbitX?: number;
+        dolly?: number;
+    };
+}): Loop;
+/**
+ * Put every shape's motions on the timeline, one keyframe per output frame.
+ * The timeline then drives the live meshes on `seek()` and ships the same
+ * samples in the manifest: one evaluator, two halves.
+ *
+ * Pass the clip's `compositionLoop()` so a clip that cannot loop by itself
+ * fades the shapes out at its end and in at its start; then open the cut on
+ * `loop.start`, not on frame 0.
+ */
+declare function animateComposition(tl: Timeline, built: BuiltComposition, duration: number, fps: number, loop?: Loop): number;
+
+export { type BuiltComposition, type BuiltShape, type Composition, type Loop, MOTION_KINDS, type Motion, type MotionKind, type Reflections, SHAPE_FINISHES, SHAPE_KINDS, type Shape, type ShapeFinish, type ShapeKind, type Vec3, animateComposition, compositionLoop, createComposition, followGlow, snapshotReflections };