angular-three-soba 2.0.0-beta.8 → 2.0.0

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,97 @@
-# 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` |
+| `maath`           | required by `NgtsScrollControls` |
+
+```bash
+npm install camera-controls maath
+# yarn add camera-controls maath
+# pnpm add camera-controls maath
+```
+
+## 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,4 @@
-export * from './orbit-controls/orbit-controls';
+export * from './lib/camera-controls';
+export * from './lib/orbit-controls';
+export * from './lib/pivot-controls/pivot-controls';
+export * from './lib/scroll-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/controls/lib/pivot-controls/axis-arrow.d.ts

@@ -0,0 +1,31 @@
+import { ElementRef, Signal } from '@angular/core';
+import { NgtThreeEvent } from 'angular-three';
+import { Group, Matrix4, Vector3 } from 'three';
+import { NgtsPivotControls } from './pivot-controls';
+import * as i0 from "@angular/core";
+export declare function calculateOffset(clickPoint: Vector3, normal: Vector3, rayStart: Vector3, rayDir: Vector3): number;
+export declare class NgtsAxisArrow {
+    protected readonly DoubleSide: 2;
+    direction: import("@angular/core").InputSignal<Vector3>;
+    axis: import("@angular/core").InputSignal<0 | 2 | 1>;
+    groupRef: Signal<ElementRef<Group<import("three").Object3DEventMap>>>;
+    annotationRef: Signal<ElementRef<HTMLDivElement> | undefined>;
+    pivotControls: NgtsPivotControls;
+    private store;
+    private controls;
+    private hovered;
+    private clickInfo;
+    private offset0;
+    color: Signal<string | number>;
+    coneWidth: Signal<number>;
+    coneLength: Signal<number>;
+    cylinderLength: Signal<number>;
+    matrixL: Signal<Matrix4>;
+    constructor();
+    onPointerDown(event: NgtThreeEvent<PointerEvent>): void;
+    onPointerUp(event: NgtThreeEvent<PointerEvent>): void;
+    onPointerMove(event: NgtThreeEvent<PointerEvent>): void;
+    onPointerOut(event: NgtThreeEvent<PointerEvent>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsAxisArrow, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsAxisArrow, "ngts-axis-arrow", never, { "direction": { "alias": "direction"; "required": true; "isSignal": true; }; "axis": { "alias": "axis"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/controls/lib/pivot-controls/axis-rotator.d.ts

@@ -0,0 +1,30 @@
+import { ElementRef, Signal } from '@angular/core';
+import { NgtThreeEvent } from 'angular-three';
+import { Group, Matrix4, Vector3 } from 'three';
+import { NgtsPivotControls } from './pivot-controls';
+import * as i0 from "@angular/core";
+export declare class NgtsAxisRotator {
+    protected readonly DoubleSide: 2;
+    dir1: import("@angular/core").InputSignal<Vector3>;
+    dir2: import("@angular/core").InputSignal<Vector3>;
+    axis: import("@angular/core").InputSignal<0 | 2 | 1>;
+    groupRef: Signal<ElementRef<Group<import("three").Object3DEventMap>>>;
+    annotationRef: Signal<ElementRef<HTMLDivElement> | undefined>;
+    pivotControls: NgtsPivotControls;
+    private store;
+    private controls;
+    hovered: import("@angular/core").WritableSignal<boolean>;
+    private angle;
+    private angle0;
+    private clickInfo;
+    matrixL: Signal<Matrix4>;
+    r: Signal<number>;
+    arc: Signal<Vector3[]>;
+    constructor();
+    onPointerDown(event: NgtThreeEvent<PointerEvent>): void;
+    onPointerMove(event: NgtThreeEvent<PointerEvent>): void;
+    onPointerUp(event: NgtThreeEvent<PointerEvent>): void;
+    onPointerOut(event: NgtThreeEvent<PointerEvent>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsAxisRotator, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsAxisRotator, "ngts-axis-rotator", never, { "dir1": { "alias": "dir1"; "required": true; "isSignal": true; }; "dir2": { "alias": "dir2"; "required": true; "isSignal": true; }; "axis": { "alias": "axis"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,110 @@
+import { ElementRef } from '@angular/core';
+import { NgtAnyRecord } from 'angular-three';
+import { Group, Matrix4, Vector3 } from 'three';
+import * as i0 from "@angular/core";
+export interface OnDragStartParameters {
+    component: 'Arrow' | 'Slider' | 'Rotator' | 'Sphere';
+    axis: 0 | 1 | 2;
+    origin: Vector3;
+    directions: Vector3[];
+}
+export interface OnDragParameters {
+    l: Matrix4;
+    deltaL: Matrix4;
+    w: Matrix4;
+    deltaW: Matrix4;
+}
+export interface NgtsPivotControlsOptions {
+    /** Enables/disables the control, true */
+    enabled: boolean;
+    /** Scale of the gizmo, 1 */
+    scale: number;
+    /** Width of the gizmo lines, this is a THREE.Line2 prop, 2.5 */
+    lineWidth: number;
+    /** If fixed is true is remains constant in size, scale is now in pixels, false */
+    fixed: boolean;
+    /** Pivot does not act as a group, it won't shift contents but can offset in position */
+    offset: [number, number, number];
+    /** Starting rotation */
+    rotation: [number, number, number];
+    /** Starting matrix */
+    matrix?: Matrix4;
+    /** BBAnchor, each axis can be between -1/0/+1 */
+    anchor?: [number, number, number];
+    /** If autoTransform is true, automatically apply the local transform on drag, true */
+    autoTransform: boolean;
+    /** Allows you to switch individual axes off */
+    activeAxes: [boolean, boolean, boolean];
+    /** Allows you to switch individual transformations off */
+    disableAxes: boolean;
+    disableSliders: boolean;
+    disableRotations: boolean;
+    disableScaling: boolean;
+    /** Limits */
+    translationLimits?: [[number, number] | undefined, [number, number] | undefined, [number, number] | undefined];
+    rotationLimits?: [[number, number] | undefined, [number, number] | undefined, [number, number] | undefined];
+    scaleLimits?: [[number, number] | undefined, [number, number] | undefined, [number, number] | undefined];
+    /** RGB colors */
+    axisColors: [string | number, string | number, string | number];
+    /** Color of the hovered item */
+    hoveredColor: string | number;
+    /** HTML value annotations, default: false */
+    annotations: boolean;
+    /** CSS Classname applied to the HTML annotations */
+    annotationsClass?: string;
+    /** Set this to false if you want the gizmo to be visible through faces */
+    depthTest: boolean;
+    opacity?: number;
+    visible: boolean;
+    userData?: NgtAnyRecord;
+}
+export declare class NgtsPivotControls {
+    options: import("@angular/core").InputSignalWithTransform<NgtsPivotControlsOptions, "" | Partial<NgtsPivotControlsOptions>>;
+    parameters: import("@angular/core").Signal<Omit<NgtsPivotControlsOptions, "enabled" | "hoveredColor" | "scale" | "lineWidth" | "fixed" | "offset" | "rotation" | "matrix" | "anchor" | "autoTransform" | "activeAxes" | "disableAxes" | "disableSliders" | "disableRotations" | "disableScaling" | "translationLimits" | "rotationLimits" | "scaleLimits" | "axisColors" | "annotations" | "annotationsClass" | "depthTest" | "opacity" | "visible" | "userData">>;
+    dragStarted: import("@angular/core").OutputEmitterRef<OnDragStartParameters>;
+    dragEnded: import("@angular/core").OutputEmitterRef<void>;
+    dragged: import("@angular/core").OutputEmitterRef<OnDragParameters>;
+    matrix: import("@angular/core").Signal<Matrix4 | undefined>;
+    annotations: import("@angular/core").Signal<boolean>;
+    annotationsClass: import("@angular/core").Signal<string | undefined>;
+    translationLimits: import("@angular/core").Signal<[[number, number] | undefined, [number, number] | undefined, [number, number] | undefined] | undefined>;
+    rotationLimits: import("@angular/core").Signal<[[number, number] | undefined, [number, number] | undefined, [number, number] | undefined] | undefined>;
+    scaleLimits: import("@angular/core").Signal<[[number, number] | undefined, [number, number] | undefined, [number, number] | undefined] | undefined>;
+    autoTransform: import("@angular/core").Signal<boolean>;
+    fixed: import("@angular/core").Signal<boolean>;
+    hoveredColor: import("@angular/core").Signal<string | number>;
+    axisColors: import("@angular/core").Signal<[string | number, string | number, string | number]>;
+    lineWidth: import("@angular/core").Signal<number>;
+    scale: import("@angular/core").Signal<number>;
+    userData: import("@angular/core").Signal<NgtAnyRecord | undefined>;
+    opacity: import("@angular/core").Signal<number | undefined>;
+    depthTest: import("@angular/core").Signal<boolean>;
+    offset: import("@angular/core").Signal<[number, number, number]>;
+    rotation: import("@angular/core").Signal<[number, number, number]>;
+    visible: import("@angular/core").Signal<boolean>;
+    enabled: import("@angular/core").Signal<boolean>;
+    disableAxes: import("@angular/core").Signal<boolean>;
+    disableSliders: import("@angular/core").Signal<boolean>;
+    disableRotations: import("@angular/core").Signal<boolean>;
+    disableScaling: import("@angular/core").Signal<boolean>;
+    activeAxes: import("@angular/core").Signal<[boolean, boolean, boolean]>;
+    xDir: Vector3;
+    yDir: Vector3;
+    zDir: Vector3;
+    parentRef: import("@angular/core").Signal<ElementRef<Group<import("three").Object3DEventMap>>>;
+    groupRef: import("@angular/core").Signal<ElementRef<Group<import("three").Object3DEventMap>>>;
+    gizmoRef: import("@angular/core").Signal<ElementRef<Group<import("three").Object3DEventMap>>>;
+    childrenRef: import("@angular/core").Signal<ElementRef<Group<import("three").Object3DEventMap>>>;
+    private store;
+    private invalidate;
+    translation: [number, number, number];
+    private anchor;
+    private cameraScale;
+    private gizmoScale;
+    constructor();
+    onDragStart(parameters: OnDragStartParameters): void;
+    onDrag(mdW: Matrix4): void;
+    onDragEnd(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsPivotControls, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsPivotControls, "ngts-pivot-controls", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, { "dragStarted": "dragStarted"; "dragEnded": "dragEnded"; "dragged": "dragged"; }, never, ["*"], true, never>;
+}

package/controls/lib/pivot-controls/plane-slider.d.ts

@@ -0,0 +1,32 @@
+import { ElementRef, Signal } from '@angular/core';
+import { NgtThreeEvent } from 'angular-three';
+import { Group, Matrix4, Vector3 } from 'three';
+import { NgtsPivotControls } from './pivot-controls';
+import * as i0 from "@angular/core";
+export declare class NgtsPlaneSlider {
+    protected readonly DoubleSide: 2;
+    dir1: import("@angular/core").InputSignal<Vector3>;
+    dir2: import("@angular/core").InputSignal<Vector3>;
+    axis: import("@angular/core").InputSignal<0 | 2 | 1>;
+    groupRef: Signal<ElementRef<Group<import("three").Object3DEventMap>>>;
+    annotationRef: Signal<ElementRef<HTMLDivElement> | undefined>;
+    pivotControls: NgtsPivotControls;
+    private store;
+    private controls;
+    private hovered;
+    private clickInfo;
+    private offsetX0;
+    private offsetY0;
+    matrixL: Signal<Matrix4>;
+    pos1: Signal<number>;
+    length: Signal<number>;
+    color: Signal<string | number>;
+    points: Signal<Vector3[]>;
+    constructor();
+    onPointerDown(event: NgtThreeEvent<PointerEvent>): void;
+    onPointerMove(event: NgtThreeEvent<PointerEvent>): void;
+    onPointerUp(event: NgtThreeEvent<PointerEvent>): void;
+    onPointerOut(event: NgtThreeEvent<PointerEvent>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsPlaneSlider, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsPlaneSlider, "ngts-plane-slider", never, { "dir1": { "alias": "dir1"; "required": true; "isSignal": true; }; "dir2": { "alias": "dir2"; "required": true; "isSignal": true; }; "axis": { "alias": "axis"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/controls/lib/pivot-controls/scaling-sphere.d.ts

@@ -0,0 +1,32 @@
+import { ElementRef, Signal } from '@angular/core';
+import { NgtThreeEvent } from 'angular-three';
+import { Group, Matrix4, Mesh, Vector3 } from 'three';
+import { NgtsPivotControls } from './pivot-controls';
+import * as i0 from "@angular/core";
+export declare function calculateOffset(clickPoint: Vector3, normal: Vector3, rayStart: Vector3, rayDir: Vector3): number;
+export declare class NgtsScalingSphere {
+    direction: import("@angular/core").InputSignal<Vector3>;
+    axis: import("@angular/core").InputSignal<0 | 2 | 1>;
+    groupRef: Signal<ElementRef<Group<import("three").Object3DEventMap>>>;
+    annotationRef: Signal<ElementRef<HTMLDivElement> | undefined>;
+    meshRef: Signal<ElementRef<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>>;
+    pivotControls: NgtsPivotControls;
+    private store;
+    private controls;
+    private size;
+    private hovered;
+    private scale0;
+    private scaleCurrent;
+    private clickInfo;
+    position: Signal<number>;
+    radius: Signal<number>;
+    matrixL: Signal<Matrix4>;
+    color: Signal<string | number>;
+    constructor();
+    onPointerDown(event: NgtThreeEvent<PointerEvent>): void;
+    onPointerMove(event: NgtThreeEvent<PointerEvent>): void;
+    onPointerUp(event: NgtThreeEvent<PointerEvent>): void;
+    onPointerOut(event: NgtThreeEvent<PointerEvent>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsScalingSphere, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsScalingSphere, "ngts-scaling-sphere", never, { "direction": { "alias": "direction"; "required": true; "isSignal": true; }; "axis": { "alias": "axis"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,78 @@
+import { NgtHTML } from 'angular-three';
+import * as i0 from "@angular/core";
+export interface NgtsScrollControlsOptions {
+    /** Precision, default 0.00001 */
+    eps: number;
+    /** Horizontal scroll, default false (vertical) */
+    horizontal: boolean;
+    /** Infinite scroll, default false (experimental!) */
+    infinite: boolean;
+    /** Defines the lenght of the scroll area, each page is height:100%, default 1 */
+    pages: number;
+    /** A factor that increases scroll bar travel,default: 1 */
+    distance: number;
+    /** Friction in seconds, default: 0.25 (1/4 second) */
+    damping: number;
+    /** maxSpeed optionally allows you to clamp the maximum speed. If damping is 0.2s and looks OK
+     *  going between, say, page 1 and 2, but not for pages far apart as it'll move very rapid,
+     *  then a maxSpeed of e.g. 3 which will clamp the speed to 3 units per second, it may now
+     *  take much longer than damping to reach the target if it is far away. Default: Infinity */
+    maxSpeed: number;
+    /** If true attaches the scroll container before the canvas */
+    prepend: boolean;
+    enabled: boolean;
+    style: Partial<CSSStyleDeclaration>;
+}
+export declare class NgtsScrollControls {
+    progress: import("@angular/core").ModelSignal<number>;
+    options: import("@angular/core").InputSignalWithTransform<NgtsScrollControlsOptions, "" | Partial<NgtsScrollControlsOptions>>;
+    private document;
+    private store;
+    private gl;
+    private events;
+    private invalidate;
+    private size;
+    private domElement;
+    private target;
+    private _el;
+    private _fill;
+    private _fixed;
+    private style;
+    private prepend;
+    private enabled;
+    private infinite;
+    private maxSpeed;
+    eps: import("@angular/core").Signal<number>;
+    horizontal: import("@angular/core").Signal<boolean>;
+    pages: import("@angular/core").Signal<number>;
+    distance: import("@angular/core").Signal<number>;
+    damping: import("@angular/core").Signal<number>;
+    scroll: number;
+    offset: number;
+    delta: number;
+    constructor();
+    get el(): HTMLDivElement;
+    get fill(): HTMLDivElement;
+    get fixed(): HTMLDivElement;
+    range(from: number, distance: number, margin?: number): number;
+    curve(from: number, distance: number, margin?: number): number;
+    visible(from: number, distance: number, margin?: number): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsScrollControls, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsScrollControls, "ngts-scroll-controls", never, { "progress": { "alias": "progress"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, { "progress": "progressChange"; }, never, ["*"], true, never>;
+}
+export declare class NgtsScrollCanvas {
+    private host;
+    private scrollControls;
+    private store;
+    private viewport;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsScrollCanvas, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsScrollCanvas, "ngt-group[ngtsScrollCanvas]", never, {}, {}, never, never, true, never>;
+}
+export declare class NgtsScrollHtml extends NgtHTML {
+    private scrollControls;
+    private size;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsScrollHtml, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsScrollHtml, "div[ngtsScrollHTML]", never, {}, {}, never, never, true, never>;
+}

package/esm2022/abstractions/index.mjs

@@ -1,7 +1,14 @@
-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/billboard';
+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/rounded-box';
+export * from './lib/text';
+export * from './lib/text-3d';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL3NvYmEvYWJzdHJhY3Rpb25zL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsWUFBWSxDQUFDO0FBQzNCLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsWUFBWSxDQUFDO0FBQzNCLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsWUFBWSxDQUFDO0FBQzNCLGNBQWMsZUFBZSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9saWIvYmlsbGJvYXJkJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NhdG11bGwtcm9tLWxpbmUnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY3ViaWMtYmV6aWVyLWxpbmUnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvZWRnZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvZ3JhZGllbnQtdGV4dHVyZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9ncmlkJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2hlbHBlcic7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9saW5lJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3ByaXNtLWdlb21ldHJ5JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3F1YWRyYXRpYy1iZXppZXItbGluZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9yb3VuZGVkLWJveCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi90ZXh0JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3RleHQtM2QnO1xuIl19

package/esm2022/abstractions/lib/billboard.mjs

@@ -0,0 +1,69 @@
+import { ChangeDetectionStrategy, Component, CUSTOM_ELEMENTS_SCHEMA, input, viewChild, } from '@angular/core';
+import { extend, injectBeforeRender, omit } from 'angular-three';
+import { mergeInputs } from 'ngxtension/inject-inputs';
+import { Group, Quaternion } from 'three';
+import * as i0 from "@angular/core";
+const defaultOptions = {
+    follow: true,
+    lockX: false,
+    lockY: false,
+    lockZ: false,
+};
+export class NgtsBillboard {
+    constructor() {
+        this.options = input(defaultOptions, { transform: mergeInputs(defaultOptions) });
+        this.parameters = omit(this.options, ['follow', 'lockX', 'lockY', 'lockZ']);
+        this.groupRef = viewChild.required('group');
+        this.innerRef = viewChild.required('inner');
+        extend({ Group });
+        const q = new Quaternion();
+        injectBeforeRender(({ camera }) => {
+            const [{ follow, lockX, lockY, lockZ }, group, inner] = [
+                this.options(),
+                this.groupRef().nativeElement,
+                this.innerRef().nativeElement,
+            ];
+            if (!follow || !group)
+                return;
+            // save previous rotation in case we're locking an axis
+            const prevRotation = group.rotation.clone();
+            // always face the camera
+            group.updateMatrix();
+            group.updateWorldMatrix(false, false);
+            group.getWorldQuaternion(q);
+            camera.getWorldQuaternion(inner.quaternion).premultiply(q.invert());
+            // readjust any axis that is locked
+            if (lockX)
+                group.rotation.x = prevRotation.x;
+            if (lockY)
+                group.rotation.y = prevRotation.y;
+            if (lockZ)
+                group.rotation.z = prevRotation.z;
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsBillboard, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "18.2.0", type: NgtsBillboard, isStandalone: true, selector: "ngts-billboard", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, viewQueries: [{ propertyName: "groupRef", first: true, predicate: ["group"], descendants: true, isSignal: true }, { propertyName: "innerRef", first: true, predicate: ["inner"], descendants: true, isSignal: true }], ngImport: i0, template: `
+		<ngt-group #group [parameters]="parameters()">
+			<ngt-group #inner>
+				<ng-content />
+			</ngt-group>
+		</ngt-group>
+	`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsBillboard, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-billboard',
+                    standalone: true,
+                    template: `
+		<ngt-group #group [parameters]="parameters()">
+			<ngt-group #inner>
+				<ng-content />
+			</ngt-group>
+		</ngt-group>
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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