angular-three-soba 1.3.2 → 1.5.0

package/abstractions/README.md

@@ -0,0 +1,3 @@
+# angular-three-soba/abstractions
+
+Secondary entry point of `angular-three-soba`. It can be used by importing from `angular-three-soba/abstractions`.

package/abstractions/index.d.ts

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

package/abstractions/lib/billboard/billboard.d.ts

@@ -0,0 +1,14 @@
+import { NgtBeforeRenderEvent, NgtRxStore } from 'angular-three';
+import { Group } from 'three';
+import * as i0 from "@angular/core";
+export declare class NgtsBillboard extends NgtRxStore {
+    billboardRef: import("angular-three").NgtInjectedRef<Group>;
+    set follow(follow: boolean);
+    set lockX(lockX: boolean);
+    set lockY(lockY: boolean);
+    set lockZ(lockZ: boolean);
+    initialize(): void;
+    onBeforeRender(event: NgtBeforeRenderEvent<Group>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsBillboard, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsBillboard, "ngts-billboard", never, { "billboardRef": "billboardRef"; "follow": "follow"; "lockX": "lockX"; "lockY": "lockY"; "lockZ": "lockZ"; }, {}, never, ["*"], true, never>;
+}

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

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

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

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

package/abstractions/lib/gizmo-helper/gizmo-helper.d.ts

@@ -0,0 +1,41 @@
+import { EventEmitter, InjectionToken, OnInit, TemplateRef } from '@angular/core';
+import { NgtRxStore } from 'angular-three';
+import { Group, Object3D, OrthographicCamera, Quaternion, Vector3 } from 'three';
+import * as i0 from "@angular/core";
+export interface NgtsGizmoHelperApi {
+    tweenCamera: (direction: Vector3) => void;
+}
+export declare const NGTS_GIZMO_HELPER_API: InjectionToken<NgtsGizmoHelperApi>;
+export declare class NgtsGizmoHelperContent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsGizmoHelperContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsGizmoHelperContent, "ng-template[ngtsGizmoHelperContent]", never, {}, {}, never, never, true, never>;
+}
+export declare class NgtsGizmoHelper extends NgtRxStore implements OnInit {
+    private readonly store;
+    readonly gizmoRef: import("angular-three").NgtInjectedRef<Group>;
+    readonly virtualCameraRef: import("angular-three").NgtInjectedRef<OrthographicCamera>;
+    animating: boolean;
+    radius: number;
+    focusPoint: Vector3;
+    q1: Quaternion;
+    q2: Quaternion;
+    target: Vector3;
+    targetPosition: Vector3;
+    dummy: Object3D<import("three").Event>;
+    private defaultUp;
+    private turnRate;
+    private matrix;
+    set alignment(alignment: 'top-left' | 'top-right' | 'bottom-right' | 'bottom-left' | 'bottom-center' | 'center-right' | 'center-left' | 'center-center' | 'top-center');
+    set margin(margin: [number, number]);
+    set renderPriority(renderPriority: number);
+    set autoClear(autoClear: boolean);
+    updated: EventEmitter<void>;
+    gizmoHelperContent: TemplateRef<unknown>;
+    initialize(): void;
+    ngOnInit(): void;
+    onBeforeRender(delta: number): void;
+    private setGizmoPosition;
+    private updateDefaultUp;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsGizmoHelper, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsGizmoHelper, "ngts-gizmo-helper", never, { "alignment": "alignment"; "margin": "margin"; "renderPriority": "renderPriority"; "autoClear": "autoClear"; }, { "updated": "updated"; }, ["gizmoHelperContent"], never, true, never>;
+}

package/abstractions/lib/gizmo-helper/gizmo-viewcube/constants.d.ts

@@ -0,0 +1,12 @@
+import * as THREE from 'three';
+export declare const colors: {
+    bg: string;
+    hover: string;
+    text: string;
+    stroke: string;
+};
+export declare const defaultFaces: string[];
+export declare const corners: THREE.Vector3[];
+export declare const cornerDimensions: [number, number, number];
+export declare const edges: THREE.Vector3[];
+export declare const edgeDimensions: [number, number, number][];

package/abstractions/lib/gizmo-helper/gizmo-viewcube/gizmo-viewcube-edge.d.ts

@@ -0,0 +1,16 @@
+import { NgtThreeEvent } from 'angular-three';
+import { Vector3 } from 'three';
+import { NgtsGizmoViewcubeInputs } from './gizmo-viewcube-inputs';
+import * as i0 from "@angular/core";
+export declare class NgtsGizmoViewcubeEdgeCube extends NgtsGizmoViewcubeInputs {
+    readonly gizmoHelperApi: import("../gizmo-helper").NgtsGizmoHelperApi;
+    hover: boolean;
+    set dimensions(dimensions: [number, number, number]);
+    set position(position: Vector3);
+    initialize(): void;
+    onPointerMove(event: NgtThreeEvent<PointerEvent>): void;
+    onPointerOut(event: NgtThreeEvent<PointerEvent>): void;
+    onClick(event: NgtThreeEvent<MouseEvent>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsGizmoViewcubeEdgeCube, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsGizmoViewcubeEdgeCube, "ngts-gizmo-viewcube-edge-cube[dimensions][position]", never, { "dimensions": "dimensions"; "position": "position"; }, {}, never, never, true, never>;
+}

package/abstractions/lib/gizmo-helper/gizmo-viewcube/gizmo-viewcube-face.d.ts

@@ -0,0 +1,24 @@
+import { NgtThreeEvent } from 'angular-three';
+import { NgtsGizmoViewcubeInputs } from './gizmo-viewcube-inputs';
+import * as i0 from "@angular/core";
+export declare class NgtsGizmoViewcubeFaceMaterial extends NgtsGizmoViewcubeInputs {
+    private readonly document;
+    set index(index: number);
+    set hover(hover: boolean);
+    set font(font: string);
+    set color(color: string);
+    initialize(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsGizmoViewcubeFaceMaterial, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsGizmoViewcubeFaceMaterial, "ngts-gizmo-viewcube-face-material[hover][index]", never, { "index": "index"; "hover": "hover"; "font": "font"; "color": "color"; }, {}, never, never, true, never>;
+}
+export declare class NgtsGizmoViewcubeFaceCube extends NgtsGizmoViewcubeInputs {
+    readonly gizmoHelperApi: import("../gizmo-helper").NgtsGizmoHelperApi;
+    set font(font: string);
+    set color(color: string);
+    hover: number;
+    onPointerMove(event: NgtThreeEvent<PointerEvent>): void;
+    onPointerOut(event: NgtThreeEvent<PointerEvent>): void;
+    onClick(event: NgtThreeEvent<MouseEvent>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsGizmoViewcubeFaceCube, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsGizmoViewcubeFaceCube, "ngts-gizmo-viewcube-face-cube", never, { "font": "font"; "color": "color"; }, {}, never, never, true, never>;
+}

package/abstractions/lib/gizmo-helper/gizmo-viewcube/gizmo-viewcube-inputs.d.ts

@@ -0,0 +1,14 @@
+import { EventEmitter } from '@angular/core';
+import { NgtRxStore, NgtStore, NgtThreeEvent } from 'angular-three';
+import * as i0 from "@angular/core";
+export declare abstract class NgtsGizmoViewcubeInputs extends NgtRxStore {
+    protected readonly store: NgtStore;
+    set opacity(opacity: number);
+    set hoverColor(hoverColor: string);
+    set textColor(textColor: string);
+    set strokeColor(strokeColor: string);
+    set faces(faces: string[]);
+    set clickEmitter(clickEmitter: EventEmitter<NgtThreeEvent<MouseEvent>>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsGizmoViewcubeInputs, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsGizmoViewcubeInputs, never, never, { "opacity": "opacity"; "hoverColor": "hoverColor"; "textColor": "textColor"; "strokeColor": "strokeColor"; "faces": "faces"; "clickEmitter": "clickEmitter"; }, {}, never, never, false, never>;
+}

package/abstractions/lib/gizmo-helper/gizmo-viewcube/gizmo-viewcube.d.ts

@@ -0,0 +1,15 @@
+import { EventEmitter } from '@angular/core';
+import { NgtThreeEvent } from 'angular-three';
+import { NgtsGizmoViewcubeInputs } from './gizmo-viewcube-inputs';
+import * as i0 from "@angular/core";
+export declare class NgtsGizmoViewcube extends NgtsGizmoViewcubeInputs {
+    readonly edges: import("three").Vector3[];
+    readonly edgeDimensions: [number, number, number][];
+    readonly corners: import("three").Vector3[];
+    readonly cornerDimensions: [number, number, number];
+    set font(font: string);
+    set color(color: string);
+    clicked: EventEmitter<NgtThreeEvent<MouseEvent>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsGizmoViewcube, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsGizmoViewcube, "ngts-gizmo-viewcube", never, { "font": "font"; "color": "color"; }, { "clicked": "clicked"; }, never, never, true, never>;
+}

package/abstractions/lib/gizmo-helper/gizmo-viewport/gizmo-viewport-axis.d.ts

@@ -0,0 +1,28 @@
+import { EventEmitter } from '@angular/core';
+import { NgtRxStore, NgtThreeEvent } from 'angular-three';
+import * as i0 from "@angular/core";
+export declare class NgtsGizmoViewportAxis extends NgtRxStore {
+    set color(color: string);
+    set rotation(rotation: [number, number, number]);
+    set scale(scale: [number, number, number]);
+    initialize(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsGizmoViewportAxis, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsGizmoViewportAxis, "ngts-gizmo-viewport-axis[color][rotation]", never, { "color": "color"; "rotation": "rotation"; "scale": "scale"; }, {}, never, never, true, never>;
+}
+export declare class NgtsGizmoViewportAxisHead extends NgtRxStore {
+    private readonly document;
+    private readonly store;
+    readonly gl: import("three").WebGLRenderer;
+    set arcStyle(arcStyle: string);
+    set label(label: string);
+    set labelColor(labelColor: string);
+    set axisHeadScale(axisHeadScale: number);
+    set disabled(disabled: boolean);
+    set font(font: string);
+    set clickEmitter(clickEmitter: EventEmitter<NgtThreeEvent<MouseEvent>>);
+    initialize(): void;
+    onPointerOver(event: NgtThreeEvent<PointerEvent>): void;
+    onPointerOut(event: NgtThreeEvent<PointerEvent>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsGizmoViewportAxisHead, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsGizmoViewportAxisHead, "ngts-gizmo-viewport-axis-head", never, { "arcStyle": "arcStyle"; "label": "label"; "labelColor": "labelColor"; "axisHeadScale": "axisHeadScale"; "disabled": "disabled"; "font": "font"; "clickEmitter": "clickEmitter"; }, {}, never, never, true, never>;
+}

package/abstractions/lib/gizmo-helper/gizmo-viewport/gizmo-viewport.d.ts

@@ -0,0 +1,21 @@
+import { EventEmitter } from '@angular/core';
+import { NgtRxStore, NgtThreeEvent } from 'angular-three';
+import * as i0 from "@angular/core";
+export declare class NgtsGizmoViewport extends NgtRxStore {
+    readonly gizmoHelperApi: import("../gizmo-helper").NgtsGizmoHelperApi;
+    readonly Math: Math;
+    set axisColors(axisColors: [string, string, string]);
+    set axisScale(axisScale: [number, number, number]);
+    set labels(labels: [string, string, string]);
+    set axisHeadScale(axisHeadScale: number);
+    set labelColor(labelColor: string);
+    set hideNegativeAxes(hideNegativeAxes: boolean);
+    set hideAxisHeads(hideAxisHeads: boolean);
+    set disabled(disabled: boolean);
+    set font(font: string);
+    clicked: EventEmitter<NgtThreeEvent<MouseEvent>>;
+    initialize(): void;
+    onPointerDown(event: NgtThreeEvent<PointerEvent>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsGizmoViewport, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsGizmoViewport, "ngts-gizmo-viewport", never, { "axisColors": "axisColors"; "axisScale": "axisScale"; "labels": "labels"; "axisHeadScale": "axisHeadScale"; "labelColor": "labelColor"; "hideNegativeAxes": "hideNegativeAxes"; "hideAxisHeads": "hideAxisHeads"; "disabled": "disabled"; "font": "font"; }, { "clicked": "clicked"; }, never, never, true, never>;
+}

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

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

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

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

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

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

package/abstractions/lib/text/text.d.ts

@@ -0,0 +1,21 @@
+import { EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { NgtRxStore } from 'angular-three';
+import * as i0 from "@angular/core";
+export declare class NgtsText extends NgtRxStore implements OnInit, OnDestroy {
+    textRef: import("angular-three").NgtInjectedRef<Text>;
+    set text(text: string);
+    set characters(characters: string);
+    set font(font: string);
+    set anchorX(anchorX: number | 'left' | 'center' | 'right');
+    set anchorY(anchorY: number | 'top' | 'top-baseline' | 'middle' | 'bottom-baseline' | 'bottom');
+    sync: EventEmitter<Text>;
+    initialize(): void;
+    private readonly store;
+    private readonly troikaText;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private preloadFont;
+    private syncText;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsText, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsText, "ngts-text[text]", never, { "textRef": "textRef"; "text": "text"; "characters": "characters"; "font": "font"; "anchorX": "anchorX"; "anchorY": "anchorY"; }, { "sync": "sync"; }, never, ["*"], true, never>;
+}

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

@@ -0,0 +1,39 @@
+import { NgtRxStore } from 'angular-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 declare class NgtsText3D extends NgtRxStore {
+    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);
+    initialize(): void;
+    private readonly font$;
+    readonly geometryArgs$: import("rxjs").Observable<any[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsText3D, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsText3D, "ngts-text-3d[font]", never, { "font": "font"; "text": "text"; "bevelEnabled": "bevelEnabled"; "bevelOffset": "bevelOffset"; "bevelSize": "bevelSize"; "bevelThickness": "bevelThickness"; "curveSegments": "curveSegments"; "bevelSegments": "bevelSegments"; "height": "height"; "size": "size"; "lineHeight": "lineHeight"; "letterSpacing": "letterSpacing"; }, {}, never, ["*"], true, never>;
+}
+export {};

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

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

package/esm2020/abstractions/index.mjs

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

package/esm2020/abstractions/lib/billboard/billboard.mjs

@@ -0,0 +1,73 @@
+import { Component, CUSTOM_ELEMENTS_SCHEMA, Input } from '@angular/core';
+import { extend, injectNgtRef, NgtRxStore } from 'angular-three';
+import { Group } from 'three';
+import * as i0 from "@angular/core";
+extend({ Group });
+export class NgtsBillboard extends NgtRxStore {
+    constructor() {
+        super(...arguments);
+        this.billboardRef = injectNgtRef();
+    }
+    set follow(follow) {
+        this.set({ follow });
+    }
+    set lockX(lockX) {
+        this.set({ lockX });
+    }
+    set lockY(lockY) {
+        this.set({ lockY });
+    }
+    set lockZ(lockZ) {
+        this.set({ lockZ });
+    }
+    initialize() {
+        super.initialize();
+        this.set({ follow: true, lockX: false, lockY: false, lockZ: false });
+    }
+    onBeforeRender(event) {
+        const { follow, lockX, lockY, lockZ } = this.get();
+        if (!follow)
+            return;
+        // save prev rotation in case we're locking axises
+        const prevRotation = event.object.rotation.clone();
+        // always face the camera
+        event.object.quaternion.copy(event.state.camera.quaternion);
+        // readjust any axis that is locked
+        if (lockX)
+            event.object.rotation.x = prevRotation.x;
+        if (lockY)
+            event.object.rotation.y = prevRotation.y;
+        if (lockZ)
+            event.object.rotation.z = prevRotation.z;
+    }
+}
+NgtsBillboard.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.3", ngImport: i0, type: NgtsBillboard, deps: null, target: i0.ɵɵFactoryTarget.Component });
+NgtsBillboard.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.1.3", 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" (beforeRender)="onBeforeRender($any($event))">
+            <ng-content />
+        </ngt-group>
+    `, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.3", ngImport: i0, type: NgtsBillboard, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-billboard',
+                    standalone: true,
+                    template: `
+        <ngt-group ngtCompound [ref]="billboardRef" (beforeRender)="onBeforeRender($any($event))">
+            <ng-content />
+        </ngt-group>
+    `,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], 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/esm2020/abstractions/lib/catmull-rom-line/catmull-rom-line.mjs

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