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

package/esm2022/cameras/cube-camera/cube-camera.mjs

@@ -0,0 +1,131 @@
+import { NgIf, NgTemplateOutlet } from '@angular/common';
+import { CUSTOM_ELEMENTS_SCHEMA, Component, ContentChild, ElementRef, Input, ViewChild, computed, inject, } from '@angular/core';
+import { NgtArgs, NgtSignalStore, NgtStore, extend, injectBeforeRender, injectNgtRef } from 'angular-three';
+import * as THREE from 'three';
+import { CubeCamera, Group } from 'three';
+import { NgtsCameraContent } from '../camera/camera-content';
+import * as i0 from "@angular/core";
+extend({ Group, CubeCamera });
+class NgtsCubeCamera extends NgtSignalStore {
+    /** Number of frames to render, Infinity */
+    set frames(frames) {
+        this.set({ frames });
+    }
+    /** Resolution of the FBO, 256 */
+    set resolution(resolution) {
+        this.set({ resolution });
+    }
+    /** Camera near, 0.1 */
+    set near(near) {
+        this.set({ near });
+    }
+    /** Camera far, 1000 */
+    set far(far) {
+        this.set({ far });
+    }
+    /** Custom environment map that is temporarily set as the scenes background */
+    set envMap(envMap) {
+        this.set({ envMap });
+    }
+    /** Custom fog that is temporarily set as the scenes fog */
+    set fog(fog) {
+        this.set({ fog });
+    }
+    #store;
+    #resolution;
+    #near;
+    #far;
+    constructor() {
+        super({ frames: Infinity, resolution: 256, near: 0.1, far: 1000 });
+        this.cameraRef = injectNgtRef();
+        this.#store = inject(NgtStore);
+        this.#resolution = this.select('resolution');
+        this.#near = this.select('near');
+        this.#far = this.select('far');
+        this.fbo = computed(() => {
+            const resolution = this.#resolution();
+            const fbo = new THREE.WebGLCubeRenderTarget(resolution);
+            fbo.texture.encoding = this.#store.get('gl').outputEncoding;
+            fbo.texture.type = THREE.HalfFloatType;
+            return fbo;
+        });
+        this.cameraArgs = computed(() => [this.#near(), this.#far(), this.fbo()]);
+        let count = 0;
+        let originalFog;
+        let originalBackground;
+        injectBeforeRender(({ scene, gl }) => {
+            const { frames, envMap, fog } = this.get();
+            if (envMap &&
+                this.cameraRef.nativeElement &&
+                this.groupRef.nativeElement &&
+                (frames === Infinity || count < frames)) {
+                this.groupRef.nativeElement.visible = false;
+                originalFog = scene.fog;
+                originalBackground = scene.background;
+                scene.background = envMap || originalBackground;
+                scene.fog = fog || originalFog;
+                this.cameraRef.nativeElement.update(gl, scene);
+                scene.fog = originalFog;
+                scene.background = originalBackground;
+                this.groupRef.nativeElement.visible = true;
+                count++;
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsCubeCamera, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: NgtsCubeCamera, isStandalone: true, selector: "ngts-cube-camera", inputs: { cameraRef: "cameraRef", frames: "frames", resolution: "resolution", near: "near", far: "far", envMap: "envMap", fog: "fog" }, queries: [{ propertyName: "cameraContent", first: true, predicate: NgtsCameraContent, descendants: true }], viewQueries: [{ propertyName: "groupRef", first: true, predicate: ["group"], descendants: true, static: true }], usesInheritance: true, ngImport: i0, template: `
+        <ngt-group ngtCompound>
+            <ngt-cube-camera [ref]="cameraRef" *args="cameraArgs()" />
+            <ngt-group #group>
+                <ng-container
+                    *ngIf="cameraContent && cameraContent.ngtsCameraContent && fbo()"
+                    [ngTemplateOutlet]="cameraContent.template"
+                    [ngTemplateOutletContext]="{ fbo: fbo(), group }"
+                />
+            </ngt-group>
+        </ngt-group>
+    `, isInline: true, dependencies: [{ kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: NgtArgs, selector: "[args]", inputs: ["args"] }] }); }
+}
+export { NgtsCubeCamera };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsCubeCamera, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-cube-camera',
+                    standalone: true,
+                    template: `
+        <ngt-group ngtCompound>
+            <ngt-cube-camera [ref]="cameraRef" *args="cameraArgs()" />
+            <ngt-group #group>
+                <ng-container
+                    *ngIf="cameraContent && cameraContent.ngtsCameraContent && fbo()"
+                    [ngTemplateOutlet]="cameraContent.template"
+                    [ngTemplateOutletContext]="{ fbo: fbo(), group }"
+                />
+            </ngt-group>
+        </ngt-group>
+    `,
+                    imports: [NgIf, NgTemplateOutlet, NgtArgs],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { groupRef: [{
+                type: ViewChild,
+                args: ['group', { static: true }]
+            }], cameraContent: [{
+                type: ContentChild,
+                args: [NgtsCameraContent]
+            }], cameraRef: [{
+                type: Input
+            }], frames: [{
+                type: Input
+            }], resolution: [{
+                type: Input
+            }], near: [{
+                type: Input
+            }], far: [{
+                type: Input
+            }], envMap: [{
+                type: Input
+            }], fog: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cube-camera.js","sourceRoot":"","sources":["../../../../../../libs/soba/cameras/src/cube-camera/cube-camera.ts"],"names":[],"mappings":"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","sourcesContent":["import { NgIf, NgTemplateOutlet } from '@angular/common';\nimport {\n    CUSTOM_ELEMENTS_SCHEMA,\n    Component,\n    ContentChild,\n    ElementRef,\n    Input,\n    ViewChild,\n    computed,\n    inject,\n} from '@angular/core';\nimport { NgtArgs, NgtSignalStore, NgtStore, extend, injectBeforeRender, injectNgtRef } from 'angular-three';\nimport * as THREE from 'three';\nimport { CubeCamera, Group } from 'three';\nimport { NgtsCameraContent } from '../camera/camera-content';\n\nextend({ Group, CubeCamera });\n\nexport interface NgtsCubeCameraState {\n    /** Number of frames to render, Infinity */\n    frames: number;\n    /** Resolution of the FBO, 256 */\n    resolution: number;\n    /** Camera near, 0.1 */\n    near: number;\n    /** Camera far, 1000 */\n    far: number;\n    /** Custom environment map that is temporarily set as the scenes background */\n    envMap: THREE.Texture;\n    /** Custom fog that is temporarily set as the scenes fog */\n    fog: THREE.Fog | THREE.FogExp2;\n}\n\n@Component({\n    selector: 'ngts-cube-camera',\n    standalone: true,\n    template: `\n        <ngt-group ngtCompound>\n            <ngt-cube-camera [ref]=\"cameraRef\" *args=\"cameraArgs()\" />\n            <ngt-group #group>\n                <ng-container\n                    *ngIf=\"cameraContent && cameraContent.ngtsCameraContent && fbo()\"\n                    [ngTemplateOutlet]=\"cameraContent.template\"\n                    [ngTemplateOutletContext]=\"{ fbo: fbo(), group }\"\n                />\n            </ngt-group>\n        </ngt-group>\n    `,\n    imports: [NgIf, NgTemplateOutlet, NgtArgs],\n    schemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsCubeCamera extends NgtSignalStore<NgtsCubeCameraState> {\n    @ViewChild('group', { static: true }) groupRef!: ElementRef<THREE.Group>;\n    @ContentChild(NgtsCameraContent) cameraContent?: NgtsCameraContent;\n\n    @Input() cameraRef = injectNgtRef<THREE.CubeCamera>();\n\n    /** Number of frames to render, Infinity */\n    @Input() set frames(frames: number) {\n        this.set({ frames });\n    }\n    /** Resolution of the FBO, 256 */\n    @Input() set resolution(resolution: number) {\n        this.set({ resolution });\n    }\n    /** Camera near, 0.1 */\n    @Input() set near(near: number) {\n        this.set({ near });\n    }\n    /** Camera far, 1000 */\n    @Input() set far(far: number) {\n        this.set({ far });\n    }\n    /** Custom environment map that is temporarily set as the scenes background */\n    @Input() set envMap(envMap: THREE.Texture) {\n        this.set({ envMap });\n    }\n    /** Custom fog that is temporarily set as the scenes fog */\n    @Input() set fog(fog: THREE.Fog | THREE.FogExp2) {\n        this.set({ fog });\n    }\n\n    readonly #store = inject(NgtStore);\n\n    readonly #resolution = this.select('resolution');\n    readonly #near = this.select('near');\n    readonly #far = this.select('far');\n\n    readonly fbo = computed(() => {\n        const resolution = this.#resolution();\n        const fbo = new THREE.WebGLCubeRenderTarget(resolution);\n        fbo.texture.encoding = this.#store.get('gl').outputEncoding;\n        fbo.texture.type = THREE.HalfFloatType;\n        return fbo;\n    });\n\n    readonly cameraArgs = computed(() => [this.#near(), this.#far(), this.fbo()]);\n\n    constructor() {\n        super({ frames: Infinity, resolution: 256, near: 0.1, far: 1000 });\n\n        let count = 0;\n        let originalFog: THREE.Scene['fog'];\n        let originalBackground: THREE.Scene['background'];\n        injectBeforeRender(({ scene, gl }) => {\n            const { frames, envMap, fog } = this.get();\n            if (\n                envMap &&\n                this.cameraRef.nativeElement &&\n                this.groupRef.nativeElement &&\n                (frames === Infinity || count < frames)\n            ) {\n                this.groupRef.nativeElement.visible = false;\n                originalFog = scene.fog;\n                originalBackground = scene.background;\n                scene.background = envMap || originalBackground;\n                scene.fog = fog || originalFog;\n                this.cameraRef.nativeElement.update(gl, scene);\n                scene.fog = originalFog;\n                scene.background = originalBackground;\n                this.groupRef.nativeElement.visible = true;\n                count++;\n            }\n        });\n    }\n}\n"]}

package/esm2022/cameras/index.mjs

@@ -0,0 +1,6 @@
+export * from './camera/camera';
+export * from './camera/camera-content';
+export * from './cube-camera/cube-camera';
+export * from './orthographic-camera/orthographic-camera';
+export * from './perspective-camera/perspective-camera';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL3NvYmEvY2FtZXJhcy9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYywyQ0FBMkMsQ0FBQztBQUMxRCxjQUFjLHlDQUF5QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9jYW1lcmEvY2FtZXJhJztcbmV4cG9ydCAqIGZyb20gJy4vY2FtZXJhL2NhbWVyYS1jb250ZW50JztcbmV4cG9ydCAqIGZyb20gJy4vY3ViZS1jYW1lcmEvY3ViZS1jYW1lcmEnO1xuZXhwb3J0ICogZnJvbSAnLi9vcnRob2dyYXBoaWMtY2FtZXJhL29ydGhvZ3JhcGhpYy1jYW1lcmEnO1xuZXhwb3J0ICogZnJvbSAnLi9wZXJzcGVjdGl2ZS1jYW1lcmEvcGVyc3BlY3RpdmUtY2FtZXJhJztcbiJdfQ==

package/esm2022/cameras/orthographic-camera/orthographic-camera.mjs

@@ -0,0 +1,99 @@
+import { NgIf, NgTemplateOutlet } from '@angular/common';
+import { CUSTOM_ELEMENTS_SCHEMA, Component, ContentChild, Input, computed } from '@angular/core';
+import { extend } from 'angular-three';
+import { Group, OrthographicCamera } from 'three';
+import { NgtsCamera } from '../camera/camera';
+import { NgtsCameraContent } from '../camera/camera-content';
+import * as i0 from "@angular/core";
+extend({ OrthographicCamera, Group });
+class NgtsOrthographicCamera extends NgtsCamera {
+    set left(left) {
+        this.set({ left });
+    }
+    set right(right) {
+        this.set({ right });
+    }
+    set top(top) {
+        this.set({ top });
+    }
+    set bottom(bottom) {
+        this.set({ bottom });
+    }
+    #left;
+    #right;
+    #top;
+    #bottom;
+    #size;
+    constructor() {
+        super();
+        this.#left = this.select('left');
+        this.#right = this.select('right');
+        this.#top = this.select('top');
+        this.#bottom = this.select('bottom');
+        this.#size = this.store.select('size');
+        this.cameraLeft = computed(() => this.#left() || this.#size().width / -2);
+        this.cameraRight = computed(() => this.#right() || this.#size().width / 2);
+        this.cameraTop = computed(() => this.#top() || this.#size().height / 2);
+        this.cameraBottom = computed(() => this.#bottom() || this.#size().height / -2);
+        this.set({ left: 0, right: 0, top: 0, bottom: 0 });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsOrthographicCamera, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: NgtsOrthographicCamera, isStandalone: true, selector: "ngts-orthographic-camera", inputs: { left: "left", right: "right", top: "top", bottom: "bottom" }, queries: [{ propertyName: "cameraContent", first: true, predicate: NgtsCameraContent, descendants: true }], usesInheritance: true, ngImport: i0, template: `
+        <ngt-orthographic-camera
+            ngtCompound
+            [ref]="cameraRef"
+            [left]="cameraLeft()"
+            [right]="cameraRight()"
+            [top]="cameraTop()"
+            [bottom]="cameraBottom()"
+        >
+            <ng-container
+                *ngIf="cameraContent && !cameraContent.ngtsCameraContent"
+                [ngTemplateOutlet]="cameraContent.template"
+            />
+        </ngt-orthographic-camera>
+        <ngt-group #group *ngIf="cameraContent && cameraContent.ngtsCameraContent">
+            <ng-container *ngTemplateOutlet="cameraContent.template; context: { fbo: fboRef(), group }" />
+        </ngt-group>
+    `, isInline: true, dependencies: [{ kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }] }); }
+}
+export { NgtsOrthographicCamera };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsOrthographicCamera, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-orthographic-camera',
+                    standalone: true,
+                    template: `
+        <ngt-orthographic-camera
+            ngtCompound
+            [ref]="cameraRef"
+            [left]="cameraLeft()"
+            [right]="cameraRight()"
+            [top]="cameraTop()"
+            [bottom]="cameraBottom()"
+        >
+            <ng-container
+                *ngIf="cameraContent && !cameraContent.ngtsCameraContent"
+                [ngTemplateOutlet]="cameraContent.template"
+            />
+        </ngt-orthographic-camera>
+        <ngt-group #group *ngIf="cameraContent && cameraContent.ngtsCameraContent">
+            <ng-container *ngTemplateOutlet="cameraContent.template; context: { fbo: fboRef(), group }" />
+        </ngt-group>
+    `,
+                    imports: [NgIf, NgTemplateOutlet],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { cameraContent: [{
+                type: ContentChild,
+                args: [NgtsCameraContent]
+            }], left: [{
+                type: Input
+            }], right: [{
+                type: Input
+            }], top: [{
+                type: Input
+            }], bottom: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/cameras/perspective-camera/perspective-camera.mjs

@@ -0,0 +1,47 @@
+import { NgIf, NgTemplateOutlet } from '@angular/common';
+import { CUSTOM_ELEMENTS_SCHEMA, Component, ContentChild } from '@angular/core';
+import { extend } from 'angular-three';
+import { Group, PerspectiveCamera } from 'three';
+import { NgtsCamera } from '../camera/camera';
+import { NgtsCameraContent } from '../camera/camera-content';
+import * as i0 from "@angular/core";
+extend({ PerspectiveCamera, Group });
+class NgtsPerspectiveCamera extends NgtsCamera {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsPerspectiveCamera, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: NgtsPerspectiveCamera, isStandalone: true, selector: "ngts-perspective-camera", queries: [{ propertyName: "cameraContent", first: true, predicate: NgtsCameraContent, descendants: true }], usesInheritance: true, ngImport: i0, template: `
+        <ngt-perspective-camera [ref]="cameraRef" ngtCompound>
+            <ng-container
+                *ngIf="cameraContent && !cameraContent.ngtsCameraContent"
+                [ngTemplateOutlet]="cameraContent.template"
+            />
+        </ngt-perspective-camera>
+        <ngt-group #group *ngIf="cameraContent && cameraContent.ngtsCameraContent">
+            <ng-container *ngTemplateOutlet="cameraContent.template; context: { fbo: fboRef(), group }" />
+        </ngt-group>
+    `, isInline: true, dependencies: [{ kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }] }); }
+}
+export { NgtsPerspectiveCamera };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsPerspectiveCamera, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-perspective-camera',
+                    standalone: true,
+                    template: `
+        <ngt-perspective-camera [ref]="cameraRef" ngtCompound>
+            <ng-container
+                *ngIf="cameraContent && !cameraContent.ngtsCameraContent"
+                [ngTemplateOutlet]="cameraContent.template"
+            />
+        </ngt-perspective-camera>
+        <ngt-group #group *ngIf="cameraContent && cameraContent.ngtsCameraContent">
+            <ng-container *ngTemplateOutlet="cameraContent.template; context: { fbo: fboRef(), group }" />
+        </ngt-group>
+    `,
+                    imports: [NgIf, NgTemplateOutlet],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], propDecorators: { cameraContent: [{
+                type: ContentChild,
+                args: [NgtsCameraContent]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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

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

package/esm2022/controls/index.mjs

@@ -0,0 +1,2 @@
+export * from './orbit-controls/orbit-controls';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL3NvYmEvY29udHJvbHMvc3JjL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsaUNBQWlDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL29yYml0LWNvbnRyb2xzL29yYml0LWNvbnRyb2xzJztcbiJdfQ==

package/esm2022/controls/orbit-controls/orbit-controls.mjs

@@ -0,0 +1,165 @@
+import { Component, computed, CUSTOM_ELEMENTS_SCHEMA, effect, EventEmitter, inject, Input, Output, } from '@angular/core';
+import { injectBeforeRender, injectNgtRef, NgtArgs, NgtSignalStore, NgtStore } from 'angular-three';
+import { OrbitControls } from 'three-stdlib';
+import * as i0 from "@angular/core";
+class NgtsOrbitControls extends NgtSignalStore {
+    set camera(camera) {
+        this.set({ camera });
+    }
+    set domElement(domElement) {
+        this.set({ domElement });
+    }
+    set makeDefault(makeDefault) {
+        this.set({ makeDefault });
+    }
+    set regress(regress) {
+        this.set({ regress });
+    }
+    set target(target) {
+        this.set({ target });
+    }
+    set enableDamping(enableDamping) {
+        this.set({ enableDamping });
+    }
+    #store;
+    constructor() {
+        super({ enableDamping: true, regress: false, makeDefault: false });
+        this.controlsRef = injectNgtRef();
+        this.change = new EventEmitter();
+        this.start = new EventEmitter();
+        this.end = new EventEmitter();
+        this.#store = inject(NgtStore);
+        this.args = computed(() => [this.controlsRef.nativeElement]);
+        this.damping = this.select('enableDamping');
+        injectBeforeRender(() => {
+            const controls = this.controlsRef.untracked;
+            if (controls && controls.enabled) {
+                controls.update();
+            }
+        }, { priority: -1 });
+        this.#setControls();
+        this.#connectElement();
+        this.#makeControlsDefault();
+        this.#setEvents();
+    }
+    #setControls() {
+        const camera = this.select('camera');
+        const defaultCamera = this.#store.select('camera');
+        const trigger = computed(() => ({ camera: camera(), defaultCamera: defaultCamera() }));
+        effect(() => {
+            const { camera, defaultCamera } = trigger();
+            const controlsCamera = camera || defaultCamera;
+            const controls = this.controlsRef.nativeElement;
+            if (!controls || controls.object !== controlsCamera) {
+                this.controlsRef.nativeElement = new OrbitControls(controlsCamera);
+            }
+        }, { allowSignalWrites: true });
+    }
+    #connectElement() {
+        const glDomElement = this.#store.select('gl', 'domElement');
+        const domElement = this.select('domElement');
+        const regress = this.select('regress');
+        const invalidate = this.#store.select('invalidate');
+        const trigger = computed(() => {
+            const eventsSource = this.#store.get('events', 'connected');
+            return {
+                controls: this.controlsRef.nativeElement,
+                domElement: domElement() || eventsSource || glDomElement(),
+                regress: regress(),
+                invalidate: invalidate(),
+            };
+        });
+        effect((onCleanup) => {
+            const { domElement, controls } = trigger();
+            if (!controls)
+                return;
+            controls.connect(domElement);
+            onCleanup(() => void controls.dispose());
+        });
+    }
+    #makeControlsDefault() {
+        const makeDefault = this.select('makeDefault');
+        const trigger = computed(() => ({ controls: this.controlsRef.nativeElement, makeDefault: makeDefault() }));
+        effect((onCleanup) => {
+            const { controls, makeDefault } = trigger();
+            if (!controls)
+                return;
+            if (makeDefault) {
+                const oldControls = this.#store.get('controls');
+                this.#store.set({ controls });
+                onCleanup(() => void this.#store.set({ controls: oldControls }));
+            }
+        }, { allowSignalWrites: true });
+    }
+    #setEvents() {
+        const invalidate = this.#store.select('invalidate');
+        const performance = this.#store.select('performance');
+        const regress = this.select('regress');
+        const trigger = computed(() => ({
+            invalidate: invalidate(),
+            performance: performance(),
+            regress: regress(),
+            controls: this.controlsRef.nativeElement,
+        }));
+        effect((onCleanup) => {
+            const { controls, invalidate, performance, regress } = trigger();
+            if (!controls)
+                return;
+            const changeCallback = (e) => {
+                invalidate();
+                if (regress)
+                    performance.regress();
+                if (this.change.observed)
+                    this.change.emit(e);
+            };
+            const startCallback = this.start.observed ? this.start.emit.bind(this.start) : null;
+            const endCallback = this.end.observed ? this.end.emit.bind(this.end) : null;
+            controls.addEventListener('change', changeCallback);
+            if (startCallback)
+                controls.addEventListener('start', startCallback);
+            if (endCallback)
+                controls.addEventListener('end', endCallback);
+            onCleanup(() => {
+                controls.removeEventListener('change', changeCallback);
+                if (startCallback)
+                    controls.removeEventListener('start', startCallback);
+                if (endCallback)
+                    controls.removeEventListener('end', endCallback);
+            });
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsOrbitControls, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: NgtsOrbitControls, isStandalone: true, selector: "ngts-orbit-controls", inputs: { controlsRef: "controlsRef", camera: "camera", domElement: "domElement", makeDefault: "makeDefault", regress: "regress", target: "target", enableDamping: "enableDamping" }, outputs: { change: "change", start: "start", end: "end" }, usesInheritance: true, ngImport: i0, template: ` <ngt-primitive *args="args()" ngtCompound [enableDamping]="damping()" /> `, isInline: true, dependencies: [{ kind: "directive", type: NgtArgs, selector: "[args]", inputs: ["args"] }] }); }
+}
+export { NgtsOrbitControls };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsOrbitControls, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-orbit-controls',
+                    standalone: true,
+                    template: ` <ngt-primitive *args="args()" ngtCompound [enableDamping]="damping()" /> `,
+                    imports: [NgtArgs],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { controlsRef: [{
+                type: Input
+            }], camera: [{
+                type: Input
+            }], domElement: [{
+                type: Input
+            }], makeDefault: [{
+                type: Input
+            }], regress: [{
+                type: Input
+            }], target: [{
+                type: Input
+            }], enableDamping: [{
+                type: Input
+            }], change: [{
+                type: Output
+            }], start: [{
+                type: Output
+            }], end: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"orbit-controls.js","sourceRoot":"","sources":["../../../../../../libs/soba/controls/src/orbit-controls/orbit-controls.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    Component,\n    computed,\n    CUSTOM_ELEMENTS_SCHEMA,\n    effect,\n    EventEmitter,\n    inject,\n    Input,\n    Output,\n} from '@angular/core';\nimport { injectBeforeRender, injectNgtRef, NgtArgs, NgtSignalStore, NgtStore, NgtVector3 } from 'angular-three';\nimport { OrbitControls } from 'three-stdlib';\n\nexport type NgtsOrbitControlsState = {\n    camera?: THREE.Camera;\n    domElement?: HTMLElement;\n    target?: NgtVector3;\n    makeDefault: boolean;\n    regress: boolean;\n    enableDamping: boolean;\n};\n\ndeclare global {\n    interface HTMLElementTagNameMap {\n        'ngts-orbit-controls': OrbitControls & NgtsOrbitControlsState;\n    }\n}\n\n@Component({\n    selector: 'ngts-orbit-controls',\n    standalone: true,\n    template: ` <ngt-primitive *args=\"args()\" ngtCompound [enableDamping]=\"damping()\" /> `,\n    imports: [NgtArgs],\n    schemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsOrbitControls extends NgtSignalStore<NgtsOrbitControlsState> {\n    @Input() controlsRef = injectNgtRef<OrbitControls>();\n\n    @Input() set camera(camera: THREE.Camera) {\n        this.set({ camera });\n    }\n\n    @Input() set domElement(domElement: HTMLElement) {\n        this.set({ domElement });\n    }\n\n    @Input() set makeDefault(makeDefault: boolean) {\n        this.set({ makeDefault });\n    }\n\n    @Input() set regress(regress: boolean) {\n        this.set({ regress });\n    }\n\n    @Input() set target(target: THREE.Vector3 | Parameters<THREE.Vector3['set']>) {\n        this.set({ target });\n    }\n\n    @Input() set enableDamping(enableDamping: boolean) {\n        this.set({ enableDamping });\n    }\n\n    @Output() change = new EventEmitter<THREE.Event>();\n    @Output() start = new EventEmitter<THREE.Event>();\n    @Output() end = new EventEmitter<THREE.Event>();\n\n    readonly #store = inject(NgtStore);\n\n    readonly args = computed(() => [this.controlsRef.nativeElement]);\n    readonly damping = this.select('enableDamping');\n\n    constructor() {\n        super({ enableDamping: true, regress: false, makeDefault: false });\n        injectBeforeRender(\n            () => {\n                const controls = this.controlsRef.untracked;\n                if (controls && controls.enabled) {\n                    controls.update();\n                }\n            },\n            { priority: -1 }\n        );\n\n        this.#setControls();\n        this.#connectElement();\n        this.#makeControlsDefault();\n        this.#setEvents();\n    }\n\n    #setControls() {\n        const camera = this.select('camera');\n        const defaultCamera = this.#store.select('camera');\n        const trigger = computed(() => ({ camera: camera(), defaultCamera: defaultCamera() }));\n\n        effect(\n            () => {\n                const { camera, defaultCamera } = trigger();\n                const controlsCamera = camera || defaultCamera;\n                const controls = this.controlsRef.nativeElement;\n                if (!controls || controls.object !== controlsCamera) {\n                    this.controlsRef.nativeElement = new OrbitControls(controlsCamera);\n                }\n            },\n            { allowSignalWrites: true }\n        );\n    }\n\n    #connectElement() {\n        const glDomElement = this.#store.select('gl', 'domElement');\n        const domElement = this.select('domElement');\n        const regress = this.select('regress');\n        const invalidate = this.#store.select('invalidate');\n\n        const trigger = computed(() => {\n            const eventsSource = this.#store.get('events', 'connected');\n            return {\n                controls: this.controlsRef.nativeElement,\n                domElement: domElement() || eventsSource || glDomElement(),\n                regress: regress(),\n                invalidate: invalidate(),\n            };\n        });\n\n        effect((onCleanup) => {\n            const { domElement, controls } = trigger();\n            if (!controls) return;\n            controls.connect(domElement);\n            onCleanup(() => void controls.dispose());\n        });\n    }\n\n    #makeControlsDefault() {\n        const makeDefault = this.select('makeDefault');\n        const trigger = computed(() => ({ controls: this.controlsRef.nativeElement, makeDefault: makeDefault() }));\n\n        effect(\n            (onCleanup) => {\n                const { controls, makeDefault } = trigger();\n                if (!controls) return;\n                if (makeDefault) {\n                    const oldControls = this.#store.get('controls');\n                    this.#store.set({ controls });\n                    onCleanup(() => void this.#store.set({ controls: oldControls }));\n                }\n            },\n            { allowSignalWrites: true }\n        );\n    }\n\n    #setEvents() {\n        const invalidate = this.#store.select('invalidate');\n        const performance = this.#store.select('performance');\n        const regress = this.select('regress');\n\n        const trigger = computed(() => ({\n            invalidate: invalidate(),\n            performance: performance(),\n            regress: regress(),\n            controls: this.controlsRef.nativeElement,\n        }));\n        effect((onCleanup) => {\n            const { controls, invalidate, performance, regress } = trigger();\n            if (!controls) return;\n            const changeCallback: (e: THREE.Event) => void = (e) => {\n                invalidate();\n                if (regress) performance.regress();\n                if (this.change.observed) this.change.emit(e);\n            };\n\n            const startCallback = this.start.observed ? this.start.emit.bind(this.start) : null;\n            const endCallback = this.end.observed ? this.end.emit.bind(this.end) : null;\n\n            controls.addEventListener('change', changeCallback);\n            if (startCallback) controls.addEventListener('start', startCallback);\n            if (endCallback) controls.addEventListener('end', endCallback);\n\n            onCleanup(() => {\n                controls.removeEventListener('change', changeCallback);\n                if (startCallback) controls.removeEventListener('start', startCallback);\n                if (endCallback) controls.removeEventListener('end', endCallback);\n            });\n        });\n    }\n}\n"]}

package/esm2022/index.mjs

@@ -0,0 +1,2 @@
+export default void 0;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9saWJzL3NvYmEvc3JjL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGVBQWUsS0FBSyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZGVmYXVsdCB2b2lkIDA7XG4iXX0=

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

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

package/esm2022/loaders/gltf-loader/gltf-loader.mjs

@@ -0,0 +1,33 @@
+import { injectNgtLoader } from 'angular-three';
+// @ts-ignore
+import { MeshoptDecoder } from 'three-stdlib';
+import { DRACOLoader } from 'three-stdlib/loaders/DRACOLoader';
+import { GLTFLoader } from 'three-stdlib/loaders/GLTFLoader';
+let dracoLoader = null;
+function _extensions(useDraco, useMeshOpt, extensions) {
+    return (loader) => {
+        if (extensions) {
+            extensions(loader);
+        }
+        if (useDraco) {
+            if (!dracoLoader) {
+                dracoLoader = new DRACOLoader();
+            }
+            dracoLoader.setDecoderPath(typeof useDraco === 'string' ? useDraco : 'https://www.gstatic.com/draco/versioned/decoders/1.4.3/');
+            loader.setDRACOLoader(dracoLoader);
+        }
+        if (useMeshOpt) {
+            loader.setMeshoptDecoder(typeof MeshoptDecoder === 'function' ? MeshoptDecoder() : MeshoptDecoder);
+        }
+    };
+}
+export function injectNgtsGLTFLoader(path, { useDraco = true, useMeshOpt = true, injector, extensions, } = {}) {
+    return injectNgtLoader(() => GLTFLoader, path, {
+        extensions: _extensions(useDraco, useMeshOpt, extensions),
+        injector,
+    });
+}
+injectNgtsGLTFLoader['preload'] = (path, { useDraco = true, useMeshOpt = true, extensions, } = {}) => {
+    injectNgtLoader['preload'](() => GLTFLoader, path, _extensions(useDraco, useMeshOpt, extensions));
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/loaders/index.mjs

@@ -0,0 +1,5 @@
+export * from './gltf-loader/gltf-loader';
+export * from './loader/loader';
+export * from './progress/progress';
+export * from './texture-loader/texture-loader';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL3NvYmEvbG9hZGVycy9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxpQ0FBaUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZ2x0Zi1sb2FkZXIvZ2x0Zi1sb2FkZXInO1xuZXhwb3J0ICogZnJvbSAnLi9sb2FkZXIvbG9hZGVyJztcbmV4cG9ydCAqIGZyb20gJy4vcHJvZ3Jlc3MvcHJvZ3Jlc3MnO1xuZXhwb3J0ICogZnJvbSAnLi90ZXh0dXJlLWxvYWRlci90ZXh0dXJlLWxvYWRlcic7XG4iXX0=