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

package/esm2022/staging/accumulative-shadows/randomized-lights.mjs

@@ -0,0 +1,208 @@
+import { CUSTOM_ELEMENTS_SCHEMA, Component, Input, computed, effect, inject } from '@angular/core';
+import { NgtArgs, NgtRepeat, NgtSignalStore, extend, injectNgtRef, requestAnimationInInjectionContext, } from 'angular-three';
+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 });
+class NgtsRandomizedLights extends NgtSignalStore {
+    /** 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 });
+    }
+    #parent;
+    #size;
+    #near;
+    #far;
+    #mapSize;
+    #ambient;
+    #position;
+    #radius;
+    constructor() {
+        super({
+            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.lightsRef = injectNgtRef();
+        this.#parent = inject(NGTS_ACCUMULATIVE_SHADOWS_API);
+        this.#size = this.select('size');
+        this.#near = this.select('near');
+        this.#far = this.select('far');
+        this.#mapSize = this.select('mapSize');
+        this.#ambient = this.select('ambient');
+        this.#position = this.select('position');
+        this.#radius = this.select('radius');
+        this.lightsAmount = this.select('amount');
+        this.lightsCastShadow = this.select('castShadow');
+        this.lightsIntensity = this.select('intensity');
+        this.lightsBias = this.select('bias');
+        this.shadowMapSize = computed(() => [this.#mapSize(), this.#mapSize()]);
+        this.cameraArgs = computed(() => [
+            -this.#size(),
+            this.#size(),
+            this.#size(),
+            -this.#size(),
+            this.#near(),
+            this.#far(),
+        ]);
+        this.length = computed(() => new THREE.Vector3(...this.#position()).length());
+        this.api = computed(() => {
+            const radius = this.#radius();
+            const position = this.#position();
+            const ambient = this.#ambient();
+            const length = this.length();
+            const lights = this.lightsRef.nativeElement;
+            const update = () => {
+                let light;
+                if (lights) {
+                    for (let l = 0; l < lights.children.length; l++) {
+                        light = lights.children[l];
+                        if (Math.random() > ambient) {
+                            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();
+                            light.position.set(Math.cos(lambda) * Math.cos(phi) * length, Math.abs(Math.cos(lambda) * Math.sin(phi) * length), Math.sin(lambda) * length);
+                        }
+                    }
+                }
+            };
+            return { update };
+        });
+        requestAnimationInInjectionContext(() => {
+            this.#updateLightsMap();
+        });
+    }
+    #updateLightsMap() {
+        effect((onCleanup) => {
+            const lights = this.lightsRef.nativeElement;
+            if (!lights)
+                return;
+            const parent = this.#parent();
+            if (parent) {
+                parent.lights.set(lights.uuid, this.api);
+                onCleanup(() => parent.lights.delete(lights.uuid));
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsRandomizedLights, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", 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" }, usesInheritance: true, ngImport: i0, template: `
+        <ngt-group ngtCompound [ref]="lightsRef">
+            <ngt-directional-light
+                *ngFor="let i; repeat: lightsAmount()"
+                [castShadow]="lightsCastShadow()"
+                [intensity]="lightsIntensity() / lightsAmount()"
+            >
+                <ngt-value [rawValue]="lightsBias()" attach="shadow.bias" />
+                <ngt-vector2 *args="shadowMapSize()" attach="shadow.mapSize" />
+                <ngt-orthographic-camera *args="cameraArgs()" attach="shadow.camera" />
+            </ngt-directional-light>
+        </ngt-group>
+    `, isInline: true, dependencies: [{ kind: "directive", type: NgtArgs, selector: "[args]", inputs: ["args"] }, { kind: "directive", type: NgtRepeat, selector: "[ngFor][ngForRepeat]", inputs: ["ngForRepeat"] }] }); }
+}
+export { NgtsRandomizedLights };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", 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: lightsAmount()"
+                [castShadow]="lightsCastShadow()"
+                [intensity]="lightsIntensity() / lightsAmount()"
+            >
+                <ngt-value [rawValue]="lightsBias()" attach="shadow.bias" />
+                <ngt-vector2 *args="shadowMapSize()" attach="shadow.mapSize" />
+                <ngt-orthographic-camera *args="cameraArgs()" attach="shadow.camera" />
+            </ngt-directional-light>
+        </ngt-group>
+    `,
+                    imports: [NgtArgs, NgtRepeat],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: function () { return []; }, 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/soba/staging/src/accumulative-shadows/randomized-lights.ts"],"names":[],"mappings":"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","sourcesContent":["import { CUSTOM_ELEMENTS_SCHEMA, Component, Input, computed, effect, inject } from '@angular/core';\nimport {\n    NgtArgs,\n    NgtRepeat,\n    NgtSignalStore,\n    extend,\n    injectNgtRef,\n    requestAnimationInInjectionContext,\n    type NgtGroup,\n} from 'angular-three';\nimport * as THREE from 'three';\nimport { DirectionalLight, Group, OrthographicCamera, Vector2 } from 'three';\nimport { NGTS_ACCUMULATIVE_SHADOWS_API } from './accumulative-shadows';\n\nextend({ Group, DirectionalLight, OrthographicCamera, Vector2 });\n\nexport interface NgtsRandomizedLightsState {\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    frames: number;\n    /** Light position, [0, 0, 0] */\n    position: [x: number, y: number, z: number];\n    /** Radius of the jiggle, higher values make softer light, 5 */\n    radius: number;\n    /** Amount of lights, 8 */\n    amount: number;\n    /** Light intensity, 1 */\n    intensity: number;\n    /** Ambient occlusion, lower values mean less AO, hight more, you can mix AO and directional light, 0.5 */\n    ambient: number;\n    /** If the lights cast shadows, this is true by default */\n    castShadow: boolean;\n    /** Default shadow bias, 0 */\n    bias: number;\n    /** Default map size, 512 */\n    mapSize: number;\n    /** Default size of the shadow camera, 10 */\n    size: number;\n    /** Default shadow camera near, 0.5 */\n    near: number;\n    /** Default shadow camera far, 500 */\n    far: number;\n}\n\ndeclare global {\n    interface HTMLElementTagNameMap {\n        'ngts-randomized-lights': NgtGroup & NgtsRandomizedLightsState;\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: lightsAmount()\"\n                [castShadow]=\"lightsCastShadow()\"\n                [intensity]=\"lightsIntensity() / lightsAmount()\"\n            >\n                <ngt-value [rawValue]=\"lightsBias()\" attach=\"shadow.bias\" />\n                <ngt-vector2 *args=\"shadowMapSize()\" attach=\"shadow.mapSize\" />\n                <ngt-orthographic-camera *args=\"cameraArgs()\" attach=\"shadow.camera\" />\n            </ngt-directional-light>\n        </ngt-group>\n    `,\n    imports: [NgtArgs, NgtRepeat],\n    schemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsRandomizedLights extends NgtSignalStore<NgtsRandomizedLightsState> {\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    readonly #parent = inject(NGTS_ACCUMULATIVE_SHADOWS_API);\n\n    readonly #size = this.select('size');\n    readonly #near = this.select('near');\n    readonly #far = this.select('far');\n    readonly #mapSize = this.select('mapSize');\n    readonly #ambient = this.select('ambient');\n    readonly #position = this.select('position');\n    readonly #radius = this.select('radius');\n\n    readonly lightsAmount = this.select('amount');\n    readonly lightsCastShadow = this.select('castShadow');\n    readonly lightsIntensity = this.select('intensity');\n    readonly lightsBias = this.select('bias');\n\n    readonly shadowMapSize = computed(() => [this.#mapSize(), this.#mapSize()]);\n    readonly cameraArgs = computed(() => [\n        -this.#size(),\n        this.#size(),\n        this.#size(),\n        -this.#size(),\n        this.#near(),\n        this.#far(),\n    ]);\n\n    readonly length = computed(() => new THREE.Vector3(...this.#position()).length());\n\n    readonly api = computed(() => {\n        const radius = this.#radius();\n        const position = this.#position();\n        const ambient = this.#ambient();\n        const length = this.length();\n        const lights = this.lightsRef.nativeElement;\n\n        const update = () => {\n            let light: THREE.DirectionalLight | undefined;\n            if (lights) {\n                for (let l = 0; l < lights.children.length; l++) {\n                    light = lights.children[l] as THREE.DirectionalLight;\n                    if (Math.random() > ambient) {\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                        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        return { update };\n    });\n\n    constructor() {\n        super({\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        requestAnimationInInjectionContext(() => {\n            this.#updateLightsMap();\n        });\n    }\n\n    #updateLightsMap() {\n        effect((onCleanup) => {\n            const lights = this.lightsRef.nativeElement;\n            if (!lights) return;\n            const parent = this.#parent();\n            if (parent) {\n                parent.lights.set(lights.uuid, this.api);\n                onCleanup(() => parent.lights.delete(lights.uuid));\n            }\n        });\n    }\n}\n"]}

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

@@ -2,4 +2,4 @@
  * Generated bundle index. Do not edit.
  */
 export * from './index';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW5ndWxhci10aHJlZS1zb2JhLXN0YWdpbmcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXItdGhyZWUtc29iYS9zdGFnaW5nL3NyYy9hbmd1bGFyLXRocmVlLXNvYmEtc3RhZ2luZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2luZGV4JztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW5ndWxhci10aHJlZS1zb2JhLXN0YWdpbmcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL3NvYmEvc3RhZ2luZy9zcmMvYW5ndWxhci10aHJlZS1zb2JhLXN0YWdpbmcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9pbmRleCc7XG4iXX0=

package/esm2022/staging/bounds/bounds.mjs

@@ -0,0 +1,307 @@
+import { Component, computed, CUSTOM_ELEMENTS_SCHEMA, effect, EventEmitter, inject, InjectionToken, Input, Output, untracked, } from '@angular/core';
+import { extend, injectBeforeRender, injectNgtRef, is, NgtSignalStore, NgtStore, requestAnimationInInjectionContext, } from 'angular-three';
+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');
+extend({ Group });
+class NgtsBounds extends NgtSignalStore {
+    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 });
+    }
+    #store;
+    #controls;
+    #camera;
+    #invalidate;
+    #size;
+    #current;
+    #goal;
+    #box;
+    #margin;
+    #damping;
+    #fit;
+    #clip;
+    #observe;
+    #count;
+    constructor() {
+        super({ damping: 6, fit: false, clip: false, observe: false, margin: 1.2, eps: 0.01 });
+        this.boundsRef = injectNgtRef();
+        this.fitted = new EventEmitter();
+        this.#store = inject(NgtStore);
+        this.#controls = this.#store.select('controls');
+        this.#camera = this.#store.select('camera');
+        this.#invalidate = this.#store.select('invalidate');
+        this.#size = this.#store.select('size');
+        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 };
+        this.#box = new THREE.Box3();
+        this.#margin = this.select('margin');
+        this.#damping = this.select('damping');
+        this.#fit = this.select('fit');
+        this.#clip = this.select('clip');
+        this.#observe = this.select('observe');
+        this.#count = 0;
+        this.api = computed(() => {
+            const margin = this.#margin();
+            const damping = this.#damping();
+            const camera = this.#camera();
+            const controls = this.#controls();
+            const invalidate = this.#invalidate();
+            const current = this.#current;
+            const goal = this.#goal;
+            const box = this.#box;
+            const ref = () => this.boundsRef.untracked;
+            const fitted = this.fitted;
+            function getSize() {
+                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 };
+            }
+            return {
+                getSize,
+                refresh(object) {
+                    if (isBox3(object))
+                        box.copy(object);
+                    else {
+                        const target = object || ref();
+                        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 should 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();
+                    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 }) {
+                    current.camera.copy(camera.position);
+                    const { center } = getSize();
+                    goal.camera.set(...position);
+                    if (target) {
+                        goal.focus.set(...target);
+                    }
+                    else {
+                        goal.focus.copy(center);
+                    }
+                    if (damping) {
+                        current.animating = true;
+                    }
+                    else {
+                        camera.position.set(...position);
+                    }
+                    return this;
+                },
+                fit() {
+                    current.camera.copy(camera.position);
+                    if (controls)
+                        current.focus.copy(controls.target);
+                    const { center, distance } = getSize();
+                    const direction = center.clone().sub(camera.position).normalize().multiplyScalar(distance);
+                    goal.camera.copy(center).sub(direction);
+                    goal.focus.copy(center);
+                    if (is.orthographicCamera(camera)) {
+                        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;
+                        goal.zoom = Math.min(zoomForHeight, zoomForWidth) / margin;
+                        if (!damping) {
+                            camera.zoom = goal.zoom;
+                            camera.updateProjectionMatrix();
+                        }
+                    }
+                    if (damping) {
+                        current.animating = true;
+                    }
+                    else {
+                        camera.position.copy(goal.camera);
+                        camera.lookAt(goal.focus);
+                        if (controls) {
+                            controls.target.copy(goal.focus);
+                            controls.update();
+                        }
+                    }
+                    if (fitted.observed)
+                        fitted.emit(this.getSize());
+                    invalidate();
+                    return this;
+                },
+            };
+        });
+        this.#preventDragHijacking();
+        requestAnimationInInjectionContext(() => {
+            this.#scalePointer();
+            injectBeforeRender(this.#onBeforeRender.bind(this));
+        });
+    }
+    #scalePointer() {
+        const trigger = computed(() => ({
+            size: this.#size(),
+            fit: this.#fit(),
+            clip: this.#clip(),
+            observe: this.#observe(),
+            camera: this.#camera(),
+            controls: this.#controls(),
+        }));
+        effect(() => {
+            const { observe, fit, clip } = trigger();
+            const api = untracked(this.api);
+            if (observe || this.#count++ === 0) {
+                api.refresh();
+                if (fit)
+                    api.fit();
+                if (clip)
+                    api.clip();
+            }
+        });
+    }
+    #onBeforeRender({ delta }) {
+        const { damping, eps } = this.get();
+        const invalidate = this.#invalidate();
+        const camera = this.#camera();
+        const controls = this.#controls();
+        if (this.#current.animating) {
+            damp(this.#current.focus, this.#goal.focus, damping, delta);
+            damp(this.#current.camera, this.#goal.camera, damping, delta);
+            this.#current.zoom = THREE.MathUtils.damp(this.#current.zoom, this.#goal.zoom, damping, delta);
+            camera.position.copy(this.#current.camera);
+            if (is.orthographicCamera(camera)) {
+                camera.zoom = this.#current.zoom;
+                camera.updateProjectionMatrix();
+            }
+            if (!controls) {
+                camera.lookAt(this.#current.focus);
+            }
+            else {
+                controls.target.copy(this.#current.focus);
+                controls.update();
+            }
+            invalidate();
+            if (is.orthographicCamera(camera) && !(Math.abs(this.#current.zoom - this.#goal.zoom) < eps))
+                return;
+            if (!is.orthographicCamera(camera) && !equals(this.#current.camera, this.#goal.camera, eps))
+                return;
+            if (controls && !equals(this.#current.focus, this.#goal.focus, eps))
+                return;
+            this.#current.animating = false;
+        }
+    }
+    #preventDragHijacking() {
+        effect((onCleanup) => {
+            const controls = this.#controls();
+            if (controls) {
+                const callback = () => (this.#current.animating = false);
+                controls.addEventListener('start', callback);
+                onCleanup(() => controls.removeEventListener('start', callback));
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsBounds, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", 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: (bounds) => bounds.api, deps: [NgtsBounds] }], usesInheritance: true, ngImport: i0, template: `
+        <ngt-group ngtCompound [ref]="boundsRef">
+            <ng-content />
+        </ngt-group>
+    `, isInline: true }); }
+}
+export { NgtsBounds };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", 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: (bounds) => bounds.api, deps: [NgtsBounds] }],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: function () { return []; }, 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/soba/staging/src/bounds/bounds.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    Component,\n    computed,\n    CUSTOM_ELEMENTS_SCHEMA,\n    effect,\n    EventEmitter,\n    inject,\n    InjectionToken,\n    Input,\n    Output,\n    Signal,\n    untracked,\n} from '@angular/core';\nimport {\n    extend,\n    injectBeforeRender,\n    injectNgtRef,\n    is,\n    NgtSignalStore,\n    NgtStore,\n    requestAnimationInInjectionContext,\n    type NgtRenderState,\n} from 'angular-three';\nimport * as THREE from 'three';\nimport { Group } from 'three';\n\nexport type NgtsBoundsSize = {\n    box: THREE.Box3;\n    size: THREE.Vector3;\n    center: THREE.Vector3;\n    distance: number;\n};\n\nexport type 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<Signal<NgtsBoundsApi>>('NgtsBounds API');\n\nexport interface NgtsBoundsState {\n    damping: number;\n    fit: boolean;\n    clip: boolean;\n    observe: boolean;\n    margin: number;\n    eps: number;\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: (bounds: NgtsBounds) => bounds.api, deps: [NgtsBounds] }],\n    schemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsBounds extends NgtSignalStore<NgtsBoundsState> {\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    readonly #store = inject(NgtStore);\n    readonly #controls = this.#store.select('controls');\n    readonly #camera = this.#store.select('camera');\n    readonly #invalidate = this.#store.select('invalidate');\n    readonly #size = this.#store.select('size');\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    readonly #box = new THREE.Box3();\n\n    readonly #margin = this.select('margin');\n    readonly #damping = this.select('damping');\n    readonly #fit = this.select('fit');\n    readonly #clip = this.select('clip');\n    readonly #observe = this.select('observe');\n\n    #count = 0;\n\n    readonly api = computed(() => {\n        const margin = this.#margin();\n        const damping = this.#damping();\n\n        const camera = this.#camera();\n        const controls = this.#controls() as unknown as ControlsProto;\n        const invalidate = this.#invalidate();\n\n        const current = this.#current;\n        const goal = this.#goal;\n\n        const box = this.#box;\n        const ref = () => this.boundsRef.untracked;\n        const fitted = this.fitted;\n\n        function getSize() {\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        return {\n            getSize,\n            refresh(object?: THREE.Object3D | THREE.Box3) {\n                if (isBox3(object)) box.copy(object);\n                else {\n                    const target = object || ref();\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 should 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\n                return this;\n            },\n\n            clip() {\n                const { distance } = getSize();\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                current.camera.copy(camera.position);\n                const { center } = getSize();\n                goal.camera.set(...position);\n\n                if (target) {\n                    goal.focus.set(...target);\n                } else {\n                    goal.focus.copy(center);\n                }\n\n                if (damping) {\n                    current.animating = true;\n                } else {\n                    camera.position.set(...position);\n                }\n\n                return this;\n            },\n            fit() {\n                current.camera.copy(camera.position);\n                if (controls) current.focus.copy(controls.target);\n\n                const { center, distance } = getSize();\n                const direction = center.clone().sub(camera.position).normalize().multiplyScalar(distance);\n\n                goal.camera.copy(center).sub(direction);\n                goal.focus.copy(center);\n\n                if (is.orthographicCamera(camera)) {\n                    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                    goal.zoom = Math.min(zoomForHeight, zoomForWidth) / margin;\n                    if (!damping) {\n                        camera.zoom = goal.zoom;\n                        camera.updateProjectionMatrix();\n                    }\n                }\n\n                if (damping) {\n                    current.animating = true;\n                } else {\n                    camera.position.copy(goal.camera);\n                    camera.lookAt(goal.focus);\n                    if (controls) {\n                        controls.target.copy(goal.focus);\n                        controls.update();\n                    }\n                }\n                if (fitted.observed) fitted.emit(this.getSize());\n                invalidate();\n                return this;\n            },\n        };\n    });\n\n    constructor() {\n        super({ damping: 6, fit: false, clip: false, observe: false, margin: 1.2, eps: 0.01 });\n        this.#preventDragHijacking();\n        requestAnimationInInjectionContext(() => {\n            this.#scalePointer();\n            injectBeforeRender(this.#onBeforeRender.bind(this));\n        });\n    }\n\n    #scalePointer() {\n        const trigger = computed(() => ({\n            size: this.#size(),\n            fit: this.#fit(),\n            clip: this.#clip(),\n            observe: this.#observe(),\n            camera: this.#camera(),\n            controls: this.#controls(),\n        }));\n        effect(() => {\n            const { observe, fit, clip } = trigger();\n            const api = untracked(this.api);\n            if (observe || this.#count++ === 0) {\n                api.refresh();\n                if (fit) api.fit();\n                if (clip) api.clip();\n            }\n        });\n    }\n\n    #onBeforeRender({ delta }: NgtRenderState) {\n        const { damping, eps } = this.get();\n        const invalidate = this.#invalidate();\n        const camera = this.#camera();\n        const controls = this.#controls() as unknown as ControlsProto;\n\n        if (this.#current.animating) {\n            damp(this.#current.focus, this.#goal.focus, damping, delta);\n            damp(this.#current.camera, this.#goal.camera, damping, delta);\n            this.#current.zoom = THREE.MathUtils.damp(this.#current.zoom, this.#goal.zoom, damping, delta);\n            camera.position.copy(this.#current.camera);\n\n            if (is.orthographicCamera(camera)) {\n                camera.zoom = this.#current.zoom;\n                camera.updateProjectionMatrix();\n            }\n\n            if (!controls) {\n                camera.lookAt(this.#current.focus);\n            } else {\n                controls.target.copy(this.#current.focus);\n                controls.update();\n            }\n\n            invalidate();\n            if (is.orthographicCamera(camera) && !(Math.abs(this.#current.zoom - this.#goal.zoom) < eps)) return;\n            if (!is.orthographicCamera(camera) && !equals(this.#current.camera, this.#goal.camera, eps)) return;\n            if (controls && !equals(this.#current.focus, this.#goal.focus, eps)) return;\n            this.#current.animating = false;\n        }\n    }\n\n    #preventDragHijacking() {\n        effect((onCleanup) => {\n            const controls = this.#controls() as unknown as ControlsProto;\n            if (controls) {\n                const callback = () => (this.#current.animating = false);\n                controls.addEventListener('start', callback);\n                onCleanup(() => controls.removeEventListener('start', callback));\n            }\n        });\n    }\n}\n"]}