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

package/esm2022/staging/lib/bounds.mjs

@@ -0,0 +1,286 @@
+import { afterNextRender, ChangeDetectionStrategy, Component, CUSTOM_ELEMENTS_SCHEMA, input, untracked, viewChild, } from '@angular/core';
+import { extend, injectBeforeRender, injectStore, is, pick } from 'angular-three';
+import { injectAutoEffect } from 'ngxtension/auto-effect';
+import { mergeInputs } from 'ngxtension/inject-inputs';
+import { Box3, Group, Matrix4, Quaternion, Vector3 } from 'three';
+import * as i0 from "@angular/core";
+var AnimationState;
+(function (AnimationState) {
+    AnimationState[AnimationState["NONE"] = 0] = "NONE";
+    AnimationState[AnimationState["START"] = 1] = "START";
+    AnimationState[AnimationState["ACTIVE"] = 2] = "ACTIVE";
+})(AnimationState || (AnimationState = {}));
+function isBox3(def) {
+    return !!def && def.isBox3;
+}
+function interpolateFuncDefault(t) {
+    // Imitates the previously used THREE.MathUtils.damp
+    return 1 - Math.exp(-5 * t) + 0.007 * t;
+}
+const defaultOptions = {
+    maxDuration: 1.0,
+    margin: 1.2,
+    interpolateFunc: interpolateFuncDefault,
+    clip: false,
+    fit: false,
+    observe: false,
+};
+export class NgtsBounds {
+    constructor() {
+        this.options = input(defaultOptions, { transform: mergeInputs(defaultOptions) });
+        this.groupRef = viewChild.required('group');
+        this.store = injectStore();
+        this.camera = this.store.select('camera');
+        this.invalidate = this.store.select('invalidate');
+        this.size = this.store.select('size');
+        this.controls = this.store.select('controls');
+        this.clipOption = pick(this.options, 'clip');
+        this.fitOption = pick(this.options, 'fit');
+        this.observe = pick(this.options, 'observe');
+        this.origin = {
+            camPos: new Vector3(),
+            camRot: new Quaternion(),
+            camZoom: 1,
+        };
+        this.goal = {
+            camPos: undefined,
+            camRot: undefined,
+            camZoom: undefined,
+            camUp: undefined,
+            target: undefined,
+        };
+        this.animationState = AnimationState.NONE;
+        // represent animation state from 0 to 1
+        this.t = 0;
+        this.box = new Box3();
+        extend({ Group });
+        const autoEffect = injectAutoEffect();
+        afterNextRender(() => {
+            autoEffect(() => {
+                const [controls, camera] = [this.controls(), untracked(this.camera)];
+                if (!controls)
+                    return;
+                const callback = () => {
+                    if (controls && this.goal.target && this.animationState !== AnimationState.NONE) {
+                        const front = new Vector3().setFromMatrixColumn(camera.matrix, 2);
+                        const d0 = this.origin.camPos.distanceTo(controls.target);
+                        const d1 = (this.goal.camPos || this.origin.camPos).distanceTo(this.goal.target);
+                        const d = (1 - this.t) * d0 + this.t * d1;
+                        controls.target.copy(camera.position).addScaledVector(front, -d);
+                        controls.update();
+                    }
+                    this.animationState = AnimationState.NONE;
+                };
+                controls.addEventListener('start', callback);
+                return () => controls.removeEventListener('start', callback);
+            });
+            let count = 0;
+            autoEffect(() => {
+                const [clip, fit, observe] = [
+                    this.clipOption(),
+                    this.fitOption(),
+                    this.observe(),
+                    this.size(),
+                    this.camera(),
+                    this.controls(),
+                ];
+                if (observe || count++ === 0) {
+                    this.refresh();
+                    if (fit)
+                        this.reset().fit();
+                    if (clip)
+                        this.clip();
+                }
+            });
+        });
+        injectBeforeRender(({ delta }) => {
+            // This [additional animation step START] is needed to guarantee that delta used in animation isn't absurdly high (2-3 seconds) which is actually possible if rendering happens on demand...
+            if (this.animationState === AnimationState.START) {
+                this.animationState = AnimationState.ACTIVE;
+                this.invalidate();
+            }
+            else if (this.animationState === AnimationState.ACTIVE) {
+                const [{ maxDuration, interpolateFunc }, camera, controls, invalidate] = [
+                    this.options(),
+                    this.camera(),
+                    this.controls(),
+                    this.invalidate(),
+                ];
+                this.t += delta / maxDuration;
+                if (this.t >= 1) {
+                    this.goal.camPos && camera.position.copy(this.goal.camPos);
+                    this.goal.camRot && camera.quaternion.copy(this.goal.camRot);
+                    this.goal.camUp && camera.up.copy(this.goal.camUp);
+                    this.goal.camZoom && is.orthographicCamera(camera) && (camera.zoom = this.goal.camZoom);
+                    camera.updateMatrixWorld();
+                    camera.updateProjectionMatrix();
+                    if (controls && this.goal.target) {
+                        controls.target.copy(this.goal.target);
+                        controls.update();
+                    }
+                    this.animationState = AnimationState.NONE;
+                }
+                else {
+                    const k = interpolateFunc(this.t);
+                    this.goal.camPos && camera.position.lerpVectors(this.origin.camPos, this.goal.camPos, k);
+                    this.goal.camRot && camera.quaternion.slerpQuaternions(this.origin.camRot, this.goal.camRot, k);
+                    this.goal.camUp && camera.up.set(0, 1, 0).applyQuaternion(camera.quaternion);
+                    this.goal.camZoom &&
+                        is.orthographicCamera(camera) &&
+                        (camera.zoom = (1 - k) * this.origin.camZoom + k * this.goal.camZoom);
+                    camera.updateMatrixWorld();
+                    camera.updateProjectionMatrix();
+                }
+                invalidate();
+            }
+        });
+    }
+    getSize() {
+        const [camera, { margin }] = [untracked(this.camera), untracked(this.options)];
+        const boxSize = this.box.getSize(new Vector3());
+        const center = this.box.getCenter(new Vector3());
+        const maxSize = Math.max(boxSize.x, boxSize.y, boxSize.z);
+        const fitHeightDistance = is.orthographicCamera(camera)
+            ? maxSize * 4
+            : maxSize / (2 * Math.atan((Math.PI * camera.fov) / 360));
+        const fitWidthDistance = is.orthographicCamera(camera) ? maxSize * 4 : fitHeightDistance / camera.aspect;
+        const distance = margin * Math.max(fitHeightDistance, fitWidthDistance);
+        return { box: this.box, size: boxSize, center, distance };
+    }
+    refresh(object) {
+        const [group, camera] = [untracked(this.groupRef).nativeElement, untracked(this.camera)];
+        if (isBox3(object))
+            this.box.copy(object);
+        else {
+            const target = object || group;
+            if (!target)
+                return this;
+            target.updateWorldMatrix(true, true);
+            this.box.setFromObject(target);
+        }
+        if (this.box.isEmpty()) {
+            const max = camera.position.length() || 10;
+            this.box.setFromCenterAndSize(new Vector3(), new Vector3(max, max, max));
+        }
+        this.origin.camPos.copy(camera.position);
+        this.origin.camRot.copy(camera.quaternion);
+        is.orthographicCamera(camera) && (this.origin.camZoom = camera.zoom);
+        this.goal.camPos = undefined;
+        this.goal.camRot = undefined;
+        this.goal.camZoom = undefined;
+        this.goal.camUp = undefined;
+        this.goal.target = undefined;
+        return this;
+    }
+    reset() {
+        const [camera] = [untracked(this.camera)];
+        const { center, distance } = this.getSize();
+        const direction = camera.position.clone().sub(center).normalize();
+        this.goal.camPos = center.clone().addScaledVector(direction, distance);
+        this.goal.target = center.clone();
+        const mCamRot = new Matrix4().lookAt(this.goal.camPos, this.goal.target, camera.up);
+        this.goal.camRot = new Quaternion().setFromRotationMatrix(mCamRot);
+        this.animationState = AnimationState.START;
+        this.t = 0;
+        return this;
+    }
+    moveTo(position) {
+        this.goal.camPos = Array.isArray(position) ? new Vector3(...position) : position.clone();
+        this.animationState = AnimationState.START;
+        this.t = 0;
+        return this;
+    }
+    lookAt({ target, up }) {
+        const [camera] = [untracked(this.camera)];
+        this.goal.target = Array.isArray(target) ? new Vector3(...target) : target.clone();
+        if (up) {
+            this.goal.camUp = Array.isArray(up) ? new Vector3(...up) : up.clone();
+        }
+        else {
+            this.goal.camUp = camera.up.clone();
+        }
+        const mCamRot = new Matrix4().lookAt(this.goal.camPos || camera.position, this.goal.target, this.goal.camUp);
+        this.goal.camRot = new Quaternion().setFromRotationMatrix(mCamRot);
+        this.animationState = AnimationState.START;
+        this.t = 0;
+        return this;
+    }
+    fit() {
+        const [camera, controls, { margin }] = [untracked(this.camera), untracked(this.controls), untracked(this.options)];
+        if (!is.orthographicCamera(camera)) {
+            // For non-orthographic cameras, fit should behave exactly like reset
+            return this.reset();
+        }
+        // For orthographic cameras, fit should only modify the zoom value
+        let maxHeight = 0;
+        let maxWidth = 0;
+        const vertices = [
+            new Vector3(this.box.min.x, this.box.min.y, this.box.min.z),
+            new Vector3(this.box.min.x, this.box.max.y, this.box.min.z),
+            new Vector3(this.box.min.x, this.box.min.y, this.box.max.z),
+            new Vector3(this.box.min.x, this.box.max.y, this.box.max.z),
+            new Vector3(this.box.max.x, this.box.max.y, this.box.max.z),
+            new Vector3(this.box.max.x, this.box.max.y, this.box.min.z),
+            new Vector3(this.box.max.x, this.box.min.y, this.box.max.z),
+            new Vector3(this.box.max.x, this.box.min.y, this.box.min.z),
+        ];
+        // Transform the center and each corner to camera space
+        const pos = this.goal.camPos || camera.position;
+        const target = this.goal.target || controls.target;
+        const up = this.goal.camUp || camera.up;
+        const mCamWInv = target
+            ? new Matrix4().lookAt(pos, target, up).setPosition(pos).invert()
+            : camera.matrixWorldInverse;
+        for (const v of vertices) {
+            v.applyMatrix4(mCamWInv);
+            maxHeight = Math.max(maxHeight, Math.abs(v.y));
+            maxWidth = Math.max(maxWidth, Math.abs(v.x));
+        }
+        maxHeight *= 2;
+        maxWidth *= 2;
+        const zoomForHeight = (camera.top - camera.bottom) / maxHeight;
+        const zoomForWidth = (camera.right - camera.left) / maxWidth;
+        this.goal.camZoom = Math.min(zoomForHeight, zoomForWidth) / margin;
+        this.animationState = AnimationState.START;
+        this.t = 0;
+        return this;
+    }
+    clip() {
+        const [camera, controls, invalidate] = [
+            untracked(this.camera),
+            untracked(this.controls),
+            untracked(this.invalidate),
+        ];
+        const { distance } = this.getSize();
+        camera.near = distance / 100;
+        camera.far = distance * 100;
+        camera.updateProjectionMatrix();
+        if (controls) {
+            controls.maxDistance = distance * 10;
+            controls.update();
+        }
+        invalidate();
+        return this;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsBounds, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "18.2.0", type: NgtsBounds, isStandalone: true, selector: "ngts-bounds", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, viewQueries: [{ propertyName: "groupRef", first: true, predicate: ["group"], descendants: true, isSignal: true }], ngImport: i0, template: `
+		<ngt-group #group>
+			<ng-content />
+		</ngt-group>
+	`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsBounds, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-bounds',
+                    standalone: true,
+                    template: `
+		<ngt-group #group>
+			<ng-content />
+		</ngt-group>
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bounds.js","sourceRoot":"","sources":["../../../../../../libs/soba/staging/src/lib/bounds.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n\tafterNextRender,\n\tChangeDetectionStrategy,\n\tComponent,\n\tCUSTOM_ELEMENTS_SCHEMA,\n\tElementRef,\n\tinput,\n\tSignal,\n\tuntracked,\n\tviewChild,\n} from '@angular/core';\nimport { extend, injectBeforeRender, injectStore, is, NgtGroup, pick } from 'angular-three';\nimport { injectAutoEffect } from 'ngxtension/auto-effect';\nimport { mergeInputs } from 'ngxtension/inject-inputs';\nimport { Box3, Group, Matrix4, Object3D, Quaternion, Vector3 } from 'three';\n\ninterface ControlsProto {\n\tupdate(): void;\n\n\ttarget: Vector3;\n\tmaxDistance: number;\n\taddEventListener: (event: string, callback: (event: any) => void) => void;\n\tremoveEventListener: (event: string, callback: (event: any) => void) => void;\n}\n\nenum AnimationState {\n\tNONE = 0,\n\tSTART = 1,\n\tACTIVE = 2,\n}\n\nfunction isBox3(def: unknown): def is Box3 {\n\treturn !!def && (def as Box3).isBox3;\n}\n\nfunction interpolateFuncDefault(t: number) {\n\t// Imitates the previously used THREE.MathUtils.damp\n\treturn 1 - Math.exp(-5 * t) + 0.007 * t;\n}\n\nexport interface NgtsBoundsOptions extends Partial<NgtGroup> {\n\tmaxDuration: number;\n\tmargin: number;\n\tobserve: boolean;\n\tfit: boolean;\n\tclip: boolean;\n\tinterpolateFunc: (t: number) => number;\n}\n\nconst defaultOptions: NgtsBoundsOptions = {\n\tmaxDuration: 1.0,\n\tmargin: 1.2,\n\tinterpolateFunc: interpolateFuncDefault,\n\tclip: false,\n\tfit: false,\n\tobserve: false,\n};\n\n@Component({\n\tselector: 'ngts-bounds',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-group #group>\n\t\t\t<ng-content />\n\t\t</ngt-group>\n\t`,\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class NgtsBounds {\n\toptions = input(defaultOptions, { transform: mergeInputs(defaultOptions) });\n\n\tgroupRef = viewChild.required<ElementRef<Group>>('group');\n\n\tprivate store = injectStore();\n\tprivate camera = this.store.select('camera');\n\tprivate invalidate = this.store.select('invalidate');\n\tprivate size = this.store.select('size');\n\tprivate controls = this.store.select('controls') as unknown as Signal<ControlsProto>;\n\n\tprivate clipOption = pick(this.options, 'clip');\n\tprivate fitOption = pick(this.options, 'fit');\n\tprivate observe = pick(this.options, 'observe');\n\n\tprivate origin = {\n\t\tcamPos: new Vector3(),\n\t\tcamRot: new Quaternion(),\n\t\tcamZoom: 1,\n\t};\n\tprivate goal = {\n\t\tcamPos: undefined as Vector3 | undefined,\n\t\tcamRot: undefined as Quaternion | undefined,\n\t\tcamZoom: undefined as number | undefined,\n\t\tcamUp: undefined as Vector3 | undefined,\n\t\ttarget: undefined as Vector3 | undefined,\n\t};\n\tprivate animationState = AnimationState.NONE;\n\n\t// represent animation state from 0 to 1\n\tprivate t = 0;\n\tprivate box = new Box3();\n\n\tconstructor() {\n\t\textend({ Group });\n\n\t\tconst autoEffect = injectAutoEffect();\n\t\tafterNextRender(() => {\n\t\t\tautoEffect(() => {\n\t\t\t\tconst [controls, camera] = [this.controls(), untracked(this.camera)];\n\t\t\t\tif (!controls) return;\n\t\t\t\tconst callback = () => {\n\t\t\t\t\tif (controls && this.goal.target && this.animationState !== AnimationState.NONE) {\n\t\t\t\t\t\tconst front = new Vector3().setFromMatrixColumn(camera.matrix, 2);\n\t\t\t\t\t\tconst d0 = this.origin.camPos.distanceTo(controls.target);\n\t\t\t\t\t\tconst d1 = (this.goal.camPos || this.origin.camPos).distanceTo(this.goal.target);\n\t\t\t\t\t\tconst d = (1 - this.t) * d0 + this.t * d1;\n\n\t\t\t\t\t\tcontrols.target.copy(camera.position).addScaledVector(front, -d);\n\t\t\t\t\t\tcontrols.update();\n\t\t\t\t\t}\n\n\t\t\t\t\tthis.animationState = AnimationState.NONE;\n\t\t\t\t};\n\n\t\t\t\tcontrols.addEventListener('start', callback);\n\t\t\t\treturn () => controls.removeEventListener('start', callback);\n\t\t\t});\n\n\t\t\tlet count = 0;\n\t\t\tautoEffect(() => {\n\t\t\t\tconst [clip, fit, observe] = [\n\t\t\t\t\tthis.clipOption(),\n\t\t\t\t\tthis.fitOption(),\n\t\t\t\t\tthis.observe(),\n\t\t\t\t\tthis.size(),\n\t\t\t\t\tthis.camera(),\n\t\t\t\t\tthis.controls(),\n\t\t\t\t];\n\t\t\t\tif (observe || count++ === 0) {\n\t\t\t\t\tthis.refresh();\n\t\t\t\t\tif (fit) this.reset().fit();\n\t\t\t\t\tif (clip) this.clip();\n\t\t\t\t}\n\t\t\t});\n\t\t});\n\n\t\tinjectBeforeRender(({ delta }) => {\n\t\t\t// This [additional animation step START] is needed to guarantee that delta used in animation isn't absurdly high (2-3 seconds) which is actually possible if rendering happens on demand...\n\t\t\tif (this.animationState === AnimationState.START) {\n\t\t\t\tthis.animationState = AnimationState.ACTIVE;\n\t\t\t\tthis.invalidate();\n\t\t\t} else if (this.animationState === AnimationState.ACTIVE) {\n\t\t\t\tconst [{ maxDuration, interpolateFunc }, camera, controls, invalidate] = [\n\t\t\t\t\tthis.options(),\n\t\t\t\t\tthis.camera(),\n\t\t\t\t\tthis.controls(),\n\t\t\t\t\tthis.invalidate(),\n\t\t\t\t];\n\t\t\t\tthis.t += delta / maxDuration;\n\n\t\t\t\tif (this.t >= 1) {\n\t\t\t\t\tthis.goal.camPos && camera.position.copy(this.goal.camPos);\n\t\t\t\t\tthis.goal.camRot && camera.quaternion.copy(this.goal.camRot);\n\t\t\t\t\tthis.goal.camUp && camera.up.copy(this.goal.camUp);\n\t\t\t\t\tthis.goal.camZoom && is.orthographicCamera(camera) && (camera.zoom = this.goal.camZoom);\n\n\t\t\t\t\tcamera.updateMatrixWorld();\n\t\t\t\t\tcamera.updateProjectionMatrix();\n\n\t\t\t\t\tif (controls && this.goal.target) {\n\t\t\t\t\t\tcontrols.target.copy(this.goal.target);\n\t\t\t\t\t\tcontrols.update();\n\t\t\t\t\t}\n\n\t\t\t\t\tthis.animationState = AnimationState.NONE;\n\t\t\t\t} else {\n\t\t\t\t\tconst k = interpolateFunc(this.t);\n\n\t\t\t\t\tthis.goal.camPos && camera.position.lerpVectors(this.origin.camPos, this.goal.camPos, k);\n\t\t\t\t\tthis.goal.camRot && camera.quaternion.slerpQuaternions(this.origin.camRot, this.goal.camRot, k);\n\t\t\t\t\tthis.goal.camUp && camera.up.set(0, 1, 0).applyQuaternion(camera.quaternion);\n\t\t\t\t\tthis.goal.camZoom &&\n\t\t\t\t\t\tis.orthographicCamera(camera) &&\n\t\t\t\t\t\t(camera.zoom = (1 - k) * this.origin.camZoom + k * this.goal.camZoom);\n\n\t\t\t\t\tcamera.updateMatrixWorld();\n\t\t\t\t\tcamera.updateProjectionMatrix();\n\t\t\t\t}\n\n\t\t\t\tinvalidate();\n\t\t\t}\n\t\t});\n\t}\n\n\tgetSize() {\n\t\tconst [camera, { margin }] = [untracked(this.camera), untracked(this.options)];\n\n\t\tconst boxSize = this.box.getSize(new Vector3());\n\t\tconst center = this.box.getCenter(new Vector3());\n\t\tconst maxSize = Math.max(boxSize.x, boxSize.y, boxSize.z);\n\t\tconst fitHeightDistance = is.orthographicCamera(camera)\n\t\t\t? maxSize * 4\n\t\t\t: maxSize / (2 * Math.atan((Math.PI * camera.fov) / 360));\n\t\tconst fitWidthDistance = is.orthographicCamera(camera) ? maxSize * 4 : fitHeightDistance / camera.aspect;\n\t\tconst distance = margin * Math.max(fitHeightDistance, fitWidthDistance);\n\n\t\treturn { box: this.box, size: boxSize, center, distance };\n\t}\n\n\trefresh(object?: Object3D | Box3) {\n\t\tconst [group, camera] = [untracked(this.groupRef).nativeElement, untracked(this.camera)];\n\n\t\tif (isBox3(object)) this.box.copy(object);\n\t\telse {\n\t\t\tconst target = object || group;\n\t\t\tif (!target) return this;\n\t\t\ttarget.updateWorldMatrix(true, true);\n\t\t\tthis.box.setFromObject(target);\n\t\t}\n\t\tif (this.box.isEmpty()) {\n\t\t\tconst max = camera.position.length() || 10;\n\t\t\tthis.box.setFromCenterAndSize(new Vector3(), new Vector3(max, max, max));\n\t\t}\n\n\t\tthis.origin.camPos.copy(camera.position);\n\t\tthis.origin.camRot.copy(camera.quaternion);\n\t\tis.orthographicCamera(camera) && (this.origin.camZoom = camera.zoom);\n\n\t\tthis.goal.camPos = undefined;\n\t\tthis.goal.camRot = undefined;\n\t\tthis.goal.camZoom = undefined;\n\t\tthis.goal.camUp = undefined;\n\t\tthis.goal.target = undefined;\n\n\t\treturn this;\n\t}\n\n\treset() {\n\t\tconst [camera] = [untracked(this.camera)];\n\t\tconst { center, distance } = this.getSize();\n\n\t\tconst direction = camera.position.clone().sub(center).normalize();\n\t\tthis.goal.camPos = center.clone().addScaledVector(direction, distance);\n\t\tthis.goal.target = center.clone();\n\t\tconst mCamRot = new Matrix4().lookAt(this.goal.camPos, this.goal.target, camera.up);\n\t\tthis.goal.camRot = new Quaternion().setFromRotationMatrix(mCamRot);\n\n\t\tthis.animationState = AnimationState.START;\n\t\tthis.t = 0;\n\n\t\treturn this;\n\t}\n\n\tmoveTo(position: Vector3 | [number, number, number]) {\n\t\tthis.goal.camPos = Array.isArray(position) ? new Vector3(...position) : position.clone();\n\n\t\tthis.animationState = AnimationState.START;\n\t\tthis.t = 0;\n\n\t\treturn this;\n\t}\n\n\tlookAt({ target, up }: { target: Vector3 | [number, number, number]; up?: Vector3 | [number, number, number] }) {\n\t\tconst [camera] = [untracked(this.camera)];\n\n\t\tthis.goal.target = Array.isArray(target) ? new Vector3(...target) : target.clone();\n\t\tif (up) {\n\t\t\tthis.goal.camUp = Array.isArray(up) ? new Vector3(...up) : up.clone();\n\t\t} else {\n\t\t\tthis.goal.camUp = camera.up.clone();\n\t\t}\n\t\tconst mCamRot = new Matrix4().lookAt(this.goal.camPos || camera.position, this.goal.target, this.goal.camUp);\n\t\tthis.goal.camRot = new Quaternion().setFromRotationMatrix(mCamRot);\n\n\t\tthis.animationState = AnimationState.START;\n\t\tthis.t = 0;\n\n\t\treturn this;\n\t}\n\n\tfit() {\n\t\tconst [camera, controls, { margin }] = [untracked(this.camera), untracked(this.controls), untracked(this.options)];\n\n\t\tif (!is.orthographicCamera(camera)) {\n\t\t\t// For non-orthographic cameras, fit should behave exactly like reset\n\t\t\treturn this.reset();\n\t\t}\n\n\t\t// For orthographic cameras, fit should only modify the zoom value\n\t\tlet maxHeight = 0;\n\t\tlet maxWidth = 0;\n\t\tconst vertices = [\n\t\t\tnew Vector3(this.box.min.x, this.box.min.y, this.box.min.z),\n\t\t\tnew Vector3(this.box.min.x, this.box.max.y, this.box.min.z),\n\t\t\tnew Vector3(this.box.min.x, this.box.min.y, this.box.max.z),\n\t\t\tnew Vector3(this.box.min.x, this.box.max.y, this.box.max.z),\n\t\t\tnew Vector3(this.box.max.x, this.box.max.y, this.box.max.z),\n\t\t\tnew Vector3(this.box.max.x, this.box.max.y, this.box.min.z),\n\t\t\tnew Vector3(this.box.max.x, this.box.min.y, this.box.max.z),\n\t\t\tnew Vector3(this.box.max.x, this.box.min.y, this.box.min.z),\n\t\t];\n\n\t\t// Transform the center and each corner to camera space\n\t\tconst pos = this.goal.camPos || camera.position;\n\t\tconst target = this.goal.target || controls.target;\n\t\tconst up = this.goal.camUp || camera.up;\n\t\tconst mCamWInv = target\n\t\t\t? new Matrix4().lookAt(pos, target, up).setPosition(pos).invert()\n\t\t\t: camera.matrixWorldInverse;\n\t\tfor (const v of vertices) {\n\t\t\tv.applyMatrix4(mCamWInv);\n\t\t\tmaxHeight = Math.max(maxHeight, Math.abs(v.y));\n\t\t\tmaxWidth = Math.max(maxWidth, Math.abs(v.x));\n\t\t}\n\t\tmaxHeight *= 2;\n\t\tmaxWidth *= 2;\n\t\tconst zoomForHeight = (camera.top - camera.bottom) / maxHeight;\n\t\tconst zoomForWidth = (camera.right - camera.left) / maxWidth;\n\n\t\tthis.goal.camZoom = Math.min(zoomForHeight, zoomForWidth) / margin;\n\n\t\tthis.animationState = AnimationState.START;\n\t\tthis.t = 0;\n\n\t\treturn this;\n\t}\n\n\tclip() {\n\t\tconst [camera, controls, invalidate] = [\n\t\t\tuntracked(this.camera),\n\t\t\tuntracked(this.controls),\n\t\t\tuntracked(this.invalidate),\n\t\t];\n\t\tconst { distance } = this.getSize();\n\n\t\tcamera.near = distance / 100;\n\t\tcamera.far = distance * 100;\n\t\tcamera.updateProjectionMatrix();\n\n\t\tif (controls) {\n\t\t\tcontrols.maxDistance = distance * 10;\n\t\t\tcontrols.update();\n\t\t}\n\n\t\tinvalidate();\n\n\t\treturn this;\n\t}\n}\n"]}

package/esm2022/staging/lib/camera-shake.mjs

@@ -0,0 +1,69 @@
+import { Directive, afterNextRender, input, untracked } from '@angular/core';
+import { injectBeforeRender, injectStore } from 'angular-three';
+import { injectAutoEffect } from 'ngxtension/auto-effect';
+import { mergeInputs } from 'ngxtension/inject-inputs';
+import { SimplexNoise } from 'three-stdlib';
+import * as i0 from "@angular/core";
+const defaultOptions = {
+    intensity: 1,
+    decayRate: 0.65,
+    maxYaw: 0.1,
+    maxPitch: 0.1,
+    maxRoll: 0.1,
+    yawFrequency: 0.1,
+    pitchFrequency: 0.1,
+    rollFrequency: 0.1,
+};
+export class NgtsCameraShake {
+    get intensity() {
+        return this.intensityOption;
+    }
+    set intensity(val) {
+        this.intensityOption = Math.min(1, Math.max(0, val));
+    }
+    constructor() {
+        this.options = input(defaultOptions, { transform: mergeInputs(defaultOptions) });
+        this.autoEffect = injectAutoEffect();
+        this.store = injectStore();
+        this.camera = this.store.select('camera');
+        this.defaultControls = this.store.select('controls');
+        this.initialRotation = untracked(this.camera).rotation.clone();
+        this.intensityOption = untracked(this.options).intensity;
+        this.yawNoise = new SimplexNoise();
+        this.pitchNoise = new SimplexNoise();
+        this.rollNoise = new SimplexNoise();
+        afterNextRender(() => {
+            this.autoEffect(() => {
+                const defaultControls = this.defaultControls();
+                if (!defaultControls)
+                    return;
+                const camera = this.camera();
+                const callback = () => void (this.initialRotation = camera.rotation.clone());
+                defaultControls.addEventListener('change', callback);
+                callback();
+                return () => void defaultControls.removeEventListener('change', callback);
+            });
+        });
+        injectBeforeRender(({ delta, clock }) => {
+            const [{ maxYaw, yawFrequency, maxPitch, pitchFrequency, maxRoll, rollFrequency, decay, decayRate }, camera] = [
+                this.options(),
+                this.camera(),
+            ];
+            const shake = Math.pow(this.intensity, 2);
+            const yaw = maxYaw * shake * this.yawNoise.noise(clock.elapsedTime * yawFrequency, 1);
+            const pitch = maxPitch * shake * this.pitchNoise.noise(clock.elapsedTime * pitchFrequency, 1);
+            const roll = maxRoll * shake * this.rollNoise.noise(clock.elapsedTime * rollFrequency, 1);
+            camera.rotation.set(this.initialRotation.x + pitch, this.initialRotation.y + yaw, this.initialRotation.z + roll);
+            if (decay && this.intensity > 0) {
+                this.intensity -= decayRate * delta;
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsCameraShake, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.0", type: NgtsCameraShake, isStandalone: true, selector: "ngts-camera-shake", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsCameraShake, decorators: [{
+            type: Directive,
+            args: [{ selector: 'ngts-camera-shake', standalone: true }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"camera-shake.js","sourceRoot":"","sources":["../../../../../../libs/soba/staging/src/lib/camera-shake.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, Signal, afterNextRender, input, untracked } from '@angular/core';\nimport { injectBeforeRender, injectStore } from 'angular-three';\nimport { injectAutoEffect } from 'ngxtension/auto-effect';\nimport { mergeInputs } from 'ngxtension/inject-inputs';\nimport { Vector3 } from 'three';\nimport { SimplexNoise } from 'three-stdlib';\n\ninterface ControlsProto {\n\tupdate(): void;\n\ttarget: Vector3;\n\taddEventListener: (event: string, callback: (event: any) => void) => void;\n\tremoveEventListener: (event: string, callback: (event: any) => void) => void;\n}\n\nexport interface NgtsCameraShakeOptions {\n\tintensity: number;\n\tdecay?: boolean;\n\tdecayRate: number;\n\tmaxYaw: number;\n\tmaxPitch: number;\n\tmaxRoll: number;\n\tyawFrequency: number;\n\tpitchFrequency: number;\n\trollFrequency: number;\n}\n\nconst defaultOptions: NgtsCameraShakeOptions = {\n\tintensity: 1,\n\tdecayRate: 0.65,\n\tmaxYaw: 0.1,\n\tmaxPitch: 0.1,\n\tmaxRoll: 0.1,\n\tyawFrequency: 0.1,\n\tpitchFrequency: 0.1,\n\trollFrequency: 0.1,\n};\n\n@Directive({ selector: 'ngts-camera-shake', standalone: true })\nexport class NgtsCameraShake {\n\toptions = input(defaultOptions, { transform: mergeInputs(defaultOptions) });\n\n\tprivate autoEffect = injectAutoEffect();\n\tprivate store = injectStore();\n\tprivate camera = this.store.select('camera');\n\tprivate defaultControls = this.store.select('controls') as unknown as Signal<ControlsProto>;\n\n\tprivate initialRotation = untracked(this.camera).rotation.clone();\n\tprivate intensityOption = untracked(this.options).intensity;\n\n\tget intensity() {\n\t\treturn this.intensityOption;\n\t}\n\n\tset intensity(val: number) {\n\t\tthis.intensityOption = Math.min(1, Math.max(0, val));\n\t}\n\n\tprivate yawNoise = new SimplexNoise();\n\tprivate pitchNoise = new SimplexNoise();\n\tprivate rollNoise = new SimplexNoise();\n\n\tconstructor() {\n\t\tafterNextRender(() => {\n\t\t\tthis.autoEffect(() => {\n\t\t\t\tconst defaultControls = this.defaultControls();\n\t\t\t\tif (!defaultControls) return;\n\t\t\t\tconst camera = this.camera();\n\n\t\t\t\tconst callback = () => void (this.initialRotation = camera.rotation.clone());\n\t\t\t\tdefaultControls.addEventListener('change', callback);\n\t\t\t\tcallback();\n\t\t\t\treturn () => void defaultControls.removeEventListener('change', callback);\n\t\t\t});\n\t\t});\n\n\t\tinjectBeforeRender(({ delta, clock }) => {\n\t\t\tconst [{ maxYaw, yawFrequency, maxPitch, pitchFrequency, maxRoll, rollFrequency, decay, decayRate }, camera] = [\n\t\t\t\tthis.options(),\n\t\t\t\tthis.camera(),\n\t\t\t];\n\t\t\tconst shake = Math.pow(this.intensity, 2);\n\t\t\tconst yaw = maxYaw * shake * this.yawNoise.noise(clock.elapsedTime * yawFrequency, 1);\n\t\t\tconst pitch = maxPitch * shake * this.pitchNoise.noise(clock.elapsedTime * pitchFrequency, 1);\n\t\t\tconst roll = maxRoll * shake * this.rollNoise.noise(clock.elapsedTime * rollFrequency, 1);\n\n\t\t\tcamera.rotation.set(this.initialRotation.x + pitch, this.initialRotation.y + yaw, this.initialRotation.z + roll);\n\n\t\t\tif (decay && this.intensity > 0) {\n\t\t\t\tthis.intensity -= decayRate * delta;\n\t\t\t}\n\t\t});\n\t}\n}\n"]}