angular-three-soba 1.0.2 → 1.2.0

package/esm2020/staging/lib/accumulative-shadows/randomized-lights.mjs

@@ -0,0 +1,196 @@
+import { Component, CUSTOM_ELEMENTS_SCHEMA, Directive, inject, InjectionToken, Input } from '@angular/core';
+import { extend, injectNgtRef, NgtRxStore } from 'angular-three';
+import { combineLatest } from 'rxjs';
+import * as THREE from 'three';
+import { DirectionalLight, Group, OrthographicCamera, Vector2 } from 'three';
+import { NGTS_ACCUMULATIVE_SHADOWS_API } from './accumulative-shadows';
+import * as i0 from "@angular/core";
+extend({ Group, DirectionalLight, OrthographicCamera, Vector2 });
+export const NGTS_RANDOMIZED_LIGHTS_API = new InjectionToken('NgtsRandomizedLights API');
+function randomizedLightsApiFactory(randomizedLights) {
+    const accumulativeApi = inject(NGTS_ACCUMULATIVE_SHADOWS_API);
+    const update = () => {
+        let light;
+        if (randomizedLights.lightsRef.nativeElement) {
+            for (let l = 0; l < randomizedLights.lightsRef.nativeElement.children.length; l++) {
+                light = randomizedLights.lightsRef.nativeElement.children[l];
+                if (Math.random() > randomizedLights.get('ambient')) {
+                    const position = randomizedLights.get('position');
+                    const radius = randomizedLights.get('radius');
+                    light.position.set(position[0] + THREE.MathUtils.randFloatSpread(radius), position[1] + THREE.MathUtils.randFloatSpread(radius), position[2] + THREE.MathUtils.randFloatSpread(radius));
+                }
+                else {
+                    const lambda = Math.acos(2 * Math.random() - 1) - Math.PI / 2.0;
+                    const phi = 2 * Math.PI * Math.random();
+                    const length = randomizedLights.get('length');
+                    light.position.set(Math.cos(lambda) * Math.cos(phi) * length, Math.abs(Math.cos(lambda) * Math.sin(phi) * length), Math.sin(lambda) * length);
+                }
+            }
+        }
+    };
+    const api = { update };
+    randomizedLights.effect(combineLatest([
+        randomizedLights.lightsRef.$,
+        randomizedLights.select('position'),
+        randomizedLights.select('radius'),
+        randomizedLights.select('length'),
+        randomizedLights.select('ambient'),
+    ]), ([group]) => {
+        if (accumulativeApi)
+            accumulativeApi.lights.set(group.uuid, api);
+        return () => accumulativeApi.lights.delete(group.uuid);
+    });
+    return api;
+}
+export class RandomizedLightsConsumer {
+    constructor() {
+        inject(NGTS_RANDOMIZED_LIGHTS_API);
+    }
+}
+RandomizedLightsConsumer.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.3", ngImport: i0, type: RandomizedLightsConsumer, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+RandomizedLightsConsumer.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.1.3", type: RandomizedLightsConsumer, isStandalone: true, selector: "ngts-randomized-lights-consumer", ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.3", ngImport: i0, type: RandomizedLightsConsumer, decorators: [{
+            type: Directive,
+            args: [{ selector: 'ngts-randomized-lights-consumer', standalone: true }]
+        }], ctorParameters: function () { return []; } });
+export class NgtsRandomizedLights extends NgtRxStore {
+    constructor() {
+        super(...arguments);
+        this.lightsRef = injectNgtRef();
+    }
+    /** How many frames it will jiggle the lights, 1.
+     *  Frames is context aware, if a provider like AccumulativeShadows exists, frames will be taken from there!  */
+    set frames(frames) {
+        this.set({ frames });
+    }
+    /** Light position, [0, 0, 0] */
+    set position(position) {
+        this.set({ position });
+    }
+    /** Radius of the jiggle, higher values make softer light, 5 */
+    set radius(radius) {
+        this.set({ radius });
+    }
+    /** Amount of lights, 8 */
+    set amount(amount) {
+        this.set({ amount });
+    }
+    /** Light intensity, 1 */
+    set intensity(intensity) {
+        this.set({ intensity });
+    }
+    /** Ambient occlusion, lower values mean less AO, hight more, you can mix AO and directional light, 0.5 */
+    set ambient(ambient) {
+        this.set({ ambient });
+    }
+    /** If the lights cast shadows, this is true by default */
+    set castShadow(castShadow) {
+        this.set({ castShadow });
+    }
+    /** Default shadow bias, 0 */
+    set bias(bias) {
+        this.set({ bias });
+    }
+    /** Default map size, 512 */
+    set mapSize(mapSize) {
+        this.set({ mapSize });
+    }
+    /** Default size of the shadow camera, 10 */
+    set size(size) {
+        this.set({ size });
+    }
+    /** Default shadow camera near, 0.5 */
+    set near(near) {
+        this.set({ near });
+    }
+    /** Default shadow camera far, 500 */
+    set far(far) {
+        this.set({ far });
+    }
+    initialize() {
+        super.initialize();
+        this.set({
+            castShadow: true,
+            bias: 0.001,
+            mapSize: 512,
+            size: 5,
+            near: 0.5,
+            far: 500,
+            frames: 1,
+            position: [0, 0, 0],
+            radius: 1,
+            amount: 8,
+            intensity: 1,
+            ambient: 0.5,
+        });
+        this.connect('cameraArgs', this.select(['size', 'near', 'far'], ({ size, near, far }) => [-size, size, size, -size, near, far]));
+        this.connect('length', this.select(['position'], ({ position }) => new THREE.Vector3(...position).length()));
+    }
+}
+NgtsRandomizedLights.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.3", ngImport: i0, type: NgtsRandomizedLights, deps: null, target: i0.ɵɵFactoryTarget.Component });
+NgtsRandomizedLights.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.1.3", type: NgtsRandomizedLights, isStandalone: true, selector: "ngts-randomized-lights", inputs: { lightsRef: "lightsRef", frames: "frames", position: "position", radius: "radius", amount: "amount", intensity: "intensity", ambient: "ambient", castShadow: "castShadow", bias: "bias", mapSize: "mapSize", size: "size", near: "near", far: "far" }, providers: [
+        { provide: NGTS_RANDOMIZED_LIGHTS_API, useFactory: randomizedLightsApiFactory, deps: [NgtsRandomizedLights] },
+    ], usesInheritance: true, ngImport: i0, template: `
+        <ngt-group ngtCompound [ref]="lightsRef">
+            <ngt-directional-light
+                *ngFor="let i; repeat: get('amount')"
+                [castShadow]="get('castShadow')"
+                [intensity]="get('intensity') / get('amount')"
+            >
+                <ngt-value [rawValue]="get('bias')" attach="shadow.bias" />
+                <ngt-vector2 *args="[get('mapSize'), get('mapSize')]" attach="shadow.mapSize" />
+                <ngt-orthographic-camera *args="get('cameraArgs')" attach="shadow.camera" />
+            </ngt-directional-light>
+        </ngt-group>
+    `, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.3", ngImport: i0, type: NgtsRandomizedLights, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-randomized-lights',
+                    standalone: true,
+                    template: `
+        <ngt-group ngtCompound [ref]="lightsRef">
+            <ngt-directional-light
+                *ngFor="let i; repeat: get('amount')"
+                [castShadow]="get('castShadow')"
+                [intensity]="get('intensity') / get('amount')"
+            >
+                <ngt-value [rawValue]="get('bias')" attach="shadow.bias" />
+                <ngt-vector2 *args="[get('mapSize'), get('mapSize')]" attach="shadow.mapSize" />
+                <ngt-orthographic-camera *args="get('cameraArgs')" attach="shadow.camera" />
+            </ngt-directional-light>
+        </ngt-group>
+    `,
+                    providers: [
+                        { provide: NGTS_RANDOMIZED_LIGHTS_API, useFactory: randomizedLightsApiFactory, deps: [NgtsRandomizedLights] },
+                    ],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], propDecorators: { lightsRef: [{
+                type: Input
+            }], frames: [{
+                type: Input
+            }], position: [{
+                type: Input
+            }], radius: [{
+                type: Input
+            }], amount: [{
+                type: Input
+            }], intensity: [{
+                type: Input
+            }], ambient: [{
+                type: Input
+            }], castShadow: [{
+                type: Input
+            }], bias: [{
+                type: Input
+            }], mapSize: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], near: [{
+                type: Input
+            }], far: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"randomized-lights.js","sourceRoot":"","sources":["../../../../../../../libs/angular-three-soba/staging/src/lib/accumulative-shadows/randomized-lights.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, CUSTOM_ELEMENTS_SCHEMA, Directive, inject, InjectionToken, Input } from '@angular/core';\nimport { extend, injectNgtRef, NgtRxStore } from 'angular-three';\nimport { combineLatest } from 'rxjs';\nimport * as THREE from 'three';\nimport { DirectionalLight, Group, OrthographicCamera, Vector2 } from 'three';\nimport { NgtsAccumulativeShadowsLightApi, NGTS_ACCUMULATIVE_SHADOWS_API } from './accumulative-shadows';\n\nextend({ Group, DirectionalLight, OrthographicCamera, Vector2 });\n\nexport const NGTS_RANDOMIZED_LIGHTS_API = new InjectionToken<NgtsAccumulativeShadowsLightApi>(\n    'NgtsRandomizedLights API'\n);\n\nfunction randomizedLightsApiFactory(randomizedLights: NgtsRandomizedLights) {\n    const accumulativeApi = inject(NGTS_ACCUMULATIVE_SHADOWS_API);\n\n    const update = () => {\n        let light: THREE.DirectionalLight | undefined;\n        if (randomizedLights.lightsRef.nativeElement) {\n            for (let l = 0; l < randomizedLights.lightsRef.nativeElement.children.length; l++) {\n                light = randomizedLights.lightsRef.nativeElement.children[l] as THREE.DirectionalLight;\n                if (Math.random() > randomizedLights.get('ambient')) {\n                    const position = randomizedLights.get('position');\n                    const radius = randomizedLights.get('radius');\n                    light.position.set(\n                        position[0] + THREE.MathUtils.randFloatSpread(radius),\n                        position[1] + THREE.MathUtils.randFloatSpread(radius),\n                        position[2] + THREE.MathUtils.randFloatSpread(radius)\n                    );\n                } else {\n                    const lambda = Math.acos(2 * Math.random() - 1) - Math.PI / 2.0;\n                    const phi = 2 * Math.PI * Math.random();\n                    const length = randomizedLights.get('length');\n                    light.position.set(\n                        Math.cos(lambda) * Math.cos(phi) * length,\n                        Math.abs(Math.cos(lambda) * Math.sin(phi) * length),\n                        Math.sin(lambda) * length\n                    );\n                }\n            }\n        }\n    };\n\n    const api = { update } as NgtsAccumulativeShadowsLightApi;\n\n    randomizedLights.effect(\n        combineLatest([\n            randomizedLights.lightsRef.$,\n            randomizedLights.select('position'),\n            randomizedLights.select('radius'),\n            randomizedLights.select('length'),\n            randomizedLights.select('ambient'),\n        ]),\n        ([group]) => {\n            if (accumulativeApi) accumulativeApi.lights.set(group.uuid, api);\n            return () => accumulativeApi.lights.delete(group.uuid);\n        }\n    );\n\n    return api;\n}\n\n@Directive({ selector: 'ngts-randomized-lights-consumer', standalone: true })\nexport class RandomizedLightsConsumer {\n    constructor() {\n        inject(NGTS_RANDOMIZED_LIGHTS_API);\n    }\n}\n\n@Component({\n    selector: 'ngts-randomized-lights',\n    standalone: true,\n    template: `\n        <ngt-group ngtCompound [ref]=\"lightsRef\">\n            <ngt-directional-light\n                *ngFor=\"let i; repeat: get('amount')\"\n                [castShadow]=\"get('castShadow')\"\n                [intensity]=\"get('intensity') / get('amount')\"\n            >\n                <ngt-value [rawValue]=\"get('bias')\" attach=\"shadow.bias\" />\n                <ngt-vector2 *args=\"[get('mapSize'), get('mapSize')]\" attach=\"shadow.mapSize\" />\n                <ngt-orthographic-camera *args=\"get('cameraArgs')\" attach=\"shadow.camera\" />\n            </ngt-directional-light>\n        </ngt-group>\n    `,\n    providers: [\n        { provide: NGTS_RANDOMIZED_LIGHTS_API, useFactory: randomizedLightsApiFactory, deps: [NgtsRandomizedLights] },\n    ],\n    schemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsRandomizedLights extends NgtRxStore {\n    @Input() lightsRef = injectNgtRef<THREE.Group>();\n    /** How many frames it will jiggle the lights, 1.\n     *  Frames is context aware, if a provider like AccumulativeShadows exists, frames will be taken from there!  */\n    @Input() set frames(frames: number) {\n        this.set({ frames });\n    }\n\n    /** Light position, [0, 0, 0] */\n    @Input() set position(position: [x: number, y: number, z: number]) {\n        this.set({ position });\n    }\n\n    /** Radius of the jiggle, higher values make softer light, 5 */\n    @Input() set radius(radius: number) {\n        this.set({ radius });\n    }\n\n    /** Amount of lights, 8 */\n    @Input() set amount(amount: number) {\n        this.set({ amount });\n    }\n\n    /** Light intensity, 1 */\n    @Input() set intensity(intensity: number) {\n        this.set({ intensity });\n    }\n\n    /** Ambient occlusion, lower values mean less AO, hight more, you can mix AO and directional light, 0.5 */\n    @Input() set ambient(ambient: number) {\n        this.set({ ambient });\n    }\n\n    /** If the lights cast shadows, this is true by default */\n    @Input() set castShadow(castShadow: boolean) {\n        this.set({ castShadow });\n    }\n\n    /** Default shadow bias, 0 */\n    @Input() set bias(bias: number) {\n        this.set({ bias });\n    }\n\n    /** Default map size, 512 */\n    @Input() set mapSize(mapSize: number) {\n        this.set({ mapSize });\n    }\n\n    /** Default size of the shadow camera, 10 */\n    @Input() set size(size: number) {\n        this.set({ size });\n    }\n\n    /** Default shadow camera near, 0.5 */\n    @Input() set near(near: number) {\n        this.set({ near });\n    }\n\n    /** Default shadow camera far, 500 */\n    @Input() set far(far: number) {\n        this.set({ far });\n    }\n\n    override initialize(): void {\n        super.initialize();\n        this.set({\n            castShadow: true,\n            bias: 0.001,\n            mapSize: 512,\n            size: 5,\n            near: 0.5,\n            far: 500,\n            frames: 1,\n            position: [0, 0, 0],\n            radius: 1,\n            amount: 8,\n            intensity: 1,\n            ambient: 0.5,\n        });\n        this.connect(\n            'cameraArgs',\n            this.select(['size', 'near', 'far'], ({ size, near, far }) => [-size, size, size, -size, near, far])\n        );\n        this.connect(\n            'length',\n            this.select(['position'], ({ position }) => new THREE.Vector3(...position).length())\n        );\n    }\n}\n"]}

package/esm2020/staging/lib/bounds/bounds.mjs

@@ -0,0 +1,283 @@
+import { Component, CUSTOM_ELEMENTS_SCHEMA, EventEmitter, inject, InjectionToken, Input, Output, } from '@angular/core';
+import { extend, injectBeforeRender, injectNgtRef, is, NgtRxStore, NgtStore } from 'angular-three';
+import { combineLatest, switchMap } from 'rxjs';
+import * as THREE from 'three';
+import { Group } from 'three';
+import * as i0 from "@angular/core";
+const isBox3 = (def) => !!def && def.isBox3;
+function equals(a, b, eps) {
+    return Math.abs(a.x - b.x) < eps && Math.abs(a.y - b.y) < eps && Math.abs(a.z - b.z) < eps;
+}
+function damp(v, t, lambda, delta) {
+    v.x = THREE.MathUtils.damp(v.x, t.x, lambda, delta);
+    v.y = THREE.MathUtils.damp(v.y, t.y, lambda, delta);
+    v.z = THREE.MathUtils.damp(v.z, t.z, lambda, delta);
+}
+export const NGTS_BOUNDS_API = new InjectionToken('NgtsBounds API');
+function boundsApiFactory(bounds) {
+    const store = inject(NgtStore);
+    const box = new THREE.Box3();
+    function getSize() {
+        const camera = store.get('camera');
+        const margin = bounds.get('margin');
+        const size = box.getSize(new THREE.Vector3());
+        const center = box.getCenter(new THREE.Vector3());
+        const maxSize = Math.max(size.x, size.y, size.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, size, center, distance };
+    }
+    const api = {
+        getSize,
+        refresh(object) {
+            const { camera, controls: storeControls } = store.get();
+            const controls = storeControls;
+            if (isBox3(object))
+                box.copy(object);
+            else {
+                const target = object || bounds.boundsRef.nativeElement;
+                if (target) {
+                    target.updateWorldMatrix(true, true);
+                    box.setFromObject(target);
+                }
+            }
+            if (box.isEmpty()) {
+                const max = camera.position.length() || 10;
+                box.setFromCenterAndSize(new THREE.Vector3(), new THREE.Vector3(max, max, max));
+            }
+            if (controls?.constructor.name === 'OrthographicTrackballControls') {
+                // put camera on a sphere along which it would move
+                const { distance } = getSize();
+                const direction = camera.position.clone().sub(controls.target).normalize().multiplyScalar(distance);
+                const newPos = controls.target.clone().add(direction);
+                camera.position.copy(newPos);
+            }
+            return this;
+        },
+        clip() {
+            const { distance } = getSize();
+            const { camera, controls: storeControls, invalidate } = store.get();
+            const controls = storeControls;
+            if (controls)
+                controls.maxDistance = distance * 10;
+            camera.near = distance / 100;
+            camera.far = distance * 100;
+            camera.updateProjectionMatrix();
+            if (controls)
+                controls.update();
+            invalidate();
+            return this;
+        },
+        to({ position, target }) {
+            const { camera } = store.get();
+            const { damping } = bounds.get();
+            bounds.current.camera.copy(camera.position);
+            const { center } = getSize();
+            bounds.goal.camera.set(...position);
+            if (target) {
+                bounds.goal.focus.set(...target);
+            }
+            else {
+                bounds.goal.focus.copy(center);
+            }
+            if (damping) {
+                bounds.current.animating = true;
+            }
+            else {
+                camera.position.set(...position);
+            }
+            return this;
+        },
+        fit() {
+            const { camera, controls: storeControls, invalidate } = store.get();
+            const controls = storeControls;
+            const { damping, margin } = bounds.get();
+            bounds.current.camera.copy(camera.position);
+            if (controls)
+                bounds.current.focus.copy(controls.target);
+            const { center, distance } = getSize();
+            const direction = center.clone().sub(camera.position).normalize().multiplyScalar(distance);
+            bounds.goal.camera.copy(center).sub(direction);
+            bounds.goal.focus.copy(center);
+            if (is.orthographicCamera(camera)) {
+                bounds.current.zoom = camera.zoom;
+                let maxHeight = 0, maxWidth = 0;
+                const vertices = [
+                    new THREE.Vector3(box.min.x, box.min.y, box.min.z),
+                    new THREE.Vector3(box.min.x, box.max.y, box.min.z),
+                    new THREE.Vector3(box.min.x, box.min.y, box.max.z),
+                    new THREE.Vector3(box.min.x, box.max.y, box.max.z),
+                    new THREE.Vector3(box.max.x, box.max.y, box.max.z),
+                    new THREE.Vector3(box.max.x, box.max.y, box.min.z),
+                    new THREE.Vector3(box.max.x, box.min.y, box.max.z),
+                    new THREE.Vector3(box.max.x, box.min.y, box.min.z),
+                ];
+                // Transform the center and each corner to camera space
+                center.applyMatrix4(camera.matrixWorldInverse);
+                for (const v of vertices) {
+                    v.applyMatrix4(camera.matrixWorldInverse);
+                    maxHeight = Math.max(maxHeight, Math.abs(v.y - center.y));
+                    maxWidth = Math.max(maxWidth, Math.abs(v.x - center.x));
+                }
+                maxHeight *= 2;
+                maxWidth *= 2;
+                const zoomForHeight = (camera.top - camera.bottom) / maxHeight;
+                const zoomForWidth = (camera.right - camera.left) / maxWidth;
+                bounds.goal.zoom = Math.min(zoomForHeight, zoomForWidth) / margin;
+                if (!damping) {
+                    camera.zoom = bounds.goal.zoom;
+                    camera.updateProjectionMatrix();
+                }
+            }
+            if (damping) {
+                bounds.current.animating = true;
+            }
+            else {
+                camera.position.copy(bounds.goal.camera);
+                camera.lookAt(bounds.goal.focus);
+                if (controls) {
+                    controls.target.copy(bounds.goal.focus);
+                    controls.update();
+                }
+            }
+            if (bounds.fitted.observed)
+                bounds.fitted.emit(this.getSize());
+            invalidate();
+            return this;
+        },
+    };
+    let count = 0;
+    bounds.hold(bounds.boundsRef.$.pipe(switchMap(() => combineLatest([
+        bounds.select('clip'),
+        bounds.select('fit'),
+        bounds.select('observe'),
+        store.select('camera'),
+        store.select('controls'),
+        store.select('size'),
+        bounds.boundsRef.children$(),
+    ]))), ([clip, fit, observe]) => {
+        if (observe || count++ === 0) {
+            api.refresh();
+            if (fit)
+                api.fit();
+            if (clip)
+                api.clip();
+        }
+    });
+    injectBeforeRender(({ delta }) => {
+        if (bounds.current.animating) {
+            const { damping, eps } = bounds.get();
+            const { camera, controls: storeControls, invalidate } = store.get();
+            const controls = storeControls;
+            damp(bounds.current.focus, bounds.goal.focus, damping, delta);
+            damp(bounds.current.camera, bounds.goal.camera, damping, delta);
+            bounds.current.zoom = THREE.MathUtils.damp(bounds.current.zoom, bounds.goal.zoom, damping, delta);
+            camera.position.copy(bounds.current.camera);
+            if (is.orthographicCamera(camera)) {
+                camera.zoom = bounds.current.zoom;
+                camera.updateProjectionMatrix();
+            }
+            if (!controls) {
+                camera.lookAt(bounds.current.focus);
+            }
+            else {
+                controls.target.copy(bounds.current.focus);
+                controls.update();
+            }
+            invalidate();
+            if (is.orthographicCamera(camera) && !(Math.abs(bounds.current.zoom - bounds.goal.zoom) < eps))
+                return;
+            if (!is.orthographicCamera(camera) && !equals(bounds.current.camera, bounds.goal.camera, eps))
+                return;
+            if (controls && !equals(bounds.current.focus, bounds.goal.focus, eps))
+                return;
+            bounds.current.animating = false;
+        }
+    });
+    return api;
+}
+extend({ Group });
+export class NgtsBounds extends NgtRxStore {
+    constructor() {
+        super(...arguments);
+        this.boundsRef = injectNgtRef();
+        this.fitted = new EventEmitter();
+        this.store = inject(NgtStore);
+        this.current = { animating: false, focus: new THREE.Vector3(), camera: new THREE.Vector3(), zoom: 1 };
+        this.goal = { focus: new THREE.Vector3(), camera: new THREE.Vector3(), zoom: 1 };
+    }
+    set damping(damping) {
+        this.set({ damping });
+    }
+    set fit(fit) {
+        this.set({ fit });
+    }
+    set clip(clip) {
+        this.set({ clip });
+    }
+    set observe(observe) {
+        this.set({ observe });
+    }
+    set margin(margin) {
+        this.set({ margin });
+    }
+    set eps(eps) {
+        this.set({ eps });
+    }
+    initialize() {
+        super.initialize();
+        this.set({ damping: 6, fit: false, clip: false, observe: false, margin: 1.2, eps: 0.01 });
+    }
+    ngOnInit() {
+        this.preventDragHijacking();
+    }
+    preventDragHijacking() {
+        this.effect(this.store.select('controls'), (controls) => {
+            if (controls) {
+                const callback = () => (this.current.animating = false);
+                controls.addEventListener('start', callback);
+                return () => controls.removeEventListener('start', callback);
+            }
+        });
+    }
+}
+NgtsBounds.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.3", ngImport: i0, type: NgtsBounds, deps: null, target: i0.ɵɵFactoryTarget.Component });
+NgtsBounds.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.1.3", type: NgtsBounds, isStandalone: true, selector: "ngts-bounds", inputs: { boundsRef: "boundsRef", damping: "damping", fit: "fit", clip: "clip", observe: "observe", margin: "margin", eps: "eps" }, outputs: { fitted: "fitted" }, providers: [{ provide: NGTS_BOUNDS_API, useFactory: boundsApiFactory, deps: [NgtsBounds] }], usesInheritance: true, ngImport: i0, template: `
+        <ngt-group ngtCompound [ref]="boundsRef">
+            <ng-content />
+        </ngt-group>
+    `, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.3", ngImport: i0, type: NgtsBounds, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-bounds',
+                    standalone: true,
+                    template: `
+        <ngt-group ngtCompound [ref]="boundsRef">
+            <ng-content />
+        </ngt-group>
+    `,
+                    providers: [{ provide: NGTS_BOUNDS_API, useFactory: boundsApiFactory, deps: [NgtsBounds] }],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], propDecorators: { boundsRef: [{
+                type: Input
+            }], damping: [{
+                type: Input
+            }], fit: [{
+                type: Input
+            }], clip: [{
+                type: Input
+            }], observe: [{
+                type: Input
+            }], margin: [{
+                type: Input
+            }], eps: [{
+                type: Input
+            }], fitted: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bounds.js","sourceRoot":"","sources":["../../../../../../../libs/angular-three-soba/staging/src/lib/bounds/bounds.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    Component,\n    CUSTOM_ELEMENTS_SCHEMA,\n    EventEmitter,\n    inject,\n    InjectionToken,\n    Input,\n    OnInit,\n    Output,\n} from '@angular/core';\nimport { extend, injectBeforeRender, injectNgtRef, is, NgtRxStore, NgtStore } from 'angular-three';\nimport { combineLatest, switchMap } from 'rxjs';\nimport * as THREE from 'three';\nimport { Group } from 'three';\n\nexport interface NgtsBoundsSize {\n    box: THREE.Box3;\n    size: THREE.Vector3;\n    center: THREE.Vector3;\n    distance: number;\n}\n\nexport interface NgtsBoundsApi {\n    getSize: () => NgtsBoundsSize;\n    refresh: (object?: THREE.Object3D | THREE.Box3) => NgtsBoundsApi;\n    clip: () => NgtsBoundsApi;\n    fit: () => NgtsBoundsApi;\n    to: ({\n        position,\n        target,\n    }: {\n        position: [number, number, number];\n        target?: [number, number, number];\n    }) => NgtsBoundsApi;\n}\n\ntype ControlsProto = {\n    update(): void;\n    target: THREE.Vector3;\n    maxDistance: number;\n    addEventListener: (event: string, callback: (event: any) => void) => void;\n    removeEventListener: (event: string, callback: (event: any) => void) => void;\n};\n\nconst isBox3 = (def: unknown): def is THREE.Box3 => !!def && (def as THREE.Box3).isBox3;\n\nfunction equals(a: THREE.Vector3, b: THREE.Vector3, eps: number) {\n    return Math.abs(a.x - b.x) < eps && Math.abs(a.y - b.y) < eps && Math.abs(a.z - b.z) < eps;\n}\n\nfunction damp(v: THREE.Vector3, t: THREE.Vector3, lambda: number, delta: number) {\n    v.x = THREE.MathUtils.damp(v.x, t.x, lambda, delta);\n    v.y = THREE.MathUtils.damp(v.y, t.y, lambda, delta);\n    v.z = THREE.MathUtils.damp(v.z, t.z, lambda, delta);\n}\n\nexport const NGTS_BOUNDS_API = new InjectionToken<NgtsBoundsApi>('NgtsBounds API');\n\nfunction boundsApiFactory(bounds: NgtsBounds) {\n    const store = inject(NgtStore);\n    const box = new THREE.Box3();\n\n    function getSize() {\n        const camera = store.get('camera');\n        const margin = bounds.get('margin');\n\n        const size = box.getSize(new THREE.Vector3());\n        const center = box.getCenter(new THREE.Vector3());\n        const maxSize = Math.max(size.x, size.y, size.z);\n        const fitHeightDistance = is.orthographicCamera(camera)\n            ? maxSize * 4\n            : maxSize / (2 * Math.atan((Math.PI * camera.fov) / 360));\n        const fitWidthDistance = is.orthographicCamera(camera) ? maxSize * 4 : fitHeightDistance / camera.aspect;\n        const distance = margin * Math.max(fitHeightDistance, fitWidthDistance);\n        return { box, size, center, distance };\n    }\n\n    const api = {\n        getSize,\n        refresh(object?: THREE.Object3D | THREE.Box3) {\n            const { camera, controls: storeControls } = store.get();\n            const controls = storeControls as unknown as ControlsProto;\n\n            if (isBox3(object)) box.copy(object);\n            else {\n                const target = object || bounds.boundsRef.nativeElement;\n                if (target) {\n                    target.updateWorldMatrix(true, true);\n                    box.setFromObject(target);\n                }\n            }\n            if (box.isEmpty()) {\n                const max = camera.position.length() || 10;\n                box.setFromCenterAndSize(new THREE.Vector3(), new THREE.Vector3(max, max, max));\n            }\n\n            if (controls?.constructor.name === 'OrthographicTrackballControls') {\n                // put camera on a sphere along which it would move\n                const { distance } = getSize();\n                const direction = camera.position.clone().sub(controls.target).normalize().multiplyScalar(distance);\n                const newPos = controls.target.clone().add(direction);\n                camera.position.copy(newPos);\n            }\n            return this;\n        },\n        clip() {\n            const { distance } = getSize();\n            const { camera, controls: storeControls, invalidate } = store.get();\n            const controls = storeControls as unknown as ControlsProto;\n            if (controls) controls.maxDistance = distance * 10;\n            camera.near = distance / 100;\n            camera.far = distance * 100;\n            camera.updateProjectionMatrix();\n            if (controls) controls.update();\n            invalidate();\n            return this;\n        },\n        to({ position, target }: { position: [number, number, number]; target?: [number, number, number] }) {\n            const { camera } = store.get();\n            const { damping } = bounds.get();\n\n            bounds.current.camera.copy(camera.position);\n            const { center } = getSize();\n            bounds.goal.camera.set(...position);\n\n            if (target) {\n                bounds.goal.focus.set(...target);\n            } else {\n                bounds.goal.focus.copy(center);\n            }\n\n            if (damping) {\n                bounds.current.animating = true;\n            } else {\n                camera.position.set(...position);\n            }\n\n            return this;\n        },\n        fit() {\n            const { camera, controls: storeControls, invalidate } = store.get();\n            const controls = storeControls as unknown as ControlsProto;\n\n            const { damping, margin } = bounds.get();\n\n            bounds.current.camera.copy(camera.position);\n            if (controls) bounds.current.focus.copy(controls.target);\n\n            const { center, distance } = getSize();\n            const direction = center.clone().sub(camera.position).normalize().multiplyScalar(distance);\n\n            bounds.goal.camera.copy(center).sub(direction);\n            bounds.goal.focus.copy(center);\n\n            if (is.orthographicCamera(camera)) {\n                bounds.current.zoom = camera.zoom;\n\n                let maxHeight = 0,\n                    maxWidth = 0;\n                const vertices = [\n                    new THREE.Vector3(box.min.x, box.min.y, box.min.z),\n                    new THREE.Vector3(box.min.x, box.max.y, box.min.z),\n                    new THREE.Vector3(box.min.x, box.min.y, box.max.z),\n                    new THREE.Vector3(box.min.x, box.max.y, box.max.z),\n                    new THREE.Vector3(box.max.x, box.max.y, box.max.z),\n                    new THREE.Vector3(box.max.x, box.max.y, box.min.z),\n                    new THREE.Vector3(box.max.x, box.min.y, box.max.z),\n                    new THREE.Vector3(box.max.x, box.min.y, box.min.z),\n                ];\n                // Transform the center and each corner to camera space\n                center.applyMatrix4(camera.matrixWorldInverse);\n                for (const v of vertices) {\n                    v.applyMatrix4(camera.matrixWorldInverse);\n                    maxHeight = Math.max(maxHeight, Math.abs(v.y - center.y));\n                    maxWidth = Math.max(maxWidth, Math.abs(v.x - center.x));\n                }\n                maxHeight *= 2;\n                maxWidth *= 2;\n                const zoomForHeight = (camera.top - camera.bottom) / maxHeight;\n                const zoomForWidth = (camera.right - camera.left) / maxWidth;\n                bounds.goal.zoom = Math.min(zoomForHeight, zoomForWidth) / margin;\n                if (!damping) {\n                    camera.zoom = bounds.goal.zoom;\n                    camera.updateProjectionMatrix();\n                }\n            }\n\n            if (damping) {\n                bounds.current.animating = true;\n            } else {\n                camera.position.copy(bounds.goal.camera);\n                camera.lookAt(bounds.goal.focus);\n                if (controls) {\n                    controls.target.copy(bounds.goal.focus);\n                    controls.update();\n                }\n            }\n            if (bounds.fitted.observed) bounds.fitted.emit(this.getSize());\n            invalidate();\n            return this;\n        },\n    } as NgtsBoundsApi;\n\n    let count = 0;\n    bounds.hold(\n        bounds.boundsRef.$.pipe(\n            switchMap(() =>\n                combineLatest([\n                    bounds.select('clip'),\n                    bounds.select('fit'),\n                    bounds.select('observe'),\n                    store.select('camera'),\n                    store.select('controls'),\n                    store.select('size'),\n                    bounds.boundsRef.children$(),\n                ])\n            )\n        ),\n        ([clip, fit, observe]) => {\n            if (observe || count++ === 0) {\n                api.refresh();\n                if (fit) api.fit();\n                if (clip) api.clip();\n            }\n        }\n    );\n\n    injectBeforeRender(({ delta }) => {\n        if (bounds.current.animating) {\n            const { damping, eps } = bounds.get();\n            const { camera, controls: storeControls, invalidate } = store.get();\n            const controls = storeControls as unknown as ControlsProto;\n\n            damp(bounds.current.focus, bounds.goal.focus, damping, delta);\n            damp(bounds.current.camera, bounds.goal.camera, damping, delta);\n            bounds.current.zoom = THREE.MathUtils.damp(bounds.current.zoom, bounds.goal.zoom, damping, delta);\n            camera.position.copy(bounds.current.camera);\n\n            if (is.orthographicCamera(camera)) {\n                camera.zoom = bounds.current.zoom;\n                camera.updateProjectionMatrix();\n            }\n\n            if (!controls) {\n                camera.lookAt(bounds.current.focus);\n            } else {\n                controls.target.copy(bounds.current.focus);\n                controls.update();\n            }\n\n            invalidate();\n            if (is.orthographicCamera(camera) && !(Math.abs(bounds.current.zoom - bounds.goal.zoom) < eps)) return;\n            if (!is.orthographicCamera(camera) && !equals(bounds.current.camera, bounds.goal.camera, eps)) return;\n            if (controls && !equals(bounds.current.focus, bounds.goal.focus, eps)) return;\n            bounds.current.animating = false;\n        }\n    });\n\n    return api;\n}\n\nextend({ Group });\n\n@Component({\n    selector: 'ngts-bounds',\n    standalone: true,\n    template: `\n        <ngt-group ngtCompound [ref]=\"boundsRef\">\n            <ng-content />\n        </ngt-group>\n    `,\n    providers: [{ provide: NGTS_BOUNDS_API, useFactory: boundsApiFactory, deps: [NgtsBounds] }],\n    schemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsBounds extends NgtRxStore implements OnInit {\n    @Input() boundsRef = injectNgtRef<Group>();\n\n    @Input() set damping(damping: number) {\n        this.set({ damping });\n    }\n\n    @Input() set fit(fit: boolean) {\n        this.set({ fit });\n    }\n\n    @Input() set clip(clip: boolean) {\n        this.set({ clip });\n    }\n\n    @Input() set observe(observe: boolean) {\n        this.set({ observe });\n    }\n\n    @Input() set margin(margin: number) {\n        this.set({ margin });\n    }\n\n    @Input() set eps(eps: number) {\n        this.set({ eps });\n    }\n\n    @Output() fitted = new EventEmitter<NgtsBoundsSize>();\n\n    private readonly store = inject(NgtStore);\n\n    readonly current = { animating: false, focus: new THREE.Vector3(), camera: new THREE.Vector3(), zoom: 1 };\n    readonly goal = { focus: new THREE.Vector3(), camera: new THREE.Vector3(), zoom: 1 };\n\n    override initialize() {\n        super.initialize();\n        this.set({ damping: 6, fit: false, clip: false, observe: false, margin: 1.2, eps: 0.01 });\n    }\n\n    ngOnInit() {\n        this.preventDragHijacking();\n    }\n\n    private preventDragHijacking() {\n        this.effect(this.store.select('controls'), (controls) => {\n            if (controls) {\n                const callback = () => (this.current.animating = false);\n                (controls as unknown as ControlsProto).addEventListener('start', callback);\n                return () => (controls as unknown as ControlsProto).removeEventListener('start', callback);\n            }\n        });\n    }\n}\n"]}