effect-motion 0.4.0 → 0.6.0

package/dist/PngExporter.js

@@ -1,85 +0,0 @@
-import { deflateSync } from "node:zlib";
-import * as Effect from "effect/Effect";
-import { FileSystem } from "effect/FileSystem";
-import { EffectMotionError } from "./EffectMotionError.js";
-const SIGNATURE = new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]);
-const crcTable = (() => {
-    const t = new Uint32Array(256);
-    for (let n = 0; n < 256; n++) {
-        let c = n;
-        for (let k = 0; k < 8; k++) {
-            c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
-        }
-        t[n] = c >>> 0;
-    }
-    return t;
-})();
-const crc32 = (bytes) => {
-    let c = 0xffffffff;
-    for (let i = 0; i < bytes.length; i++) {
-        c = crcTable[(c ^ bytes[i]) & 0xff] ^ (c >>> 8);
-    }
-    return (c ^ 0xffffffff) >>> 0;
-};
-const chunk = (type, data) => {
-    const typeBytes = new Uint8Array([
-        type.charCodeAt(0),
-        type.charCodeAt(1),
-        type.charCodeAt(2),
-        type.charCodeAt(3),
-    ]);
-    const body = new Uint8Array(typeBytes.length + data.length);
-    body.set(typeBytes, 0);
-    body.set(data, typeBytes.length);
-    const out = new Uint8Array(4 + body.length + 4);
-    const view = new DataView(out.buffer);
-    view.setUint32(0, data.length, false);
-    out.set(body, 4);
-    view.setUint32(4 + body.length, crc32(body), false);
-    return out;
-};
-/** Encode a raw RGBA8888 buffer (`width * height * 4` bytes) as a PNG. */
-const encodePng = Effect.fnUntraced(function* (rgba, width, height) {
-    if (rgba.length !== width * height * 4) {
-        return yield* Effect.fail(EffectMotionError.of(`Could not encode PNG: buffer is ${rgba.length} bytes, expected ${width * height * 4} (${width}x${height} RGBA)`));
-    }
-    // prepend a filter byte (0 = none) to each scanline
-    const stride = width * 4;
-    const raw = new Uint8Array((stride + 1) * height);
-    for (let y = 0; y < height; y++) {
-        raw[y * (stride + 1)] = 0;
-        raw.set(rgba.subarray(y * stride, y * stride + stride), y * (stride + 1) + 1);
-    }
-    const ihdr = new Uint8Array(13);
-    const ihdrView = new DataView(ihdr.buffer);
-    ihdrView.setUint32(0, width, false);
-    ihdrView.setUint32(4, height, false);
-    ihdr[8] = 8; // bit depth
-    ihdr[9] = 6; // color type: RGBA
-    // [10] compression, [11] filter, [12] interlace all 0
-    const idat = new Uint8Array(deflateSync(raw));
-    const chunks = [
-        SIGNATURE,
-        chunk("IHDR", ihdr),
-        chunk("IDAT", idat),
-        chunk("IEND", new Uint8Array(0)),
-    ];
-    const total = chunks.reduce((n, c) => n + c.length, 0);
-    const png = new Uint8Array(total);
-    let offset = 0;
-    for (const c of chunks) {
-        png.set(c, offset);
-        offset += c.length;
-    }
-    return png;
-});
-export const toBuffer = (fb) => {
-    return encodePng(fb.rgba, fb.width, fb.height);
-};
-export const toFile = (fb, outPath) => {
-    return Effect.gen(function* () {
-        const fs = yield* FileSystem;
-        const png = yield* toBuffer(fb);
-        yield* fs.writeFile(outPath, png);
-    });
-};

package/dist/Renderer.d.ts

@@ -1,118 +0,0 @@
-import type { OwnedPaint, RenderSession, ThorvgException, ThorvgWasm } from "@effect-motion/thorvg";
-import * as Tvg from "@effect-motion/thorvg";
-import type { Canvas } from "@effect-motion/thorvg/Canvas";
-import * as Effect from "effect/Effect";
-import type * as Scope from "effect/Scope";
-import * as Color from "./Color.js";
-import type * as Entity from "./Entity.js";
-import * as Projection from "./Projection.js";
-import type { Frame } from "./Scene.js";
-/**
- * The projection handed to each paint function — how the camera places a
- * paintable this frame. `screen` is the projected billboard placement (an
- * affine the paint fn applies via `setTransform`); `depth` is the view-space
- * sort key; `scale` is the perspective scale (<= 0 means the anchor is behind
- * the camera — cull, unless a `quad` or `segment` is present). `quad`, when
- * present, is the projected, near-plane-clipped screen polygon of a tilted
- * plane (3–5 vertices — see Projection.projectPlane); a shape that can tilt
- * paints an exact path from these instead of applying the billboard affine.
- * `segment`, when present, is the exact projected screen endpoints of a
- * skeletal shape (Line) — each endpoint carries its own world depth, so the
- * pair is projected per point (see Projection.projectSegment) and the paint
- * fn draws it directly, skipping the billboard affine. `subpaths`, when
- * present, is the projected screen geometry of a skeletal path (Path): every
- * command point projected individually and near-plane-clipped per subpath
- * (see Projection.projectPath) — the paint fn emits it directly at screen
- * coordinates.
- */
-export interface PaintProjection {
-    readonly screen: Projection.Affine;
-    readonly depth: number;
-    readonly scale: number;
-    readonly quad?: ReadonlyArray<Projection.Vec2>;
-    readonly segment?: readonly [Projection.Vec2, Projection.Vec2];
-    readonly subpaths?: Projection.ProjectedPath["subpaths"];
-}
-/** The frame's render metadata, handed to paint functions. */
-export interface FrameMeta {
-    readonly frameRate: number;
-    readonly width: number;
-    readonly height: number;
-    readonly backgroundColor: Color.Color;
-    /**
-     * the active camera's view — world position `{x, y, z}`, Euler
-     * orientation `{rotX, rotY, rotZ}`, and `focalLength` (FOV). The renderer
-     * projects every instance through it. The resting camera (see
-     * Camera.identity) reproduces plain-2D placement for z=0 content.
-     */
-    readonly camera: {
-        readonly x: number;
-        readonly y: number;
-        readonly z: number;
-        readonly rotX: number;
-        readonly rotY: number;
-        readonly rotZ: number;
-        readonly focalLength: number;
-    };
-}
-/**
- * Paints one entity instance onto the shared ThorVG scene. It issues ThorVG
- * C-API calls (make a shape, append geometry, style it, apply the projection,
- * add it to `scene`) — there is no intermediate description value. A container
- * (Group / root) paints nothing itself; its position has already composed into
- * its children's world coordinates by the time this is called.
- */
-export type PaintFunction<Ent extends Entity.AnyEntity> = (payload: {
-    readonly entity: Ent;
-    readonly id: string;
-    readonly data: Ent["data"]["Type"];
-    readonly projection: PaintProjection;
-    readonly canvas: Canvas;
-    readonly scene: OwnedPaint;
-    readonly meta: FrameMeta;
-}) => Effect.Effect<void, ThorvgException, ThorvgWasm | RenderSession | Scope.Scope>;
-/**
- * A registry of paint functions keyed by entity name. `PaintFunctions<E>` is
- * the exhaustive map over an entity union — a built-in with no paint function
- * is a type error at the render call, not a runtime surprise (the old
- * "coverage manifest" guarantee, kept without a Context registry).
- */
-export type PaintFunctions<Entities extends Entity.AnyEntity> = {
-    readonly [K in Entities as K["name"]]: PaintFunction<K>;
-};
-/** RGBA8888 framebuffer plus its dimensions, straight from the SW canvas. */
-export interface Framebuffer {
-    readonly rgba: Uint8Array;
-    /** physical pixel size of the rgba buffer (logical size × dpr) */
-    readonly width: number;
-    readonly height: number;
-    /**
-     * logical scene size — the resolution the buffer should be displayed at
-     * (CSS pixels). Equals width/height when rendered at dpr 1.
-     */
-    readonly logicalWidth: number;
-    readonly logicalHeight: number;
-}
-/**
- * Render one frame to an RGBA framebuffer, shared by both output adapters.
- *
- * Uses the RenderSession's canvas (resized in place to the frame's physical
- * size, cleared of the previous frame), adds a root scene, folds the frame
- * onto it via `Renderer.render`, then update/draw/sync and reads the SW
- * framebuffer. The scene and every painted shape are scoped per frame; the
- * canvas belongs to the session (a player mount, an export run) and is
- * deleted when the session closes.
- *
- * The background is painted as a filled rect (not a canvas clear color) so it
- * survives into the buffer the same way the SVG sink emitted a background
- * rect.
- */
-export declare const render: (frame: Frame, options?: {
-    /**
-     * device-pixel-ratio multiplier for high-dpi displays. The buffer is
-     * rasterized at `logical × dpr` while paint functions keep working in
-     * logical scene coordinates (the root scene is scaled). Callers display
-     * the buffer at the logical size. Default 1 (node/export paths).
-     */
-    readonly dpr?: number;
-}) => Effect.Effect<Framebuffer, ThorvgException, Tvg.ThorvgWasm | Tvg.RenderSession | Scope.Scope>;