angular-three-soba 1.14.0 → 2.0.0-beta.3

package/abstractions/text-3d/text-3d.d.ts

@@ -0,0 +1,74 @@
+import { NgtSignalStore, type NgtMesh } from 'angular-three';
+import { Mesh } from 'three';
+import * as i0 from "@angular/core";
+declare type Glyph = {
+    _cachedOutline: string[];
+    ha: number;
+    o: string;
+};
+declare type FontData = {
+    boundingBox: {
+        yMax: number;
+        yMin: number;
+    };
+    familyName: string;
+    glyphs: {
+        [k: string]: Glyph;
+    };
+    resolution: number;
+    underlineThickness: number;
+};
+export type NgtsText3DState = {
+    font: FontData | string;
+    text: string;
+    letterSpacing: number;
+    lineHeight: number;
+    size: number;
+    height: number;
+    bevelThickness: number;
+    bevelSize: number;
+    bevelEnabled: boolean;
+    bevelOffset: number;
+    bevelSegments: number;
+    curveSegments: number;
+    smooth?: number;
+};
+declare global {
+    interface HTMLElementTagNameMap {
+        'ngts-text-3d': NgtsText3DState & NgtMesh;
+    }
+}
+export declare class NgtsText3D extends NgtSignalStore<NgtsText3DState> {
+    #private;
+    textRef: import("angular-three").NgtInjectedRef<Mesh<import("three").BufferGeometry, import("three").Material | import("three").Material[]>>;
+    set font(font: FontData | string);
+    set text(text: string);
+    set bevelEnabled(bevelEnabled: boolean);
+    set bevelOffset(bevelOffset: number);
+    set bevelSize(bevelSize: number);
+    set bevelThickness(bevelThickness: number);
+    set curveSegments(curveSegments: number);
+    set bevelSegments(bevelSegments: number);
+    set height(height: number);
+    set size(size: number);
+    set lineHeight(lineHeight: number);
+    set letterSpacing(letterSpacing: number);
+    set smooth(smooth: number);
+    constructor();
+    readonly geometryArgs: import("@angular/core").Signal<(string | {
+        font: import("three-stdlib").Font;
+        size: number;
+        height: number;
+        bevelThickness: number;
+        bevelSize: number;
+        bevelSegments: number;
+        bevelEnabled: boolean;
+        bevelOffset: number;
+        curveSegments: number;
+        letterSpacing: number;
+        lineHeight: number;
+    })[] | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsText3D, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsText3D, "ngts-text-3d", never, { "textRef": { "alias": "textRef"; "required": false; }; "font": { "alias": "font"; "required": true; }; "text": { "alias": "text"; "required": true; }; "bevelEnabled": { "alias": "bevelEnabled"; "required": false; }; "bevelOffset": { "alias": "bevelOffset"; "required": false; }; "bevelSize": { "alias": "bevelSize"; "required": false; }; "bevelThickness": { "alias": "bevelThickness"; "required": false; }; "curveSegments": { "alias": "curveSegments"; "required": false; }; "bevelSegments": { "alias": "bevelSegments"; "required": false; }; "height": { "alias": "height"; "required": false; }; "size": { "alias": "size"; "required": false; }; "lineHeight": { "alias": "lineHeight"; "required": false; }; "letterSpacing": { "alias": "letterSpacing"; "required": false; }; "smooth": { "alias": "smooth"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+export {};

package/cameras/{lib/camera → camera}/camera-content.d.ts

@@ -3,7 +3,7 @@ import * as THREE from 'three';
 import * as i0 from "@angular/core";
 export declare class NgtsCameraContent {
     readonly template: TemplateRef<any>;
-    ngtsCameraContent: boolean | '';
+    ngtsCameraContent: true | '';
     static ngTemplateContextGuard(_: NgtsCameraContent, ctx: unknown): ctx is {
         fbo: THREE.WebGLRenderTarget;
         group?: THREE.Group;

package/cameras/{lib/camera → camera}/camera.d.ts

@@ -1,7 +1,14 @@
-import { OnInit } from '@angular/core';
-import { NgtCamera, NgtRxStore, NgtStore } from 'angular-three';
+import { NgtSignalStore, NgtStore, type NgtCamera } from 'angular-three';
 import * as i0 from "@angular/core";
-export declare abstract class NgtsCamera<TCamera extends NgtCamera> extends NgtRxStore implements OnInit {
+export interface NgtsCameraState {
+    makeDefault: boolean;
+    manual: boolean;
+    frames: number;
+    resolution: number;
+    envMap?: THREE.Texture;
+}
+export declare abstract class NgtsCamera<TCamera extends NgtCamera> extends NgtSignalStore<NgtsCameraState> {
+    #private;
     set makeDefault(makeDefault: boolean);
     set manual(manual: boolean);
     set frames(frames: number);
@@ -9,11 +16,8 @@ export declare abstract class NgtsCamera<TCamera extends NgtCamera> extends NgtR
     set envMap(envMap: THREE.Texture);
     cameraRef: import("angular-three").NgtInjectedRef<TCamera>;
     protected readonly store: NgtStore;
-    readonly fboRef: import("angular-three").NgtInjectedRef<import("three").WebGLRenderTarget>;
-    initialize(): void;
-    ngOnInit(): void;
-    private setDefaultCamera;
-    private updateProjectionMatrix;
+    readonly fboRef: import("@angular/core").Signal<import("three").WebGLRenderTarget>;
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsCamera<any>, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsCamera<any>, never, never, { "makeDefault": { "alias": "makeDefault"; "required": false; }; "manual": { "alias": "manual"; "required": false; }; "frames": { "alias": "frames"; "required": false; }; "resolution": { "alias": "resolution"; "required": false; }; "envMap": { "alias": "envMap"; "required": false; }; "cameraRef": { "alias": "cameraRef"; "required": false; }; }, {}, never, never, false, never>;
 }

package/cameras/cube-camera/cube-camera.d.ts

@@ -0,0 +1,42 @@
+import { ElementRef } from '@angular/core';
+import { NgtSignalStore } from 'angular-three';
+import * as THREE from 'three';
+import { NgtsCameraContent } from '../camera/camera-content';
+import * as i0 from "@angular/core";
+export interface NgtsCubeCameraState {
+    /** Number of frames to render, Infinity */
+    frames: number;
+    /** Resolution of the FBO, 256 */
+    resolution: number;
+    /** Camera near, 0.1 */
+    near: number;
+    /** Camera far, 1000 */
+    far: number;
+    /** Custom environment map that is temporarily set as the scenes background */
+    envMap: THREE.Texture;
+    /** Custom fog that is temporarily set as the scenes fog */
+    fog: THREE.Fog | THREE.FogExp2;
+}
+export declare class NgtsCubeCamera extends NgtSignalStore<NgtsCubeCameraState> {
+    #private;
+    groupRef: ElementRef<THREE.Group>;
+    cameraContent?: NgtsCameraContent;
+    cameraRef: import("angular-three").NgtInjectedRef<THREE.CubeCamera>;
+    /** Number of frames to render, Infinity */
+    set frames(frames: number);
+    /** Resolution of the FBO, 256 */
+    set resolution(resolution: number);
+    /** Camera near, 0.1 */
+    set near(near: number);
+    /** Camera far, 1000 */
+    set far(far: number);
+    /** Custom environment map that is temporarily set as the scenes background */
+    set envMap(envMap: THREE.Texture);
+    /** Custom fog that is temporarily set as the scenes fog */
+    set fog(fog: THREE.Fog | THREE.FogExp2);
+    readonly fbo: import("@angular/core").Signal<THREE.WebGLCubeRenderTarget>;
+    readonly cameraArgs: import("@angular/core").Signal<(number | THREE.WebGLCubeRenderTarget)[]>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsCubeCamera, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsCubeCamera, "ngts-cube-camera", never, { "cameraRef": { "alias": "cameraRef"; "required": false; }; "frames": { "alias": "frames"; "required": false; }; "resolution": { "alias": "resolution"; "required": false; }; "near": { "alias": "near"; "required": false; }; "far": { "alias": "far"; "required": false; }; "envMap": { "alias": "envMap"; "required": false; }; "fog": { "alias": "fog"; "required": false; }; }, {}, ["cameraContent"], never, true, never>;
+}

package/cameras/index.d.ts

@@ -1,4 +1,5 @@
-export * from './lib/camera/camera-content';
-export * from './lib/cube-camera/cube-camera';
-export * from './lib/orthographic-camera/orthographic-camera';
-export * from './lib/perspective-camera/perspective-camera';
+export * from './camera/camera';
+export * from './camera/camera-content';
+export * from './cube-camera/cube-camera';
+export * from './orthographic-camera/orthographic-camera';
+export * from './perspective-camera/perspective-camera';

package/cameras/{lib/orthographic-camera → orthographic-camera}/orthographic-camera.d.ts

@@ -1,17 +1,26 @@
 import { NgtsCamera } from '../camera/camera';
 import { NgtsCameraContent } from '../camera/camera-content';
 import * as i0 from "@angular/core";
+declare module '../camera/camera' {
+    interface NgtsCameraState {
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+    }
+}
 export declare class NgtsOrthographicCamera extends NgtsCamera<THREE.OrthographicCamera> {
+    #private;
     cameraContent?: NgtsCameraContent;
     set left(left: number);
     set right(right: number);
     set top(top: number);
     set bottom(bottom: number);
-    initialize(): void;
-    readonly left$: import("rxjs").Observable<any>;
-    readonly right$: import("rxjs").Observable<any>;
-    readonly top$: import("rxjs").Observable<any>;
-    readonly bottom$: import("rxjs").Observable<any>;
+    readonly cameraLeft: import("@angular/core").Signal<number>;
+    readonly cameraRight: import("@angular/core").Signal<number>;
+    readonly cameraTop: import("@angular/core").Signal<number>;
+    readonly cameraBottom: import("@angular/core").Signal<number>;
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsOrthographicCamera, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<NgtsOrthographicCamera, "ngts-orthographic-camera", never, { "left": { "alias": "left"; "required": false; }; "right": { "alias": "right"; "required": false; }; "top": { "alias": "top"; "required": false; }; "bottom": { "alias": "bottom"; "required": false; }; }, {}, ["cameraContent"], never, true, never>;
 }

package/controls/index.d.ts

@@ -1 +1 @@
-export * from './lib/orbit-controls/orbit-controls';
+export * from './orbit-controls/orbit-controls';

package/controls/{lib/orbit-controls → orbit-controls}/orbit-controls.d.ts

@@ -1,8 +1,22 @@
-import { EventEmitter, OnInit } from '@angular/core';
-import { NgtRxStore } from 'angular-three';
+import { EventEmitter } from '@angular/core';
+import { NgtSignalStore, NgtVector3 } from 'angular-three';
 import { OrbitControls } from 'three-stdlib';
 import * as i0 from "@angular/core";
-export declare class NgtsOrbitControls extends NgtRxStore implements OnInit {
+export type NgtsOrbitControlsState = {
+    camera?: THREE.Camera;
+    domElement?: HTMLElement;
+    target?: NgtVector3;
+    makeDefault: boolean;
+    regress: boolean;
+    enableDamping: boolean;
+};
+declare global {
+    interface HTMLElementTagNameMap {
+        'ngts-orbit-controls': OrbitControls & NgtsOrbitControlsState;
+    }
+}
+export declare class NgtsOrbitControls extends NgtSignalStore<NgtsOrbitControlsState> {
+    #private;
     controlsRef: import("angular-three").NgtInjectedRef<OrbitControls>;
     set camera(camera: THREE.Camera);
     set domElement(domElement: HTMLElement);
@@ -13,15 +27,9 @@ export declare class NgtsOrbitControls extends NgtRxStore implements OnInit {
     change: EventEmitter<import("three").Event>;
     start: EventEmitter<import("three").Event>;
     end: EventEmitter<import("three").Event>;
-    private readonly store;
-    readonly enableDamping$: import("rxjs").Observable<any>;
+    readonly args: import("@angular/core").Signal<OrbitControls[]>;
+    readonly damping: import("@angular/core").Signal<boolean>;
     constructor();
-    initialize(): void;
-    ngOnInit(): void;
-    private setControls;
-    private connectElement;
-    private makeControlsDefault;
-    private setEvents;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsOrbitControls, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<NgtsOrbitControls, "ngts-orbit-controls", never, { "controlsRef": { "alias": "controlsRef"; "required": false; }; "camera": { "alias": "camera"; "required": false; }; "domElement": { "alias": "domElement"; "required": false; }; "makeDefault": { "alias": "makeDefault"; "required": false; }; "regress": { "alias": "regress"; "required": false; }; "target": { "alias": "target"; "required": false; }; "enableDamping": { "alias": "enableDamping"; "required": false; }; }, { "change": "change"; "start": "start"; "end": "end"; }, never, never, true, never>;
 }

package/esm2022/abstractions/angular-three-soba-abstractions.mjs

@@ -2,4 +2,4 @@
  * Generated bundle index. Do not edit.
  */
 export * from './index';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW5ndWxhci10aHJlZS1zb2JhLWFic3RyYWN0aW9ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnMvYW5ndWxhci10aHJlZS1zb2JhL2Fic3RyYWN0aW9ucy9zcmMvYW5ndWxhci10aHJlZS1zb2JhLWFic3RyYWN0aW9ucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2luZGV4JztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW5ndWxhci10aHJlZS1zb2JhLWFic3RyYWN0aW9ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnMvc29iYS9hYnN0cmFjdGlvbnMvc3JjL2FuZ3VsYXItdGhyZWUtc29iYS1hYnN0cmFjdGlvbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9pbmRleCc7XG4iXX0=

package/esm2022/abstractions/billboard/billboard.mjs

@@ -0,0 +1,71 @@
+import { CUSTOM_ELEMENTS_SCHEMA, Component, Input } from '@angular/core';
+import { NgtSignalStore, extend, injectBeforeRender, injectNgtRef } from 'angular-three';
+import { Group } from 'three';
+import * as i0 from "@angular/core";
+extend({ Group });
+class NgtsBillboard extends NgtSignalStore {
+    set follow(follow) {
+        this.set({ follow });
+    }
+    set lockX(lockX) {
+        this.set({ lockX });
+    }
+    set lockY(lockY) {
+        this.set({ lockY });
+    }
+    set lockZ(lockZ) {
+        this.set({ lockZ });
+    }
+    constructor() {
+        super({ follow: true, lockX: false, lockY: false, lockZ: false });
+        this.billboardRef = injectNgtRef();
+        injectBeforeRender(({ camera }) => {
+            const ref = this.billboardRef.untracked;
+            const { follow, lockX, lockY, lockZ } = this.get();
+            if (!ref || !follow)
+                return;
+            // save previous rotation in case we're locking an axis
+            const prevRotation = ref.rotation.clone();
+            // always face the camera
+            camera.getWorldQuaternion(ref.quaternion);
+            // re-adjust any axis that is locked
+            if (lockX)
+                ref.rotation.x = prevRotation.x;
+            if (lockY)
+                ref.rotation.y = prevRotation.y;
+            if (lockZ)
+                ref.rotation.z = prevRotation.z;
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsBillboard, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: NgtsBillboard, isStandalone: true, selector: "ngts-billboard", inputs: { billboardRef: "billboardRef", follow: "follow", lockX: "lockX", lockY: "lockY", lockZ: "lockZ" }, usesInheritance: true, ngImport: i0, template: `
+        <ngt-group ngtCompound [ref]="billboardRef">
+            <ng-content />
+        </ngt-group>
+    `, isInline: true }); }
+}
+export { NgtsBillboard };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsBillboard, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-billboard',
+                    standalone: true,
+                    template: `
+        <ngt-group ngtCompound [ref]="billboardRef">
+            <ng-content />
+        </ngt-group>
+    `,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { billboardRef: [{
+                type: Input
+            }], follow: [{
+                type: Input
+            }], lockX: [{
+                type: Input
+            }], lockY: [{
+                type: Input
+            }], lockZ: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/abstractions/catmull-rom-line/catmull-rom-line.mjs

@@ -0,0 +1,131 @@
+import { Component, computed, CUSTOM_ELEMENTS_SCHEMA, Input } from '@angular/core';
+import { injectNgtRef } from 'angular-three';
+import * as THREE from 'three';
+import { CatmullRomCurve3 } from 'three';
+import { NgtsLine } from '../line/line';
+import { NgtsLineInputs } from '../line/line-input';
+import * as i0 from "@angular/core";
+class NgtsCatmullRomLine extends NgtsLineInputs {
+    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 });
+    }
+    #points;
+    #closed;
+    #curveType;
+    #tension;
+    #vertexColors;
+    #curve;
+    #segments;
+    constructor() {
+        super();
+        this.lineRef = injectNgtRef();
+        this.#points = this.select('points');
+        this.#closed = this.select('closed');
+        this.#curveType = this.select('curveType');
+        this.#tension = this.select('tension');
+        this.#vertexColors = this.select('vertexColors');
+        this.#curve = computed(() => {
+            const mappedPoints = this.#points().map((p) => p instanceof THREE.Vector3 ? p : new THREE.Vector3(...p));
+            return new CatmullRomCurve3(mappedPoints, this.#closed(), this.#curveType(), this.#tension());
+        });
+        this.#segments = this.select('segments');
+        this.segmentedPoints = computed(() => {
+            const curve = this.#curve();
+            return curve.getPoints(this.#segments());
+        });
+        this.interpolatedVertexColors = computed(() => {
+            const vertexColors = this.#vertexColors();
+            const segments = this.#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]);
+            return iColors;
+        });
+        this.set({ closed: false, curveType: 'centripetal', tension: 0.5, segments: 64 });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsCatmullRomLine, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: NgtsCatmullRomLine, isStandalone: true, selector: "ngts-catmull-rom-line", inputs: { lineRef: "lineRef", points: "points", closed: "closed", curveType: "curveType", tension: "tension", segments: "segments" }, usesInheritance: true, ngImport: i0, template: `
+        <ngts-line
+            [lineRef]="lineRef"
+            [points]="segmentedPoints()"
+            [vertexColors]="interpolatedVertexColors()"
+            [color]="lineParameters().color"
+            [resolution]="lineParameters().resolution"
+            [lineWidth]="lineParameters().linewidth"
+            [alphaToCoverage]="lineParameters().alphaToCoverage"
+            [dashed]="lineParameters().dashed"
+            [dashScale]="lineParameters().dashScale"
+            [dashSize]="lineParameters().dashSize"
+            [dashOffset]="lineParameters().dashOffset"
+            [gapSize]="lineParameters().gapSize"
+            [wireframe]="lineParameters().wireframe"
+            [worldUnits]="lineParameters().worldUnits"
+        />
+    `, isInline: true, dependencies: [{ kind: "component", type: NgtsLine, selector: "ngts-line", inputs: ["lineRef", "points", "segments"] }] }); }
+}
+export { NgtsCatmullRomLine };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsCatmullRomLine, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-catmull-rom-line',
+                    standalone: true,
+                    template: `
+        <ngts-line
+            [lineRef]="lineRef"
+            [points]="segmentedPoints()"
+            [vertexColors]="interpolatedVertexColors()"
+            [color]="lineParameters().color"
+            [resolution]="lineParameters().resolution"
+            [lineWidth]="lineParameters().linewidth"
+            [alphaToCoverage]="lineParameters().alphaToCoverage"
+            [dashed]="lineParameters().dashed"
+            [dashScale]="lineParameters().dashScale"
+            [dashSize]="lineParameters().dashSize"
+            [dashOffset]="lineParameters().dashOffset"
+            [gapSize]="lineParameters().gapSize"
+            [wireframe]="lineParameters().wireframe"
+            [worldUnits]="lineParameters().worldUnits"
+        />
+    `,
+                    imports: [NgtsLine],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { lineRef: [{
+                type: Input
+            }], points: [{
+                type: Input,
+                args: [{ required: true }]
+            }], 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/soba/abstractions/src/catmull-rom-line/catmull-rom-line.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, computed, CUSTOM_ELEMENTS_SCHEMA, Input } from '@angular/core';\nimport { injectNgtRef } from 'angular-three';\nimport * as THREE from 'three';\nimport { CatmullRomCurve3 } from 'three';\nimport { Line2 } from 'three-stdlib';\nimport { NgtsLine } from '../line/line';\nimport { NgtsLineInputs } from '../line/line-input';\n\ndeclare module '../line/line-input' {\n    interface NgtsLineState {\n        closed: boolean;\n        curveType: 'centripetal' | 'chordal' | 'catmullrom';\n        tension: number;\n    }\n}\n\n@Component({\n    selector: 'ngts-catmull-rom-line',\n    standalone: true,\n    template: `\n        <ngts-line\n            [lineRef]=\"lineRef\"\n            [points]=\"segmentedPoints()\"\n            [vertexColors]=\"interpolatedVertexColors()\"\n            [color]=\"lineParameters().color\"\n            [resolution]=\"lineParameters().resolution\"\n            [lineWidth]=\"lineParameters().linewidth\"\n            [alphaToCoverage]=\"lineParameters().alphaToCoverage\"\n            [dashed]=\"lineParameters().dashed\"\n            [dashScale]=\"lineParameters().dashScale\"\n            [dashSize]=\"lineParameters().dashSize\"\n            [dashOffset]=\"lineParameters().dashOffset\"\n            [gapSize]=\"lineParameters().gapSize\"\n            [wireframe]=\"lineParameters().wireframe\"\n            [worldUnits]=\"lineParameters().worldUnits\"\n        />\n    `,\n    imports: [NgtsLine],\n    schemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsCatmullRomLine extends NgtsLineInputs {\n    @Input() lineRef = injectNgtRef<Line2>();\n\n    @Input({ required: true }) 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    readonly #points = this.select('points');\n    readonly #closed = this.select('closed');\n    readonly #curveType = this.select('curveType');\n    readonly #tension = this.select('tension');\n    readonly #vertexColors = this.select('vertexColors');\n\n    readonly #curve = computed(() => {\n        const mappedPoints = this.#points().map((p) =>\n            p instanceof THREE.Vector3 ? p : new THREE.Vector3(...(p as [number, number, number]))\n        );\n        return new CatmullRomCurve3(mappedPoints, this.#closed(), this.#curveType(), this.#tension());\n    });\n\n    readonly #segments = this.select('segments');\n    readonly segmentedPoints = computed(() => {\n        const curve = this.#curve();\n        return curve.getPoints(this.#segments() as number);\n    });\n\n    readonly interpolatedVertexColors = computed(() => {\n        const vertexColors = this.#vertexColors();\n        const segments = this.#segments() as number;\n\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        return iColors;\n    });\n\n    constructor() {\n        super();\n        this.set({ closed: false, curveType: 'centripetal', tension: 0.5, segments: 64 });\n    }\n}\n"]}

package/esm2022/abstractions/cubic-bezier-line/cubic-bezier-line.mjs

@@ -0,0 +1,113 @@
+import { Component, Input, computed } from '@angular/core';
+import { injectNgtRef } from 'angular-three';
+import * as THREE from 'three';
+import { NgtsLine } from '../line/line';
+import { NgtsLineInputs } from '../line/line-input';
+import * as i0 from "@angular/core";
+class NgtsCubicBezierLine extends NgtsLineInputs {
+    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 });
+    }
+    #start;
+    #end;
+    #midA;
+    #midB;
+    #segments;
+    constructor() {
+        super();
+        this.lineRef = injectNgtRef();
+        this.#start = this.select('start');
+        this.#end = this.select('end');
+        this.#midA = this.select('midA');
+        this.#midB = this.select('midB');
+        this.#segments = this.select('segments');
+        this.points = computed(() => {
+            const start = this.#start();
+            const end = this.#end();
+            const midA = this.#midA();
+            const midB = this.#midB();
+            const segments = this.#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);
+        });
+        this.set({ segments: 10 });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsCubicBezierLine, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: NgtsCubicBezierLine, isStandalone: true, selector: "ngts-cubic-bezier-line", inputs: { lineRef: "lineRef", start: "start", end: "end", midA: "midA", midB: "midB", segments: "segments" }, usesInheritance: true, ngImport: i0, template: `
+        <ngts-line
+            [lineRef]="lineRef"
+            [points]="points()"
+            [color]="lineParameters().color"
+            [vertexColors]="lineParameters().vertexColors"
+            [resolution]="lineParameters().resolution"
+            [lineWidth]="lineParameters().linewidth"
+            [alphaToCoverage]="lineParameters().alphaToCoverage"
+            [dashed]="lineParameters().dashed"
+            [dashScale]="lineParameters().dashScale"
+            [dashSize]="lineParameters().dashSize"
+            [dashOffset]="lineParameters().dashOffset"
+            [gapSize]="lineParameters().gapSize"
+            [wireframe]="lineParameters().wireframe"
+            [worldUnits]="lineParameters().worldUnits"
+        />
+    `, isInline: true, dependencies: [{ kind: "component", type: NgtsLine, selector: "ngts-line", inputs: ["lineRef", "points", "segments"] }] }); }
+}
+export { NgtsCubicBezierLine };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsCubicBezierLine, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-cubic-bezier-line',
+                    standalone: true,
+                    template: `
+        <ngts-line
+            [lineRef]="lineRef"
+            [points]="points()"
+            [color]="lineParameters().color"
+            [vertexColors]="lineParameters().vertexColors"
+            [resolution]="lineParameters().resolution"
+            [lineWidth]="lineParameters().linewidth"
+            [alphaToCoverage]="lineParameters().alphaToCoverage"
+            [dashed]="lineParameters().dashed"
+            [dashScale]="lineParameters().dashScale"
+            [dashSize]="lineParameters().dashSize"
+            [dashOffset]="lineParameters().dashOffset"
+            [gapSize]="lineParameters().gapSize"
+            [wireframe]="lineParameters().wireframe"
+            [worldUnits]="lineParameters().worldUnits"
+        />
+    `,
+                    imports: [NgtsLine],
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { lineRef: [{
+                type: Input
+            }], start: [{
+                type: Input,
+                args: [{ required: true }]
+            }], end: [{
+                type: Input,
+                args: [{ required: true }]
+            }], midA: [{
+                type: Input,
+                args: [{ required: true }]
+            }], midB: [{
+                type: Input,
+                args: [{ required: true }]
+            }], segments: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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