angular-three-soba 2.0.0-beta.2 → 2.0.0-beta.21

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.2.2", ngImport: i0, type: NgtsCurveModifier, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.2", 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.2.2", 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.2.2", ngImport: i0, type: NgtsAdaptiveDpr, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.2", type: NgtsAdaptiveDpr, isStandalone: true, selector: "ngts-adaptive-dpr", inputs: { _pixelated: ["pixelated", "_pixelated"] }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", 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.2.2", ngImport: i0, type: NgtsAdaptiveEvents, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.2", type: NgtsAdaptiveEvents, isStandalone: true, selector: "ngts-adaptive-events", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", 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,8 @@
+export * from './adaptive-dpr/adaptive-dpr';
+export * from './adaptive-events/adaptive-events';
+export * from './instances/instances';
+export * from './instances/position-mesh';
+export * from './points/points';
+export * from './segments/segment-object';
+export * from './segments/segments';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL3NvYmEvcGVyZm9ybWFuY2VzL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsbUNBQW1DLENBQUM7QUFDbEQsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLHFCQUFxQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9hZGFwdGl2ZS1kcHIvYWRhcHRpdmUtZHByJztcbmV4cG9ydCAqIGZyb20gJy4vYWRhcHRpdmUtZXZlbnRzL2FkYXB0aXZlLWV2ZW50cyc7XG5leHBvcnQgKiBmcm9tICcuL2luc3RhbmNlcy9pbnN0YW5jZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9pbnN0YW5jZXMvcG9zaXRpb24tbWVzaCc7XG5leHBvcnQgKiBmcm9tICcuL3BvaW50cy9wb2ludHMnO1xuZXhwb3J0ICogZnJvbSAnLi9zZWdtZW50cy9zZWdtZW50LW9iamVjdCc7XG5leHBvcnQgKiBmcm9tICcuL3NlZ21lbnRzL3NlZ21lbnRzJztcbiJdfQ==

package/esm2022/performances/instances/instances.mjs

@@ -0,0 +1,220 @@
+import { NgTemplateOutlet } from '@angular/common';
+import { Component, computed, ContentChild, CUSTOM_ELEMENTS_SCHEMA, effect, forwardRef, inject, Injector, Input, NgZone, signal, TemplateRef, untracked, } from '@angular/core';
+import { checkUpdate, createInjectionToken, extend, injectBeforeRender, injectNgtRef, is, NgtArgs, signalStore, } from 'angular-three';
+import { NgtsSobaContent } from 'angular-three-soba/utils';
+import * as THREE from 'three';
+import { InstancedBufferAttribute, InstancedMesh } from 'three';
+import { PositionMesh } from './position-mesh';
+import * as i0 from "@angular/core";
+extend({ PositionMesh, InstancedMesh, InstancedBufferAttribute });
+const parentMatrix = /*@__PURE__*/ new THREE.Matrix4();
+const instanceMatrix = /*@__PURE__*/ new THREE.Matrix4();
+const tempMatrix = /*@__PURE__*/ new THREE.Matrix4();
+const translation = /*@__PURE__*/ new THREE.Vector3();
+const rotation = /*@__PURE__*/ new THREE.Quaternion();
+const scale = /*@__PURE__*/ new THREE.Vector3();
+export const [injectNgtsInstancesApi, provideNgtsInstancesApi] = createInjectionToken((instances) => instances.api, { isRoot: false, deps: [forwardRef(() => NgtsInstances)] });
+export class NgtsInstance {
+    constructor() {
+        this.instanceRef = injectNgtRef();
+        this.zone = inject(NgZone);
+        this.injector = inject(Injector);
+        this.instancesApi = injectNgtsInstancesApi();
+    }
+    ngOnInit() {
+        effect((onCleanup) => {
+            const cleanup = this.zone.runOutsideAngular(() => this.instancesApi.subscribe(this.instanceRef));
+            onCleanup(cleanup);
+        }, { injector: this.injector });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsInstance, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.2", type: NgtsInstance, isStandalone: true, selector: "ngts-instance", inputs: { instanceRef: "instanceRef" }, ngImport: i0, template: `
+		<ngt-position-mesh
+			[ref]="instanceRef"
+			[instance]="instancesApi.getParent()"
+			[instanceKey]="instanceRef"
+			ngtCompound
+		>
+			<ng-content />
+		</ngt-position-mesh>
+	`, isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsInstance, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-instance',
+                    standalone: true,
+                    template: `
+		<ngt-position-mesh
+			[ref]="instanceRef"
+			[instance]="instancesApi.getParent()"
+			[instanceKey]="instanceRef"
+			ngtCompound
+		>
+			<ng-content />
+		</ngt-position-mesh>
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], propDecorators: { instanceRef: [{
+                type: Input
+            }] } });
+export class NgtsInstances {
+    set _range(range) {
+        this.inputs.set({ range });
+    }
+    set _limit(limit) {
+        this.inputs.set({ limit });
+    }
+    set _frames(frames) {
+        this.inputs.set({ frames });
+    }
+    constructor() {
+        this.DynamicDrawUsage = THREE.DynamicDrawUsage;
+        this.nullRaycast = () => null;
+        this.inputs = signalStore({ limit: 1000, frames: Infinity });
+        this.instancesRef = injectNgtRef();
+        this.limit = this.inputs.select('limit');
+        this.positionMeshes = signal([]);
+        this.meshes = this.positionMeshes.asReadonly();
+        this.buffers = computed(() => {
+            const limit = this.limit();
+            const matrices = new Float32Array(limit * 16);
+            for (let i = 0; i < limit; i++) {
+                tempMatrix.identity().toArray(matrices, i * 16);
+            }
+            const colors = new Float32Array([...Array.from({ length: limit * 3 }, () => 1)]);
+            return { matrices, colors };
+        });
+        this.api = {
+            getParent: () => this.instancesRef,
+            subscribe: (meshRef) => {
+                untracked(() => {
+                    this.positionMeshes.update((s) => [...s, meshRef]);
+                });
+                return () => {
+                    untracked(() => {
+                        this.positionMeshes.update((s) => s.filter((positionMesh) => positionMesh !== meshRef));
+                    });
+                };
+            },
+        };
+        this.checkUpdate();
+        this.beforeRender();
+    }
+    checkUpdate() {
+        effect(() => {
+            const instancedMesh = this.instancesRef.nativeElement;
+            if (!instancedMesh)
+                return;
+            // NOTE: not sure why matrices ends up a different instance than array
+            // we reassign it here
+            instancedMesh.instanceMatrix.array = untracked(this.buffers).matrices;
+            checkUpdate(instancedMesh.instanceMatrix);
+        });
+    }
+    beforeRender() {
+        let count = 0;
+        let updateRange = 0;
+        injectBeforeRender(() => {
+            const [{ frames, limit, range }, instancedMesh, instances, { matrices, colors }] = [
+                this.inputs.get(),
+                this.instancesRef.nativeElement,
+                this.meshes(),
+                this.buffers(),
+            ];
+            if ((frames === Infinity || count < frames) && instancedMesh) {
+                instancedMesh.updateMatrix();
+                instancedMesh.updateMatrixWorld();
+                parentMatrix.copy(instancedMesh.matrixWorld).invert();
+                updateRange = Math.min(limit, range !== undefined ? range : limit, instances.length);
+                instancedMesh.count = updateRange;
+                instancedMesh.instanceMatrix.updateRange.count = updateRange * 16;
+                if (instancedMesh.instanceColor) {
+                    instancedMesh.instanceColor.updateRange.count = updateRange * 3;
+                }
+                for (let i = 0; i < instances.length; i++) {
+                    const instanceRef = instances[i];
+                    const instance = is.ref(instanceRef) ? instanceRef.nativeElement : instanceRef;
+                    // Multiply the inverse of the InstancedMesh world matrix or else
+                    // Instances will be double-transformed if <Instances> isn't at identity
+                    instance.matrixWorld.decompose(translation, rotation, scale);
+                    instanceMatrix.compose(translation, rotation, scale).premultiply(parentMatrix);
+                    instanceMatrix.toArray(matrices, i * 16);
+                    checkUpdate(instancedMesh.instanceMatrix);
+                    instance.color.toArray(colors, i * 3);
+                    checkUpdate(instancedMesh.instanceColor);
+                }
+                count++;
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsInstances, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.2", type: NgtsInstances, isStandalone: true, selector: "ngts-instances", inputs: { instancesRef: "instancesRef", _range: ["range", "_range"], _limit: ["limit", "_limit"], _frames: ["frames", "_frames"] }, providers: [provideNgtsInstancesApi()], queries: [{ propertyName: "content", first: true, predicate: NgtsSobaContent, descendants: true, read: TemplateRef, static: true }], ngImport: i0, template: `
+		<ngt-instanced-mesh
+			[userData]="{ instances: meshes() }"
+			[ref]="instancesRef"
+			[matrixAutoUpdate]="false"
+			[raycast]="nullRaycast"
+			ngtCompound
+		>
+			<ngt-instanced-buffer-attribute
+				*args="[buffers().matrices, 16]"
+				attach="instanceMatrix"
+				[usage]="DynamicDrawUsage"
+			/>
+			<ngt-instanced-buffer-attribute
+				*args="[buffers().colors, 3]"
+				attach="instanceColor"
+				[usage]="DynamicDrawUsage"
+			/>
+			<ng-container *ngTemplateOutlet="content" />
+		</ngt-instanced-mesh>
+	`, isInline: true, dependencies: [{ kind: "directive", type: NgtArgs, selector: "ng-template[args]", inputs: ["args"] }, { kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsInstances, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-instances',
+                    standalone: true,
+                    template: `
+		<ngt-instanced-mesh
+			[userData]="{ instances: meshes() }"
+			[ref]="instancesRef"
+			[matrixAutoUpdate]="false"
+			[raycast]="nullRaycast"
+			ngtCompound
+		>
+			<ngt-instanced-buffer-attribute
+				*args="[buffers().matrices, 16]"
+				attach="instanceMatrix"
+				[usage]="DynamicDrawUsage"
+			/>
+			<ngt-instanced-buffer-attribute
+				*args="[buffers().colors, 3]"
+				attach="instanceColor"
+				[usage]="DynamicDrawUsage"
+			/>
+			<ng-container *ngTemplateOutlet="content" />
+		</ngt-instanced-mesh>
+	`,
+                    imports: [NgtArgs, NgTemplateOutlet],
+                    providers: [provideNgtsInstancesApi()],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { instancesRef: [{
+                type: Input
+            }], _range: [{
+                type: Input,
+                args: [{ alias: 'range' }]
+            }], _limit: [{
+                type: Input,
+                args: [{ alias: 'limit' }]
+            }], _frames: [{
+                type: Input,
+                args: [{ alias: 'frames' }]
+            }], content: [{
+                type: ContentChild,
+                args: [NgtsSobaContent, { static: true, read: TemplateRef }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"instances.js","sourceRoot":"","sources":["../../../../../../libs/soba/performances/src/instances/instances.ts"],"names":[],"mappings":"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","sourcesContent":["import { NgTemplateOutlet } from '@angular/common';\nimport {\n\tComponent,\n\tcomputed,\n\tContentChild,\n\tCUSTOM_ELEMENTS_SCHEMA,\n\teffect,\n\tforwardRef,\n\tinject,\n\tInjector,\n\tInput,\n\tNgZone,\n\tsignal,\n\tTemplateRef,\n\tuntracked,\n} from '@angular/core';\nimport {\n\tcheckUpdate,\n\tcreateInjectionToken,\n\textend,\n\tinjectBeforeRender,\n\tinjectNgtRef,\n\tis,\n\tNgtArgs,\n\tsignalStore,\n\ttype NgtGroup,\n\ttype NgtInstancedMesh,\n\ttype NgtRef,\n} from 'angular-three';\nimport { NgtsSobaContent } from 'angular-three-soba/utils';\nimport * as THREE from 'three';\nimport { InstancedBufferAttribute, InstancedMesh } from 'three';\nimport { PositionMesh } from './position-mesh';\n\nextend({ PositionMesh, InstancedMesh, InstancedBufferAttribute });\n\nexport type NgtsInstancesState = {\n\trange?: number;\n\tlimit: number;\n\tframes: number;\n};\n\ndeclare global {\n\tinterface HTMLElementTagNameMap {\n\t\t/**\n\t\t * @extends ngt-group\n\t\t */\n\t\t'ngt-position-mesh': PositionMesh & NgtGroup;\n\t\t/**\n\t\t * @extends ngt-instanced-mesh\n\t\t */\n\t\t'ngts-instances': NgtsInstancesState & NgtInstancedMesh;\n\t}\n}\n\nconst parentMatrix = /*@__PURE__*/ new THREE.Matrix4();\nconst instanceMatrix = /*@__PURE__*/ new THREE.Matrix4();\nconst tempMatrix = /*@__PURE__*/ new THREE.Matrix4();\nconst translation = /*@__PURE__*/ new THREE.Vector3();\nconst rotation = /*@__PURE__*/ new THREE.Quaternion();\nconst scale = /*@__PURE__*/ new THREE.Vector3();\n\nexport const [injectNgtsInstancesApi, provideNgtsInstancesApi] = createInjectionToken(\n\t(instances: NgtsInstances) => instances.api,\n\t{ isRoot: false, deps: [forwardRef(() => NgtsInstances)] },\n);\n\n@Component({\n\tselector: 'ngts-instance',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-position-mesh\n\t\t\t[ref]=\"instanceRef\"\n\t\t\t[instance]=\"instancesApi.getParent()\"\n\t\t\t[instanceKey]=\"instanceRef\"\n\t\t\tngtCompound\n\t\t>\n\t\t\t<ng-content />\n\t\t</ngt-position-mesh>\n\t`,\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsInstance {\n\t@Input() instanceRef = injectNgtRef<PositionMesh>();\n\n\tprivate zone = inject(NgZone);\n\tprivate injector = inject(Injector);\n\tinstancesApi = injectNgtsInstancesApi();\n\n\tngOnInit() {\n\t\teffect(\n\t\t\t(onCleanup) => {\n\t\t\t\tconst cleanup = this.zone.runOutsideAngular(() => this.instancesApi.subscribe(this.instanceRef));\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-instances',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-instanced-mesh\n\t\t\t[userData]=\"{ instances: meshes() }\"\n\t\t\t[ref]=\"instancesRef\"\n\t\t\t[matrixAutoUpdate]=\"false\"\n\t\t\t[raycast]=\"nullRaycast\"\n\t\t\tngtCompound\n\t\t>\n\t\t\t<ngt-instanced-buffer-attribute\n\t\t\t\t*args=\"[buffers().matrices, 16]\"\n\t\t\t\tattach=\"instanceMatrix\"\n\t\t\t\t[usage]=\"DynamicDrawUsage\"\n\t\t\t/>\n\t\t\t<ngt-instanced-buffer-attribute\n\t\t\t\t*args=\"[buffers().colors, 3]\"\n\t\t\t\tattach=\"instanceColor\"\n\t\t\t\t[usage]=\"DynamicDrawUsage\"\n\t\t\t/>\n\t\t\t<ng-container *ngTemplateOutlet=\"content\" />\n\t\t</ngt-instanced-mesh>\n\t`,\n\timports: [NgtArgs, NgTemplateOutlet],\n\tproviders: [provideNgtsInstancesApi()],\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsInstances {\n\tDynamicDrawUsage = THREE.DynamicDrawUsage;\n\tnullRaycast = () => null;\n\n\tprivate inputs = signalStore<NgtsInstancesState>({ limit: 1000, frames: Infinity });\n\n\t@Input() instancesRef = injectNgtRef<InstancedMesh>();\n\n\t@Input({ alias: 'range' }) set _range(range: number) {\n\t\tthis.inputs.set({ range });\n\t}\n\n\t@Input({ alias: 'limit' }) set _limit(limit: number) {\n\t\tthis.inputs.set({ limit });\n\t}\n\n\t@Input({ alias: 'frames' }) set _frames(frames: number) {\n\t\tthis.inputs.set({ frames });\n\t}\n\n\t@ContentChild(NgtsSobaContent, { static: true, read: TemplateRef }) content!: TemplateRef<unknown>;\n\n\tprivate limit = this.inputs.select('limit');\n\n\tprivate positionMeshes = signal<NgtRef<PositionMesh>[]>([]);\n\tmeshes = this.positionMeshes.asReadonly();\n\n\tbuffers = computed(() => {\n\t\tconst limit = this.limit();\n\t\tconst matrices = new Float32Array(limit * 16);\n\n\t\tfor (let i = 0; i < limit; i++) {\n\t\t\ttempMatrix.identity().toArray(matrices, i * 16);\n\t\t}\n\n\t\tconst colors = new Float32Array([...Array.from({ length: limit * 3 }, () => 1)]);\n\t\treturn { matrices, colors };\n\t});\n\n\tapi = {\n\t\tgetParent: () => this.instancesRef,\n\t\tsubscribe: (meshRef: NgtRef<PositionMesh>) => {\n\t\t\tuntracked(() => {\n\t\t\t\tthis.positionMeshes.update((s) => [...s, meshRef]);\n\t\t\t});\n\t\t\treturn () => {\n\t\t\t\tuntracked(() => {\n\t\t\t\t\tthis.positionMeshes.update((s) => s.filter((positionMesh) => positionMesh !== meshRef));\n\t\t\t\t});\n\t\t\t};\n\t\t},\n\t};\n\n\tconstructor() {\n\t\tthis.checkUpdate();\n\t\tthis.beforeRender();\n\t}\n\n\tprivate checkUpdate() {\n\t\teffect(() => {\n\t\t\tconst instancedMesh = this.instancesRef.nativeElement;\n\t\t\tif (!instancedMesh) return;\n\t\t\t// NOTE: not sure why matrices ends up a different instance than array\n\t\t\t// we reassign it here\n\t\t\tinstancedMesh.instanceMatrix.array = untracked(this.buffers).matrices;\n\t\t\tcheckUpdate(instancedMesh.instanceMatrix);\n\t\t});\n\t}\n\n\tprivate beforeRender() {\n\t\tlet count = 0;\n\t\tlet updateRange = 0;\n\t\tinjectBeforeRender(() => {\n\t\t\tconst [{ frames, limit, range }, instancedMesh, instances, { matrices, colors }] = [\n\t\t\t\tthis.inputs.get(),\n\t\t\t\tthis.instancesRef.nativeElement,\n\t\t\t\tthis.meshes(),\n\t\t\t\tthis.buffers(),\n\t\t\t];\n\t\t\tif ((frames === Infinity || count < frames) && instancedMesh) {\n\t\t\t\tinstancedMesh.updateMatrix();\n\t\t\t\tinstancedMesh.updateMatrixWorld();\n\t\t\t\tparentMatrix.copy(instancedMesh.matrixWorld).invert();\n\n\t\t\t\tupdateRange = Math.min(limit, range !== undefined ? range : limit, instances.length);\n\t\t\t\tinstancedMesh.count = updateRange;\n\t\t\t\tinstancedMesh.instanceMatrix.updateRange.count = updateRange * 16;\n\t\t\t\tif (instancedMesh.instanceColor) {\n\t\t\t\t\tinstancedMesh.instanceColor.updateRange.count = updateRange * 3;\n\t\t\t\t}\n\n\t\t\t\tfor (let i = 0; i < instances.length; i++) {\n\t\t\t\t\tconst instanceRef = instances[i];\n\t\t\t\t\tconst instance = is.ref(instanceRef) ? instanceRef.nativeElement : instanceRef;\n\t\t\t\t\t// Multiply the inverse of the InstancedMesh world matrix or else\n\t\t\t\t\t// Instances will be double-transformed if <Instances> isn't at identity\n\t\t\t\t\tinstance.matrixWorld.decompose(translation, rotation, scale);\n\t\t\t\t\tinstanceMatrix.compose(translation, rotation, scale).premultiply(parentMatrix);\n\t\t\t\t\tinstanceMatrix.toArray(matrices, i * 16);\n\t\t\t\t\tcheckUpdate(instancedMesh.instanceMatrix);\n\t\t\t\t\tinstance.color.toArray(colors, i * 3);\n\t\t\t\t\tcheckUpdate(instancedMesh.instanceColor);\n\t\t\t\t}\n\t\t\t\tcount++;\n\t\t\t}\n\t\t});\n\t}\n}\n"]}

package/esm2022/performances/instances/position-mesh.mjs

@@ -0,0 +1,52 @@
+import { ElementRef } from '@angular/core';
+import * as THREE from 'three';
+const _instanceLocalMatrix = /*@__PURE__*/ new THREE.Matrix4();
+const _instanceWorldMatrix = /*@__PURE__*/ new THREE.Matrix4();
+const _instanceIntersects = /*@__PURE__*/ [];
+const _mesh = /*@__PURE__*/ new THREE.Mesh();
+export class PositionMesh extends THREE.Group {
+    constructor() {
+        super();
+        this.color = new THREE.Color('white');
+        this.instance = new ElementRef(undefined);
+        this.instanceKey = new ElementRef(undefined);
+    }
+    // This will allow the virtual instance have bounds
+    get geometry() {
+        return this.instance.nativeElement?.geometry;
+    }
+    // And this will allow the virtual instance to receive events
+    raycast(raycaster, intersects) {
+        const parent = this.instance.nativeElement;
+        if (!parent)
+            return;
+        if (!parent.geometry || !parent.material)
+            return;
+        _mesh.geometry = parent.geometry;
+        const matrixWorld = parent.matrixWorld;
+        const instanceId = parent.userData['instances'].indexOf(this.instanceKey);
+        // If the instance wasn't found or exceeds the parents draw range, bail out
+        if (instanceId === -1 || instanceId > parent.count)
+            return;
+        // calculate the world matrix for each instance
+        parent.getMatrixAt(instanceId, _instanceLocalMatrix);
+        _instanceWorldMatrix.multiplyMatrices(matrixWorld, _instanceLocalMatrix);
+        // the mesh represents this single instance
+        _mesh.matrixWorld = _instanceWorldMatrix;
+        // raycast side according to instance material
+        if (parent.material instanceof THREE.Material)
+            _mesh.material.side = parent.material.side;
+        else
+            _mesh.material.side = parent.material[0].side;
+        _mesh.raycast(raycaster, _instanceIntersects);
+        // process the result of raycast
+        for (let i = 0, l = _instanceIntersects.length; i < l; i++) {
+            const intersect = _instanceIntersects[i];
+            intersect.instanceId = instanceId;
+            intersect.object = this;
+            intersects.push(intersect);
+        }
+        _instanceIntersects.length = 0;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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.2.2", ngImport: i0, type: NgtsPointsInput, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.2", 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.2.2", 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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