@efxlab/motion-canvas-2d 4.0.0

package/lib/components/Line.d.ts

@@ -0,0 +1,158 @@
+import { BBox, PossibleVector2, SignalValue, SimpleSignal, ThreadGenerator, TimingFunction, Vector2 } from '@efxlab/motion-canvas-core';
+import { CurveProfile } from '../curves';
+import { Curve, CurveProps } from './Curve';
+export interface LineProps extends CurveProps {
+    /**
+     * {@inheritDoc Line.radius}
+     */
+    radius?: SignalValue<number>;
+    /**
+     * {@inheritDoc Line.points}
+     */
+    points?: SignalValue<SignalValue<PossibleVector2>[]>;
+}
+/**
+ * A node for drawing lines and polygons.
+ *
+ * @remarks
+ * This node can be used to render any polygonal shape defined by a set of
+ * points.
+ *
+ * @preview
+ * ```tsx editor
+ * // snippet Simple line
+ * import {makeScene2D, Line} from '@efxlab/motion-canvas-2d';
+ *
+ * export default makeScene2D(function* (view) {
+ *   view.add(
+ *     <Line
+ *       points={[
+ *         [150, 50],
+ *         [0, -50],
+ *         [-150, 50],
+ *       ]}
+ *       stroke={'lightseagreen'}
+ *       lineWidth={8}
+ *       radius={40}
+ *       startArrow
+ *     />,
+ *   );
+ * });
+ *
+ * // snippet Polygon
+ * import {makeScene2D, Line} from '@efxlab/motion-canvas-2d';
+ *
+ * export default makeScene2D(function* (view) {
+ *   view.add(
+ *     <Line
+ *       points={[
+ *         [-200, 70],
+ *         [150, 70],
+ *         [100, -70],
+ *         [-100, -70],
+ *       ]}
+ *       fill={'lightseagreen'}
+ *       closed
+ *     />,
+ *   );
+ * });
+ *
+ * // snippet Using signals
+ * import {makeScene2D, Line} from '@efxlab/motion-canvas-2d';
+ * import {createSignal} from '@efxlab/motion-canvas-core';
+ *
+ * export default makeScene2D(function* (view) {
+ *   const tip = createSignal(-150);
+ *   view.add(
+ *     <Line
+ *       points={[
+ *         [-150, 70],
+ *         [150, 70],
+ *         // this point is dynamically calculated based on the signal:
+ *         () => [tip(), -70],
+ *       ]}
+ *       stroke={'lightseagreen'}
+ *       lineWidth={8}
+ *       closed
+ *     />,
+ *   );
+ *
+ *   yield* tip(150, 1).back(1);
+ * });
+ *
+ * // snippet Tweening points
+ * import {makeScene2D, Line} from '@efxlab/motion-canvas-2d';
+ * import {createRef} from '@efxlab/motion-canvas-core';
+ *
+ * export default makeScene2D(function* (view) {
+ *   const line = createRef<Line>();
+ *   view.add(
+ *     <Line
+ *       ref={line}
+ *       points={[
+ *         [-150, 70],
+ *         [150, 70],
+ *         [0, -70],
+ *       ]}
+ *       stroke={'lightseagreen'}
+ *       lineWidth={8}
+ *       radius={20}
+ *       closed
+ *     />,
+ *   );
+ *
+ *   yield* line()
+ *     .points(
+ *       [
+ *         [-150, 0],
+ *         [0, 100],
+ *         [150, 0],
+ *         [150, -70],
+ *         [-150, -70],
+ *       ],
+ *       2,
+ *     )
+ *     .back(2);
+ * });
+ * ```
+ */
+export declare class Line extends Curve {
+    /**
+     * Rotate the points to minimize the overall distance traveled when tweening.
+     *
+     * @param points - The points to rotate.
+     * @param reference - The reference points to which the distance is measured.
+     * @param closed - Whether the points form a closed polygon.
+     */
+    private static rotatePoints;
+    /**
+     * Distribute additional points along the polyline.
+     *
+     * @param points - The points of a polyline along which new points should be
+     *                 distributed.
+     * @param count - The number of points to add.
+     */
+    private static distributePoints;
+    /**
+     * The radius of the line's corners.
+     */
+    readonly radius: SimpleSignal<number, this>;
+    /**
+     * The points of the line.
+     *
+     * @remarks
+     * When set to `null`, the Line will use the positions of its children as
+     * points.
+     */
+    readonly points: SimpleSignal<SignalValue<PossibleVector2>[] | null, this>;
+    protected tweenPoints(value: SignalValue<SignalValue<PossibleVector2>[] | null>, time: number, timingFunction: TimingFunction): ThreadGenerator;
+    private tweenedPoints;
+    constructor(props: LineProps);
+    protected childrenBBox(): BBox;
+    parsedPoints(): Vector2[];
+    profile(): CurveProfile;
+    protected lineWidthCoefficient(): number;
+    drawOverlay(context: CanvasRenderingContext2D, matrix: DOMMatrix): void;
+    private parsePoints;
+}
+//# sourceMappingURL=Line.d.ts.map

package/lib/components/Line.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Line.d.ts","sourceRoot":"","sources":["../../src/lib/components/Line.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EAEJ,eAAe,EACf,WAAW,EACX,YAAY,EAEZ,eAAe,EACf,cAAc,EAId,OAAO,EACR,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAC,YAAY,EAAqB,MAAM,WAAW,CAAC;AAS3D,OAAO,EAAC,KAAK,EAAE,UAAU,EAAC,MAAM,SAAS,CAAC;AAG1C,MAAM,WAAW,SAAU,SAAQ,UAAU;IAC3C;;OAEG;IACH,MAAM,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC7B;;OAEG;IACH,MAAM,CAAC,EAAE,WAAW,CAAC,WAAW,CAAC,eAAe,CAAC,EAAE,CAAC,CAAC;CACtD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwGG;AACH,qBACa,IAAK,SAAQ,KAAK;IAC7B;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,YAAY;IAkC3B;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,gBAAgB;IA+C/B;;OAEG;IACH,SAEwB,MAAM,EAAE,YAAY,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IAE3D;;;;;;OAMG;IACH,SAEwB,MAAM,EAAE,YAAY,CAC1C,WAAW,CAAC,eAAe,CAAC,EAAE,GAAG,IAAI,EACrC,IAAI,CACL,CAAC;IAGF,SAAS,CAAE,WAAW,CACpB,KAAK,EAAE,WAAW,CAAC,WAAW,CAAC,eAAe,CAAC,EAAE,GAAG,IAAI,CAAC,EACzD,IAAI,EAAE,MAAM,EACZ,cAAc,EAAE,cAAc,GAC7B,eAAe;IAuBlB,OAAO,CAAC,aAAa,CAAwC;gBAE1C,KAAK,EAAE,SAAS;IAanC,SAAS,CAAC,YAAY;IAef,YAAY,IAAI,OAAO,EAAE;IAKhB,OAAO,IAAI,YAAY;cAQpB,oBAAoB,IAAI,MAAM;IAgBjC,WAAW,CACzB,OAAO,EAAE,wBAAwB,EACjC,MAAM,EAAE,SAAS;IAuCnB,OAAO,CAAC,WAAW;CAKpB"}

package/lib/components/Line.js

@@ -0,0 +1,315 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var Line_1;
+import { BBox, createSignal, threadable, tween, unwrap, useLogger, Vector2, } from '@efxlab/motion-canvas-core';
+import { getPolylineProfile } from '../curves';
+import { calculateLerpDistance, polygonLength, polygonPointsLerp, } from '../curves/createCurveProfileLerp';
+import { computed, initial, nodeName, signal } from '../decorators';
+import { arc, drawLine, drawPivot, lineTo, moveTo } from '../utils';
+import { Curve } from './Curve';
+import { Layout } from './Layout';
+/**
+ * A node for drawing lines and polygons.
+ *
+ * @remarks
+ * This node can be used to render any polygonal shape defined by a set of
+ * points.
+ *
+ * @preview
+ * ```tsx editor
+ * // snippet Simple line
+ * import {makeScene2D, Line} from '@efxlab/motion-canvas-2d';
+ *
+ * export default makeScene2D(function* (view) {
+ *   view.add(
+ *     <Line
+ *       points={[
+ *         [150, 50],
+ *         [0, -50],
+ *         [-150, 50],
+ *       ]}
+ *       stroke={'lightseagreen'}
+ *       lineWidth={8}
+ *       radius={40}
+ *       startArrow
+ *     />,
+ *   );
+ * });
+ *
+ * // snippet Polygon
+ * import {makeScene2D, Line} from '@efxlab/motion-canvas-2d';
+ *
+ * export default makeScene2D(function* (view) {
+ *   view.add(
+ *     <Line
+ *       points={[
+ *         [-200, 70],
+ *         [150, 70],
+ *         [100, -70],
+ *         [-100, -70],
+ *       ]}
+ *       fill={'lightseagreen'}
+ *       closed
+ *     />,
+ *   );
+ * });
+ *
+ * // snippet Using signals
+ * import {makeScene2D, Line} from '@efxlab/motion-canvas-2d';
+ * import {createSignal} from '@efxlab/motion-canvas-core';
+ *
+ * export default makeScene2D(function* (view) {
+ *   const tip = createSignal(-150);
+ *   view.add(
+ *     <Line
+ *       points={[
+ *         [-150, 70],
+ *         [150, 70],
+ *         // this point is dynamically calculated based on the signal:
+ *         () => [tip(), -70],
+ *       ]}
+ *       stroke={'lightseagreen'}
+ *       lineWidth={8}
+ *       closed
+ *     />,
+ *   );
+ *
+ *   yield* tip(150, 1).back(1);
+ * });
+ *
+ * // snippet Tweening points
+ * import {makeScene2D, Line} from '@efxlab/motion-canvas-2d';
+ * import {createRef} from '@efxlab/motion-canvas-core';
+ *
+ * export default makeScene2D(function* (view) {
+ *   const line = createRef<Line>();
+ *   view.add(
+ *     <Line
+ *       ref={line}
+ *       points={[
+ *         [-150, 70],
+ *         [150, 70],
+ *         [0, -70],
+ *       ]}
+ *       stroke={'lightseagreen'}
+ *       lineWidth={8}
+ *       radius={20}
+ *       closed
+ *     />,
+ *   );
+ *
+ *   yield* line()
+ *     .points(
+ *       [
+ *         [-150, 0],
+ *         [0, 100],
+ *         [150, 0],
+ *         [150, -70],
+ *         [-150, -70],
+ *       ],
+ *       2,
+ *     )
+ *     .back(2);
+ * });
+ * ```
+ */
+let Line = Line_1 = class Line extends Curve {
+    /**
+     * Rotate the points to minimize the overall distance traveled when tweening.
+     *
+     * @param points - The points to rotate.
+     * @param reference - The reference points to which the distance is measured.
+     * @param closed - Whether the points form a closed polygon.
+     */
+    static rotatePoints(points, reference, closed) {
+        if (closed) {
+            let minDistance = Infinity;
+            let bestOffset = 0;
+            for (let offset = 0; offset < points.length; offset += 1) {
+                const distance = calculateLerpDistance(points, reference, offset);
+                if (distance < minDistance) {
+                    minDistance = distance;
+                    bestOffset = offset;
+                }
+            }
+            if (bestOffset) {
+                const spliced = points.splice(0, bestOffset);
+                points.splice(points.length, 0, ...spliced);
+            }
+        }
+        else {
+            const originalDistance = calculateLerpDistance(points, reference, 0);
+            const reversedPoints = [...points].reverse();
+            const reversedDistance = calculateLerpDistance(reversedPoints, reference, 0);
+            if (reversedDistance < originalDistance) {
+                points.reverse();
+            }
+        }
+    }
+    /**
+     * Distribute additional points along the polyline.
+     *
+     * @param points - The points of a polyline along which new points should be
+     *                 distributed.
+     * @param count - The number of points to add.
+     */
+    static distributePoints(points, count) {
+        if (points.length === 0) {
+            for (let j = 0; j < count; j++) {
+                points.push(Vector2.zero);
+            }
+            return;
+        }
+        if (points.length === 1) {
+            const point = points[0];
+            for (let j = 0; j < count; j++) {
+                points.push(point);
+            }
+            return;
+        }
+        const desiredLength = points.length + count;
+        const arcLength = polygonLength(points);
+        let density = arcLength === 0 ? 0 : count / arcLength;
+        let i = 0;
+        while (points.length < desiredLength) {
+            const pointsLeft = desiredLength - points.length;
+            if (i + 1 >= points.length) {
+                density = arcLength === 0 ? 0 : pointsLeft / arcLength;
+                i = 0;
+                continue;
+            }
+            const a = points[i];
+            const b = points[i + 1];
+            const length = a.sub(b).magnitude;
+            let pointCount = Math.min(Math.round(length * density), pointsLeft) + 1;
+            if (arcLength === 0) {
+                pointCount = 2;
+            }
+            for (let j = 1; j < pointCount; j++) {
+                points.splice(++i, 0, Vector2.lerp(a, b, j / pointCount));
+            }
+            i++;
+        }
+    }
+    *tweenPoints(value, time, timingFunction) {
+        const fromPoints = [...this.parsedPoints()];
+        const toPoints = this.parsePoints(unwrap(value));
+        const closed = this.closed();
+        const diff = fromPoints.length - toPoints.length;
+        Line_1.distributePoints(diff < 0 ? fromPoints : toPoints, Math.abs(diff));
+        Line_1.rotatePoints(toPoints, fromPoints, closed);
+        this.tweenedPoints(fromPoints);
+        yield* tween(time, value => {
+            const progress = timingFunction(value);
+            this.tweenedPoints(polygonPointsLerp(fromPoints, toPoints, progress));
+        }, () => {
+            this.tweenedPoints(null);
+            this.points(value);
+        });
+    }
+    tweenedPoints = createSignal(null);
+    constructor(props) {
+        super(props);
+        if (props.children === undefined && props.points === undefined) {
+            useLogger().warn({
+                message: 'No points specified for the line',
+                remarks: "<p>The line won&#39;t be visible unless you specify at least two points:</p>\n<pre class=\"\"><code class=\"language-tsx\">&lt;<span class=\"hljs-title class_\">Line</span>\n  stroke=<span class=\"hljs-string\">&quot;#fff&quot;</span>\n  lineWidth={<span class=\"hljs-number\">8</span>}\n  points={[\n    [<span class=\"hljs-number\">100</span>, <span class=\"hljs-number\">0</span>],\n    [<span class=\"hljs-number\">0</span>, <span class=\"hljs-number\">0</span>],\n    [<span class=\"hljs-number\">0</span>, <span class=\"hljs-number\">100</span>],\n  ]}\n/&gt;</code></pre><p>Alternatively, you can define the points using the children:</p>\n<pre class=\"\"><code class=\"language-tsx\">&lt;<span class=\"hljs-title class_\">Line</span> stroke=<span class=\"hljs-string\">&quot;#fff&quot;</span> lineWidth={<span class=\"hljs-number\">8</span>}&gt;\n  <span class=\"language-xml\"><span class=\"hljs-tag\">&lt;<span class=\"hljs-name\">Node</span> <span class=\"hljs-attr\">x</span>=<span class=\"hljs-string\">{100}</span> /&gt;</span></span>\n  <span class=\"language-xml\"><span class=\"hljs-tag\">&lt;<span class=\"hljs-name\">Node</span> /&gt;</span></span>\n  <span class=\"language-xml\"><span class=\"hljs-tag\">&lt;<span class=\"hljs-name\">Node</span> <span class=\"hljs-attr\">y</span>=<span class=\"hljs-string\">{100}</span> /&gt;</span></span>\n&lt;/<span class=\"hljs-title class_\">Line</span>&gt;</code></pre><p>If you did this intentionally, and want to disable this message, set the\n<code>points</code> property to <code>null</code>:</p>\n<pre class=\"\"><code class=\"language-tsx\">&lt;<span class=\"hljs-title class_\">Line</span> stroke=<span class=\"hljs-string\">&quot;#fff&quot;</span> lineWidth={<span class=\"hljs-number\">8</span>} points={<span class=\"hljs-literal\">null</span>} /&gt;</code></pre>",
+                inspect: this.key,
+            });
+        }
+    }
+    childrenBBox() {
+        let points = this.tweenedPoints();
+        if (!points) {
+            const custom = this.points();
+            points = custom
+                ? custom.map(signal => new Vector2(unwrap(signal)))
+                : this.children()
+                    .filter(child => !(child instanceof Layout) || child.isLayoutRoot())
+                    .map(child => child.position());
+        }
+        return BBox.fromPoints(...points);
+    }
+    parsedPoints() {
+        return this.parsePoints(this.points());
+    }
+    profile() {
+        return getPolylineProfile(this.tweenedPoints() ?? this.parsedPoints(), this.radius(), this.closed());
+    }
+    lineWidthCoefficient() {
+        const radius = this.radius();
+        const join = this.lineJoin();
+        let coefficient = super.lineWidthCoefficient();
+        if (radius === 0 && join === 'miter') {
+            const { minSin } = this.profile();
+            if (minSin > 0) {
+                coefficient = Math.max(coefficient, 0.5 / minSin);
+            }
+        }
+        return coefficient;
+    }
+    drawOverlay(context, matrix) {
+        const box = this.childrenBBox().transformCorners(matrix);
+        const size = this.computedSize();
+        const offset = size.mul(this.offset()).scale(0.5).transformAsPoint(matrix);
+        context.fillStyle = 'white';
+        context.strokeStyle = 'black';
+        context.lineWidth = 1;
+        const path = new Path2D();
+        const points = (this.tweenedPoints() ?? this.parsedPoints()).map(point => point.transformAsPoint(matrix));
+        if (points.length > 0) {
+            moveTo(path, points[0]);
+            for (const point of points) {
+                lineTo(path, point);
+                context.beginPath();
+                arc(context, point, 4);
+                context.closePath();
+                context.fill();
+                context.stroke();
+            }
+        }
+        context.strokeStyle = 'white';
+        context.stroke(path);
+        context.beginPath();
+        drawPivot(context, offset);
+        context.stroke();
+        context.beginPath();
+        drawLine(context, box);
+        context.closePath();
+        context.stroke();
+    }
+    parsePoints(points) {
+        return points
+            ? points.map(signal => new Vector2(unwrap(signal)))
+            : this.children().map(child => child.position());
+    }
+};
+__decorate([
+    initial(0),
+    signal()
+], Line.prototype, "radius", void 0);
+__decorate([
+    initial(null),
+    signal()
+], Line.prototype, "points", void 0);
+__decorate([
+    threadable()
+], Line.prototype, "tweenPoints", null);
+__decorate([
+    computed()
+], Line.prototype, "childrenBBox", null);
+__decorate([
+    computed()
+], Line.prototype, "parsedPoints", null);
+__decorate([
+    computed()
+], Line.prototype, "profile", null);
+Line = Line_1 = __decorate([
+    nodeName('Line')
+], Line);
+export { Line };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Line.js","sourceRoot":"","sources":["../../src/lib/components/Line.ts"],"names":[],"mappings":"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"}