angular-three-soba 2.0.0-beta.26 → 2.0.0-beta.261

package/cameras/lib/perspective-camera.d.ts

@@ -0,0 +1,36 @@
+import { ElementRef, TemplateRef } from '@angular/core';
+import { NgtPerspectiveCamera } from 'angular-three';
+import { Group, PerspectiveCamera, Texture } from 'three';
+import * as i0 from "@angular/core";
+export interface NgtsPerspectiveCameraOptions extends Partial<NgtPerspectiveCamera> {
+    /** Registers the camera as the system default, fiber will start rendering with it */
+    makeDefault?: boolean;
+    /** Making it manual will stop responsiveness and you have to calculate aspect ratio yourself. */
+    manual?: boolean;
+    /** Number of frames to render, Infinity */
+    frames: number;
+    /** Resolution of the FBO, 256 */
+    resolution: number;
+    /** Optional environment map for functional use */
+    envMap?: Texture;
+}
+export declare class NgtsPerspectiveCamera {
+    options: import("@angular/core").InputSignalWithTransform<NgtsPerspectiveCameraOptions, "" | Partial<NgtsPerspectiveCameraOptions>>;
+    parameters: import("@angular/core").Signal<Omit<NgtsPerspectiveCameraOptions, "resolution" | "envMap" | "frames" | "makeDefault" | "manual">>;
+    content: import("@angular/core").Signal<TemplateRef<any> | undefined>;
+    cameraContent: import("@angular/core").Signal<TemplateRef<any> | undefined>;
+    cameraRef: import("@angular/core").Signal<ElementRef<PerspectiveCamera>>;
+    groupRef: import("@angular/core").Signal<ElementRef<Group<import("three").Object3DEventMap>>>;
+    private autoEffect;
+    private store;
+    private camera;
+    private size;
+    private manual;
+    private makeDefault;
+    private resolution;
+    private fbo;
+    texture: import("@angular/core").Signal<Texture>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsPerspectiveCamera, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsPerspectiveCamera, "ngts-perspective-camera", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, ["content", "cameraContent"], never, true, never>;
+}

package/controls/README.md

@@ -1,3 +1,96 @@
-# angular-three-soba/controls
+# `angular-three-soba/controls`
 
-Secondary entry point of `angular-three-soba`. It can be used by importing from `angular-three-soba/controls`.
+This secondary entry point includes controls for manipulating the camera in your scene. It requires `camera-controls` as an additional dependency.
+
+| Package           | Description                      |
+| ----------------- | -------------------------------- |
+| `camera-controls` | required by `NgtsCameraControls` |
+
+```bash
+npm install camera-controls
+# yarn add camera-controls
+# pnpm add camera-controls
+```
+
+## TOC
+
+- [NgtsCameraControls](#ngtscameracontrols)
+- [NgtsOrbitControls](#ngtsorbitcontrols)
+
+## NgtsCameraControls
+
+A component that provides advanced camera controls based on the `camera-controls` library. It allows you to manipulate the camera's position, rotation, and other properties through various interactions.
+
+### Object Input (`NgtsCameraControlsOptions`)
+
+| Property    | Description                                                                                          | Default Value            |
+| ----------- | ---------------------------------------------------------------------------------------------------- | ------------------------ |
+| camera      | An instance of `NgtCamera` that the controls will manipulate.                                        | `NgtStore.camera`        |
+| domElement  | The HTML element that the controls will listen for events on.                                        | `NgtStore.gl.domElement` |
+| makeDefault | A boolean flag indicating whether these controls should be set as the default controls in the store. | `false`                  |
+| events      | A boolean flag indicating whether to enable or disable event listeners for the controls.             | `false`                  |
+| regress     | A boolean flag indicating whether to enable or disable performance regression for the controls.      | `false`                  |
+
+Other options are available in the `camera-controls` library. For more information, see the [official documentation](https://github.com/yomotsu/camera-controls?tab=readme-ov-file)
+
+### Usage
+
+```ts
+@Component({
+	standalone: true,
+	template: `
+		<ngt-mesh>
+			<ngt-box-geometry />
+			<ngt-mesh-basic-material color="red" [wireframe]="true" />
+		</ngt-mesh>
+
+		<ngt-grid-helper *args="[50, 50]" [position]="[0, -1, 0]" />
+
+		<ngts-camera-controls />
+	`,
+	imports: [NgtsCameraControls, NgtArgs],
+	schemas: [CUSTOM_ELEMENTS_SCHEMA],
+	changeDetection: ChangeDetectionStrategy.OnPush,
+})
+class DefaultCameraControlsStory {
+	rotate = input<keyof typeof rotations | 'none'>('none');
+
+	cameraControlsRef = viewChild.required(NgtsCameraControls);
+
+	constructor() {
+		effect(() => {
+			const [rotate, controls] = [this.rotate(), this.cameraControlsRef().controls()];
+			if (rotate !== 'none') {
+				const [theta, phi, animate] = rotations[rotate];
+				void controls.rotate(theta, phi, animate);
+			} else {
+				void controls.reset(true);
+			}
+		});
+	}
+}
+```
+
+## NgtsOrbitControls
+
+A component that provides orbit controls for rotating the camera around a target point. It is based on the OrbitControls class from the `three-stdlib` library.
+
+### Object Input (`NgtsOrbitControlsOptions`)
+
+| Property      | Description                                                                                          | Default Value            |
+| ------------- | ---------------------------------------------------------------------------------------------------- | ------------------------ |
+| camera        | An instance of `NgtCamera` that the controls will manipulate.                                        | `NgtStore.camera`        |
+| domElement    | The HTML element that the controls will listen for events on.                                        | `NgtStore.gl.domElement` |
+| target        | The coordinates that the camera will orbit around.                                                   | `[0, 0, 0]`              |
+| makeDefault   | A boolean flag indicating whether these controls should be set as the default controls in the store. | `false`                  |
+| regress       | A boolean flag indicating whether to enable or disable performance regression for the controls.      | `false`                  |
+| enableDamping | A boolean flag indicating whether to enable or disable damping (smoothness) of the camera movement.  | `true`                   |
+| keyEvents     | A boolean flag or an HTML element indicating whether to enable keyboard events for the controls.     | `false`                  |
+
+Other options can pass through to `OrbitControls`.
+
+### Usage
+
+```html
+<ngts-orbit-controls [options]="{ autoRotate: true }" />
+```

package/controls/index.d.ts

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

package/controls/lib/camera-controls.d.ts

@@ -0,0 +1,31 @@
+import { NgtCamera } from 'angular-three';
+import CameraControls from 'camera-controls';
+import * as i0 from "@angular/core";
+export interface NgtsCameraControlsOptions {
+    camera?: NgtCamera;
+    domElement?: HTMLElement;
+    makeDefault: boolean;
+    events: boolean;
+    regress: boolean;
+}
+export declare class NgtsCameraControls {
+    options: import("@angular/core").InputSignalWithTransform<Partial<CameraControls> & NgtsCameraControlsOptions, "" | Partial<Partial<CameraControls> & NgtsCameraControlsOptions>>;
+    parameters: import("@angular/core").Signal<Omit<Partial<CameraControls> & NgtsCameraControlsOptions, "camera" | "makeDefault" | "regress" | "domElement">>;
+    changed: import("@angular/core").OutputEmitterRef<any>;
+    started: import("@angular/core").OutputEmitterRef<any>;
+    ended: import("@angular/core").OutputEmitterRef<any>;
+    private store;
+    private invalidate;
+    private performanceRegress;
+    private defaultCamera;
+    private glDomElement;
+    private eventsElement;
+    private camera;
+    private regress;
+    private domElement;
+    private makeDefault;
+    controls: import("@angular/core").Signal<CameraControls>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsCameraControls, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsCameraControls, "ngts-camera-controls", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, { "changed": "changed"; "started": "started"; "ended": "ended"; }, never, ["*"], true, never>;
+}

package/controls/lib/orbit-controls.d.ts

@@ -0,0 +1,38 @@
+import { NgtVector3 } from 'angular-three';
+import { Camera, Event } from 'three';
+import { OrbitControls } from 'three-stdlib';
+import * as i0 from "@angular/core";
+export interface NgtsOrbitControlsOptions {
+    camera?: Camera;
+    domElement?: HTMLElement;
+    target?: NgtVector3;
+    makeDefault: boolean;
+    regress: boolean;
+    enableDamping: boolean;
+    keyEvents: boolean | HTMLElement;
+}
+export declare class NgtsOrbitControls {
+    options: import("@angular/core").InputSignalWithTransform<Partial<OrbitControls> & NgtsOrbitControlsOptions, "" | Partial<Partial<OrbitControls> & NgtsOrbitControlsOptions>>;
+    parameters: import("@angular/core").Signal<Omit<Partial<OrbitControls> & NgtsOrbitControlsOptions, "camera" | "makeDefault" | "regress" | "domElement" | "enableDamping" | "keyEvents">>;
+    changed: import("@angular/core").OutputEmitterRef<Event<string, unknown>>;
+    started: import("@angular/core").OutputEmitterRef<Event<string, unknown>>;
+    ended: import("@angular/core").OutputEmitterRef<Event<string, unknown>>;
+    private store;
+    private invalidate;
+    private performanceRegress;
+    private defaultCamera;
+    private glDomElement;
+    private camera;
+    private regress;
+    private keyEvents;
+    private domElement;
+    private makeDefault;
+    controls: import("@angular/core").Signal<OrbitControls>;
+    protected enableDamping: import("@angular/core").Signal<boolean>;
+    constructor();
+    private connectElement;
+    private makeControlsDefault;
+    private setEvents;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsOrbitControls, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsOrbitControls, "ngts-orbit-controls", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, { "changed": "changed"; "started": "started"; "ended": "ended"; }, never, ["*"], true, never>;
+}

package/esm2022/abstractions/index.mjs

@@ -1,7 +1,12 @@
-export * from './billboard/billboard';
-export * from './detailed/detailed';
-export * from './edges/edges';
-export * from './grid/grid';
-export * from './text-3d/text-3d';
-export * from './text/text';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL3NvYmEvYWJzdHJhY3Rpb25zL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLGFBQWEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYmlsbGJvYXJkL2JpbGxib2FyZCc7XG5leHBvcnQgKiBmcm9tICcuL2RldGFpbGVkL2RldGFpbGVkJztcbmV4cG9ydCAqIGZyb20gJy4vZWRnZXMvZWRnZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9ncmlkL2dyaWQnO1xuZXhwb3J0ICogZnJvbSAnLi90ZXh0LTNkL3RleHQtM2QnO1xuZXhwb3J0ICogZnJvbSAnLi90ZXh0L3RleHQnO1xuIl19
+export * from './lib/catmull-rom-line';
+export * from './lib/cubic-bezier-line';
+export * from './lib/edges';
+export * from './lib/gradient-texture';
+export * from './lib/grid';
+export * from './lib/helper';
+export * from './lib/line';
+export * from './lib/prism-geometry';
+export * from './lib/quadratic-bezier-line';
+export * from './lib/text';
+export * from './lib/text-3d';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL3NvYmEvYWJzdHJhY3Rpb25zL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYyxlQUFlLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2xpYi9jYXRtdWxsLXJvbS1saW5lJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2N1YmljLWJlemllci1saW5lJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2VkZ2VzJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2dyYWRpZW50LXRleHR1cmUnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvZ3JpZCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9oZWxwZXInO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvbGluZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9wcmlzbS1nZW9tZXRyeSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9xdWFkcmF0aWMtYmV6aWVyLWxpbmUnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvdGV4dCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi90ZXh0LTNkJztcbiJdfQ==

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

@@ -0,0 +1,76 @@
+import { ChangeDetectionStrategy, Component, computed, input, untracked, viewChild } from '@angular/core';
+import { omit, pick } from 'angular-three';
+import { mergeInputs } from 'ngxtension/inject-inputs';
+import { CatmullRomCurve3, Color, Vector3 } from 'three';
+import { NgtsLine } from './line';
+import * as i0 from "@angular/core";
+const defaultOptions = {
+    curveType: 'centripetal',
+    tension: 0.5,
+    segments: 20,
+    closed: false,
+    lineWidth: 1,
+};
+export class NgtsCatmullRomLine {
+    constructor() {
+        this.points = input.required();
+        this.options = input(defaultOptions, { transform: mergeInputs(defaultOptions) });
+        this.parameters = omit(this.options, ['curveType', 'tension', 'segments', 'closed', 'vertexColors']);
+        this.line = viewChild.required(NgtsLine);
+        this.closed = pick(this.options, 'closed');
+        this.curveType = pick(this.options, 'curveType');
+        this.tension = pick(this.options, 'tension');
+        this.segments = pick(this.options, 'segments');
+        this.vertexColors = pick(this.options, 'vertexColors');
+        this.curve = computed(() => {
+            const [points, closed, curveType, tension] = [this.points(), this.closed(), this.curveType(), this.tension()];
+            const mappedPoints = points.map((pt) => pt instanceof Vector3 ? pt : new Vector3(...pt));
+            return new CatmullRomCurve3(mappedPoints, closed, curveType, tension);
+        });
+        this.segmentedPoints = computed(() => {
+            const [curve, segments] = [this.curve(), this.segments()];
+            return curve.getPoints(segments);
+        });
+        this.interpolatedVertexColors = computed(() => {
+            const [vertexColors, segments] = [this.vertexColors(), this.segments()];
+            if (!vertexColors || vertexColors.length < 2)
+                return undefined;
+            if (vertexColors.length === segments + 1)
+                return vertexColors;
+            const mappedColors = vertexColors.map((color) => color instanceof Color ? color : new Color(...color));
+            if (untracked(this.closed))
+                mappedColors.push(mappedColors[0].clone());
+            const iColors = [mappedColors[0]];
+            const divisions = segments / (mappedColors.length - 1);
+            for (let i = 1; 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.lineOptions = computed(() => ({ ...this.parameters(), vertexColors: this.interpolatedVertexColors() }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: NgtsCatmullRomLine, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "18.1.0", type: NgtsCatmullRomLine, isStandalone: true, selector: "ngts-catmull-rom-line", inputs: { points: { classPropertyName: "points", publicName: "points", isSignal: true, isRequired: true, transformFunction: null }, options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, viewQueries: [{ propertyName: "line", first: true, predicate: NgtsLine, descendants: true, isSignal: true }], ngImport: i0, template: `
+		<ngts-line [points]="segmentedPoints()" [options]="lineOptions()">
+			<ng-content />
+		</ngts-line>
+	`, isInline: true, dependencies: [{ kind: "component", type: NgtsLine, selector: "ngts-line", inputs: ["points", "options"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: NgtsCatmullRomLine, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-catmull-rom-line',
+                    standalone: true,
+                    template: `
+		<ngts-line [points]="segmentedPoints()" [options]="lineOptions()">
+			<ng-content />
+		</ngts-line>
+	`,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [NgtsLine],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"catmull-rom-line.js","sourceRoot":"","sources":["../../../../../../libs/soba/abstractions/src/lib/catmull-rom-line.ts"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, Component, computed, input, untracked, viewChild } from '@angular/core';\nimport { omit, pick } from 'angular-three';\nimport { mergeInputs } from 'ngxtension/inject-inputs';\nimport { CatmullRomCurve3, Color, Vector3 } from 'three';\nimport { NgtsLine, NgtsLineOptions } from './line';\n\nexport interface NgtsCatmullRomLineOptions extends Omit<NgtsLineOptions, 'segments'> {\n\tcurveType: 'centripetal' | 'chordal' | 'catmullrom';\n\ttension: number;\n\tsegments: number;\n\tclosed: boolean;\n}\n\nconst defaultOptions: NgtsCatmullRomLineOptions = {\n\tcurveType: 'centripetal',\n\ttension: 0.5,\n\tsegments: 20,\n\tclosed: false,\n\tlineWidth: 1,\n};\n\n@Component({\n\tselector: 'ngts-catmull-rom-line',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngts-line [points]=\"segmentedPoints()\" [options]=\"lineOptions()\">\n\t\t\t<ng-content />\n\t\t</ngts-line>\n\t`,\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n\timports: [NgtsLine],\n})\nexport class NgtsCatmullRomLine {\n\tpoints = input.required<Array<Vector3 | [number, number, number]>>();\n\toptions = input(defaultOptions, { transform: mergeInputs(defaultOptions) });\n\tparameters = omit(this.options, ['curveType', 'tension', 'segments', 'closed', 'vertexColors']);\n\n\tline = viewChild.required(NgtsLine);\n\n\tprivate closed = pick(this.options, 'closed');\n\tprivate curveType = pick(this.options, 'curveType');\n\tprivate tension = pick(this.options, 'tension');\n\tprivate segments = pick(this.options, 'segments');\n\tprivate vertexColors = pick(this.options, 'vertexColors');\n\n\tprivate curve = computed(() => {\n\t\tconst [points, closed, curveType, tension] = [this.points(), this.closed(), this.curveType(), this.tension()];\n\n\t\tconst mappedPoints = points.map((pt) =>\n\t\t\tpt instanceof Vector3 ? pt : new Vector3(...(pt as [number, number, number])),\n\t\t);\n\n\t\treturn new CatmullRomCurve3(mappedPoints, closed, curveType, tension);\n\t});\n\n\tsegmentedPoints = computed(() => {\n\t\tconst [curve, segments] = [this.curve(), this.segments()];\n\t\treturn curve.getPoints(segments);\n\t});\n\n\tprivate interpolatedVertexColors = computed(() => {\n\t\tconst [vertexColors, segments] = [this.vertexColors(), this.segments()];\n\t\tif (!vertexColors || vertexColors.length < 2) return undefined;\n\n\t\tif (vertexColors.length === segments + 1) return vertexColors;\n\n\t\tconst mappedColors = vertexColors.map((color) =>\n\t\t\tcolor instanceof Color ? color : new Color(...(color as [number, number, number])),\n\t\t);\n\t\tif (untracked(this.closed)) mappedColors.push(mappedColors[0].clone());\n\n\t\tconst iColors: Color[] = [mappedColors[0]];\n\t\tconst divisions = segments / (mappedColors.length - 1);\n\t\tfor (let i = 1; i < segments; i++) {\n\t\t\tconst alpha = (i % divisions) / divisions;\n\t\t\tconst colorIndex = Math.floor(i / divisions);\n\t\t\tiColors.push(mappedColors[colorIndex].clone().lerp(mappedColors[colorIndex + 1], alpha));\n\t\t}\n\t\tiColors.push(mappedColors[mappedColors.length - 1]);\n\n\t\treturn iColors;\n\t});\n\n\tlineOptions = computed(() => ({ ...this.parameters(), vertexColors: this.interpolatedVertexColors() }));\n}\n"]}

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

@@ -0,0 +1,51 @@
+import { ChangeDetectionStrategy, Component, computed, input, viewChild } from '@angular/core';
+import { omit, pick } from 'angular-three';
+import { mergeInputs } from 'ngxtension/inject-inputs';
+import { CubicBezierCurve3, Vector3 } from 'three';
+import { NgtsLine } from './line';
+import * as i0 from "@angular/core";
+const defaultOptions = {
+    lineWidth: 1,
+    segments: 20,
+};
+export class NgtsCubicBezierLine {
+    constructor() {
+        this.start = input.required();
+        this.end = input.required();
+        this.midA = input.required();
+        this.midB = input.required();
+        this.options = input(defaultOptions, { transform: mergeInputs(defaultOptions) });
+        this.parameters = omit(this.options, ['segments']);
+        this.line = viewChild.required(NgtsLine);
+        this.segments = pick(this.options, 'segments');
+        this.points = computed(() => {
+            const [start, end, midA, midB, segments] = [this.start(), this.end(), this.midA(), this.midB(), this.segments()];
+            const startV = start instanceof Vector3 ? start : new Vector3(...start);
+            const endV = end instanceof Vector3 ? end : new Vector3(...end);
+            const midAV = midA instanceof Vector3 ? midA : new Vector3(...midA);
+            const midBV = midB instanceof Vector3 ? midB : new Vector3(...midB);
+            return new CubicBezierCurve3(startV, midAV, midBV, endV).getPoints(segments);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: NgtsCubicBezierLine, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "18.1.0", type: NgtsCubicBezierLine, isStandalone: true, selector: "ngts-cubic-bezier-line", inputs: { start: { classPropertyName: "start", publicName: "start", isSignal: true, isRequired: true, transformFunction: null }, end: { classPropertyName: "end", publicName: "end", isSignal: true, isRequired: true, transformFunction: null }, midA: { classPropertyName: "midA", publicName: "midA", isSignal: true, isRequired: true, transformFunction: null }, midB: { classPropertyName: "midB", publicName: "midB", isSignal: true, isRequired: true, transformFunction: null }, options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, viewQueries: [{ propertyName: "line", first: true, predicate: NgtsLine, descendants: true, isSignal: true }], ngImport: i0, template: `
+		<ngts-line [points]="points()" [options]="parameters()">
+			<ng-content />
+		</ngts-line>
+	`, isInline: true, dependencies: [{ kind: "component", type: NgtsLine, selector: "ngts-line", inputs: ["points", "options"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: NgtsCubicBezierLine, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-cubic-bezier-line',
+                    standalone: true,
+                    template: `
+		<ngts-line [points]="points()" [options]="parameters()">
+			<ng-content />
+		</ngts-line>
+	`,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [NgtsLine],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/abstractions/lib/edges.mjs

@@ -0,0 +1,70 @@
+import { afterNextRender, ChangeDetectionStrategy, Component, computed, input, viewChild } from '@angular/core';
+import { checkNeedsUpdate, getLocalState, omit } from 'angular-three';
+import { injectAutoEffect } from 'ngxtension/auto-effect';
+import { mergeInputs } from 'ngxtension/inject-inputs';
+import { EdgesGeometry } from 'three';
+import { NgtsLine } from './line';
+import * as i0 from "@angular/core";
+const defaultOptions = {
+    lineWidth: 1,
+    threshold: 15,
+};
+export class NgtsEdges {
+    constructor() {
+        this.options = input(defaultOptions, { transform: mergeInputs(defaultOptions) });
+        this.parameters = omit(this.options, ['threshold', 'geometry']);
+        this.lineOptions = computed(() => ({ ...this.parameters(), raycast: () => null }));
+        this.tmpPoints = [0, 0, 0, 1, 0, 0];
+        this.line = viewChild.required(NgtsLine);
+        const autoEffect = injectAutoEffect();
+        afterNextRender(() => {
+            autoEffect(() => {
+                const line = this.line().line()?.nativeElement;
+                if (!line)
+                    return;
+                const lS = getLocalState(line);
+                if (!lS)
+                    return;
+                const parent = lS.parent();
+                if (!parent)
+                    return;
+                const { geometry: explicitGeometry, threshold } = this.options();
+                const geometry = explicitGeometry ?? parent.geometry;
+                if (!geometry)
+                    return;
+                const cached = this.memoizedGeometry === geometry && this.memoizedThreshold === threshold;
+                if (cached)
+                    return;
+                this.memoizedGeometry = geometry;
+                this.memoizedThreshold = threshold;
+                const points = new EdgesGeometry(geometry, threshold).attributes['position']
+                    .array;
+                line.geometry.setPositions(points);
+                checkNeedsUpdate(line.geometry.attributes['instanceStart']);
+                checkNeedsUpdate(line.geometry.attributes['instanceEnd']);
+                line.computeLineDistances();
+            });
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: NgtsEdges, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "18.1.0", type: NgtsEdges, isStandalone: true, selector: "ngts-edges", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, viewQueries: [{ propertyName: "line", first: true, predicate: NgtsLine, descendants: true, isSignal: true }], ngImport: i0, template: `
+		<ngts-line [points]="tmpPoints" [options]="lineOptions()">
+			<ng-content />
+		</ngts-line>
+	`, isInline: true, dependencies: [{ kind: "component", type: NgtsLine, selector: "ngts-line", inputs: ["points", "options"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: NgtsEdges, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-edges',
+                    standalone: true,
+                    template: `
+		<ngts-line [points]="tmpPoints" [options]="lineOptions()">
+			<ng-content />
+		</ngts-line>
+	`,
+                    imports: [NgtsLine],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/abstractions/lib/gradient-texture.mjs

@@ -0,0 +1,91 @@
+import { DOCUMENT } from '@angular/common';
+import { ChangeDetectionStrategy, Component, computed, CUSTOM_ELEMENTS_SCHEMA, inject, input, untracked, } from '@angular/core';
+import { extend, injectStore, NgtArgs, omit } from 'angular-three';
+import { mergeInputs } from 'ngxtension/inject-inputs';
+import { CanvasTexture, Color } from 'three';
+import * as i0 from "@angular/core";
+const defaultOptions = {
+    size: 1024,
+    width: 16,
+    type: 'linear',
+    innerCircleRadius: 0,
+    outerCircleRadius: 'auto',
+};
+export class NgtsGradientTexture {
+    constructor() {
+        this.attach = input('map');
+        this.stops = input.required();
+        this.colors = input.required();
+        this.options = input(defaultOptions, { transform: mergeInputs(defaultOptions) });
+        this.parameters = omit(this.options, ['size', 'width', 'type', 'innerCircleRadius', 'outerCircleRadius']);
+        this.store = injectStore();
+        this.gl = this.store.select('gl');
+        this.document = inject(DOCUMENT);
+        this.canvas = computed(() => {
+            const canvas = this.document.createElement('canvas');
+            const context = canvas.getContext('2d');
+            const [{ width, size, type, outerCircleRadius, innerCircleRadius }, stops, colors] = [
+                untracked(this.options),
+                this.stops(),
+                this.colors(),
+            ];
+            canvas.width = width;
+            canvas.height = size;
+            let gradient;
+            if (type === 'linear') {
+                gradient = context.createLinearGradient(0, 0, 0, size);
+            }
+            else {
+                const canvasCenterX = canvas.width / 2;
+                const canvasCenterY = canvas.height / 2;
+                const radius = outerCircleRadius !== 'auto'
+                    ? Math.abs(Number(outerCircleRadius))
+                    : Math.sqrt(canvasCenterX ** 2 + canvasCenterY ** 2);
+                gradient = context.createRadialGradient(canvasCenterX, canvasCenterY, Math.abs(innerCircleRadius), canvasCenterX, canvasCenterY, radius);
+            }
+            const tempColor = new Color(); // reuse instance for performance
+            let i = stops.length;
+            while (i--) {
+                gradient.addColorStop(stops[i], tempColor.set(colors[i]).getStyle());
+            }
+            context.save();
+            context.fillStyle = gradient;
+            context.fillRect(0, 0, width, size);
+            context.restore();
+            return canvas;
+        });
+        extend({ CanvasTexture });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: NgtsGradientTexture, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.1.0", type: NgtsGradientTexture, isStandalone: true, selector: "ngts-gradient-texture", inputs: { attach: { classPropertyName: "attach", publicName: "attach", isSignal: true, isRequired: false, transformFunction: null }, stops: { classPropertyName: "stops", publicName: "stops", isSignal: true, isRequired: true, transformFunction: null }, colors: { classPropertyName: "colors", publicName: "colors", isSignal: true, isRequired: true, transformFunction: null }, options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: `
+		<ngt-canvas-texture
+			*args="[canvas()]"
+			[attach]="attach()"
+			[colorSpace]="gl().outputColorSpace"
+			[parameters]="parameters()"
+		>
+			<ng-content />
+		</ngt-canvas-texture>
+	`, isInline: true, dependencies: [{ kind: "directive", type: NgtArgs, selector: "ng-template[args]", inputs: ["args"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: NgtsGradientTexture, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-gradient-texture',
+                    standalone: true,
+                    template: `
+		<ngt-canvas-texture
+			*args="[canvas()]"
+			[attach]="attach()"
+			[colorSpace]="gl().outputColorSpace"
+			[parameters]="parameters()"
+		>
+			<ng-content />
+		</ngt-canvas-texture>
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [NgtArgs],
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gradient-texture.js","sourceRoot":"","sources":["../../../../../../libs/soba/abstractions/src/lib/gradient-texture.ts"],"names":[],"mappings":"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","sourcesContent":["import { DOCUMENT } from '@angular/common';\nimport {\n\tChangeDetectionStrategy,\n\tComponent,\n\tcomputed,\n\tCUSTOM_ELEMENTS_SCHEMA,\n\tinject,\n\tinput,\n\tuntracked,\n} from '@angular/core';\nimport { extend, injectStore, NgtArgs, NgtTexture, omit } from 'angular-three';\nimport { mergeInputs } from 'ngxtension/inject-inputs';\nimport { CanvasTexture, Color, ColorRepresentation } from 'three';\n\nexport interface NgtsGradientTextureOptions extends Partial<Omit<NgtTexture, 'type'>> {\n\tsize: number;\n\twidth: number;\n\ttype: 'linear' | 'radial';\n\tinnerCircleRadius: number;\n\touterCircleRadius: string | number;\n}\n\nconst defaultOptions: NgtsGradientTextureOptions = {\n\tsize: 1024,\n\twidth: 16,\n\ttype: 'linear',\n\tinnerCircleRadius: 0,\n\touterCircleRadius: 'auto',\n};\n\n@Component({\n\tselector: 'ngts-gradient-texture',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-canvas-texture\n\t\t\t*args=\"[canvas()]\"\n\t\t\t[attach]=\"attach()\"\n\t\t\t[colorSpace]=\"gl().outputColorSpace\"\n\t\t\t[parameters]=\"parameters()\"\n\t\t>\n\t\t\t<ng-content />\n\t\t</ngt-canvas-texture>\n\t`,\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n\timports: [NgtArgs],\n})\nexport class NgtsGradientTexture {\n\tattach = input('map');\n\tstops = input.required<Array<number>>();\n\tcolors = input.required<Array<ColorRepresentation>>();\n\toptions = input(defaultOptions, { transform: mergeInputs(defaultOptions) });\n\tparameters = omit(this.options, ['size', 'width', 'type', 'innerCircleRadius', 'outerCircleRadius']);\n\n\tprivate store = injectStore();\n\tgl = this.store.select('gl');\n\tprivate document = inject(DOCUMENT);\n\n\tcanvas = computed(() => {\n\t\tconst canvas = this.document.createElement('canvas');\n\t\tconst context = canvas.getContext('2d')!;\n\t\tconst [{ width, size, type, outerCircleRadius, innerCircleRadius }, stops, colors] = [\n\t\t\tuntracked(this.options),\n\t\t\tthis.stops(),\n\t\t\tthis.colors(),\n\t\t];\n\t\tcanvas.width = width;\n\t\tcanvas.height = size;\n\n\t\tlet gradient: CanvasGradient;\n\n\t\tif (type === 'linear') {\n\t\t\tgradient = context.createLinearGradient(0, 0, 0, size);\n\t\t} else {\n\t\t\tconst canvasCenterX = canvas.width / 2;\n\t\t\tconst canvasCenterY = canvas.height / 2;\n\t\t\tconst radius =\n\t\t\t\touterCircleRadius !== 'auto'\n\t\t\t\t\t? Math.abs(Number(outerCircleRadius))\n\t\t\t\t\t: Math.sqrt(canvasCenterX ** 2 + canvasCenterY ** 2);\n\t\t\tgradient = context.createRadialGradient(\n\t\t\t\tcanvasCenterX,\n\t\t\t\tcanvasCenterY,\n\t\t\t\tMath.abs(innerCircleRadius),\n\t\t\t\tcanvasCenterX,\n\t\t\t\tcanvasCenterY,\n\t\t\t\tradius,\n\t\t\t);\n\t\t}\n\n\t\tconst tempColor = new Color(); // reuse instance for performance\n\n\t\tlet i = stops.length;\n\t\twhile (i--) {\n\t\t\tgradient.addColorStop(stops[i], tempColor.set(colors[i]).getStyle());\n\t\t}\n\n\t\tcontext.save();\n\t\tcontext.fillStyle = gradient;\n\t\tcontext.fillRect(0, 0, width, size);\n\t\tcontext.restore();\n\n\t\treturn canvas;\n\t});\n\n\tconstructor() {\n\t\textend({ CanvasTexture });\n\t}\n}\n"]}