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

package/esm2022/modifiers/curve-modifier/curve-modifier.mjs

@@ -0,0 +1,64 @@
+import { CUSTOM_ELEMENTS_SCHEMA, Component, Input, effect, signal, untracked } from '@angular/core';
+import { NgtArgs, NgtPortal, NgtPortalContent, injectNgtRef, prepare, signalStore } from 'angular-three';
+import * as THREE from 'three';
+import { Flow } from 'three-stdlib';
+import * as i0 from "@angular/core";
+export class NgtsCurveModifier {
+    set _curve(curve) {
+        this.inputs.set({ curve });
+    }
+    constructor() {
+        this.inputs = signalStore();
+        this.curve = this.inputs.select('curve');
+        this.sceneRef = injectNgtRef(prepare(new THREE.Scene()));
+        this.sceneRefChildren = this.sceneRef.children();
+        this.modifierObject = signal(null);
+        effect(() => {
+            this.sceneRefChildren();
+            untracked(() => {
+                this.modifier = new Flow(this.sceneRef.nativeElement.children[0]);
+                this.modifierObject.set(this.modifier.object3D);
+            });
+        });
+        effect(() => {
+            const curve = this.curve();
+            this.modifierObject();
+            if (curve) {
+                this.modifier?.updateCurve(0, curve);
+            }
+        });
+    }
+    moveAlongCurve(value) {
+        this.modifier?.moveAlongCurve(value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsCurveModifier, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.7", type: NgtsCurveModifier, isStandalone: true, selector: "ngts-curve-modifier", inputs: { _curve: ["curve", "_curve"] }, ngImport: i0, template: `
+		<ngt-portal [container]="sceneRef" [autoRender]="false">
+			<ng-template ngtPortalContent>
+				<ng-content />
+			</ng-template>
+		</ngt-portal>
+		<ngt-primitive *args="[modifierObject()]" />
+	`, isInline: true, dependencies: [{ kind: "directive", type: NgtArgs, selector: "ng-template[args]", inputs: ["args"] }, { kind: "component", type: NgtPortal, selector: "ngt-portal", inputs: ["container", "state", "autoRender", "autoRenderPriority"], outputs: ["beforeRender"] }, { kind: "directive", type: NgtPortalContent, selector: "ng-template[ngtPortalContent]" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsCurveModifier, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-curve-modifier',
+                    standalone: true,
+                    template: `
+		<ngt-portal [container]="sceneRef" [autoRender]="false">
+			<ng-template ngtPortalContent>
+				<ng-content />
+			</ng-template>
+		</ngt-portal>
+		<ngt-primitive *args="[modifierObject()]" />
+	`,
+                    imports: [NgtArgs, NgtPortal, NgtPortalContent],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { _curve: [{
+                type: Input,
+                args: [{ alias: 'curve' }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/modifiers/index.mjs

@@ -0,0 +1,2 @@
+export * from './curve-modifier/curve-modifier';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL3NvYmEvbW9kaWZpZXJzL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGlDQUFpQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9jdXJ2ZS1tb2RpZmllci9jdXJ2ZS1tb2RpZmllcic7XG4iXX0=

package/esm2022/performances/adaptive-dpr/adaptive-dpr.mjs

@@ -0,0 +1,44 @@
+import { Directive, Input, effect, signal, untracked } from '@angular/core';
+import { injectNgtStore } from 'angular-three';
+import * as i0 from "@angular/core";
+export class NgtsAdaptiveDpr {
+    set _pixelated(pixelated) {
+        this.pixelated.set(pixelated);
+    }
+    constructor() {
+        this.pixelated = signal(false);
+        this.store = injectNgtStore();
+        this.current = this.store.select('performance', 'current');
+        this.active = this.store.get('internal', 'active');
+        this.setDpr = this.store.get('setDpr');
+        this.initialDpr = this.store.get('viewport', 'initialDpr');
+        this.domElement = this.store.get('gl', 'domElement');
+        effect((onCleanup) => {
+            onCleanup(() => {
+                if (this.active) {
+                    this.setDpr(this.initialDpr);
+                }
+                if (this.pixelated() && this.domElement) {
+                    this.domElement.style.imageRendering = 'auto';
+                }
+            });
+        });
+        effect(() => {
+            const current = this.current();
+            this.setDpr(current * this.initialDpr);
+            if (untracked(this.pixelated) && this.domElement) {
+                this.domElement.style.imageRendering = current === 1 ? 'auto' : 'pixelated';
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsAdaptiveDpr, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.7", type: NgtsAdaptiveDpr, isStandalone: true, selector: "ngts-adaptive-dpr", inputs: { _pixelated: ["pixelated", "_pixelated"] }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsAdaptiveDpr, decorators: [{
+            type: Directive,
+            args: [{ selector: 'ngts-adaptive-dpr', standalone: true }]
+        }], ctorParameters: function () { return []; }, propDecorators: { _pixelated: [{
+                type: Input,
+                args: [{ alias: 'pixelated' }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/performances/adaptive-events/adaptive-events.mjs

@@ -0,0 +1,27 @@
+import { Directive, effect } from '@angular/core';
+import { injectNgtStore } from 'angular-three';
+import * as i0 from "@angular/core";
+export class NgtsAdaptiveEvents {
+    constructor() {
+        this.store = injectNgtStore();
+        this.setEvents = this.store.get('setEvents');
+        this.current = this.store.select('performance', 'current');
+        effect((onCleanup) => {
+            const enabled = this.store.get('events', 'enabled');
+            onCleanup(() => {
+                this.setEvents({ enabled });
+            });
+        });
+        effect(() => {
+            const current = this.current();
+            this.setEvents({ enabled: current === 1 });
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsAdaptiveEvents, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.7", type: NgtsAdaptiveEvents, isStandalone: true, selector: "ngts-adaptive-events", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsAdaptiveEvents, decorators: [{
+            type: Directive,
+            args: [{ selector: 'ngts-adaptive-events', standalone: true }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

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

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

package/esm2022/performances/index.mjs

@@ -0,0 +1,6 @@
+export * from './adaptive-dpr/adaptive-dpr';
+export * from './adaptive-events/adaptive-events';
+export * from './points/points';
+export * from './segments/segment-object';
+export * from './segments/segments';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL3NvYmEvcGVyZm9ybWFuY2VzL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsbUNBQW1DLENBQUM7QUFDbEQsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMscUJBQXFCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2FkYXB0aXZlLWRwci9hZGFwdGl2ZS1kcHInO1xuZXhwb3J0ICogZnJvbSAnLi9hZGFwdGl2ZS1ldmVudHMvYWRhcHRpdmUtZXZlbnRzJztcbmV4cG9ydCAqIGZyb20gJy4vcG9pbnRzL3BvaW50cyc7XG5leHBvcnQgKiBmcm9tICcuL3NlZ21lbnRzL3NlZ21lbnQtb2JqZWN0JztcbmV4cG9ydCAqIGZyb20gJy4vc2VnbWVudHMvc2VnbWVudHMnO1xuIl19

package/esm2022/performances/points/points-input.mjs

@@ -0,0 +1,64 @@
+import { Directive, Input, computed } from '@angular/core';
+import { injectNgtRef, signalStore } from 'angular-three';
+import * as i0 from "@angular/core";
+export class NgtsPointsInput {
+    constructor() {
+        this.inputs = signalStore({
+            stride: 3,
+            limit: 1000,
+        });
+        this.pointsRef = injectNgtRef();
+        this.limit = this.inputs.select('limit');
+        this.range = this.inputs.select('range');
+        this.positions = this.inputs.select('positions');
+        this.colors = this.inputs.select('colors');
+        this.colorsLength = computed(() => this.colors()?.length || 0);
+        this.sizes = this.inputs.select('sizes');
+        this.sizesLength = computed(() => this.sizes()?.length || 0);
+        this.stride = this.inputs.select('stride');
+    }
+    set _range(range) {
+        this.inputs.set({ range });
+    }
+    set _limit(limit) {
+        this.inputs.set({ limit });
+    }
+    set _positions(positions) {
+        this.inputs.set({ positions });
+    }
+    set _colors(colors) {
+        this.inputs.set({ colors });
+    }
+    set _sizes(sizes) {
+        this.inputs.set({ sizes });
+    }
+    set _stride(stride) {
+        this.inputs.set({ stride });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsPointsInput, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.7", type: NgtsPointsInput, inputs: { pointsRef: "pointsRef", _range: ["range", "_range"], _limit: ["limit", "_limit"], _positions: ["positions", "_positions"], _colors: ["colors", "_colors"], _sizes: ["sizes", "_sizes"], _stride: ["stride", "_stride"] }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsPointsInput, decorators: [{
+            type: Directive
+        }], propDecorators: { pointsRef: [{
+                type: Input
+            }], _range: [{
+                type: Input,
+                args: [{ alias: 'range' }]
+            }], _limit: [{
+                type: Input,
+                args: [{ alias: 'limit' }]
+            }], _positions: [{
+                type: Input,
+                args: [{ alias: 'positions' }]
+            }], _colors: [{
+                type: Input,
+                args: [{ alias: 'colors' }]
+            }], _sizes: [{
+                type: Input,
+                args: [{ alias: 'sizes' }]
+            }], _stride: [{
+                type: Input,
+                args: [{ alias: 'stride' }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/performances/points/points.mjs

@@ -0,0 +1,329 @@
+import { NgIf, NgTemplateOutlet } from '@angular/common';
+import { CUSTOM_ELEMENTS_SCHEMA, Component, ContentChild, Injector, Input, NgZone, TemplateRef, computed, effect, forwardRef, inject, signal, untracked, } from '@angular/core';
+import { checkUpdate, createInjectionToken, extend, injectBeforeRender, injectNgtRef, injectNgtStore, is, } from 'angular-three';
+import { NgtsSobaContent } from 'angular-three-soba/utils';
+import * as THREE from 'three';
+import { BufferAttribute, BufferGeometry, Points } from 'three';
+import { NgtsPointsInput } from './points-input';
+import { PositionPoint } from './position-point';
+import * as i0 from "@angular/core";
+extend({ Points, BufferGeometry, BufferAttribute, PositionPoint });
+export const [injectNgtsPointsInstanceApi, provideNgtsPointsInstancesApi] = createInjectionToken(function pointsInstancesApi(instances) {
+    return instances.api;
+}, { isRoot: false, deps: [forwardRef(() => NgtsPointsInstances)] });
+export class NgtsPointsInstances {
+    constructor() {
+        this.nullRaycast = () => null;
+        this.DynamicDrawUsage = THREE.DynamicDrawUsage;
+        this.pointsInput = inject(NgtsPointsInput);
+        this.positionPoints = signal([]);
+        this.parentMatrix = new THREE.Matrix4();
+        this.position = new THREE.Vector3();
+        this.points = this.positionPoints.asReadonly();
+        this.positions = computed(() => new Float32Array(this.pointsInput.limit() * 3));
+        this.colors = computed(() => Float32Array.from({ length: this.pointsInput.limit() * 3 }, () => 1));
+        this.sizes = computed(() => Float32Array.from({ length: this.pointsInput.limit() }, () => 1));
+        this.injector = inject(Injector);
+        this.api = computed(() => ({
+            getParent: () => this.pointsInput.pointsRef,
+            subscribe: (pointRef) => {
+                untracked(() => {
+                    this.positionPoints.update((s) => [...s, pointRef]);
+                });
+                return () => {
+                    untracked(() => {
+                        this.positionPoints.update((s) => s.filter((positionPoint) => positionPoint !== pointRef));
+                    });
+                };
+            },
+        }));
+        this.checkUpdatePositionAttribute();
+        this.beforeRender();
+    }
+    checkUpdatePositionAttribute() {
+        effect(() => {
+            const points = this.pointsInput.pointsRef.nativeElement;
+            if (!points)
+                return;
+            checkUpdate(points.geometry.attributes['position']);
+        });
+    }
+    beforeRender() {
+        injectBeforeRender(() => {
+            const points = this.pointsInput.pointsRef.nativeElement;
+            if (!points)
+                return;
+            const [limit, range, positionPoints, positions, colors, sizes] = [
+                this.pointsInput.limit(),
+                this.pointsInput.range(),
+                this.positionPoints(),
+                this.positions(),
+                this.colors(),
+                this.sizes(),
+            ];
+            points.updateMatrix();
+            points.updateMatrixWorld();
+            this.parentMatrix.copy(points.matrixWorld).invert();
+            points.geometry.drawRange.count = Math.min(limit, range !== undefined ? range : limit, positionPoints.length);
+            for (let i = 0; i < positionPoints.length; i++) {
+                const positionPointRef = positionPoints[i];
+                const positionPoint = is.ref(positionPointRef) ? positionPointRef.nativeElement : positionPointRef;
+                if (!positionPoint)
+                    continue;
+                positionPoint.getWorldPosition(this.position).applyMatrix4(this.parentMatrix);
+                this.position.toArray(positions, i * 3);
+                checkUpdate(points.geometry.attributes['position']);
+                positionPoint.matrixWorldNeedsUpdate = true;
+                positionPoint.color.toArray(colors, i * 3);
+                checkUpdate(points.geometry.attributes['color']);
+                sizes.set([positionPoint.size], i);
+                checkUpdate(points.geometry.attributes['size']);
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsPointsInstances, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.7", type: NgtsPointsInstances, isStandalone: true, selector: "ngts-points-instances", providers: [provideNgtsPointsInstancesApi()], ngImport: i0, template: `
+		<ngt-points
+			[ref]="pointsInput.pointsRef"
+			[userData]="{ instances: points() }"
+			[matrixAutoUpdate]="false"
+			[raycast]="nullRaycast"
+			ngtCompound
+		>
+			<ngt-buffer-geometry>
+				<ngt-buffer-attribute
+					attach="attributes.position"
+					[count]="positions().length / 3"
+					[array]="positions()"
+					[itemSize]="3"
+					[usage]="DynamicDrawUsage"
+				/>
+				<ngt-buffer-attribute
+					attach="attributes.color"
+					[count]="colors().length / 3"
+					[array]="colors()"
+					[itemSize]="3"
+					[usage]="DynamicDrawUsage"
+				/>
+				<ngt-buffer-attribute
+					attach="attributes.size"
+					[count]="sizes().length"
+					[array]="sizes()"
+					[itemSize]="1"
+					[usage]="DynamicDrawUsage"
+				/>
+			</ngt-buffer-geometry>
+			<ng-content />
+		</ngt-points>
+	`, isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsPointsInstances, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-points-instances',
+                    standalone: true,
+                    template: `
+		<ngt-points
+			[ref]="pointsInput.pointsRef"
+			[userData]="{ instances: points() }"
+			[matrixAutoUpdate]="false"
+			[raycast]="nullRaycast"
+			ngtCompound
+		>
+			<ngt-buffer-geometry>
+				<ngt-buffer-attribute
+					attach="attributes.position"
+					[count]="positions().length / 3"
+					[array]="positions()"
+					[itemSize]="3"
+					[usage]="DynamicDrawUsage"
+				/>
+				<ngt-buffer-attribute
+					attach="attributes.color"
+					[count]="colors().length / 3"
+					[array]="colors()"
+					[itemSize]="3"
+					[usage]="DynamicDrawUsage"
+				/>
+				<ngt-buffer-attribute
+					attach="attributes.size"
+					[count]="sizes().length"
+					[array]="sizes()"
+					[itemSize]="1"
+					[usage]="DynamicDrawUsage"
+				/>
+			</ngt-buffer-geometry>
+			<ng-content />
+		</ngt-points>
+	`,
+                    providers: [provideNgtsPointsInstancesApi()],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: function () { return []; } });
+export class NgtsPoint {
+    constructor() {
+        this.pointRef = injectNgtRef();
+        this.zone = inject(NgZone);
+        this.injector = inject(Injector);
+        this.pointsInstancesApi = injectNgtsPointsInstanceApi();
+    }
+    ngOnInit() {
+        effect((onCleanup) => {
+            const cleanup = this.zone.runOutsideAngular(() => {
+                const api = this.pointsInstancesApi();
+                return api.subscribe(this.pointRef);
+            });
+            onCleanup(cleanup);
+        }, { injector: this.injector });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsPoint, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.7", type: NgtsPoint, isStandalone: true, selector: "ngts-point", inputs: { pointRef: "pointRef" }, ngImport: i0, template: `
+		<ngt-position-point
+			[instance]="pointsInstancesApi().getParent()"
+			[ref]="pointRef"
+			[instanceKey]="pointRef"
+			ngtCompound
+		>
+			<ng-content />
+		</ngt-position-point>
+	`, isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsPoint, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-point',
+                    standalone: true,
+                    template: `
+		<ngt-position-point
+			[instance]="pointsInstancesApi().getParent()"
+			[ref]="pointRef"
+			[instanceKey]="pointRef"
+			ngtCompound
+		>
+			<ng-content />
+		</ngt-position-point>
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], propDecorators: { pointRef: [{
+                type: Input
+            }] } });
+export class NgtsPointsBuffers {
+    constructor() {
+        this.DynamicDrawUsage = THREE.DynamicDrawUsage;
+        this.pointsInput = inject(NgtsPointsInput);
+        this.store = injectNgtStore();
+        injectBeforeRender(() => {
+            const points = this.pointsInput.pointsRef.nativeElement;
+            if (!points)
+                return;
+            const [sizes, colors] = [this.pointsInput.sizes(), this.pointsInput.colors()];
+            const attr = points.geometry.attributes;
+            checkUpdate(attr['position']);
+            if (colors)
+                checkUpdate(attr['color']);
+            if (sizes)
+                checkUpdate(attr['size']);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsPointsBuffers, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.7", type: NgtsPointsBuffers, isStandalone: true, selector: "ngts-points-buffers", ngImport: i0, template: `
+		<ngt-points [ref]="pointsInput.pointsRef" ngtCompound>
+			<ngt-buffer-geometry>
+				<ngt-buffer-attribute
+					attach="attributes.position"
+					[count]="pointsInput.positions().length / pointsInput.stride()"
+					[array]="pointsInput.positions()"
+					[itemSize]="pointsInput.stride()"
+					[usage]="DynamicDrawUsage"
+				/>
+				<ngt-buffer-attribute
+					attach="attributes.color"
+					[count]="pointsInput.colorsLength() / pointsInput.stride()"
+					[array]="pointsInput.colors()"
+					[itemSize]="pointsInput.stride()"
+					[usage]="DynamicDrawUsage"
+				/>
+				<ngt-buffer-attribute
+					attach="attributes.size"
+					[count]="pointsInput.sizesLength() / pointsInput.stride()"
+					[array]="pointsInput.sizes()"
+					[itemSize]="1"
+					[usage]="DynamicDrawUsage"
+				/>
+			</ngt-buffer-geometry>
+			<ng-content />
+		</ngt-points>
+	`, isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsPointsBuffers, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-points-buffers',
+                    standalone: true,
+                    template: `
+		<ngt-points [ref]="pointsInput.pointsRef" ngtCompound>
+			<ngt-buffer-geometry>
+				<ngt-buffer-attribute
+					attach="attributes.position"
+					[count]="pointsInput.positions().length / pointsInput.stride()"
+					[array]="pointsInput.positions()"
+					[itemSize]="pointsInput.stride()"
+					[usage]="DynamicDrawUsage"
+				/>
+				<ngt-buffer-attribute
+					attach="attributes.color"
+					[count]="pointsInput.colorsLength() / pointsInput.stride()"
+					[array]="pointsInput.colors()"
+					[itemSize]="pointsInput.stride()"
+					[usage]="DynamicDrawUsage"
+				/>
+				<ngt-buffer-attribute
+					attach="attributes.size"
+					[count]="pointsInput.sizesLength() / pointsInput.stride()"
+					[array]="pointsInput.sizes()"
+					[itemSize]="1"
+					[usage]="DynamicDrawUsage"
+				/>
+			</ngt-buffer-geometry>
+			<ng-content />
+		</ngt-points>
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: function () { return []; } });
+export class NgtsPoints extends NgtsPointsInput {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsPoints, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.7", type: NgtsPoints, isStandalone: true, selector: "ngts-points", providers: [{ provide: NgtsPointsInput, useExisting: NgtsPoints }], queries: [{ propertyName: "content", first: true, predicate: NgtsSobaContent, descendants: true, read: TemplateRef, static: true }], usesInheritance: true, ngImport: i0, template: `
+		<ngts-points-buffers *ngIf="positions()">
+			<ng-container *ngTemplateOutlet="content" />
+		</ngts-points-buffers>
+		<ngts-points-instances *ngIf="!positions()" #pointsInstances>
+			<!-- NOTE: passing in the injector to templateOutlet allow the consumers to abstract ngts-point -->
+			<ng-container *ngTemplateOutlet="content; injector: pointsInstances.injector" />
+		</ngts-points-instances>
+	`, isInline: true, dependencies: [{ kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: NgtsPointsBuffers, selector: "ngts-points-buffers" }, { kind: "component", type: NgtsPointsInstances, selector: "ngts-points-instances" }, { kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsPoints, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-points',
+                    standalone: true,
+                    template: `
+		<ngts-points-buffers *ngIf="positions()">
+			<ng-container *ngTemplateOutlet="content" />
+		</ngts-points-buffers>
+		<ngts-points-instances *ngIf="!positions()" #pointsInstances>
+			<!-- NOTE: passing in the injector to templateOutlet allow the consumers to abstract ngts-point -->
+			<ng-container *ngTemplateOutlet="content; injector: pointsInstances.injector" />
+		</ngts-points-instances>
+	`,
+                    imports: [NgIf, NgtsPointsBuffers, NgtsPointsInstances, NgTemplateOutlet],
+                    providers: [{ provide: NgtsPointsInput, useExisting: NgtsPoints }],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], propDecorators: { content: [{
+                type: ContentChild,
+                args: [NgtsSobaContent, { static: true, read: TemplateRef }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"points.js","sourceRoot":"","sources":["../../../../../../libs/soba/performances/src/points/points.ts"],"names":[],"mappings":"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","sourcesContent":["import { NgIf, NgTemplateOutlet } from '@angular/common';\nimport {\n\tCUSTOM_ELEMENTS_SCHEMA,\n\tComponent,\n\tContentChild,\n\tInjector,\n\tInput,\n\tNgZone,\n\tOnInit,\n\tTemplateRef,\n\tcomputed,\n\teffect,\n\tforwardRef,\n\tinject,\n\tsignal,\n\tuntracked,\n} from '@angular/core';\nimport {\n\tcheckUpdate,\n\tcreateInjectionToken,\n\textend,\n\tinjectBeforeRender,\n\tinjectNgtRef,\n\tinjectNgtStore,\n\tis,\n\ttype NgtGroup,\n\ttype NgtPoints,\n\ttype NgtRef,\n} from 'angular-three';\nimport { NgtsSobaContent } from 'angular-three-soba/utils';\nimport * as THREE from 'three';\nimport { BufferAttribute, BufferGeometry, Points } from 'three';\nimport { NgtsPointsInput, type NgtsPointsBuffersState, type NgtsPointsInstancesState } from './points-input';\nimport { PositionPoint } from './position-point';\n\nextend({ Points, BufferGeometry, BufferAttribute, PositionPoint });\n\ndeclare global {\n\tinterface HTMLElementTagNameMap {\n\t\t/**\n\t\t * @extends ngt-points\n\t\t */\n\t\t'ngts-points-instances': NgtsPointsInstancesState & NgtPoints;\n\t\t/**\n\t\t * @extends ngt-points\n\t\t */\n\t\t'ngts-points-buffers': NgtsPointsBuffersState & NgtPoints;\n\t\t/**\n\t\t * @extends ngt-points\n\t\t */\n\t\t'ngts-points': (NgtsPointsBuffersState | NgtsPointsInstancesState) & NgtsPoints;\n\t\t/**\n\t\t * @extends ngt-group\n\t\t */\n\t\t'ngt-position-point': PositionPoint & NgtGroup;\n\t}\n}\n\nexport const [injectNgtsPointsInstanceApi, provideNgtsPointsInstancesApi] = createInjectionToken(\n\tfunction pointsInstancesApi(instances: NgtsPointsInstances) {\n\t\treturn instances.api;\n\t},\n\t{ isRoot: false, deps: [forwardRef(() => NgtsPointsInstances)] },\n);\n\n@Component({\n\tselector: 'ngts-points-instances',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-points\n\t\t\t[ref]=\"pointsInput.pointsRef\"\n\t\t\t[userData]=\"{ instances: points() }\"\n\t\t\t[matrixAutoUpdate]=\"false\"\n\t\t\t[raycast]=\"nullRaycast\"\n\t\t\tngtCompound\n\t\t>\n\t\t\t<ngt-buffer-geometry>\n\t\t\t\t<ngt-buffer-attribute\n\t\t\t\t\tattach=\"attributes.position\"\n\t\t\t\t\t[count]=\"positions().length / 3\"\n\t\t\t\t\t[array]=\"positions()\"\n\t\t\t\t\t[itemSize]=\"3\"\n\t\t\t\t\t[usage]=\"DynamicDrawUsage\"\n\t\t\t\t/>\n\t\t\t\t<ngt-buffer-attribute\n\t\t\t\t\tattach=\"attributes.color\"\n\t\t\t\t\t[count]=\"colors().length / 3\"\n\t\t\t\t\t[array]=\"colors()\"\n\t\t\t\t\t[itemSize]=\"3\"\n\t\t\t\t\t[usage]=\"DynamicDrawUsage\"\n\t\t\t\t/>\n\t\t\t\t<ngt-buffer-attribute\n\t\t\t\t\tattach=\"attributes.size\"\n\t\t\t\t\t[count]=\"sizes().length\"\n\t\t\t\t\t[array]=\"sizes()\"\n\t\t\t\t\t[itemSize]=\"1\"\n\t\t\t\t\t[usage]=\"DynamicDrawUsage\"\n\t\t\t\t/>\n\t\t\t</ngt-buffer-geometry>\n\t\t\t<ng-content />\n\t\t</ngt-points>\n\t`,\n\tproviders: [provideNgtsPointsInstancesApi()],\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsPointsInstances {\n\tnullRaycast = () => null;\n\tDynamicDrawUsage = THREE.DynamicDrawUsage;\n\n\tpointsInput = inject(NgtsPointsInput);\n\n\tprivate positionPoints = signal<NgtRef<PositionPoint>[]>([]);\n\tprivate parentMatrix = new THREE.Matrix4();\n\tprivate position = new THREE.Vector3();\n\n\tpoints = this.positionPoints.asReadonly();\n\tpositions = computed(() => new Float32Array(this.pointsInput.limit() * 3));\n\tcolors = computed(() => Float32Array.from({ length: this.pointsInput.limit() * 3 }, () => 1));\n\tsizes = computed(() => Float32Array.from({ length: this.pointsInput.limit() }, () => 1));\n\n\tinjector = inject(Injector);\n\n\tapi = computed(() => ({\n\t\tgetParent: () => this.pointsInput.pointsRef,\n\t\tsubscribe: (pointRef: NgtRef<PositionPoint>) => {\n\t\t\tuntracked(() => {\n\t\t\t\tthis.positionPoints.update((s) => [...s, pointRef]);\n\t\t\t});\n\t\t\treturn () => {\n\t\t\t\tuntracked(() => {\n\t\t\t\t\tthis.positionPoints.update((s) => s.filter((positionPoint) => positionPoint !== pointRef));\n\t\t\t\t});\n\t\t\t};\n\t\t},\n\t}));\n\n\tconstructor() {\n\t\tthis.checkUpdatePositionAttribute();\n\t\tthis.beforeRender();\n\t}\n\n\tprivate checkUpdatePositionAttribute() {\n\t\teffect(() => {\n\t\t\tconst points = this.pointsInput.pointsRef.nativeElement;\n\t\t\tif (!points) return;\n\t\t\tcheckUpdate(points.geometry.attributes['position']);\n\t\t});\n\t}\n\n\tprivate beforeRender() {\n\t\tinjectBeforeRender(() => {\n\t\t\tconst points = this.pointsInput.pointsRef.nativeElement;\n\t\t\tif (!points) return;\n\t\t\tconst [limit, range, positionPoints, positions, colors, sizes] = [\n\t\t\t\tthis.pointsInput.limit(),\n\t\t\t\tthis.pointsInput.range(),\n\t\t\t\tthis.positionPoints(),\n\t\t\t\tthis.positions(),\n\t\t\t\tthis.colors(),\n\t\t\t\tthis.sizes(),\n\t\t\t];\n\n\t\t\tpoints.updateMatrix();\n\t\t\tpoints.updateMatrixWorld();\n\t\t\tthis.parentMatrix.copy(points.matrixWorld).invert();\n\n\t\t\tpoints.geometry.drawRange.count = Math.min(\n\t\t\t\tlimit,\n\t\t\t\trange !== undefined ? range : limit,\n\t\t\t\tpositionPoints.length,\n\t\t\t);\n\n\t\t\tfor (let i = 0; i < positionPoints.length; i++) {\n\t\t\t\tconst positionPointRef = positionPoints[i];\n\t\t\t\tconst positionPoint = is.ref(positionPointRef) ? positionPointRef.nativeElement : positionPointRef;\n\t\t\t\tif (!positionPoint) continue;\n\t\t\t\tpositionPoint.getWorldPosition(this.position).applyMatrix4(this.parentMatrix);\n\t\t\t\tthis.position.toArray(positions, i * 3);\n\t\t\t\tcheckUpdate(points.geometry.attributes['position']);\n\t\t\t\tpositionPoint.matrixWorldNeedsUpdate = true;\n\n\t\t\t\tpositionPoint.color.toArray(colors, i * 3);\n\t\t\t\tcheckUpdate(points.geometry.attributes['color']);\n\n\t\t\t\tsizes.set([positionPoint.size], i);\n\t\t\t\tcheckUpdate(points.geometry.attributes['size']);\n\t\t\t}\n\t\t});\n\t}\n}\n\n@Component({\n\tselector: 'ngts-point',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-position-point\n\t\t\t[instance]=\"pointsInstancesApi().getParent()\"\n\t\t\t[ref]=\"pointRef\"\n\t\t\t[instanceKey]=\"pointRef\"\n\t\t\tngtCompound\n\t\t>\n\t\t\t<ng-content />\n\t\t</ngt-position-point>\n\t`,\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsPoint implements OnInit {\n\t@Input() pointRef = injectNgtRef<PositionPoint>();\n\n\tprivate zone = inject(NgZone);\n\tprivate injector = inject(Injector);\n\tpointsInstancesApi = injectNgtsPointsInstanceApi();\n\n\tngOnInit() {\n\t\teffect(\n\t\t\t(onCleanup) => {\n\t\t\t\tconst cleanup = this.zone.runOutsideAngular(() => {\n\t\t\t\t\tconst api = this.pointsInstancesApi();\n\t\t\t\t\treturn api.subscribe(this.pointRef);\n\t\t\t\t});\n\t\t\t\tonCleanup(cleanup);\n\t\t\t},\n\t\t\t{ injector: this.injector },\n\t\t);\n\t}\n}\n\n@Component({\n\tselector: 'ngts-points-buffers',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-points [ref]=\"pointsInput.pointsRef\" ngtCompound>\n\t\t\t<ngt-buffer-geometry>\n\t\t\t\t<ngt-buffer-attribute\n\t\t\t\t\tattach=\"attributes.position\"\n\t\t\t\t\t[count]=\"pointsInput.positions().length / pointsInput.stride()\"\n\t\t\t\t\t[array]=\"pointsInput.positions()\"\n\t\t\t\t\t[itemSize]=\"pointsInput.stride()\"\n\t\t\t\t\t[usage]=\"DynamicDrawUsage\"\n\t\t\t\t/>\n\t\t\t\t<ngt-buffer-attribute\n\t\t\t\t\tattach=\"attributes.color\"\n\t\t\t\t\t[count]=\"pointsInput.colorsLength() / pointsInput.stride()\"\n\t\t\t\t\t[array]=\"pointsInput.colors()\"\n\t\t\t\t\t[itemSize]=\"pointsInput.stride()\"\n\t\t\t\t\t[usage]=\"DynamicDrawUsage\"\n\t\t\t\t/>\n\t\t\t\t<ngt-buffer-attribute\n\t\t\t\t\tattach=\"attributes.size\"\n\t\t\t\t\t[count]=\"pointsInput.sizesLength() / pointsInput.stride()\"\n\t\t\t\t\t[array]=\"pointsInput.sizes()\"\n\t\t\t\t\t[itemSize]=\"1\"\n\t\t\t\t\t[usage]=\"DynamicDrawUsage\"\n\t\t\t\t/>\n\t\t\t</ngt-buffer-geometry>\n\t\t\t<ng-content />\n\t\t</ngt-points>\n\t`,\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsPointsBuffers {\n\tDynamicDrawUsage = THREE.DynamicDrawUsage;\n\n\tpointsInput = inject(NgtsPointsInput);\n\n\tstore = injectNgtStore();\n\n\tconstructor() {\n\t\tinjectBeforeRender(() => {\n\t\t\tconst points = this.pointsInput.pointsRef.nativeElement;\n\t\t\tif (!points) return;\n\t\t\tconst [sizes, colors] = [this.pointsInput.sizes(), this.pointsInput.colors()];\n\t\t\tconst attr = points.geometry.attributes;\n\t\t\tcheckUpdate(attr['position']);\n\t\t\tif (colors) checkUpdate(attr['color']);\n\t\t\tif (sizes) checkUpdate(attr['size']);\n\t\t});\n\t}\n}\n\n@Component({\n\tselector: 'ngts-points',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngts-points-buffers *ngIf=\"positions()\">\n\t\t\t<ng-container *ngTemplateOutlet=\"content\" />\n\t\t</ngts-points-buffers>\n\t\t<ngts-points-instances *ngIf=\"!positions()\" #pointsInstances>\n\t\t\t<!-- NOTE: passing in the injector to templateOutlet allow the consumers to abstract ngts-point -->\n\t\t\t<ng-container *ngTemplateOutlet=\"content; injector: pointsInstances.injector\" />\n\t\t</ngts-points-instances>\n\t`,\n\timports: [NgIf, NgtsPointsBuffers, NgtsPointsInstances, NgTemplateOutlet],\n\tproviders: [{ provide: NgtsPointsInput, useExisting: NgtsPoints }],\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsPoints extends NgtsPointsInput {\n\t@ContentChild(NgtsSobaContent, { static: true, read: TemplateRef }) content!: TemplateRef<unknown>;\n}\n"]}