angular-three-soba 2.0.0-beta.3 → 2.0.0-beta.30

package/esm2022/misc/shadow/shadow.mjs

@@ -0,0 +1,111 @@
+import { CUSTOM_ELEMENTS_SCHEMA, Component, Input, computed } from '@angular/core';
+import { NgtArgs, extend, injectNgtRef, signalStore } from 'angular-three';
+import * as THREE from 'three';
+import { CanvasTexture, Mesh, MeshBasicMaterial, PlaneGeometry } from 'three';
+import * as i0 from "@angular/core";
+extend({ Mesh, CanvasTexture, PlaneGeometry, MeshBasicMaterial });
+export class NgtsShadow {
+    constructor() {
+        this.Math = Math;
+        this.DoubleSide = THREE.DoubleSide;
+        this.inputs = signalStore({
+            fog: false,
+            depthWrite: false,
+            colorStop: 0.0,
+            color: 'black',
+            opacity: 0.5,
+        });
+        this.shadowRef = injectNgtRef();
+        this.colorStop = this.inputs.select('colorStop');
+        this.color = this.inputs.select('color');
+        this.opacity = this.inputs.select('opacity');
+        this.fog = this.inputs.select('fog');
+        this.depthWrite = this.inputs.select('depthWrite');
+        this.canvas = computed(() => {
+            const [colorStop, color] = [this.colorStop(), this.color()];
+            const canvas = document.createElement('canvas');
+            canvas.width = 128;
+            canvas.height = 128;
+            const context = canvas.getContext('2d');
+            const gradient = context.createRadialGradient(canvas.width / 2, canvas.height / 2, 0, canvas.width / 2, canvas.height / 2, canvas.width / 2);
+            gradient.addColorStop(colorStop, new THREE.Color(color).getStyle());
+            gradient.addColorStop(1, 'rgba(0,0,0,0)');
+            context.fillStyle = gradient;
+            context.fillRect(0, 0, canvas.width, canvas.height);
+            return canvas;
+        });
+    }
+    set _colorStop(colorStop) {
+        this.inputs.set({ colorStop });
+    }
+    set _fog(fog) {
+        this.inputs.set({ fog });
+    }
+    set _color(color) {
+        this.inputs.set({ color });
+    }
+    set _opacity(opacity) {
+        this.inputs.set({ opacity });
+    }
+    set _depthWrite(depthWrite) {
+        this.inputs.set({ depthWrite });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.3", ngImport: i0, type: NgtsShadow, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.3", type: NgtsShadow, isStandalone: true, selector: "ngts-shadow", inputs: { shadowRef: "shadowRef", _colorStop: ["colorStop", "_colorStop"], _fog: ["fog", "_fog"], _color: ["color", "_color"], _opacity: ["opacity", "_opacity"], _depthWrite: ["depthWrite", "_depthWrite"] }, ngImport: i0, template: `
+		<ngt-mesh ngtCompound [ref]="shadowRef" [rotation]="[-Math.PI / 2, 0, 0]">
+			<ngt-plane-geometry />
+			<ngt-mesh-basic-material
+				[transparent]="true"
+				[opacity]="opacity()"
+				[fog]="fog()"
+				[depthWrite]="depthWrite()"
+				[side]="DoubleSide"
+			>
+				<ngt-canvas-texture *args="[canvas()]" attach="map" />
+			</ngt-mesh-basic-material>
+			<ng-content />
+		</ngt-mesh>
+	`, isInline: true, dependencies: [{ kind: "directive", type: NgtArgs, selector: "ng-template[args]", inputs: ["args"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.3", ngImport: i0, type: NgtsShadow, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-shadow',
+                    standalone: true,
+                    template: `
+		<ngt-mesh ngtCompound [ref]="shadowRef" [rotation]="[-Math.PI / 2, 0, 0]">
+			<ngt-plane-geometry />
+			<ngt-mesh-basic-material
+				[transparent]="true"
+				[opacity]="opacity()"
+				[fog]="fog()"
+				[depthWrite]="depthWrite()"
+				[side]="DoubleSide"
+			>
+				<ngt-canvas-texture *args="[canvas()]" attach="map" />
+			</ngt-mesh-basic-material>
+			<ng-content />
+		</ngt-mesh>
+	`,
+                    imports: [NgtArgs],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], propDecorators: { shadowRef: [{
+                type: Input
+            }], _colorStop: [{
+                type: Input,
+                args: [{ alias: 'colorStop' }]
+            }], _fog: [{
+                type: Input,
+                args: [{ alias: 'fog' }]
+            }], _color: [{
+                type: Input,
+                args: [{ alias: 'color' }]
+            }], _opacity: [{
+                type: Input,
+                args: [{ alias: 'opacity' }]
+            }], _depthWrite: [{
+                type: Input,
+                args: [{ alias: 'depthWrite' }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"shadow.js","sourceRoot":"","sources":["../../../../../../libs/soba/misc/src/shadow/shadow.ts"],"names":[],"mappings":"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","sourcesContent":["import { CUSTOM_ELEMENTS_SCHEMA, Component, Input, computed } from '@angular/core';\nimport { NgtArgs, extend, injectNgtRef, signalStore, type NgtMesh } from 'angular-three';\nimport * as THREE from 'three';\nimport { CanvasTexture, Mesh, MeshBasicMaterial, PlaneGeometry } from 'three';\n\nexport type NgtsShadowState = {\n\tcolorStop: number;\n\tfog: boolean;\n\tcolor: THREE.ColorRepresentation;\n\topacity: number;\n\tdepthWrite: boolean;\n};\n\ndeclare global {\n\tinterface HTMLElementTagNameMap {\n\t\t/**\n\t\t * @extends ngt-mesh\n\t\t */\n\t\t'ngts-shadow': NgtsShadowState & NgtMesh;\n\t}\n}\n\nextend({ Mesh, CanvasTexture, PlaneGeometry, MeshBasicMaterial });\n\n@Component({\n\tselector: 'ngts-shadow',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-mesh ngtCompound [ref]=\"shadowRef\" [rotation]=\"[-Math.PI / 2, 0, 0]\">\n\t\t\t<ngt-plane-geometry />\n\t\t\t<ngt-mesh-basic-material\n\t\t\t\t[transparent]=\"true\"\n\t\t\t\t[opacity]=\"opacity()\"\n\t\t\t\t[fog]=\"fog()\"\n\t\t\t\t[depthWrite]=\"depthWrite()\"\n\t\t\t\t[side]=\"DoubleSide\"\n\t\t\t>\n\t\t\t\t<ngt-canvas-texture *args=\"[canvas()]\" attach=\"map\" />\n\t\t\t</ngt-mesh-basic-material>\n\t\t\t<ng-content />\n\t\t</ngt-mesh>\n\t`,\n\timports: [NgtArgs],\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsShadow {\n\tMath = Math;\n\tDoubleSide = THREE.DoubleSide;\n\n\tprivate inputs = signalStore<NgtsShadowState>({\n\t\tfog: false,\n\t\tdepthWrite: false,\n\t\tcolorStop: 0.0,\n\t\tcolor: 'black',\n\t\topacity: 0.5,\n\t});\n\n\t@Input() shadowRef = injectNgtRef<Mesh>();\n\n\t@Input({ alias: 'colorStop' }) set _colorStop(colorStop: number) {\n\t\tthis.inputs.set({ colorStop });\n\t}\n\n\t@Input({ alias: 'fog' }) set _fog(fog: boolean) {\n\t\tthis.inputs.set({ fog });\n\t}\n\n\t@Input({ alias: 'color' }) set _color(color: THREE.ColorRepresentation) {\n\t\tthis.inputs.set({ color });\n\t}\n\n\t@Input({ alias: 'opacity' }) set _opacity(opacity: number) {\n\t\tthis.inputs.set({ opacity });\n\t}\n\n\t@Input({ alias: 'depthWrite' }) set _depthWrite(depthWrite: boolean) {\n\t\tthis.inputs.set({ depthWrite });\n\t}\n\n\tprivate colorStop = this.inputs.select('colorStop');\n\tprivate color = this.inputs.select('color');\n\n\topacity = this.inputs.select('opacity');\n\tfog = this.inputs.select('fog');\n\tdepthWrite = this.inputs.select('depthWrite');\n\n\tcanvas = computed(() => {\n\t\tconst [colorStop, color] = [this.colorStop(), this.color()];\n\t\tconst canvas = document.createElement('canvas');\n\t\tcanvas.width = 128;\n\t\tcanvas.height = 128;\n\t\tconst context = canvas.getContext('2d') as CanvasRenderingContext2D;\n\t\tconst gradient = context.createRadialGradient(\n\t\t\tcanvas.width / 2,\n\t\t\tcanvas.height / 2,\n\t\t\t0,\n\t\t\tcanvas.width / 2,\n\t\t\tcanvas.height / 2,\n\t\t\tcanvas.width / 2,\n\t\t);\n\t\tgradient.addColorStop(colorStop, new THREE.Color(color).getStyle());\n\t\tgradient.addColorStop(1, 'rgba(0,0,0,0)');\n\t\tcontext.fillStyle = gradient;\n\t\tcontext.fillRect(0, 0, canvas.width, canvas.height);\n\t\treturn canvas;\n\t});\n}\n\n//\n//\n// type Props = JSX.IntrinsicElements['mesh'] & {\n//   colorStop?: number\n//   fog?: boolean\n//   color?: Color | number | string\n//   opacity?: number\n//   depthWrite?: boolean\n// }\n//\n// export const Shadow = React.forwardRef(\n//   (\n//     { fog = false, renderOrder, depthWrite = false, colorStop = 0.0, color = 'black', opacity = 0.5, ...props }: Props,\n//     ref\n//   ) => {\n//     const canvas = React.useMemo(() => {\n//       const canvas = document.createElement('canvas')\n//       canvas.width = 128\n//       canvas.height = 128\n//       const context = canvas.getContext('2d') as CanvasRenderingContext2D\n//       const gradient = context.createRadialGradient(\n//         canvas.width / 2,\n//         canvas.height / 2,\n//         0,\n//         canvas.width / 2,\n//         canvas.height / 2,\n//         canvas.width / 2\n//       )\n//       gradient.addColorStop(colorStop, new Color(color).getStyle())\n//       gradient.addColorStop(1, 'rgba(0,0,0,0)')\n//       context.fillStyle = gradient\n//       context.fillRect(0, 0, canvas.width, canvas.height)\n//       return canvas\n//     }, [color, colorStop])\n//     return (\n//       <mesh renderOrder={renderOrder} ref={ref as React.MutableRefObject<Mesh>} rotation-x={-Math.PI / 2} {...props}>\n//         <planeGeometry />\n//         <meshBasicMaterial transparent opacity={opacity} fog={fog} depthWrite={depthWrite} side={DoubleSide}>\n//           <canvasTexture attach=\"map\" args={[canvas]} />\n//         </meshBasicMaterial>\n//       </mesh>\n//     )\n//   }\n// )\n"]}

package/esm2022/misc/stats-gl/stats-gl.mjs

@@ -0,0 +1,61 @@
+import { DOCUMENT } from '@angular/common';
+import { Directive, Input, computed, effect, inject } from '@angular/core';
+import { addAfterEffect, addEffect, injectNgtStore, is, signalStore } from 'angular-three';
+import Stats from 'stats-gl';
+import * as i0 from "@angular/core";
+export class NgtsStatsGL {
+    set _parent(parent) {
+        this.inputs.set({ parent });
+    }
+    set _containerClass(containerClass) {
+        this.inputs.set({ containerClass });
+    }
+    set _config(config) {
+        this.inputs.set({ config });
+    }
+    constructor() {
+        this.inputs = signalStore();
+        this.document = inject(DOCUMENT);
+        this.store = injectNgtStore();
+        this.gl = this.store.select('gl');
+        this.config = this.inputs.select('config');
+        this.parent = this.inputs.select('parent');
+        this.containerClass = this.inputs.select('containerClass');
+        this.stats = computed(() => {
+            const [config, gl] = [this.config() || {}, this.gl()];
+            const stats = new Stats(config);
+            stats.init(gl.domElement);
+            return stats;
+        });
+        effect((onCleanup) => {
+            const [parent, stats, containerClass] = [this.parent(), this.stats(), this.containerClass()];
+            const node = parent ? (is.ref(parent) ? parent.nativeElement : parent) : this.document.body;
+            node.appendChild(stats.container);
+            if (containerClass)
+                stats.container.classList.add(...containerClass.split(' ').filter(Boolean));
+            const begin = addEffect(() => stats.begin());
+            const end = addAfterEffect(() => stats.end());
+            onCleanup(() => {
+                node.removeChild(stats.container);
+                begin();
+                end();
+            });
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.3", ngImport: i0, type: NgtsStatsGL, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.3", type: NgtsStatsGL, isStandalone: true, selector: "ngts-stats-gl", inputs: { _parent: ["parent", "_parent"], _containerClass: ["containerClass", "_containerClass"], _config: ["config", "_config"] }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.3", ngImport: i0, type: NgtsStatsGL, decorators: [{
+            type: Directive,
+            args: [{ selector: 'ngts-stats-gl', standalone: true }]
+        }], ctorParameters: function () { return []; }, propDecorators: { _parent: [{
+                type: Input,
+                args: [{ alias: 'parent' }]
+            }], _containerClass: [{
+                type: Input,
+                args: [{ alias: 'containerClass' }]
+            }], _config: [{
+                type: Input,
+                args: [{ alias: 'config' }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/misc/trail/trail.mjs

@@ -0,0 +1,210 @@
+import { CUSTOM_ELEMENTS_SCHEMA, Component, Input, computed, effect, runInInjectionContext, } from '@angular/core';
+import { NgtPortal, NgtPortalContent, extend, injectBeforeRender, injectNgtRef, injectNgtStore, is, signalStore, } from 'angular-three';
+import { MeshLineGeometry, MeshLineMaterial } from 'meshline';
+import { assertInjector } from 'ngxtension/assert-injector';
+import * as THREE from 'three';
+import { Group, Mesh } from 'three';
+import * as i0 from "@angular/core";
+const shiftLeft = (collection, steps = 1) => {
+    collection.set(collection.subarray(steps));
+    collection.fill(-Infinity, -steps);
+    return collection;
+};
+const defaultSettings = {
+    width: 0.2,
+    length: 1,
+    decay: 1,
+    local: false,
+    stride: 0,
+    interval: 1,
+};
+export function injectNgtsTrail(targetFactory, settingsFactory, { injector } = {}) {
+    injector = assertInjector(injectNgtsTrail, injector);
+    return runInInjectionContext(injector, () => {
+        const points = injectNgtRef();
+        let frameCount = 0;
+        const prevPosition = new THREE.Vector3();
+        const worldPosition = new THREE.Vector3();
+        const _target = computed(() => {
+            const _target = targetFactory();
+            if (is.ref(_target))
+                return _target.nativeElement;
+            return _target;
+        });
+        const _settings = computed(() => ({ ...defaultSettings, ...settingsFactory() }));
+        const _length = computed(() => _settings().length);
+        effect(() => {
+            const [target, length] = [_target(), _length()];
+            if (target) {
+                points.nativeElement = Float32Array.from({ length: length * 10 * 3 }, (_, i) => target.position.getComponent(i % 3));
+            }
+        });
+        injectBeforeRender(() => {
+            const [target, _points, { local, decay, stride, interval }] = [
+                _target(),
+                points.nativeElement,
+                _settings(),
+            ];
+            if (!target)
+                return;
+            if (!_points)
+                return;
+            if (frameCount === 0) {
+                let newPosition;
+                if (local) {
+                    newPosition = target.position;
+                }
+                else {
+                    target.getWorldPosition(worldPosition);
+                    newPosition = worldPosition;
+                }
+                const steps = 1 * decay;
+                for (let i = 0; i < steps; i++) {
+                    if (newPosition.distanceTo(prevPosition) < stride)
+                        continue;
+                    shiftLeft(_points, 3);
+                    _points.set(newPosition.toArray(), _points.length - 3);
+                }
+                prevPosition.copy(newPosition);
+            }
+            frameCount++;
+            frameCount = frameCount % interval;
+        });
+        return points;
+    });
+}
+extend({ Group, Mesh });
+export class NgtsTrail {
+    set _color(color) {
+        this.inputs.set({ color });
+    }
+    set _attenuation(attenuation) {
+        this.inputs.set({ attenuation });
+    }
+    set _target(target) {
+        this.inputs.set({ target });
+    }
+    set _settings(settings) {
+        this.inputs.set({ settings: { ...defaultSettings, ...settings } });
+    }
+    constructor() {
+        this.inputs = signalStore({ settings: defaultSettings, color: 'hotpink' });
+        this.trailRef = injectNgtRef();
+        this.groupRef = injectNgtRef();
+        this.children = this.groupRef.children('both');
+        this.store = injectNgtStore();
+        this.size = this.store.select('size');
+        this.target = this.inputs.select('target');
+        this.settings = this.inputs.select('settings');
+        this.width = computed(() => this.settings().width);
+        this.color = this.inputs.select('color');
+        this.attenuation = this.inputs.select('attenuation');
+        this.anchor = computed(() => {
+            const target = this.target();
+            if (target)
+                return target;
+            const group = this.groupRef.nativeElement;
+            if (group) {
+                return group.children.find((child) => child instanceof THREE.Object3D) || null;
+            }
+            return null;
+        });
+        this.points = injectNgtsTrail(this.anchor, this.settings);
+        this.scene = this.store.select('scene');
+        this.geometry = new MeshLineGeometry();
+        this.material = computed(() => {
+            const [width, color, size] = [this.width(), this.color(), this.size()];
+            const m = new MeshLineMaterial({
+                lineWidth: 0.1 * width,
+                color,
+                sizeAttenuation: 1,
+                resolution: new THREE.Vector2(size.width, size.height),
+            });
+            // TODO: understand this first
+            // Get and apply first <meshLineMaterial /> from children
+            // let matOverride: React.ReactElement | undefined;
+            // if (children) {
+            // 	if (Array.isArray(children)) {
+            // 		matOverride = children.find((child: React.ReactNode) => {
+            // 			const c = child as React.ReactElement;
+            // 			return typeof c.type === 'string' && c.type === 'meshLineMaterial';
+            // 		}) as React.ReactElement | undefined;
+            // 	} else {
+            // 		const c = children as React.ReactElement;
+            // 		if (typeof c.type === 'string' && c.type === 'meshLineMaterial') {
+            // 			matOverride = c;
+            // 		}
+            // 	}
+            // }
+            // if (typeof matOverride?.props === 'object') {
+            // 	m.setValues(matOverride.props);
+            // }
+            return m;
+        });
+        this.setMaterialSize();
+        this.beforeRender();
+    }
+    setMaterialSize() {
+        effect(() => {
+            const [material, size] = [this.material(), this.size()];
+            material.uniforms['resolution'].value.set(size.width, size.height);
+        });
+    }
+    beforeRender() {
+        injectBeforeRender(() => {
+            const [points, attenuation] = [this.points.nativeElement, this.attenuation()];
+            if (!points)
+                return;
+            this.geometry.setPoints(points, attenuation);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.3", ngImport: i0, type: NgtsTrail, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.3", type: NgtsTrail, isStandalone: true, selector: "ngts-trail", inputs: { trailRef: "trailRef", _color: ["color", "_color"], _attenuation: ["attenuation", "_attenuation"], _target: ["target", "_target"], _settings: ["settings", "_settings"] }, ngImport: i0, template: `
+		<ngt-group>
+			<ngt-portal [container]="scene()" [autoRender]="false">
+				<ng-template ngtPortalContent>
+					<ngt-mesh [ref]="trailRef" [geometry]="geometry" [material]="material()" />
+				</ng-template>
+			</ngt-portal>
+			<ngt-group [ref]="groupRef">
+				<ng-content />
+			</ngt-group>
+		</ngt-group>
+	`, isInline: true, dependencies: [{ 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.3", ngImport: i0, type: NgtsTrail, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-trail',
+                    standalone: true,
+                    template: `
+		<ngt-group>
+			<ngt-portal [container]="scene()" [autoRender]="false">
+				<ng-template ngtPortalContent>
+					<ngt-mesh [ref]="trailRef" [geometry]="geometry" [material]="material()" />
+				</ng-template>
+			</ngt-portal>
+			<ngt-group [ref]="groupRef">
+				<ng-content />
+			</ngt-group>
+		</ngt-group>
+	`,
+                    imports: [NgtPortal, NgtPortalContent],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { trailRef: [{
+                type: Input
+            }], _color: [{
+                type: Input,
+                args: [{ alias: 'color' }]
+            }], _attenuation: [{
+                type: Input,
+                args: [{ alias: 'attenuation' }]
+            }], _target: [{
+                type: Input,
+                args: [{ alias: 'target' }]
+            }], _settings: [{
+                type: Input,
+                args: [{ alias: 'settings' }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"trail.js","sourceRoot":"","sources":["../../../../../../libs/soba/misc/src/trail/trail.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n\tCUSTOM_ELEMENTS_SCHEMA,\n\tComponent,\n\tInput,\n\tcomputed,\n\teffect,\n\trunInInjectionContext,\n\ttype Injector,\n} from '@angular/core';\nimport {\n\tNgtPortal,\n\tNgtPortalContent,\n\textend,\n\tinjectBeforeRender,\n\tinjectNgtRef,\n\tinjectNgtStore,\n\tis,\n\tsignalStore,\n\ttype NgtRef,\n} from 'angular-three';\nimport { MeshLineGeometry, MeshLineMaterial } from 'meshline';\nimport { assertInjector } from 'ngxtension/assert-injector';\nimport * as THREE from 'three';\nimport { Group, Mesh } from 'three';\n\nconst shiftLeft = (collection: Float32Array, steps = 1): Float32Array => {\n\tcollection.set(collection.subarray(steps));\n\tcollection.fill(-Infinity, -steps);\n\treturn collection;\n};\n\nexport type NgtsTrailSettings = {\n\twidth: number;\n\tlength: number;\n\tdecay: number;\n\t/**\n\t * Wether to use the target's world or local positions\n\t */\n\tlocal: boolean;\n\t// Min distance between previous and current points\n\tstride: number;\n\t// Number of frames to wait before next calculation\n\tinterval: number;\n};\n\nconst defaultSettings: NgtsTrailSettings = {\n\twidth: 0.2,\n\tlength: 1,\n\tdecay: 1,\n\tlocal: false,\n\tstride: 0,\n\tinterval: 1,\n};\n\nexport function injectNgtsTrail(\n\ttargetFactory: () => NgtRef<THREE.Object3D> | null,\n\tsettingsFactory: () => Partial<NgtsTrailSettings>,\n\t{ injector }: { injector?: Injector } = {},\n) {\n\tinjector = assertInjector(injectNgtsTrail, injector);\n\treturn runInInjectionContext(injector, () => {\n\t\tconst points = injectNgtRef<Float32Array>();\n\t\tlet frameCount = 0;\n\n\t\tconst prevPosition = new THREE.Vector3();\n\t\tconst worldPosition = new THREE.Vector3();\n\n\t\tconst _target = computed(() => {\n\t\t\tconst _target = targetFactory();\n\t\t\tif (is.ref(_target)) return _target.nativeElement;\n\t\t\treturn _target;\n\t\t});\n\n\t\tconst _settings = computed(() => ({ ...defaultSettings, ...settingsFactory() }));\n\t\tconst _length = computed(() => _settings().length);\n\n\t\teffect(() => {\n\t\t\tconst [target, length] = [_target(), _length()];\n\t\t\tif (target) {\n\t\t\t\tpoints.nativeElement = Float32Array.from({ length: length * 10 * 3 }, (_, i) =>\n\t\t\t\t\ttarget.position.getComponent(i % 3),\n\t\t\t\t);\n\t\t\t}\n\t\t});\n\n\t\tinjectBeforeRender(() => {\n\t\t\tconst [target, _points, { local, decay, stride, interval }] = [\n\t\t\t\t_target(),\n\t\t\t\tpoints.nativeElement,\n\t\t\t\t_settings(),\n\t\t\t];\n\t\t\tif (!target) return;\n\t\t\tif (!_points) return;\n\n\t\t\tif (frameCount === 0) {\n\t\t\t\tlet newPosition: THREE.Vector3;\n\t\t\t\tif (local) {\n\t\t\t\t\tnewPosition = target.position;\n\t\t\t\t} else {\n\t\t\t\t\ttarget.getWorldPosition(worldPosition);\n\t\t\t\t\tnewPosition = worldPosition;\n\t\t\t\t}\n\n\t\t\t\tconst steps = 1 * decay;\n\t\t\t\tfor (let i = 0; i < steps; i++) {\n\t\t\t\t\tif (newPosition.distanceTo(prevPosition) < stride) continue;\n\n\t\t\t\t\tshiftLeft(_points, 3);\n\t\t\t\t\t_points.set(newPosition.toArray(), _points.length - 3);\n\t\t\t\t}\n\t\t\t\tprevPosition.copy(newPosition);\n\t\t\t}\n\n\t\t\tframeCount++;\n\t\t\tframeCount = frameCount % interval;\n\t\t});\n\n\t\treturn points;\n\t});\n}\n\nexport type NgtsTrailState = {\n\tcolor: THREE.ColorRepresentation;\n\tattenuation: (width: number) => number;\n\tsettings: NgtsTrailSettings;\n\ttarget?: NgtRef<THREE.Object3D>;\n};\n\ndeclare global {\n\tinterface HTMLElementTagNameMap {\n\t\t'ngts-trail': NgtsTrailState;\n\t}\n}\n\nextend({ Group, Mesh });\n\n@Component({\n\tselector: 'ngts-trail',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-group>\n\t\t\t<ngt-portal [container]=\"scene()\" [autoRender]=\"false\">\n\t\t\t\t<ng-template ngtPortalContent>\n\t\t\t\t\t<ngt-mesh [ref]=\"trailRef\" [geometry]=\"geometry\" [material]=\"material()\" />\n\t\t\t\t</ng-template>\n\t\t\t</ngt-portal>\n\t\t\t<ngt-group [ref]=\"groupRef\">\n\t\t\t\t<ng-content />\n\t\t\t</ngt-group>\n\t\t</ngt-group>\n\t`,\n\timports: [NgtPortal, NgtPortalContent],\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsTrail {\n\tprivate inputs = signalStore<NgtsTrailState>({ settings: defaultSettings, color: 'hotpink' });\n\n\t@Input() trailRef = injectNgtRef<Mesh>();\n\n\t@Input({ alias: 'color' }) set _color(color: THREE.ColorRepresentation) {\n\t\tthis.inputs.set({ color });\n\t}\n\n\t@Input({ alias: 'attenuation' }) set _attenuation(attenuation: (width: number) => number) {\n\t\tthis.inputs.set({ attenuation });\n\t}\n\n\t@Input({ alias: 'target' }) set _target(target: NgtRef<THREE.Object3D>) {\n\t\tthis.inputs.set({ target });\n\t}\n\n\t@Input({ alias: 'settings' }) set _settings(settings: Partial<NgtsTrailSettings>) {\n\t\tthis.inputs.set({ settings: { ...defaultSettings, ...settings } });\n\t}\n\n\tgroupRef = injectNgtRef<Group>();\n\n\tprivate children = this.groupRef.children('both');\n\n\tprivate store = injectNgtStore();\n\tprivate size = this.store.select('size');\n\n\tprivate target = this.inputs.select('target');\n\tprivate settings = this.inputs.select('settings');\n\tprivate width = computed(() => this.settings().width);\n\tprivate color = this.inputs.select('color');\n\tprivate attenuation = this.inputs.select('attenuation');\n\n\tprivate anchor = computed(() => {\n\t\tconst target = this.target();\n\t\tif (target) return target;\n\t\tconst group = this.groupRef.nativeElement;\n\t\tif (group) {\n\t\t\treturn group.children.find((child) => child instanceof THREE.Object3D) || null;\n\t\t}\n\t\treturn null;\n\t});\n\n\tprivate points = injectNgtsTrail(this.anchor, this.settings);\n\n\tscene = this.store.select('scene');\n\tgeometry = new MeshLineGeometry();\n\tmaterial = computed(() => {\n\t\tconst [width, color, size] = [this.width(), this.color(), this.size()];\n\n\t\tconst m = new MeshLineMaterial({\n\t\t\tlineWidth: 0.1 * width,\n\t\t\tcolor,\n\t\t\tsizeAttenuation: 1,\n\t\t\tresolution: new THREE.Vector2(size.width, size.height),\n\t\t});\n\n\t\t// TODO: understand this first\n\t\t// Get and apply first <meshLineMaterial /> from children\n\t\t// let matOverride: React.ReactElement | undefined;\n\t\t// if (children) {\n\t\t// \tif (Array.isArray(children)) {\n\t\t// \t\tmatOverride = children.find((child: React.ReactNode) => {\n\t\t// \t\t\tconst c = child as React.ReactElement;\n\t\t// \t\t\treturn typeof c.type === 'string' && c.type === 'meshLineMaterial';\n\t\t// \t\t}) as React.ReactElement | undefined;\n\t\t// \t} else {\n\t\t// \t\tconst c = children as React.ReactElement;\n\t\t// \t\tif (typeof c.type === 'string' && c.type === 'meshLineMaterial') {\n\t\t// \t\t\tmatOverride = c;\n\t\t// \t\t}\n\t\t// \t}\n\t\t// }\n\t\t// if (typeof matOverride?.props === 'object') {\n\t\t// \tm.setValues(matOverride.props);\n\t\t// }\n\n\t\treturn m;\n\t});\n\n\tconstructor() {\n\t\tthis.setMaterialSize();\n\t\tthis.beforeRender();\n\t}\n\n\tprivate setMaterialSize() {\n\t\teffect(() => {\n\t\t\tconst [material, size] = [this.material(), this.size()];\n\t\t\tmaterial.uniforms['resolution'].value.set(size.width, size.height);\n\t\t});\n\t}\n\n\tprivate beforeRender() {\n\t\tinjectBeforeRender(() => {\n\t\t\tconst [points, attenuation] = [this.points.nativeElement, this.attenuation()];\n\t\t\tif (!points) return;\n\t\t\tthis.geometry.setPoints(points, attenuation);\n\t\t});\n\t}\n}\n"]}

package/esm2022/misc/trail-texture/inject-trail-texture.mjs

@@ -0,0 +1,18 @@
+import { Injector, computed, runInInjectionContext } from '@angular/core';
+import { injectBeforeRender } from 'angular-three';
+import { assertInjector } from 'ngxtension/assert-injector';
+import { TrailTexture } from './trail-texture';
+export function injectNgtsTrailTexture(trailConfigFn, { injector } = {}) {
+    injector = assertInjector(injectNgtsTrailTexture, injector);
+    return runInInjectionContext(injector, () => {
+        const config = computed(() => trailConfigFn() || {});
+        const trail = computed(() => new TrailTexture(config()));
+        const texture = computed(() => trail().texture);
+        injectBeforeRender(({ delta }) => {
+            trail().update(delta);
+        });
+        const onMove = (ev) => trail().addTouch(ev.uv);
+        return { texture, onMove };
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/misc/trail-texture/trail-texture.mjs

@@ -0,0 +1,106 @@
+import { Texture } from 'three';
+// default ease
+const easeCircleOut = (x) => Math.sqrt(1 - Math.pow(x - 1, 2));
+// smooth new sample (measurement) based on previous sample (current)
+function smoothAverage(current, measurement, smoothing = 0.9) {
+    return measurement * smoothing + current * (1.0 - smoothing);
+}
+export class TrailTexture {
+    constructor({ size = 256, maxAge = 750, radius = 0.3, intensity = 0.2, interpolate = 0, smoothing = 0, minForce = 0.3, blend = 'screen', // source-over is canvas default. Others are slower
+    ease = easeCircleOut, } = {}) {
+        this.size = size;
+        this.maxAge = maxAge;
+        this.radius = radius;
+        this.intensity = intensity;
+        this.ease = ease;
+        this.interpolate = interpolate;
+        this.smoothing = smoothing;
+        this.minForce = minForce;
+        this.blend = blend;
+        this.trail = [];
+        this.force = 0;
+        this.initTexture();
+    }
+    initTexture() {
+        this.canvas = document.createElement('canvas');
+        this.canvas.width = this.canvas.height = this.size;
+        this.ctx = this.canvas.getContext('2d');
+        this.ctx.fillStyle = 'black';
+        this.ctx.fillRect(0, 0, this.canvas.width, this.canvas.height);
+        this.texture = new Texture(this.canvas);
+        this.canvas.id = 'touchTexture';
+        this.canvas.style.width = this.canvas.style.height = `${this.canvas.width}px`;
+    }
+    update(delta) {
+        this.clear();
+        // age points
+        this.trail.forEach((point, i) => {
+            point.age += delta * 1000;
+            // remove old
+            if (point.age > this.maxAge) {
+                this.trail.splice(i, 1);
+            }
+        });
+        // reset force when empty (when smoothing)
+        if (!this.trail.length)
+            this.force = 0;
+        this.trail.forEach((point) => {
+            this.drawTouch(point);
+        });
+        this.texture.needsUpdate = true;
+    }
+    clear() {
+        this.ctx.globalCompositeOperation = 'source-over';
+        this.ctx.fillStyle = 'black';
+        this.ctx.fillRect(0, 0, this.canvas.width, this.canvas.height);
+    }
+    addTouch(point) {
+        const last = this.trail[this.trail.length - 1];
+        if (last) {
+            const dx = last.x - point.x;
+            const dy = last.y - point.y;
+            const dd = dx * dx + dy * dy;
+            const force = Math.max(this.minForce, Math.min(dd * 10000, 1));
+            this.force = smoothAverage(force, this.force, this.smoothing);
+            if (!!this.interpolate) {
+                const lines = Math.ceil(dd / Math.pow((this.radius * 0.5) / this.interpolate, 2));
+                if (lines > 1) {
+                    for (let i = 1; i < lines; i++) {
+                        this.trail.push({
+                            x: last.x - (dx / lines) * i,
+                            y: last.y - (dy / lines) * i,
+                            age: 0,
+                            force,
+                        });
+                    }
+                }
+            }
+        }
+        this.trail.push({ x: point.x, y: point.y, age: 0, force: this.force });
+    }
+    drawTouch(point) {
+        const pos = {
+            x: point.x * this.size,
+            y: (1 - point.y) * this.size,
+        };
+        let intensity = 1;
+        if (point.age < this.maxAge * 0.3) {
+            intensity = this.ease(point.age / (this.maxAge * 0.3));
+        }
+        else {
+            intensity = this.ease(1 - (point.age - this.maxAge * 0.3) / (this.maxAge * 0.7));
+        }
+        intensity *= point.force;
+        // apply blending
+        this.ctx.globalCompositeOperation = this.blend;
+        const radius = this.size * this.radius * intensity;
+        const grd = this.ctx.createRadialGradient(pos.x, pos.y, Math.max(0, radius * 0.25), pos.x, pos.y, Math.max(0, radius));
+        grd.addColorStop(0, `rgba(255, 255, 255, ${this.intensity})`);
+        grd.addColorStop(1, `rgba(0, 0, 0, 0.0)`);
+        this.ctx.beginPath();
+        this.ctx.fillStyle = grd;
+        this.ctx.arc(pos.x, pos.y, Math.max(0, radius), 0, Math.PI * 2);
+        this.ctx.fill();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"trail-texture.js","sourceRoot":"","sources":["../../../../../../libs/soba/misc/src/trail-texture/trail-texture.ts"],"names":[],"mappings":"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","sourcesContent":["import { Texture } from 'three';\n\nexport type Point = {\n\tx: number;\n\ty: number;\n\tage: number;\n\tforce: number;\n};\n\nexport type TrailConfig = {\n\t/** texture size (default: 256x256) */\n\tsize?: number;\n\t/** Max age (ms) of trail points (default: 750) */\n\tmaxAge?: number;\n\t/** Trail radius (default: 0.3) */\n\tradius?: number;\n\t/** Canvas trail opacity (default: 0.2) */\n\tintensity?: number;\n\t/** Add points in between slow pointer events (default: 0) */\n\tinterpolate?: number;\n\t/** Moving average of pointer force (default: 0) */\n\tsmoothing?: number;\n\t/** Minimum pointer force (default: 0.3) */\n\tminForce?: number;\n\t/** Blend mode (default: 'screen') */\n\tblend?: CanvasRenderingContext2D['globalCompositeOperation'];\n\t/** Easing (default: easeCircOut) */\n\tease?: (t: number) => number;\n};\n\n// default ease\nconst easeCircleOut = (x: number) => Math.sqrt(1 - Math.pow(x - 1, 2));\n\n// smooth new sample (measurement) based on previous sample (current)\nfunction smoothAverage(current: number, measurement: number, smoothing = 0.9) {\n\treturn measurement * smoothing + current * (1.0 - smoothing);\n}\n\nexport class TrailTexture {\n\ttrail: Point[];\n\tcanvas!: HTMLCanvasElement;\n\tctx!: CanvasRenderingContext2D;\n\ttexture!: Texture;\n\tforce: number;\n\tsize: number;\n\tmaxAge: number;\n\tradius: number;\n\tintensity: number;\n\tease: (t: number) => number;\n\tminForce: number;\n\tinterpolate: number;\n\tsmoothing: number;\n\tblend: CanvasRenderingContext2D['globalCompositeOperation'];\n\n\tconstructor({\n\t\tsize = 256,\n\t\tmaxAge = 750,\n\t\tradius = 0.3,\n\t\tintensity = 0.2,\n\t\tinterpolate = 0,\n\t\tsmoothing = 0,\n\t\tminForce = 0.3,\n\t\tblend = 'screen', // source-over is canvas default. Others are slower\n\t\tease = easeCircleOut,\n\t}: TrailConfig = {}) {\n\t\tthis.size = size;\n\t\tthis.maxAge = maxAge;\n\t\tthis.radius = radius;\n\t\tthis.intensity = intensity;\n\t\tthis.ease = ease;\n\t\tthis.interpolate = interpolate;\n\t\tthis.smoothing = smoothing;\n\t\tthis.minForce = minForce;\n\t\tthis.blend = blend as GlobalCompositeOperation;\n\n\t\tthis.trail = [];\n\t\tthis.force = 0;\n\t\tthis.initTexture();\n\t}\n\n\tinitTexture() {\n\t\tthis.canvas = document.createElement('canvas');\n\t\tthis.canvas.width = this.canvas.height = this.size;\n\t\tthis.ctx = this.canvas.getContext('2d')!;\n\t\tthis.ctx.fillStyle = 'black';\n\t\tthis.ctx.fillRect(0, 0, this.canvas.width, this.canvas.height);\n\n\t\tthis.texture = new Texture(this.canvas);\n\n\t\tthis.canvas.id = 'touchTexture';\n\t\tthis.canvas.style.width = this.canvas.style.height = `${this.canvas.width}px`;\n\t}\n\n\tupdate(delta: number) {\n\t\tthis.clear();\n\n\t\t// age points\n\t\tthis.trail.forEach((point, i) => {\n\t\t\tpoint.age += delta * 1000;\n\t\t\t// remove old\n\t\t\tif (point.age > this.maxAge) {\n\t\t\t\tthis.trail.splice(i, 1);\n\t\t\t}\n\t\t});\n\n\t\t// reset force when empty (when smoothing)\n\t\tif (!this.trail.length) this.force = 0;\n\n\t\tthis.trail.forEach((point) => {\n\t\t\tthis.drawTouch(point);\n\t\t});\n\n\t\tthis.texture.needsUpdate = true;\n\t}\n\n\tclear() {\n\t\tthis.ctx.globalCompositeOperation = 'source-over';\n\t\tthis.ctx.fillStyle = 'black';\n\t\tthis.ctx.fillRect(0, 0, this.canvas.width, this.canvas.height);\n\t}\n\n\taddTouch(point: Pick<Point, 'x' | 'y'>) {\n\t\tconst last = this.trail[this.trail.length - 1];\n\n\t\tif (last) {\n\t\t\tconst dx = last.x - point.x;\n\t\t\tconst dy = last.y - point.y;\n\t\t\tconst dd = dx * dx + dy * dy;\n\n\t\t\tconst force = Math.max(this.minForce, Math.min(dd * 10000, 1));\n\n\t\t\tthis.force = smoothAverage(force, this.force, this.smoothing);\n\n\t\t\tif (!!this.interpolate) {\n\t\t\t\tconst lines = Math.ceil(dd / Math.pow((this.radius * 0.5) / this.interpolate, 2));\n\n\t\t\t\tif (lines > 1) {\n\t\t\t\t\tfor (let i = 1; i < lines; i++) {\n\t\t\t\t\t\tthis.trail.push({\n\t\t\t\t\t\t\tx: last.x - (dx / lines) * i,\n\t\t\t\t\t\t\ty: last.y - (dy / lines) * i,\n\t\t\t\t\t\t\tage: 0,\n\t\t\t\t\t\t\tforce,\n\t\t\t\t\t\t});\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tthis.trail.push({ x: point.x, y: point.y, age: 0, force: this.force });\n\t}\n\n\tdrawTouch(point: Point) {\n\t\tconst pos = {\n\t\t\tx: point.x * this.size,\n\t\t\ty: (1 - point.y) * this.size,\n\t\t};\n\n\t\tlet intensity = 1;\n\t\tif (point.age < this.maxAge * 0.3) {\n\t\t\tintensity = this.ease(point.age / (this.maxAge * 0.3));\n\t\t} else {\n\t\t\tintensity = this.ease(1 - (point.age - this.maxAge * 0.3) / (this.maxAge * 0.7));\n\t\t}\n\n\t\tintensity *= point.force;\n\n\t\t// apply blending\n\t\tthis.ctx.globalCompositeOperation = this.blend;\n\n\t\tconst radius = this.size * this.radius * intensity;\n\t\tconst grd = this.ctx.createRadialGradient(\n\t\t\tpos.x,\n\t\t\tpos.y,\n\t\t\tMath.max(0, radius * 0.25),\n\t\t\tpos.x,\n\t\t\tpos.y,\n\t\t\tMath.max(0, radius),\n\t\t);\n\t\tgrd.addColorStop(0, `rgba(255, 255, 255, ${this.intensity})`);\n\t\tgrd.addColorStop(1, `rgba(0, 0, 0, 0.0)`);\n\n\t\tthis.ctx.beginPath();\n\t\tthis.ctx.fillStyle = grd;\n\t\tthis.ctx.arc(pos.x, pos.y, Math.max(0, radius), 0, Math.PI * 2);\n\t\tthis.ctx.fill();\n\t}\n}\n"]}

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

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