angular-three-soba 1.4.0 → 1.5.0

package/abstractions/index.d.ts

@@ -1,6 +1,10 @@
 export * from './lib/billboard/billboard';
+export * from './lib/catmull-rom-line/catmull-rom-line';
+export * from './lib/cubic-bezier-line/cubic-bezier-line';
 export * from './lib/gizmo-helper/gizmo-helper';
 export * from './lib/gizmo-helper/gizmo-viewcube/gizmo-viewcube';
 export * from './lib/gizmo-helper/gizmo-viewport/gizmo-viewport';
+export * from './lib/line/line';
+export * from './lib/quadratic-bezier-line/quadratic-bezier-line';
 export * from './lib/text-3d/text-3d';
 export * from './lib/text/text';

package/abstractions/lib/catmull-rom-line/catmull-rom-line.d.ts

@@ -0,0 +1,15 @@
+import * as THREE from 'three';
+import { Line2 } from 'three-stdlib';
+import { NgtsLineInput } from '../line/line-input';
+import * as i0 from "@angular/core";
+export declare class NgtsCatmullRomLine extends NgtsLineInput {
+    lineRef: import("angular-three").NgtInjectedRef<Line2>;
+    set points(points: Array<THREE.Vector3 | THREE.Vector2 | [number, number, number] | [number, number] | number>);
+    set closed(closed: boolean);
+    set curveType(curveType: 'centripetal' | 'chordal' | 'catmullrom');
+    set tension(tension: number);
+    set segments(segments: number);
+    initialize(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsCatmullRomLine, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsCatmullRomLine, "ngts-catmull-rom-line[points]", never, { "lineRef": "lineRef"; "points": "points"; "closed": "closed"; "curveType": "curveType"; "tension": "tension"; "segments": "segments"; }, {}, never, never, true, never>;
+}

package/abstractions/lib/cubic-bezier-line/cubic-bezier-line.d.ts

@@ -0,0 +1,15 @@
+import * as THREE from 'three';
+import { Line2 } from 'three-stdlib';
+import { NgtsLineInput } from '../line/line-input';
+import * as i0 from "@angular/core";
+export declare class NgtsCubicBezierLine extends NgtsLineInput {
+    lineRef: import("angular-three").NgtInjectedRef<Line2>;
+    set start(start: THREE.Vector3 | [number, number, number]);
+    set end(end: THREE.Vector3 | [number, number, number]);
+    set midA(midA: THREE.Vector3 | [number, number, number]);
+    set midB(midB: THREE.Vector3 | [number, number, number]);
+    set segments(segments: number);
+    initialize(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsCubicBezierLine, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsCubicBezierLine, "ngts-cubic-bezier-line[start][end][midA][midB]", never, { "lineRef": "lineRef"; "start": "start"; "end": "end"; "midA": "midA"; "midB": "midB"; "segments": "segments"; }, {}, never, never, true, never>;
+}

package/abstractions/lib/line/line-input.d.ts

@@ -0,0 +1,19 @@
+import { NgtRxStore } from 'angular-three';
+import * as i0 from "@angular/core";
+export declare abstract class NgtsLineInput extends NgtRxStore {
+    set vertexColors(vertexColors: Array<THREE.Color | [number, number, number]>);
+    set lineWidth(lineWidth: number);
+    set alphaToCoverage(alphaToCoverage: boolean);
+    set color(color: THREE.ColorRepresentation);
+    set dashed(dashed: boolean);
+    set dashScale(dashScale: number);
+    set dashSize(dashSize: number);
+    set dashOffset(dashOffset: number);
+    set gapSize(gapSize: number);
+    set resolution(resolution: THREE.Vector2);
+    set wireframe(wireframe: boolean);
+    set worldUnits(worldUnits: boolean);
+    initialize(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsLineInput, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsLineInput, never, never, { "vertexColors": "vertexColors"; "lineWidth": "lineWidth"; "alphaToCoverage": "alphaToCoverage"; "color": "color"; "dashed": "dashed"; "dashScale": "dashScale"; "dashSize": "dashSize"; "dashOffset": "dashOffset"; "gapSize": "gapSize"; "resolution": "resolution"; "wireframe": "wireframe"; "worldUnits": "worldUnits"; }, {}, never, never, false, never>;
+}

package/abstractions/lib/line/line.d.ts

@@ -0,0 +1,21 @@
+import { OnInit } from '@angular/core';
+import { NgtAfterAttach } from 'angular-three';
+import * as THREE from 'three';
+import { Line2, LineGeometry, LineMaterial, LineSegments2 } from 'three-stdlib';
+import { NgtsLineInput } from './line-input';
+import * as i0 from "@angular/core";
+export declare class NgtsLine extends NgtsLineInput implements OnInit {
+    readonly Boolean: BooleanConstructor;
+    readonly lineMaterial: LineMaterial;
+    private readonly store;
+    lineRef: import("angular-three").NgtInjectedRef<LineSegments2 | Line2>;
+    set points(points: Array<THREE.Vector3 | THREE.Vector2 | [number, number, number] | [number, number] | number>);
+    set segments(segments: boolean);
+    onAfterGeometryAttached({ parent }: NgtAfterAttach<Line2 | LineSegments2, LineGeometry>): void;
+    initialize(): void;
+    ngOnInit(): void;
+    private computeLineDistances;
+    private disposeGeometry;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsLine, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsLine, "ngts-line[points]", never, { "lineRef": "lineRef"; "points": "points"; "segments": "segments"; }, {}, never, never, true, never>;
+}

package/abstractions/lib/quadratic-bezier-line/quadratic-bezier-line.d.ts

@@ -0,0 +1,19 @@
+import { OnInit } from '@angular/core';
+import * as THREE from 'three';
+import { Line2 } from 'three-stdlib';
+import { NgtsLineInput } from '../line/line-input';
+import * as i0 from "@angular/core";
+export declare class NgtsQuadraticBezierLine extends NgtsLineInput implements OnInit {
+    readonly curve: THREE.QuadraticBezierCurve3;
+    lineRef: import("angular-three").NgtInjectedRef<Line2>;
+    set start(start: THREE.Vector3 | [number, number, number]);
+    set end(end: THREE.Vector3 | [number, number, number]);
+    set mid(mid: THREE.Vector3 | [number, number, number]);
+    set segments(segments: number);
+    initialize(): void;
+    ngOnInit(): void;
+    private replaceSetPoints;
+    private getPoints;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsQuadraticBezierLine, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsQuadraticBezierLine, "ngts-quadratic-bezier-line", never, { "lineRef": "lineRef"; "start": "start"; "end": "end"; "mid": "mid"; "segments": "segments"; }, {}, never, never, true, never>;
+}

package/esm2020/abstractions/index.mjs

@@ -1,7 +1,11 @@
 export * from './lib/billboard/billboard';
+export * from './lib/catmull-rom-line/catmull-rom-line';
+export * from './lib/cubic-bezier-line/cubic-bezier-line';
 export * from './lib/gizmo-helper/gizmo-helper';
 export * from './lib/gizmo-helper/gizmo-viewcube/gizmo-viewcube';
 export * from './lib/gizmo-helper/gizmo-viewport/gizmo-viewport';
+export * from './lib/line/line';
+export * from './lib/quadratic-bezier-line/quadratic-bezier-line';
 export * from './lib/text-3d/text-3d';
 export * from './lib/text/text';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXItdGhyZWUtc29iYS9hYnN0cmFjdGlvbnMvc3JjL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyxpQ0FBaUMsQ0FBQztBQUNoRCxjQUFjLGtEQUFrRCxDQUFDO0FBQ2pFLGNBQWMsa0RBQWtELENBQUM7QUFDakUsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLGlCQUFpQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9saWIvYmlsbGJvYXJkL2JpbGxib2FyZCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9naXptby1oZWxwZXIvZ2l6bW8taGVscGVyJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2dpem1vLWhlbHBlci9naXptby12aWV3Y3ViZS9naXptby12aWV3Y3ViZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9naXptby1oZWxwZXIvZ2l6bW8tdmlld3BvcnQvZ2l6bW8tdmlld3BvcnQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvdGV4dC0zZC90ZXh0LTNkJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3RleHQvdGV4dCc7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXItdGhyZWUtc29iYS9hYnN0cmFjdGlvbnMvc3JjL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyx5Q0FBeUMsQ0FBQztBQUN4RCxjQUFjLDJDQUEyQyxDQUFDO0FBQzFELGNBQWMsaUNBQWlDLENBQUM7QUFDaEQsY0FBYyxrREFBa0QsQ0FBQztBQUNqRSxjQUFjLGtEQUFrRCxDQUFDO0FBQ2pFLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxtREFBbUQsQ0FBQztBQUNsRSxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsaUJBQWlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2xpYi9iaWxsYm9hcmQvYmlsbGJvYXJkJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NhdG11bGwtcm9tLWxpbmUvY2F0bXVsbC1yb20tbGluZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jdWJpYy1iZXppZXItbGluZS9jdWJpYy1iZXppZXItbGluZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9naXptby1oZWxwZXIvZ2l6bW8taGVscGVyJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2dpem1vLWhlbHBlci9naXptby12aWV3Y3ViZS9naXptby12aWV3Y3ViZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9naXptby1oZWxwZXIvZ2l6bW8tdmlld3BvcnQvZ2l6bW8tdmlld3BvcnQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvbGluZS9saW5lJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3F1YWRyYXRpYy1iZXppZXItbGluZS9xdWFkcmF0aWMtYmV6aWVyLWxpbmUnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvdGV4dC0zZC90ZXh0LTNkJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3RleHQvdGV4dCc7XG4iXX0=

package/esm2020/abstractions/lib/catmull-rom-line/catmull-rom-line.mjs

@@ -0,0 +1,119 @@
+import { Component, CUSTOM_ELEMENTS_SCHEMA, Input } from '@angular/core';
+import { injectNgtRef, startWithUndefined } from 'angular-three';
+import { combineLatest, map } from 'rxjs';
+import * as THREE from 'three';
+import { CatmullRomCurve3 } from 'three';
+import { NgtsLine } from '../line/line';
+import { NgtsLineInput } from '../line/line-input';
+import * as i0 from "@angular/core";
+export class NgtsCatmullRomLine extends NgtsLineInput {
+    constructor() {
+        super(...arguments);
+        this.lineRef = injectNgtRef();
+    }
+    set points(points) {
+        this.set({ points });
+    }
+    set closed(closed) {
+        this.set({ closed });
+    }
+    set curveType(curveType) {
+        this.set({ curveType });
+    }
+    set tension(tension) {
+        this.set({ tension });
+    }
+    set segments(segments) {
+        this.set({ segments });
+    }
+    initialize() {
+        super.initialize();
+        this.set({ closed: false, curveType: 'centripetal', tension: 0.5, segments: 64 });
+        this.connect('curve', combineLatest([
+            this.select('points'),
+            this.select('closed'),
+            this.select('curveType'),
+            this.select('tension'),
+        ]).pipe(map(([points, closed, curveType, tension]) => {
+            const mappedPoints = points.map((p) => p instanceof THREE.Vector3 ? p : new THREE.Vector3(...p));
+            return new CatmullRomCurve3(mappedPoints, closed, curveType, tension);
+        })));
+        this.connect('segmentedPoints', combineLatest([this.select('curve'), this.select('segments')]).pipe(map(([curve, segments]) => curve.getPoints(segments))));
+        this.connect('interpolatedVertexColors', combineLatest([this.select('vertexColors').pipe(startWithUndefined()), this.select('segments')]).pipe(map(([vertexColors, segments]) => {
+            if (!vertexColors || vertexColors.length < 2)
+                return undefined;
+            if (vertexColors.length === segments + 1)
+                return vertexColors;
+            const mappedColors = vertexColors.map((color) => color instanceof THREE.Color ? color : new THREE.Color(...color));
+            if (this.get('closed'))
+                mappedColors.push(mappedColors[0].clone());
+            const iColors = [mappedColors[0]];
+            const divisions = segments / (mappedColors.length - 1);
+            for (let i = 0; i < segments; i++) {
+                const alpha = (i % divisions) / divisions;
+                const colorIndex = Math.floor(i / divisions);
+                iColors.push(mappedColors[colorIndex].clone().lerp(mappedColors[colorIndex + 1], alpha));
+            }
+            iColors.push(mappedColors[mappedColors.length - 1]);
+        })));
+    }
+}
+NgtsCatmullRomLine.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.3", ngImport: i0, type: NgtsCatmullRomLine, deps: null, target: i0.ɵɵFactoryTarget.Component });
+NgtsCatmullRomLine.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.1.3", type: NgtsCatmullRomLine, isStandalone: true, selector: "ngts-catmull-rom-line[points]", inputs: { lineRef: "lineRef", points: "points", closed: "closed", curveType: "curveType", tension: "tension", segments: "segments" }, usesInheritance: true, ngImport: i0, template: `
+        <ngts-line
+            [lineRef]="lineRef"
+            [points]="get('segmentedPoints')"
+            [color]="get('color')"
+            [vertexColors]="get('interpolatedVertexColors')"
+            [resolution]="get('resolution')"
+            [lineWidth]="get('lineWidth')"
+            [alphaToCoverage]="get('alphaToCoverage')"
+            [dashed]="get('dashed')"
+            [dashScale]="get('dashScale')"
+            [dashOffset]="get('dashOffset')"
+            [dashSize]="get('dashSize')"
+            [gapSize]="get('gapSize')"
+            [wireframe]="get('wireframe')"
+            [worldUnits]="get('worldUnits')"
+        />
+    `, isInline: true, dependencies: [{ kind: "component", type: NgtsLine, selector: "ngts-line[points]", inputs: ["lineRef", "points", "segments"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.3", ngImport: i0, type: NgtsCatmullRomLine, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-catmull-rom-line[points]',
+                    standalone: true,
+                    template: `
+        <ngts-line
+            [lineRef]="lineRef"
+            [points]="get('segmentedPoints')"
+            [color]="get('color')"
+            [vertexColors]="get('interpolatedVertexColors')"
+            [resolution]="get('resolution')"
+            [lineWidth]="get('lineWidth')"
+            [alphaToCoverage]="get('alphaToCoverage')"
+            [dashed]="get('dashed')"
+            [dashScale]="get('dashScale')"
+            [dashOffset]="get('dashOffset')"
+            [dashSize]="get('dashSize')"
+            [gapSize]="get('gapSize')"
+            [wireframe]="get('wireframe')"
+            [worldUnits]="get('worldUnits')"
+        />
+    `,
+                    imports: [NgtsLine],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], propDecorators: { lineRef: [{
+                type: Input
+            }], points: [{
+                type: Input
+            }], closed: [{
+                type: Input
+            }], curveType: [{
+                type: Input
+            }], tension: [{
+                type: Input
+            }], segments: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"catmull-rom-line.js","sourceRoot":"","sources":["../../../../../../../libs/angular-three-soba/abstractions/src/lib/catmull-rom-line/catmull-rom-line.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, CUSTOM_ELEMENTS_SCHEMA, Input } from '@angular/core';\nimport { injectNgtRef, startWithUndefined } from 'angular-three';\nimport { combineLatest, map } from 'rxjs';\nimport * as THREE from 'three';\nimport { CatmullRomCurve3 } from 'three';\nimport { Line2 } from 'three-stdlib';\nimport { NgtsLine } from '../line/line';\nimport { NgtsLineInput } from '../line/line-input';\n\n@Component({\n    selector: 'ngts-catmull-rom-line[points]',\n    standalone: true,\n    template: `\n        <ngts-line\n            [lineRef]=\"lineRef\"\n            [points]=\"get('segmentedPoints')\"\n            [color]=\"get('color')\"\n            [vertexColors]=\"get('interpolatedVertexColors')\"\n            [resolution]=\"get('resolution')\"\n            [lineWidth]=\"get('lineWidth')\"\n            [alphaToCoverage]=\"get('alphaToCoverage')\"\n            [dashed]=\"get('dashed')\"\n            [dashScale]=\"get('dashScale')\"\n            [dashOffset]=\"get('dashOffset')\"\n            [dashSize]=\"get('dashSize')\"\n            [gapSize]=\"get('gapSize')\"\n            [wireframe]=\"get('wireframe')\"\n            [worldUnits]=\"get('worldUnits')\"\n        />\n    `,\n    imports: [NgtsLine],\n    schemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsCatmullRomLine extends NgtsLineInput {\n    @Input() lineRef = injectNgtRef<Line2>();\n\n    @Input() set points(\n        points: Array<THREE.Vector3 | THREE.Vector2 | [number, number, number] | [number, number] | number>\n    ) {\n        this.set({ points });\n    }\n\n    @Input() set closed(closed: boolean) {\n        this.set({ closed });\n    }\n\n    @Input() set curveType(curveType: 'centripetal' | 'chordal' | 'catmullrom') {\n        this.set({ curveType });\n    }\n\n    @Input() set tension(tension: number) {\n        this.set({ tension });\n    }\n\n    @Input() set segments(segments: number) {\n        this.set({ segments });\n    }\n\n    override initialize(): void {\n        super.initialize();\n        this.set({ closed: false, curveType: 'centripetal', tension: 0.5, segments: 64 });\n        this.connect(\n            'curve',\n            combineLatest([\n                this.select('points'),\n                this.select('closed'),\n                this.select('curveType'),\n                this.select('tension'),\n            ]).pipe(\n                map(([points, closed, curveType, tension]) => {\n                    const mappedPoints = (points as NgtsCatmullRomLine['points']).map((p) =>\n                        p instanceof THREE.Vector3 ? p : new THREE.Vector3(...(p as [number, number, number]))\n                    );\n                    return new CatmullRomCurve3(mappedPoints, closed, curveType, tension);\n                })\n            )\n        );\n\n        this.connect(\n            'segmentedPoints',\n            combineLatest([this.select('curve'), this.select('segments')]).pipe(\n                map(([curve, segments]) => curve.getPoints(segments))\n            )\n        );\n\n        this.connect(\n            'interpolatedVertexColors',\n            combineLatest([this.select('vertexColors').pipe(startWithUndefined()), this.select('segments')]).pipe(\n                map(([vertexColors, segments]) => {\n                    if (!vertexColors || vertexColors.length < 2) return undefined;\n                    if (vertexColors.length === segments + 1) return vertexColors;\n\n                    const mappedColors = vertexColors.map((color: THREE.Color | [number, number, number]) =>\n                        color instanceof THREE.Color ? color : new THREE.Color(...color)\n                    );\n                    if (this.get('closed')) mappedColors.push(mappedColors[0].clone());\n\n                    const iColors: THREE.Color[] = [mappedColors[0]];\n                    const divisions = segments / (mappedColors.length - 1);\n                    for (let i = 0; i < segments; i++) {\n                        const alpha = (i % divisions) / divisions;\n                        const colorIndex = Math.floor(i / divisions);\n                        iColors.push(mappedColors[colorIndex].clone().lerp(mappedColors[colorIndex + 1], alpha));\n                    }\n                    iColors.push(mappedColors[mappedColors.length - 1]);\n                })\n            )\n        );\n    }\n}\n"]}

package/esm2020/abstractions/lib/cubic-bezier-line/cubic-bezier-line.mjs

@@ -0,0 +1,98 @@
+import { NgIf } from '@angular/common';
+import { Component, CUSTOM_ELEMENTS_SCHEMA, Input } from '@angular/core';
+import { injectNgtRef } from 'angular-three';
+import * as THREE from 'three';
+import { NgtsLine } from '../line/line';
+import { NgtsLineInput } from '../line/line-input';
+import * as i0 from "@angular/core";
+export class NgtsCubicBezierLine extends NgtsLineInput {
+    constructor() {
+        super(...arguments);
+        this.lineRef = injectNgtRef();
+    }
+    set start(start) {
+        this.set({ start });
+    }
+    set end(end) {
+        this.set({ end });
+    }
+    set midA(midA) {
+        this.set({ midA });
+    }
+    set midB(midB) {
+        this.set({ midB });
+    }
+    set segments(segments) {
+        this.set({ segments });
+    }
+    initialize() {
+        super.initialize();
+        this.set({ segments: 10 });
+        this.connect('points', this.select(['start', 'end', 'midA', 'midB', 'segments'], ({ start, end, midA, midB, segments }) => {
+            const startV = start instanceof THREE.Vector3 ? start : new THREE.Vector3(...start);
+            const endV = end instanceof THREE.Vector3 ? end : new THREE.Vector3(...end);
+            const midAV = midA instanceof THREE.Vector3 ? midA : new THREE.Vector3(...midA);
+            const midBV = midB instanceof THREE.Vector3 ? midB : new THREE.Vector3(...midB);
+            return new THREE.CubicBezierCurve3(startV, midAV, midBV, endV).getPoints(segments);
+        }));
+    }
+}
+NgtsCubicBezierLine.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.3", ngImport: i0, type: NgtsCubicBezierLine, deps: null, target: i0.ɵɵFactoryTarget.Component });
+NgtsCubicBezierLine.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.1.3", type: NgtsCubicBezierLine, isStandalone: true, selector: "ngts-cubic-bezier-line[start][end][midA][midB]", inputs: { lineRef: "lineRef", start: "start", end: "end", midA: "midA", midB: "midB", segments: "segments" }, usesInheritance: true, ngImport: i0, template: `
+        <ngts-line
+            [lineRef]="lineRef"
+            [points]="get('points')"
+            [color]="get('color')"
+            [vertexColors]="get('vertexColors')"
+            [resolution]="get('resolution')"
+            [lineWidth]="get('lineWidth')"
+            [alphaToCoverage]="get('alphaToCoverage')"
+            [dashed]="get('dashed')"
+            [dashScale]="get('dashScale')"
+            [dashSize]="get('dashSize')"
+            [dashOffset]="get('dashOffset')"
+            [gapSize]="get('gapSize')"
+            [wireframe]="get('wireframe')"
+            [worldUnits]="get('worldUnits')"
+        />
+    `, isInline: true, dependencies: [{ kind: "component", type: NgtsLine, selector: "ngts-line[points]", inputs: ["lineRef", "points", "segments"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.3", ngImport: i0, type: NgtsCubicBezierLine, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-cubic-bezier-line[start][end][midA][midB]',
+                    standalone: true,
+                    template: `
+        <ngts-line
+            [lineRef]="lineRef"
+            [points]="get('points')"
+            [color]="get('color')"
+            [vertexColors]="get('vertexColors')"
+            [resolution]="get('resolution')"
+            [lineWidth]="get('lineWidth')"
+            [alphaToCoverage]="get('alphaToCoverage')"
+            [dashed]="get('dashed')"
+            [dashScale]="get('dashScale')"
+            [dashSize]="get('dashSize')"
+            [dashOffset]="get('dashOffset')"
+            [gapSize]="get('gapSize')"
+            [wireframe]="get('wireframe')"
+            [worldUnits]="get('worldUnits')"
+        />
+    `,
+                    imports: [NgtsLine, NgIf],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], propDecorators: { lineRef: [{
+                type: Input
+            }], start: [{
+                type: Input
+            }], end: [{
+                type: Input
+            }], midA: [{
+                type: Input
+            }], midB: [{
+                type: Input
+            }], segments: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/abstractions/lib/line/line-input.mjs

@@ -0,0 +1,75 @@
+import { Directive, Input } from '@angular/core';
+import { NgtRxStore } from 'angular-three';
+import * as i0 from "@angular/core";
+export class NgtsLineInput extends NgtRxStore {
+    set vertexColors(vertexColors) {
+        this.set({ vertexColors });
+    }
+    set lineWidth(lineWidth) {
+        this.set({ lineWidth });
+    }
+    set alphaToCoverage(alphaToCoverage) {
+        this.set({ alphaToCoverage });
+    }
+    set color(color) {
+        this.set({ color });
+    }
+    set dashed(dashed) {
+        this.set({ dashed });
+    }
+    set dashScale(dashScale) {
+        this.set({ dashScale });
+    }
+    set dashSize(dashSize) {
+        this.set({ dashSize });
+    }
+    set dashOffset(dashOffset) {
+        this.set({ dashOffset });
+    }
+    set gapSize(gapSize) {
+        this.set({ gapSize });
+    }
+    set resolution(resolution) {
+        this.set({ resolution });
+    }
+    set wireframe(wireframe) {
+        this.set({ wireframe });
+    }
+    set worldUnits(worldUnits) {
+        this.set({ worldUnits });
+    }
+    initialize() {
+        super.initialize();
+        this.set({ color: 'black' });
+    }
+}
+NgtsLineInput.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.3", ngImport: i0, type: NgtsLineInput, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+NgtsLineInput.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.1.3", type: NgtsLineInput, inputs: { vertexColors: "vertexColors", lineWidth: "lineWidth", alphaToCoverage: "alphaToCoverage", color: "color", dashed: "dashed", dashScale: "dashScale", dashSize: "dashSize", dashOffset: "dashOffset", gapSize: "gapSize", resolution: "resolution", wireframe: "wireframe", worldUnits: "worldUnits" }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.3", ngImport: i0, type: NgtsLineInput, decorators: [{
+            type: Directive
+        }], propDecorators: { vertexColors: [{
+                type: Input
+            }], lineWidth: [{
+                type: Input
+            }], alphaToCoverage: [{
+                type: Input
+            }], color: [{
+                type: Input
+            }], dashed: [{
+                type: Input
+            }], dashScale: [{
+                type: Input
+            }], dashSize: [{
+                type: Input
+            }], dashOffset: [{
+                type: Input
+            }], gapSize: [{
+                type: Input
+            }], resolution: [{
+                type: Input
+            }], wireframe: [{
+                type: Input
+            }], worldUnits: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/abstractions/lib/line/line.mjs

@@ -0,0 +1,147 @@
+import { Component, CUSTOM_ELEMENTS_SCHEMA, inject, Input } from '@angular/core';
+import { injectNgtRef, NgtArgs, NgtStore, startWithUndefined } from 'angular-three';
+import { combineLatest, map } from 'rxjs';
+import * as THREE from 'three';
+import { Line2, LineGeometry, LineMaterial, LineSegments2, LineSegmentsGeometry } from 'three-stdlib';
+import { NgtsLineInput } from './line-input';
+import * as i0 from "@angular/core";
+export class NgtsLine extends NgtsLineInput {
+    constructor() {
+        super(...arguments);
+        this.Boolean = Boolean;
+        this.lineMaterial = new LineMaterial();
+        this.store = inject(NgtStore);
+        this.lineRef = injectNgtRef();
+    }
+    set points(points) {
+        this.set({ points });
+    }
+    set segments(segments) {
+        this.set({ segments });
+    }
+    // TODO: Figure out if this is the case for everything else.
+    // We'd want to run computeLineDistances on the Line2 on "points" changed
+    // Consequently,when "points" changes, LineGeometry also changes and that causes
+    // the Renderer to replace the LineGeometry on the Line2, which is what's happening.
+    // But the effect that runs line.computeLineDistances() runs a little BEFORE the new lineGeometry
+    // has been attached. So it doesn't work with the props changed from the Material
+    //
+    // Alternatively, we can also run the effect on line#children changes.
+    onAfterGeometryAttached({ parent }) {
+        // parent.computeLineDistances();
+    }
+    initialize() {
+        super.initialize();
+        this.set({ segments: false });
+        this.connect('lineGeometry', combineLatest([
+            this.select('points'),
+            this.select('segments'),
+            this.select('vertexColors').pipe(startWithUndefined()),
+        ]).pipe(map(([points, segments, vertexColors]) => {
+            const geometry = segments ? new LineSegmentsGeometry() : new LineGeometry();
+            const pValues = points.map((p) => {
+                const isArray = Array.isArray(p);
+                return p instanceof THREE.Vector3
+                    ? [p.x, p.y, p.z]
+                    : p instanceof THREE.Vector2
+                        ? [p.x, p.y, 0]
+                        : isArray && p.length === 3
+                            ? [p[0], p[1], p[2]]
+                            : isArray && p.length === 2
+                                ? [p[0], p[1], 0]
+                                : p;
+            });
+            geometry.setPositions(pValues.flat());
+            if (vertexColors) {
+                const cValues = vertexColors.map((c) => c instanceof THREE.Color ? c.toArray() : c);
+                geometry.setColors(cValues.flat());
+            }
+            return geometry;
+        })));
+    }
+    ngOnInit() {
+        this.connect('materialResolution', combineLatest([this.store.select('size'), this.select('resolution').pipe(startWithUndefined())]).pipe(map(([size, resolution]) => resolution ?? [size.width, size.height])));
+        if (!this.lineRef.nativeElement) {
+            this.lineRef.nativeElement = this.get('segments') ? new LineSegments2() : new Line2();
+        }
+        this.computeLineDistances();
+        this.disposeGeometry();
+    }
+    computeLineDistances() {
+        this.hold(combineLatest([this.lineRef.$, this.lineRef.children$('nonObjects'), this.select('points')]), ([line]) => {
+            line.computeLineDistances();
+        });
+    }
+    disposeGeometry() {
+        this.effect(this.select('lineGeometry'), (lineGeometry) => {
+            return () => lineGeometry.dispose();
+        });
+    }
+}
+NgtsLine.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.3", ngImport: i0, type: NgtsLine, deps: null, target: i0.ɵɵFactoryTarget.Component });
+NgtsLine.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.1.3", type: NgtsLine, isStandalone: true, selector: "ngts-line[points]", inputs: { lineRef: "lineRef", points: "points", segments: "segments" }, usesInheritance: true, ngImport: i0, template: `
+        <ngt-primitive *args="[lineRef.nativeElement]" [ref]="lineRef" ngtCompound>
+            <ngt-primitive
+                *args="[get('lineGeometry')]"
+                attach="geometry"
+                (afterAttach)="onAfterGeometryAttached($any($event))"
+            />
+            <ngt-primitive
+                *args="[lineMaterial]"
+                attach="material"
+                [color]="get('color')"
+                [vertexColors]="Boolean(get('vertexColors'))"
+                [resolution]="get('materialResolution')"
+                [linewidth]="get('lineWidth')"
+                [alphaToCoverage]="get('alphaToCoverage')"
+                [dashed]="get('dashed')"
+                [dashScale]="get('dashScale') ?? lineMaterial.dashScale"
+                [dashSize]="get('dashSize') ?? lineMaterial.dashSize"
+                [dashOffset]="get('dashOffset') ?? lineMaterial.dashOffset"
+                [gapSize]="get('gapSize') ?? lineMaterial.gapSize"
+                [wireframe]="get('wireframe') ?? lineMaterial.wireframe"
+                [worldUnits]="get('worldUnits')"
+            />
+        </ngt-primitive>
+    `, isInline: true, dependencies: [{ kind: "directive", type: NgtArgs, selector: "[args]", inputs: ["args"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.3", ngImport: i0, type: NgtsLine, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-line[points]',
+                    standalone: true,
+                    template: `
+        <ngt-primitive *args="[lineRef.nativeElement]" [ref]="lineRef" ngtCompound>
+            <ngt-primitive
+                *args="[get('lineGeometry')]"
+                attach="geometry"
+                (afterAttach)="onAfterGeometryAttached($any($event))"
+            />
+            <ngt-primitive
+                *args="[lineMaterial]"
+                attach="material"
+                [color]="get('color')"
+                [vertexColors]="Boolean(get('vertexColors'))"
+                [resolution]="get('materialResolution')"
+                [linewidth]="get('lineWidth')"
+                [alphaToCoverage]="get('alphaToCoverage')"
+                [dashed]="get('dashed')"
+                [dashScale]="get('dashScale') ?? lineMaterial.dashScale"
+                [dashSize]="get('dashSize') ?? lineMaterial.dashSize"
+                [dashOffset]="get('dashOffset') ?? lineMaterial.dashOffset"
+                [gapSize]="get('gapSize') ?? lineMaterial.gapSize"
+                [wireframe]="get('wireframe') ?? lineMaterial.wireframe"
+                [worldUnits]="get('worldUnits')"
+            />
+        </ngt-primitive>
+    `,
+                    imports: [NgtArgs],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], propDecorators: { lineRef: [{
+                type: Input
+            }], points: [{
+                type: Input
+            }], segments: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"line.js","sourceRoot":"","sources":["../../../../../../../libs/angular-three-soba/abstractions/src/lib/line/line.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, CUSTOM_ELEMENTS_SCHEMA, inject, Input, OnInit } from '@angular/core';\nimport { injectNgtRef, NgtAfterAttach, NgtArgs, NgtStore, startWithUndefined } from 'angular-three';\nimport { combineLatest, map } from 'rxjs';\nimport * as THREE from 'three';\nimport { Line2, LineGeometry, LineMaterial, LineSegments2, LineSegmentsGeometry } from 'three-stdlib';\nimport { NgtsLineInput } from './line-input';\n\n@Component({\n    selector: 'ngts-line[points]',\n    standalone: true,\n    template: `\n        <ngt-primitive *args=\"[lineRef.nativeElement]\" [ref]=\"lineRef\" ngtCompound>\n            <ngt-primitive\n                *args=\"[get('lineGeometry')]\"\n                attach=\"geometry\"\n                (afterAttach)=\"onAfterGeometryAttached($any($event))\"\n            />\n            <ngt-primitive\n                *args=\"[lineMaterial]\"\n                attach=\"material\"\n                [color]=\"get('color')\"\n                [vertexColors]=\"Boolean(get('vertexColors'))\"\n                [resolution]=\"get('materialResolution')\"\n                [linewidth]=\"get('lineWidth')\"\n                [alphaToCoverage]=\"get('alphaToCoverage')\"\n                [dashed]=\"get('dashed')\"\n                [dashScale]=\"get('dashScale') ?? lineMaterial.dashScale\"\n                [dashSize]=\"get('dashSize') ?? lineMaterial.dashSize\"\n                [dashOffset]=\"get('dashOffset') ?? lineMaterial.dashOffset\"\n                [gapSize]=\"get('gapSize') ?? lineMaterial.gapSize\"\n                [wireframe]=\"get('wireframe') ?? lineMaterial.wireframe\"\n                [worldUnits]=\"get('worldUnits')\"\n            />\n        </ngt-primitive>\n    `,\n    imports: [NgtArgs],\n    schemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsLine extends NgtsLineInput implements OnInit {\n    readonly Boolean = Boolean;\n    readonly lineMaterial = new LineMaterial();\n\n    private readonly store = inject(NgtStore);\n\n    @Input() lineRef = injectNgtRef<LineSegments2 | Line2>();\n\n    @Input() set points(\n        points: Array<THREE.Vector3 | THREE.Vector2 | [number, number, number] | [number, number] | number>\n    ) {\n        this.set({ points });\n    }\n\n    @Input() set segments(segments: boolean) {\n        this.set({ segments });\n    }\n\n    // TODO: Figure out if this is the case for everything else.\n    // We'd want to run computeLineDistances on the Line2 on \"points\" changed\n    // Consequently,when \"points\" changes, LineGeometry also changes and that causes\n    // the Renderer to replace the LineGeometry on the Line2, which is what's happening.\n    // But the effect that runs line.computeLineDistances() runs a little BEFORE the new lineGeometry\n    // has been attached. So it doesn't work with the props changed from the Material\n    //\n    // Alternatively, we can also run the effect on line#children changes.\n    onAfterGeometryAttached({ parent }: NgtAfterAttach<Line2 | LineSegments2, LineGeometry>) {\n        // parent.computeLineDistances();\n    }\n\n    override initialize(): void {\n        super.initialize();\n        this.set({ segments: false });\n        this.connect(\n            'lineGeometry',\n            combineLatest([\n                this.select('points'),\n                this.select('segments'),\n                this.select('vertexColors').pipe(startWithUndefined()),\n            ]).pipe(\n                map(([points, segments, vertexColors]) => {\n                    const geometry = segments ? new LineSegmentsGeometry() : new LineGeometry();\n                    const pValues = (points as NgtsLine['points']).map((p) => {\n                        const isArray = Array.isArray(p);\n                        return p instanceof THREE.Vector3\n                            ? [p.x, p.y, p.z]\n                            : p instanceof THREE.Vector2\n                            ? [p.x, p.y, 0]\n                            : isArray && p.length === 3\n                            ? [p[0], p[1], p[2]]\n                            : isArray && p.length === 2\n                            ? [p[0], p[1], 0]\n                            : p;\n                    });\n\n                    geometry.setPositions(pValues.flat());\n\n                    if (vertexColors) {\n                        const cValues = (vertexColors as NgtsLineInput['vertexColors']).map((c) =>\n                            c instanceof THREE.Color ? c.toArray() : c\n                        );\n                        geometry.setColors(cValues.flat());\n                    }\n\n                    return geometry;\n                })\n            )\n        );\n    }\n\n    ngOnInit() {\n        this.connect(\n            'materialResolution',\n            combineLatest([this.store.select('size'), this.select('resolution').pipe(startWithUndefined())]).pipe(\n                map(([size, resolution]) => resolution ?? [size.width, size.height])\n            )\n        );\n\n        if (!this.lineRef.nativeElement) {\n            this.lineRef.nativeElement = this.get('segments') ? new LineSegments2() : new Line2();\n        }\n\n        this.computeLineDistances();\n        this.disposeGeometry();\n    }\n\n    private computeLineDistances() {\n        this.hold(\n            combineLatest([this.lineRef.$, this.lineRef.children$('nonObjects'), this.select('points')]),\n            ([line]) => {\n                line.computeLineDistances();\n            }\n        );\n    }\n\n    private disposeGeometry() {\n        this.effect(this.select('lineGeometry'), (lineGeometry: LineGeometry) => {\n            return () => lineGeometry.dispose();\n        });\n    }\n}\n"]}