@tongue-core/engine 0.1.0-rc.2 → 0.1.0-rc.3

package/dist/paint/stroke.js

@@ -0,0 +1,233 @@
+import { cos, PI, sin } from "@tongue-core/film/model";
+/** Corners sharper than this (a ratio of miter length to width) are beveled, as in SVG. */
+const MITER_LIMIT = 4;
+const dist = (ax, ay, bx, by) => Math.sqrt((bx - ax) * (bx - ax) + (by - ay) * (by - ay));
+/** Straight pieces per curve: enough that none strays more than `tolerance` from the curve. */
+const pieces = (bend, tolerance) => Math.min(96, Math.max(1, Math.ceil(Math.sqrt(bend / tolerance))));
+/** The path as polylines, one per subpath, with repeated points removed. */
+export function flatten(verbs, tolerance) {
+    const lines = [];
+    let current = [];
+    let x = 0, y = 0;
+    const add = (px, py, smooth) => {
+        const last = current[current.length - 1];
+        if (!last || last.x !== px || last.y !== py)
+            current.push({ x: px, y: py, smooth });
+        x = px;
+        y = py;
+    };
+    const end = (closed) => {
+        if (current.length > 0)
+            lines.push({ points: current, closed: closed && current.length > 2 });
+        current = [];
+    };
+    for (const v of verbs) {
+        switch (v.kind) {
+            case "move":
+                end(false);
+                add(v.x, v.y, false);
+                break;
+            case "line":
+                add(v.x, v.y, false);
+                break;
+            case "quad": {
+                const x0 = x, y0 = y;
+                const n = pieces(0.25 * dist(x0 - v.cx, y0 - v.cy, v.cx - v.x, v.cy - v.y), tolerance);
+                for (let i = 1; i <= n; i++) {
+                    const t = i / n, u = 1 - t;
+                    add(u * u * x0 + 2 * u * t * v.cx + t * t * v.x, u * u * y0 + 2 * u * t * v.cy + t * t * v.y, i < n);
+                }
+                break;
+            }
+            case "cubic": {
+                const x0 = x, y0 = y;
+                const bend = 0.75 * Math.max(dist(x0 - v.c1x, y0 - v.c1y, v.c1x - v.c2x, v.c1y - v.c2y), dist(v.c1x - v.c2x, v.c1y - v.c2y, v.c2x - v.x, v.c2y - v.y));
+                const n = pieces(bend, tolerance);
+                for (let i = 1; i <= n; i++) {
+                    const t = i / n, u = 1 - t;
+                    const a = u * u * u, b = 3 * u * u * t, c = 3 * u * t * t, d = t * t * t;
+                    add(a * x0 + b * v.c1x + c * v.c2x + d * v.x, a * y0 + b * v.c1y + c * v.c2y + d * v.y, i < n);
+                }
+                break;
+            }
+            case "close": {
+                const first = current[0];
+                if (first) {
+                    // Back at the start, the closing line's end is that same point, not a second one.
+                    const last = current[current.length - 1];
+                    if (last && last.x === first.x && last.y === first.y && current.length > 1)
+                        current.pop();
+                    end(true);
+                    x = first.x;
+                    y = first.y;
+                    add(x, y, false);
+                }
+                break;
+            }
+        }
+    }
+    // A lone point left by a close, or by a move that nothing followed.
+    if (current.length > 1)
+        end(false);
+    return lines;
+}
+const lengthOf = (line) => {
+    let total = 0;
+    const count = line.closed ? line.points.length : line.points.length - 1;
+    for (let i = 0; i < count; i++) {
+        const a = line.points[i], b = line.points[(i + 1) % line.points.length];
+        if (a && b)
+            total += dist(a.x, a.y, b.x, b.y);
+    }
+    return total;
+};
+/** The stretches of `lines` between two distances along their combined length. */
+function trimmed(lines, from, to) {
+    const out = [];
+    let start = 0;
+    for (const line of lines) {
+        const length = lengthOf(line);
+        const a = Math.max(from - start, 0), b = Math.min(to - start, length);
+        start += length;
+        if (b <= a && !(length === 0 && a === 0 && b === 0))
+            continue;
+        if (a <= 0 && b >= length) {
+            out.push(line);
+            continue;
+        }
+        const points = [];
+        let walked = 0;
+        const count = line.closed ? line.points.length : line.points.length - 1;
+        for (let i = 0; i < count; i++) {
+            const p = line.points[i], q = line.points[(i + 1) % line.points.length];
+            if (!p || !q)
+                continue;
+            const seg = dist(p.x, p.y, q.x, q.y);
+            const lo = (a - walked) / seg, hi = (b - walked) / seg;
+            if (hi >= 0 && lo <= 1) {
+                const t0 = Math.max(lo, 0), t1 = Math.min(hi, 1);
+                if (points.length === 0)
+                    points.push({ x: p.x + (q.x - p.x) * t0, y: p.y + (q.y - p.y) * t0, smooth: false });
+                if (t1 > t0)
+                    points.push({ x: p.x + (q.x - p.x) * t1, y: p.y + (q.y - p.y) * t1, smooth: t1 < 1 ? false : q.smooth });
+            }
+            walked += seg;
+        }
+        if (points.length > 1)
+            out.push({ points, closed: false });
+    }
+    return out;
+}
+/** A polygon, wound so its signed area is positive, so overlaps add up and never cancel out. */
+function polygon(out, xs, ys) {
+    const n = xs.length;
+    let area = 0;
+    for (let i = 0; i < n; i++) {
+        const j = (i + 1) % n;
+        area += (xs[i] ?? 0) * (ys[j] ?? 0) - (xs[j] ?? 0) * (ys[i] ?? 0);
+    }
+    if (area === 0)
+        return;
+    for (let k = 0; k < n; k++) {
+        const i = area > 0 ? k : n - 1 - k;
+        out.push({ kind: k === 0 ? "move" : "line", x: xs[i] ?? 0, y: ys[i] ?? 0 });
+    }
+    out.push({ kind: "close" });
+}
+function disk(out, x, y, r, sides) {
+    const xs = [], ys = [];
+    for (let i = 0; i < sides; i++) {
+        const a = (i / sides) * 2 * PI;
+        xs.push(x + r * cos(a));
+        ys.push(y + r * sin(a));
+    }
+    polygon(out, xs, ys);
+}
+function corner(out, p, ax, ay, bx, by, hw, join, sides) {
+    // (ax, ay) and (bx, by): unit directions arriving at and leaving p.
+    const turn = ax * by - ay * bx, along = ax * bx + ay * by;
+    if (turn === 0 && along >= 0)
+        return;
+    if (join === "round" && !p.smooth) {
+        disk(out, p.x, p.y, hw, sides);
+        return;
+    }
+    // The outer side of the turn: rotate the direction a quarter away from where it is turning.
+    const side = turn > 0 ? -1 : 1;
+    const nax = -ay * side, nay = ax * side, nbx = -by * side, nby = bx * side;
+    const a1 = p.x + nax * hw, a2 = p.y + nay * hw, b1 = p.x + nbx * hw, b2 = p.y + nby * hw;
+    if (join === "miter" && !p.smooth) {
+        // Miter ratio is 1 / sin(half the angle between the pieces).
+        const half = Math.sqrt(Math.max(0, (1 + along) / 2));
+        if (half > 0 && 1 / half <= MITER_LIMIT) {
+            const mx = nax + nbx, my = nay + nby;
+            const ml = Math.sqrt(mx * mx + my * my);
+            if (ml > 0) {
+                const reach = hw / half;
+                polygon(out, [p.x, a1, p.x + (mx / ml) * reach, b1], [p.y, a2, p.y + (my / ml) * reach, b2]);
+                return;
+            }
+        }
+    }
+    polygon(out, [p.x, a1, b1], [p.y, a2, b2]);
+}
+/** The outline of a stroked path as fillable verbs (nonzero rule). `scale` is how many surface
+ *  pixels one path unit covers: it sets how finely curves and round ends are drawn. */
+export function strokeOutline(verbs, stroke, scale) {
+    if (!(stroke.width > 0) || !(scale > 0))
+        return [];
+    const hw = stroke.width / 2;
+    const tolerance = 0.2 / scale;
+    const sides = Math.min(64, Math.max(8, Math.ceil(PI * Math.sqrt(hw * scale) * 2)));
+    const lines = flatten(verbs, tolerance);
+    const total = lines.reduce((sum, l) => sum + lengthOf(l), 0);
+    const from = Math.min(Math.max(stroke.trim[0], 0), 1) * total, to = Math.min(Math.max(stroke.trim[1], 0), 1) * total;
+    if (to <= from && total > 0)
+        return [];
+    const out = [];
+    for (const line of from <= 0 && to >= total ? lines : trimmed(lines, from, to)) {
+        const n = line.points.length;
+        const first = line.points[0];
+        if (!first)
+            continue;
+        if (n === 1) {
+            if (stroke.cap === "round")
+                disk(out, first.x, first.y, hw, sides);
+            continue;
+        }
+        const count = line.closed ? n : n - 1;
+        let px = 0, py = 0;
+        let startX = 0, startY = 0;
+        for (let i = 0; i < count; i++) {
+            const a = line.points[i], b = line.points[(i + 1) % n];
+            if (!a || !b)
+                continue;
+            const l = dist(a.x, a.y, b.x, b.y);
+            if (l === 0)
+                continue;
+            const dx = (b.x - a.x) / l, dy = (b.y - a.y) / l;
+            const nx = -dy * hw, ny = dx * hw;
+            if (i === 0) {
+                startX = dx;
+                startY = dy;
+            }
+            else
+                corner(out, a, px, py, dx, dy, hw, stroke.join, sides);
+            const openStart = !line.closed && i === 0 && stroke.cap === "square" ? hw : 0;
+            const openEnd = !line.closed && i === count - 1 && stroke.cap === "square" ? hw : 0;
+            const ax = a.x - dx * openStart, ay = a.y - dy * openStart, bx = b.x + dx * openEnd, by = b.y + dy * openEnd;
+            polygon(out, [ax + nx, bx + nx, bx - nx, ax - nx], [ay + ny, by + ny, by - ny, ay - ny]);
+            px = dx;
+            py = dy;
+        }
+        if (line.closed)
+            corner(out, first, px, py, startX, startY, hw, stroke.join, sides);
+        else if (stroke.cap === "round") {
+            const last = line.points[n - 1];
+            disk(out, first.x, first.y, hw, sides);
+            if (last)
+                disk(out, last.x, last.y, hw, sides);
+        }
+    }
+    return out;
+}

package/dist/raster/raster.d.ts

@@ -26,6 +26,9 @@ export declare class Raster implements RasterBackend {
     /** Uploads an image as a QOI file. */
     loadImage(id: number, qoi: Uint8Array): void;
     hasImage(id: number): boolean;
+    /** The raster's WebAssembly memory. It grows to its high-water mark and stays there; what is freed
+     *  inside it is used again. */
+    get memoryBytes(): number;
     /** Executes a display list into the frame. */
     render(list: Uint8Array): void;
     private copy;

package/dist/raster/raster.js

@@ -118,6 +118,11 @@ export class Raster {
     hasImage(id) {
         return this.x.has_image(id) === 1;
     }
+    /** The raster's WebAssembly memory. It grows to its high-water mark and stays there; what is freed
+     *  inside it is used again. */
+    get memoryBytes() {
+        return this.x.memory.buffer.byteLength;
+    }
     /** Executes a display list into the frame. */
     render(list) {
         const code = this.withBytes(list, (ptr, len) => this.x.render(ptr, len));