angular-three-soba 2.0.0-beta.9 → 2.1.0

package/esm2022/performances/lib/instances/instances.mjs

@@ -0,0 +1,183 @@
+import { afterNextRender, ChangeDetectionStrategy, Component, computed, CUSTOM_ELEMENTS_SCHEMA, inject, input, viewChild, } from '@angular/core';
+import { checkUpdate, extend, injectBeforeRender, NgtArgs, omit, pick, resolveRef, } from 'angular-three';
+import { setUpdateRange } from 'angular-three-soba/misc';
+import { injectAutoEffect } from 'ngxtension/auto-effect';
+import { mergeInputs } from 'ngxtension/inject-inputs';
+import { DynamicDrawUsage, InstancedBufferAttribute, InstancedMesh, Matrix4, Quaternion, Vector3 } from 'three';
+import { PositionMesh } from './position-mesh';
+import * as i0 from "@angular/core";
+const parentMatrix = new Matrix4();
+const instanceMatrix = new Matrix4();
+const tempMatrix = new Matrix4();
+const translation = new Vector3();
+const rotation = new Quaternion();
+const scale = new Vector3();
+export class NgtsInstance {
+    constructor() {
+        this.options = input({});
+        this.instances = inject(NgtsInstances);
+        this.positionMeshRef = viewChild.required('positionMesh');
+        extend({ PositionMesh });
+        const autoEffect = injectAutoEffect();
+        afterNextRender(() => {
+            autoEffect(() => {
+                return this.instances.subscribe(this.positionMeshRef().nativeElement);
+            });
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsInstance, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "18.2.0", type: NgtsInstance, isStandalone: true, selector: "ngts-instance", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, viewQueries: [{ propertyName: "positionMeshRef", first: true, predicate: ["positionMesh"], descendants: true, isSignal: true }], ngImport: i0, template: `
+		<ngt-position-mesh #positionMesh [instance]="instances.instancedMeshRef()" [parameters]="options()">
+			<ng-content />
+		</ngt-position-mesh>
+	`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsInstance, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-instance',
+                    standalone: true,
+                    template: `
+		<ngt-position-mesh #positionMesh [instance]="instances.instancedMeshRef()" [parameters]="options()">
+			<ng-content />
+		</ngt-position-mesh>
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: () => [] });
+const defaultOptions = {
+    limit: 1000,
+    frames: Infinity,
+};
+export class NgtsInstances {
+    constructor() {
+        this.DynamicDrawUsage = DynamicDrawUsage;
+        this.options = input(defaultOptions, { transform: mergeInputs(defaultOptions) });
+        this.parameters = omit(this.options, ['limit', 'frames', 'range']);
+        this.instancedMeshRef = viewChild.required('instancedMesh');
+        this.limit = pick(this.options, 'limit');
+        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.instances = [];
+        extend({ InstancedMesh, InstancedBufferAttribute });
+        const autoEffect = injectAutoEffect();
+        afterNextRender(() => {
+            autoEffect(() => {
+                const instancedMesh = this.instancedMeshRef()?.nativeElement;
+                if (!instancedMesh)
+                    return;
+                checkUpdate(instancedMesh.instanceMatrix);
+            });
+        });
+        let iterations = 0;
+        let count = 0;
+        injectBeforeRender(() => {
+            const instancedMesh = this.instancedMeshRef()?.nativeElement;
+            if (!instancedMesh)
+                return;
+            const { frames, limit, range } = this.options();
+            const { matrices, colors } = this.buffers();
+            if (frames === Infinity || iterations < frames) {
+                instancedMesh.updateMatrix();
+                instancedMesh.updateMatrixWorld();
+                parentMatrix.copy(instancedMesh.matrixWorld).invert();
+                count = Math.min(limit, range !== undefined ? range : limit, this.instances.length);
+                instancedMesh.count = count;
+                setUpdateRange(instancedMesh.instanceMatrix, { offset: 0, count: count * 16 });
+                if (instancedMesh.instanceColor) {
+                    setUpdateRange(instancedMesh.instanceColor, { offset: 0, count: count * 3 });
+                }
+                for (let i = 0; i < this.instances.length; i++) {
+                    const instance = resolveRef(this.instances[i]);
+                    if (instance) {
+                        // 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);
+                    }
+                }
+                iterations++;
+            }
+        });
+    }
+    subscribe(ref) {
+        this.instances.push(ref);
+        return () => {
+            this.instances = this.instances.filter((i) => i !== ref);
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsInstances, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "18.2.0", type: NgtsInstances, isStandalone: true, selector: "ngts-instances", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, viewQueries: [{ propertyName: "instancedMeshRef", first: true, predicate: ["instancedMesh"], descendants: true, isSignal: true }], ngImport: i0, template: `
+		<ngt-instanced-mesh
+			#instancedMesh
+			[userData]="{ instances }"
+			[matrixAutoUpdate]="false"
+			[raycast]="null"
+			[parameters]="parameters()"
+		>
+			<ngt-instanced-buffer-attribute
+				attach="instanceMatrix"
+				[usage]="DynamicDrawUsage"
+				[count]="buffers().matrices.length / 16"
+				[array]="buffers().matrices"
+				[itemSize]="16"
+			/>
+			<ngt-instanced-buffer-attribute
+				attach="instanceColor"
+				[usage]="DynamicDrawUsage"
+				[count]="buffers().colors.length / 3"
+				[array]="buffers().colors"
+				[itemSize]="3"
+			/>
+			<ng-content />
+		</ngt-instanced-mesh>
+	`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsInstances, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-instances',
+                    standalone: true,
+                    template: `
+		<ngt-instanced-mesh
+			#instancedMesh
+			[userData]="{ instances }"
+			[matrixAutoUpdate]="false"
+			[raycast]="null"
+			[parameters]="parameters()"
+		>
+			<ngt-instanced-buffer-attribute
+				attach="instanceMatrix"
+				[usage]="DynamicDrawUsage"
+				[count]="buffers().matrices.length / 16"
+				[array]="buffers().matrices"
+				[itemSize]="16"
+			/>
+			<ngt-instanced-buffer-attribute
+				attach="instanceColor"
+				[usage]="DynamicDrawUsage"
+				[count]="buffers().colors.length / 3"
+				[array]="buffers().colors"
+				[itemSize]="3"
+			/>
+			<ng-content />
+		</ngt-instanced-mesh>
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [NgtArgs],
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"instances.js","sourceRoot":"","sources":["../../../../../../../libs/soba/performances/src/lib/instances/instances.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n\tafterNextRender,\n\tChangeDetectionStrategy,\n\tComponent,\n\tcomputed,\n\tCUSTOM_ELEMENTS_SCHEMA,\n\tElementRef,\n\tinject,\n\tinput,\n\tviewChild,\n} from '@angular/core';\nimport {\n\tcheckUpdate,\n\textend,\n\tinjectBeforeRender,\n\tNgtArgs,\n\tNgtInstancedMesh,\n\tomit,\n\tpick,\n\tresolveRef,\n} from 'angular-three';\nimport { setUpdateRange } from 'angular-three-soba/misc';\nimport { injectAutoEffect } from 'ngxtension/auto-effect';\nimport { mergeInputs } from 'ngxtension/inject-inputs';\nimport { DynamicDrawUsage, InstancedBufferAttribute, InstancedMesh, Matrix4, Quaternion, Vector3 } from 'three';\nimport { NgtPositionMesh, PositionMesh } from './position-mesh';\n\nconst parentMatrix = new Matrix4();\nconst instanceMatrix = new Matrix4();\nconst tempMatrix = new Matrix4();\nconst translation = new Vector3();\nconst rotation = new Quaternion();\nconst scale = new Vector3();\n\n@Component({\n\tselector: 'ngts-instance',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-position-mesh #positionMesh [instance]=\"instances.instancedMeshRef()\" [parameters]=\"options()\">\n\t\t\t<ng-content />\n\t\t</ngt-position-mesh>\n\t`,\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class NgtsInstance {\n\toptions = input({} as Partial<NgtPositionMesh>);\n\n\tinstances = inject(NgtsInstances);\n\n\tpositionMeshRef = viewChild.required<ElementRef<PositionMesh>>('positionMesh');\n\n\tconstructor() {\n\t\textend({ PositionMesh });\n\n\t\tconst autoEffect = injectAutoEffect();\n\n\t\tafterNextRender(() => {\n\t\t\tautoEffect(() => {\n\t\t\t\treturn this.instances.subscribe(this.positionMeshRef().nativeElement);\n\t\t\t});\n\t\t});\n\t}\n}\n\nexport interface NgtsInstancesOptions extends Partial<NgtInstancedMesh> {\n\trange?: number;\n\tlimit: number;\n\tframes: number;\n}\n\nconst defaultOptions: NgtsInstancesOptions = {\n\tlimit: 1000,\n\tframes: Infinity,\n};\n\n@Component({\n\tselector: 'ngts-instances',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-instanced-mesh\n\t\t\t#instancedMesh\n\t\t\t[userData]=\"{ instances }\"\n\t\t\t[matrixAutoUpdate]=\"false\"\n\t\t\t[raycast]=\"null\"\n\t\t\t[parameters]=\"parameters()\"\n\t\t>\n\t\t\t<ngt-instanced-buffer-attribute\n\t\t\t\tattach=\"instanceMatrix\"\n\t\t\t\t[usage]=\"DynamicDrawUsage\"\n\t\t\t\t[count]=\"buffers().matrices.length / 16\"\n\t\t\t\t[array]=\"buffers().matrices\"\n\t\t\t\t[itemSize]=\"16\"\n\t\t\t/>\n\t\t\t<ngt-instanced-buffer-attribute\n\t\t\t\tattach=\"instanceColor\"\n\t\t\t\t[usage]=\"DynamicDrawUsage\"\n\t\t\t\t[count]=\"buffers().colors.length / 3\"\n\t\t\t\t[array]=\"buffers().colors\"\n\t\t\t\t[itemSize]=\"3\"\n\t\t\t/>\n\t\t\t<ng-content />\n\t\t</ngt-instanced-mesh>\n\t`,\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n\timports: [NgtArgs],\n})\nexport class NgtsInstances {\n\tprotected readonly DynamicDrawUsage = DynamicDrawUsage;\n\n\toptions = input(defaultOptions, { transform: mergeInputs(defaultOptions) });\n\tparameters = omit(this.options, ['limit', 'frames', 'range']);\n\n\tinstancedMeshRef = viewChild.required<ElementRef<InstancedMesh>>('instancedMesh');\n\n\tlimit = pick(this.options, 'limit');\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\tinstances: Array<ElementRef<PositionMesh> | PositionMesh> = [];\n\n\tconstructor() {\n\t\textend({ InstancedMesh, InstancedBufferAttribute });\n\n\t\tconst autoEffect = injectAutoEffect();\n\n\t\tafterNextRender(() => {\n\t\t\tautoEffect(() => {\n\t\t\t\tconst instancedMesh = this.instancedMeshRef()?.nativeElement;\n\t\t\t\tif (!instancedMesh) return;\n\t\t\t\tcheckUpdate(instancedMesh.instanceMatrix);\n\t\t\t});\n\t\t});\n\n\t\tlet iterations = 0;\n\t\tlet count = 0;\n\n\t\tinjectBeforeRender(() => {\n\t\t\tconst instancedMesh = this.instancedMeshRef()?.nativeElement;\n\t\t\tif (!instancedMesh) return;\n\t\t\tconst { frames, limit, range } = this.options();\n\t\t\tconst { matrices, colors } = this.buffers();\n\t\t\tif (frames === Infinity || iterations < frames) {\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\tcount = Math.min(limit, range !== undefined ? range : limit, this.instances.length);\n\t\t\t\tinstancedMesh.count = count;\n\t\t\t\tsetUpdateRange(instancedMesh.instanceMatrix, { offset: 0, count: count * 16 });\n\t\t\t\tif (instancedMesh.instanceColor) {\n\t\t\t\t\tsetUpdateRange(instancedMesh.instanceColor, { offset: 0, count: count * 3 });\n\t\t\t\t}\n\n\t\t\t\tfor (let i = 0; i < this.instances.length; i++) {\n\t\t\t\t\tconst instance = resolveRef(this.instances[i]);\n\t\t\t\t\tif (instance) {\n\t\t\t\t\t\t// Multiply the inverse of the InstancedMesh world matrix or else\n\t\t\t\t\t\t// Instances will be double-transformed if <Instances> isn't at identity\n\t\t\t\t\t\tinstance.matrixWorld.decompose(translation, rotation, scale);\n\t\t\t\t\t\tinstanceMatrix.compose(translation, rotation, scale).premultiply(parentMatrix);\n\t\t\t\t\t\tinstanceMatrix.toArray(matrices, i * 16);\n\t\t\t\t\t\tcheckUpdate(instancedMesh.instanceMatrix);\n\t\t\t\t\t\tinstance.color.toArray(colors, i * 3);\n\t\t\t\t\t\tcheckUpdate(instancedMesh.instanceColor);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\titerations++;\n\t\t\t}\n\t\t});\n\t}\n\n\tsubscribe(ref: ElementRef<PositionMesh> | PositionMesh) {\n\t\tthis.instances.push(ref);\n\t\treturn () => {\n\t\t\tthis.instances = this.instances.filter((i) => i !== ref);\n\t\t};\n\t}\n}\n"]}

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

@@ -0,0 +1,51 @@
+import { resolveRef } from 'angular-three';
+import { Color, Group, Material, Matrix4, Mesh, } from 'three';
+const _instanceLocalMatrix = new Matrix4();
+const _instanceWorldMatrix = new Matrix4();
+const _instanceIntersects = [];
+const _mesh = new Mesh();
+export class PositionMesh extends Group {
+    constructor() {
+        super();
+        this.color = new Color('white');
+        this.instance = undefined;
+    }
+    // This will allow the virtual instance have bounds
+    get geometry() {
+        return resolveRef(this.instance)?.geometry;
+    }
+    // And this will allow the virtual instance to receive events
+    raycast(raycaster, intersects) {
+        const parent = resolveRef(this.instance);
+        if (!parent)
+            return;
+        if (!parent.geometry || !parent.material)
+            return;
+        _mesh.geometry = parent.geometry;
+        const matrixWorld = parent.matrixWorld;
+        const instanceId = parent.userData['instances'].indexOf(this);
+        // 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 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/lib/points/points.mjs

@@ -0,0 +1,278 @@
+import { afterNextRender, ChangeDetectionStrategy, Component, computed, CUSTOM_ELEMENTS_SCHEMA, inject, input, viewChild, } from '@angular/core';
+import { checkUpdate, extend, injectBeforeRender, omit, pick, resolveRef } from 'angular-three';
+import { injectAutoEffect } from 'ngxtension/auto-effect';
+import { mergeInputs } from 'ngxtension/inject-inputs';
+import { BufferAttribute, BufferGeometry, DynamicDrawUsage, Matrix4, Points, Vector3 } from 'three';
+import { PositionPoint } from './position-point';
+import * as i0 from "@angular/core";
+export class NgtsPoint {
+    constructor() {
+        this.options = input({});
+        this.positionPointRef = viewChild.required('positionPoint');
+        this.points = inject(NgtsPointsInstances);
+        extend({ PositionPoint });
+        const autoEffect = injectAutoEffect();
+        afterNextRender(() => {
+            autoEffect(() => {
+                return this.points.subscribe(this.positionPointRef().nativeElement);
+            });
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsPoint, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "18.2.0", type: NgtsPoint, isStandalone: true, selector: "ngts-point", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, viewQueries: [{ propertyName: "positionPointRef", first: true, predicate: ["positionPoint"], descendants: true, isSignal: true }], ngImport: i0, template: `
+		<ngt-position-point #positionPoint [parameters]="options()" [instance]="points.pointsRef()">
+			<ng-content />
+		</ngt-position-point>
+	`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsPoint, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-point',
+                    standalone: true,
+                    template: `
+		<ngt-position-point #positionPoint [parameters]="options()" [instance]="points.pointsRef()">
+			<ng-content />
+		</ngt-position-point>
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: () => [] });
+export class NgtsPointsBuffer {
+    constructor() {
+        this.positions = input.required();
+        this.colors = input();
+        this.sizes = input();
+        this.stride = input(3);
+        this.options = input({});
+        this.pointsRef = viewChild.required('points');
+        this.DynamicDrawUsage = DynamicDrawUsage;
+        extend({ Points, BufferAttribute, BufferGeometry });
+        injectBeforeRender(() => {
+            const points = this.pointsRef()?.nativeElement;
+            if (!points)
+                return;
+            const attributes = points.geometry.attributes;
+            checkUpdate(attributes['position']);
+            if (this.colors())
+                checkUpdate(attributes['color']);
+            if (this.sizes())
+                checkUpdate(attributes['size']);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsPointsBuffer, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.0", type: NgtsPointsBuffer, isStandalone: true, selector: "ngts-points-buffer", inputs: { positions: { classPropertyName: "positions", publicName: "positions", isSignal: true, isRequired: true, transformFunction: null }, colors: { classPropertyName: "colors", publicName: "colors", isSignal: true, isRequired: false, transformFunction: null }, sizes: { classPropertyName: "sizes", publicName: "sizes", isSignal: true, isRequired: false, transformFunction: null }, stride: { classPropertyName: "stride", publicName: "stride", isSignal: true, isRequired: false, transformFunction: null }, options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, viewQueries: [{ propertyName: "pointsRef", first: true, predicate: ["points"], descendants: true, isSignal: true }], ngImport: i0, template: `
+		<ngt-points #points [parameters]="options()">
+			<ngt-buffer-geometry>
+				<ngt-buffer-attribute
+					attach="attributes.position"
+					[count]="positions().length / stride()"
+					[array]="positions()"
+					[itemSize]="stride()"
+					[usage]="DynamicDrawUsage"
+				/>
+				@if (colors(); as colors) {
+					<ngt-buffer-attribute
+						attach="attributes.color"
+						[count]="colors.length / stride()"
+						[array]="colors"
+						[itemSize]="3"
+						[usage]="DynamicDrawUsage"
+					/>
+				}
+				@if (sizes(); as sizes) {
+					<ngt-buffer-attribute
+						attach="attributes.size"
+						[count]="sizes.length / stride()"
+						[array]="sizes"
+						[itemSize]="1"
+						[usage]="DynamicDrawUsage"
+					/>
+				}
+			</ngt-buffer-geometry>
+			<ng-content />
+		</ngt-points>
+	`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsPointsBuffer, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-points-buffer',
+                    standalone: true,
+                    template: `
+		<ngt-points #points [parameters]="options()">
+			<ngt-buffer-geometry>
+				<ngt-buffer-attribute
+					attach="attributes.position"
+					[count]="positions().length / stride()"
+					[array]="positions()"
+					[itemSize]="stride()"
+					[usage]="DynamicDrawUsage"
+				/>
+				@if (colors(); as colors) {
+					<ngt-buffer-attribute
+						attach="attributes.color"
+						[count]="colors.length / stride()"
+						[array]="colors"
+						[itemSize]="3"
+						[usage]="DynamicDrawUsage"
+					/>
+				}
+				@if (sizes(); as sizes) {
+					<ngt-buffer-attribute
+						attach="attributes.size"
+						[count]="sizes.length / stride()"
+						[array]="sizes"
+						[itemSize]="1"
+						[usage]="DynamicDrawUsage"
+					/>
+				}
+			</ngt-buffer-geometry>
+			<ng-content />
+		</ngt-points>
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: () => [] });
+const parentMatrix = new Matrix4();
+const position = new Vector3();
+const defaultInstancesOptions = { limit: 1000 };
+export class NgtsPointsInstances {
+    constructor() {
+        this.options = input(defaultInstancesOptions, { transform: mergeInputs(defaultInstancesOptions) });
+        this.parameters = omit(this.options, ['limit', 'range']);
+        this.pointsRef = viewChild.required('points');
+        this.limit = pick(this.options, 'limit');
+        this.buffers = computed(() => {
+            const limit = this.limit();
+            return {
+                positions: new Float32Array(limit * 3),
+                colors: Float32Array.from({ length: limit * 3 }, () => 1),
+                sizes: Float32Array.from({ length: limit }, () => 1),
+            };
+        });
+        this.positionPoints = [];
+        this.DynamicDrawUsage = DynamicDrawUsage;
+        extend({ Points, BufferAttribute, BufferGeometry });
+        const autoEffect = injectAutoEffect();
+        afterNextRender(() => {
+            autoEffect(() => {
+                const points = this.pointsRef()?.nativeElement;
+                if (!points)
+                    return;
+                checkUpdate(points.geometry.attributes['position']);
+            });
+        });
+        injectBeforeRender(() => {
+            const points = this.pointsRef()?.nativeElement;
+            if (!points)
+                return;
+            const { limit, range } = this.options();
+            const { positions, sizes, colors } = this.buffers();
+            points.updateMatrix();
+            points.updateMatrixWorld();
+            parentMatrix.copy(points.matrixWorld).invert();
+            points.geometry.drawRange.count = Math.min(limit, range !== undefined ? range : limit, this.positionPoints.length);
+            for (let i = 0; i < this.positionPoints.length; i++) {
+                const positionPoint = resolveRef(this.positionPoints[i]);
+                if (positionPoint) {
+                    positionPoint.getWorldPosition(position).applyMatrix4(parentMatrix);
+                    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']);
+                }
+            }
+        });
+    }
+    subscribe(ref) {
+        this.positionPoints.push(ref);
+        return () => {
+            this.positionPoints = this.positionPoints.filter((p) => p !== ref);
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsPointsInstances, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "18.2.0", type: NgtsPointsInstances, isStandalone: true, selector: "ngts-points-instances", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, viewQueries: [{ propertyName: "pointsRef", first: true, predicate: ["points"], descendants: true, isSignal: true }], ngImport: i0, template: `
+		<ngt-points
+			#points
+			[userData]="{ instances: positionPoints }"
+			[matrixAutoUpdate]="false"
+			[raycast]="null"
+			[parameters]="parameters()"
+		>
+			<ngt-buffer-geometry>
+				<ngt-buffer-attribute
+					attach="attributes.position"
+					[count]="buffers().positions.length / 3"
+					[array]="buffers().positions"
+					[itemSize]="3"
+					[usage]="DynamicDrawUsage"
+				/>
+				<ngt-buffer-attribute
+					attach="attributes.color"
+					[count]="buffers().colors.length / 3"
+					[array]="buffers().colors"
+					[itemSize]="3"
+					[usage]="DynamicDrawUsage"
+				/>
+				<ngt-buffer-attribute
+					attach="attributes.size"
+					[count]="buffers().sizes.length"
+					[array]="buffers().sizes"
+					[itemSize]="1"
+					[usage]="DynamicDrawUsage"
+				/>
+			</ngt-buffer-geometry>
+			<ng-content />
+		</ngt-points>
+	`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsPointsInstances, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-points-instances',
+                    standalone: true,
+                    template: `
+		<ngt-points
+			#points
+			[userData]="{ instances: positionPoints }"
+			[matrixAutoUpdate]="false"
+			[raycast]="null"
+			[parameters]="parameters()"
+		>
+			<ngt-buffer-geometry>
+				<ngt-buffer-attribute
+					attach="attributes.position"
+					[count]="buffers().positions.length / 3"
+					[array]="buffers().positions"
+					[itemSize]="3"
+					[usage]="DynamicDrawUsage"
+				/>
+				<ngt-buffer-attribute
+					attach="attributes.color"
+					[count]="buffers().colors.length / 3"
+					[array]="buffers().colors"
+					[itemSize]="3"
+					[usage]="DynamicDrawUsage"
+				/>
+				<ngt-buffer-attribute
+					attach="attributes.size"
+					[count]="buffers().sizes.length"
+					[array]="buffers().sizes"
+					[itemSize]="1"
+					[usage]="DynamicDrawUsage"
+				/>
+			</ngt-buffer-geometry>
+			<ng-content />
+		</ngt-points>
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"points.js","sourceRoot":"","sources":["../../../../../../../libs/soba/performances/src/lib/points/points.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n\tafterNextRender,\n\tChangeDetectionStrategy,\n\tComponent,\n\tcomputed,\n\tCUSTOM_ELEMENTS_SCHEMA,\n\tElementRef,\n\tinject,\n\tinput,\n\tviewChild,\n} from '@angular/core';\nimport { checkUpdate, extend, injectBeforeRender, NgtPoints, omit, pick, resolveRef } from 'angular-three';\nimport { injectAutoEffect } from 'ngxtension/auto-effect';\nimport { mergeInputs } from 'ngxtension/inject-inputs';\nimport { BufferAttribute, BufferGeometry, DynamicDrawUsage, Matrix4, Points, Vector3 } from 'three';\nimport { NgtPositionPoint, PositionPoint } from './position-point';\n\n@Component({\n\tselector: 'ngts-point',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-position-point #positionPoint [parameters]=\"options()\" [instance]=\"points.pointsRef()\">\n\t\t\t<ng-content />\n\t\t</ngt-position-point>\n\t`,\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class NgtsPoint {\n\toptions = input({} as Partial<NgtPositionPoint>);\n\n\tpositionPointRef = viewChild.required<ElementRef<PositionPoint>>('positionPoint');\n\n\tpoints = inject(NgtsPointsInstances);\n\n\tconstructor() {\n\t\textend({ PositionPoint });\n\n\t\tconst autoEffect = injectAutoEffect();\n\n\t\tafterNextRender(() => {\n\t\t\tautoEffect(() => {\n\t\t\t\treturn this.points.subscribe(this.positionPointRef().nativeElement);\n\t\t\t});\n\t\t});\n\t}\n}\n\n@Component({\n\tselector: 'ngts-points-buffer',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-points #points [parameters]=\"options()\">\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 / stride()\"\n\t\t\t\t\t[array]=\"positions()\"\n\t\t\t\t\t[itemSize]=\"stride()\"\n\t\t\t\t\t[usage]=\"DynamicDrawUsage\"\n\t\t\t\t/>\n\t\t\t\t@if (colors(); as colors) {\n\t\t\t\t\t<ngt-buffer-attribute\n\t\t\t\t\t\tattach=\"attributes.color\"\n\t\t\t\t\t\t[count]=\"colors.length / stride()\"\n\t\t\t\t\t\t[array]=\"colors\"\n\t\t\t\t\t\t[itemSize]=\"3\"\n\t\t\t\t\t\t[usage]=\"DynamicDrawUsage\"\n\t\t\t\t\t/>\n\t\t\t\t}\n\t\t\t\t@if (sizes(); as sizes) {\n\t\t\t\t\t<ngt-buffer-attribute\n\t\t\t\t\t\tattach=\"attributes.size\"\n\t\t\t\t\t\t[count]=\"sizes.length / stride()\"\n\t\t\t\t\t\t[array]=\"sizes\"\n\t\t\t\t\t\t[itemSize]=\"1\"\n\t\t\t\t\t\t[usage]=\"DynamicDrawUsage\"\n\t\t\t\t\t/>\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\tchangeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class NgtsPointsBuffer {\n\tpositions = input.required<Float32Array>();\n\tcolors = input<Float32Array>();\n\tsizes = input<Float32Array>();\n\tstride = input<2 | 3>(3);\n\toptions = input({} as Partial<NgtPositionPoint>);\n\n\tpointsRef = viewChild.required<ElementRef<Points>>('points');\n\n\tconstructor() {\n\t\textend({ Points, BufferAttribute, BufferGeometry });\n\n\t\tinjectBeforeRender(() => {\n\t\t\tconst points = this.pointsRef()?.nativeElement;\n\t\t\tif (!points) return;\n\n\t\t\tconst attributes = points.geometry.attributes;\n\t\t\tcheckUpdate(attributes['position']);\n\t\t\tif (this.colors()) checkUpdate(attributes['color']);\n\t\t\tif (this.sizes()) checkUpdate(attributes['size']);\n\t\t});\n\t}\n\n\tprotected readonly DynamicDrawUsage = DynamicDrawUsage;\n}\n\nconst parentMatrix = new Matrix4();\nconst position = new Vector3();\n\nexport interface NgtsPointsInstancesOptions extends Partial<NgtPoints> {\n\trange?: number;\n\tlimit: number;\n}\n\nconst defaultInstancesOptions: NgtsPointsInstancesOptions = { limit: 1000 };\n\n@Component({\n\tselector: 'ngts-points-instances',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-points\n\t\t\t#points\n\t\t\t[userData]=\"{ instances: positionPoints }\"\n\t\t\t[matrixAutoUpdate]=\"false\"\n\t\t\t[raycast]=\"null\"\n\t\t\t[parameters]=\"parameters()\"\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]=\"buffers().positions.length / 3\"\n\t\t\t\t\t[array]=\"buffers().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]=\"buffers().colors.length / 3\"\n\t\t\t\t\t[array]=\"buffers().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]=\"buffers().sizes.length\"\n\t\t\t\t\t[array]=\"buffers().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\tchangeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class NgtsPointsInstances {\n\toptions = input(defaultInstancesOptions, { transform: mergeInputs(defaultInstancesOptions) });\n\tparameters = omit(this.options, ['limit', 'range']);\n\n\tpointsRef = viewChild.required<ElementRef<Points>>('points');\n\n\tprivate limit = pick(this.options, 'limit');\n\n\tbuffers = computed(() => {\n\t\tconst limit = this.limit();\n\n\t\treturn {\n\t\t\tpositions: new Float32Array(limit * 3),\n\t\t\tcolors: Float32Array.from({ length: limit * 3 }, () => 1),\n\t\t\tsizes: Float32Array.from({ length: limit }, () => 1),\n\t\t};\n\t});\n\n\tpositionPoints: Array<ElementRef<PositionPoint> | PositionPoint> = [];\n\n\tconstructor() {\n\t\textend({ Points, BufferAttribute, BufferGeometry });\n\t\tconst autoEffect = injectAutoEffect();\n\n\t\tafterNextRender(() => {\n\t\t\tautoEffect(() => {\n\t\t\t\tconst points = this.pointsRef()?.nativeElement;\n\t\t\t\tif (!points) return;\n\t\t\t\tcheckUpdate(points.geometry.attributes['position']);\n\t\t\t});\n\t\t});\n\n\t\tinjectBeforeRender(() => {\n\t\t\tconst points = this.pointsRef()?.nativeElement;\n\t\t\tif (!points) return;\n\n\t\t\tconst { limit, range } = this.options();\n\t\t\tconst { positions, sizes, colors } = this.buffers();\n\n\t\t\tpoints.updateMatrix();\n\t\t\tpoints.updateMatrixWorld();\n\t\t\tparentMatrix.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\tthis.positionPoints.length,\n\t\t\t);\n\n\t\t\tfor (let i = 0; i < this.positionPoints.length; i++) {\n\t\t\t\tconst positionPoint = resolveRef(this.positionPoints[i]);\n\t\t\t\tif (positionPoint) {\n\t\t\t\t\tpositionPoint.getWorldPosition(position).applyMatrix4(parentMatrix);\n\t\t\t\t\tposition.toArray(positions, i * 3);\n\t\t\t\t\tcheckUpdate(points.geometry.attributes['position']);\n\n\t\t\t\t\tpositionPoint.matrixWorldNeedsUpdate = true;\n\t\t\t\t\tpositionPoint.color.toArray(colors, i * 3);\n\t\t\t\t\tcheckUpdate(points.geometry.attributes['color']);\n\n\t\t\t\t\tsizes.set([positionPoint.size], i);\n\t\t\t\t\tcheckUpdate(points.geometry.attributes['size']);\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\t}\n\n\tsubscribe(ref: ElementRef<PositionPoint> | PositionPoint) {\n\t\tthis.positionPoints.push(ref);\n\t\treturn () => {\n\t\t\tthis.positionPoints = this.positionPoints.filter((p) => p !== ref);\n\t\t};\n\t}\n\n\tprotected readonly DynamicDrawUsage = DynamicDrawUsage;\n}\n"]}

package/esm2022/performances/lib/points/position-point.mjs

@@ -0,0 +1,53 @@
+import { resolveRef } from 'angular-three';
+import { Color, Group, Matrix4, Ray, Sphere, Vector3 } from 'three';
+const _inverseMatrix = new Matrix4();
+const _ray = new Ray();
+const _sphere = new Sphere();
+const _position = new Vector3();
+export class PositionPoint extends Group {
+    constructor() {
+        super();
+        this.size = 0;
+        this.color = new Color('white');
+        this.instance = undefined;
+    }
+    // This will allow the virtual instance have bounds
+    get geometry() {
+        return resolveRef(this.instance)?.geometry;
+    }
+    raycast(raycaster, intersects) {
+        const parent = resolveRef(this.instance);
+        if (!parent || !parent.geometry)
+            return;
+        const instanceId = parent.userData['instances'].indexOf(this);
+        // If the instance wasn't found or exceeds the parents draw range, bail out
+        if (instanceId === -1 || instanceId > parent.geometry.drawRange.count)
+            return;
+        const threshold = raycaster.params.Points?.threshold ?? 1;
+        _sphere.set(this.getWorldPosition(_position), threshold);
+        if (raycaster.ray.intersectsSphere(_sphere) === false)
+            return;
+        _inverseMatrix.copy(parent.matrixWorld).invert();
+        _ray.copy(raycaster.ray).applyMatrix4(_inverseMatrix);
+        const localThreshold = threshold / ((this.scale.x + this.scale.y + this.scale.z) / 3);
+        const localThresholdSq = localThreshold * localThreshold;
+        const rayPointDistanceSq = _ray.distanceSqToPoint(this.position);
+        if (rayPointDistanceSq < localThresholdSq) {
+            const intersectPoint = new Vector3();
+            _ray.closestPointToPoint(this.position, intersectPoint);
+            intersectPoint.applyMatrix4(this.matrixWorld);
+            const distance = raycaster.ray.origin.distanceTo(intersectPoint);
+            if (distance < raycaster.near || distance > raycaster.far)
+                return;
+            intersects.push({
+                distance: distance,
+                distanceToRay: Math.sqrt(rayPointDistanceSq),
+                point: intersectPoint,
+                index: instanceId,
+                face: null,
+                object: this,
+            });
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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