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

package/esm2022/abstractions/text-3d/text-3d.mjs

@@ -0,0 +1,167 @@
+import { Component, computed, CUSTOM_ELEMENTS_SCHEMA, Input } from '@angular/core';
+import { toObservable, toSignal } from '@angular/core/rxjs-interop';
+import { extend, injectNgtRef, NgtArgs, NgtSignalStore } from 'angular-three';
+import { map, of, switchMap } from 'rxjs';
+import { Mesh } from 'three';
+import { FontLoader, TextGeometry } from 'three-stdlib';
+import * as i0 from "@angular/core";
+extend({ Mesh, TextGeometry });
+class NgtsText3D extends NgtSignalStore {
+    set font(font) {
+        this.set({ font });
+    }
+    set text(text) {
+        this.set({ text });
+    }
+    set bevelEnabled(bevelEnabled) {
+        this.set({ bevelEnabled });
+    }
+    set bevelOffset(bevelOffset) {
+        this.set({ bevelOffset });
+    }
+    set bevelSize(bevelSize) {
+        this.set({ bevelSize });
+    }
+    set bevelThickness(bevelThickness) {
+        this.set({ bevelThickness });
+    }
+    set curveSegments(curveSegments) {
+        this.set({ curveSegments });
+    }
+    set bevelSegments(bevelSegments) {
+        this.set({ bevelSegments });
+    }
+    set height(height) {
+        this.set({ height });
+    }
+    set size(size) {
+        this.set({ size });
+    }
+    set lineHeight(lineHeight) {
+        this.set({ lineHeight });
+    }
+    set letterSpacing(letterSpacing) {
+        this.set({ letterSpacing });
+    }
+    set smooth(smooth) {
+        this.set({ smooth });
+    }
+    constructor() {
+        super({
+            lineHeight: 1,
+            letterSpacing: 0,
+            size: 1,
+            height: 0.2,
+            bevelThickness: 0.1,
+            bevelSize: 0.01,
+            bevelEnabled: false,
+            bevelOffset: 0,
+            bevelSegments: 4,
+            curveSegments: 8,
+        });
+        this.textRef = injectNgtRef();
+        this.#fontData = toSignal(toObservable(this.select('font')).pipe(switchMap((font) => {
+            if (typeof font === 'string')
+                return fetch(font).then((res) => res.json());
+            return of(font);
+        }), map((fontData) => new FontLoader().parse(fontData))));
+        this.#text = this.select('text');
+        this.#size = this.select('size');
+        this.#height = this.select('height');
+        this.#bevelThickness = this.select('bevelThickness');
+        this.#bevelSize = this.select('bevelSize');
+        this.#bevelEnabled = this.select('bevelEnabled');
+        this.#bevelSegments = this.select('bevelSegments');
+        this.#bevelOffset = this.select('bevelOffset');
+        this.#curveSegments = this.select('curveSegments');
+        this.#letterSpacing = this.select('letterSpacing');
+        this.#lineHeight = this.select('lineHeight');
+        this.geometryArgs = computed(() => {
+            const fontData = this.#fontData();
+            if (!fontData)
+                return null;
+            return [
+                this.#text(),
+                {
+                    font: fontData,
+                    size: this.#size(),
+                    height: this.#height(),
+                    bevelThickness: this.#bevelThickness(),
+                    bevelSize: this.#bevelSize(),
+                    bevelSegments: this.#bevelSegments(),
+                    bevelEnabled: this.#bevelEnabled(),
+                    bevelOffset: this.#bevelOffset(),
+                    curveSegments: this.#curveSegments(),
+                    letterSpacing: this.#letterSpacing(),
+                    lineHeight: this.#lineHeight(),
+                },
+            ];
+        });
+    }
+    #fontData;
+    #text;
+    #size;
+    #height;
+    #bevelThickness;
+    #bevelSize;
+    #bevelEnabled;
+    #bevelSegments;
+    #bevelOffset;
+    #curveSegments;
+    #letterSpacing;
+    #lineHeight;
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsText3D, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: NgtsText3D, isStandalone: true, selector: "ngts-text-3d", inputs: { textRef: "textRef", font: "font", text: "text", bevelEnabled: "bevelEnabled", bevelOffset: "bevelOffset", bevelSize: "bevelSize", bevelThickness: "bevelThickness", curveSegments: "curveSegments", bevelSegments: "bevelSegments", height: "height", size: "size", lineHeight: "lineHeight", letterSpacing: "letterSpacing", smooth: "smooth" }, usesInheritance: true, ngImport: i0, template: `
+        <ngt-mesh ngtCompound [ref]="textRef">
+            <ngt-text-geometry *args="geometryArgs()" />
+            <ng-content />
+        </ngt-mesh>
+    `, isInline: true, dependencies: [{ kind: "directive", type: NgtArgs, selector: "[args]", inputs: ["args"] }] }); }
+}
+export { NgtsText3D };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsText3D, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-text-3d',
+                    standalone: true,
+                    template: `
+        <ngt-mesh ngtCompound [ref]="textRef">
+            <ngt-text-geometry *args="geometryArgs()" />
+            <ng-content />
+        </ngt-mesh>
+    `,
+                    imports: [NgtArgs],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { textRef: [{
+                type: Input
+            }], font: [{
+                type: Input,
+                args: [{ required: true }]
+            }], text: [{
+                type: Input,
+                args: [{ required: true }]
+            }], bevelEnabled: [{
+                type: Input
+            }], bevelOffset: [{
+                type: Input
+            }], bevelSize: [{
+                type: Input
+            }], bevelThickness: [{
+                type: Input
+            }], curveSegments: [{
+                type: Input
+            }], bevelSegments: [{
+                type: Input
+            }], height: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], lineHeight: [{
+                type: Input
+            }], letterSpacing: [{
+                type: Input
+            }], smooth: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"text-3d.js","sourceRoot":"","sources":["../../../../../../libs/soba/abstractions/src/text-3d/text-3d.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, computed, CUSTOM_ELEMENTS_SCHEMA, Input } from '@angular/core';\nimport { toObservable, toSignal } from '@angular/core/rxjs-interop';\nimport { extend, injectNgtRef, NgtArgs, NgtSignalStore, type NgtMesh } from 'angular-three';\nimport { map, of, switchMap } from 'rxjs';\nimport { Mesh } from 'three';\nimport { FontLoader, TextGeometry } from 'three-stdlib';\n\ndeclare type Glyph = { _cachedOutline: string[]; ha: number; o: string };\n\ndeclare type FontData = {\n    boundingBox: { yMax: number; yMin: number };\n    familyName: string;\n    glyphs: { [k: string]: Glyph };\n    resolution: number;\n    underlineThickness: number;\n};\n\nextend({ Mesh, TextGeometry });\n\nexport type NgtsText3DState = {\n    font: FontData | string;\n    text: string;\n    letterSpacing: number;\n    lineHeight: number;\n    size: number;\n    height: number;\n    bevelThickness: number;\n    bevelSize: number;\n    bevelEnabled: boolean;\n    bevelOffset: number;\n    bevelSegments: number;\n    curveSegments: number;\n    smooth?: number;\n};\n\ndeclare global {\n    interface HTMLElementTagNameMap {\n        'ngts-text-3d': NgtsText3DState & NgtMesh;\n    }\n}\n\n@Component({\n    selector: 'ngts-text-3d',\n    standalone: true,\n    template: `\n        <ngt-mesh ngtCompound [ref]=\"textRef\">\n            <ngt-text-geometry *args=\"geometryArgs()\" />\n            <ng-content />\n        </ngt-mesh>\n    `,\n    imports: [NgtArgs],\n    schemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsText3D extends NgtSignalStore<NgtsText3DState> {\n    @Input() textRef = injectNgtRef<Mesh>();\n\n    @Input({ required: true }) set font(font: FontData | string) {\n        this.set({ font });\n    }\n\n    @Input({ required: true }) set text(text: string) {\n        this.set({ text });\n    }\n\n    @Input() set bevelEnabled(bevelEnabled: boolean) {\n        this.set({ bevelEnabled });\n    }\n\n    @Input() set bevelOffset(bevelOffset: number) {\n        this.set({ bevelOffset });\n    }\n\n    @Input() set bevelSize(bevelSize: number) {\n        this.set({ bevelSize });\n    }\n\n    @Input() set bevelThickness(bevelThickness: number) {\n        this.set({ bevelThickness });\n    }\n\n    @Input() set curveSegments(curveSegments: number) {\n        this.set({ curveSegments });\n    }\n\n    @Input() set bevelSegments(bevelSegments: number) {\n        this.set({ bevelSegments });\n    }\n\n    @Input() set height(height: number) {\n        this.set({ height });\n    }\n\n    @Input() set size(size: number) {\n        this.set({ size });\n    }\n\n    @Input() set lineHeight(lineHeight: number) {\n        this.set({ lineHeight });\n    }\n\n    @Input() set letterSpacing(letterSpacing: number) {\n        this.set({ letterSpacing });\n    }\n\n    @Input() set smooth(smooth: number) {\n        this.set({ smooth });\n    }\n\n    constructor() {\n        super({\n            lineHeight: 1,\n            letterSpacing: 0,\n            size: 1,\n            height: 0.2,\n            bevelThickness: 0.1,\n            bevelSize: 0.01,\n            bevelEnabled: false,\n            bevelOffset: 0,\n            bevelSegments: 4,\n            curveSegments: 8,\n        });\n    }\n\n    readonly #fontData = toSignal(\n        toObservable(this.select('font')).pipe(\n            switchMap((font) => {\n                if (typeof font === 'string') return fetch(font).then((res) => res.json()) as Promise<FontData>;\n                return of(font as FontData);\n            }),\n            map((fontData) => new FontLoader().parse(fontData))\n        )\n    );\n\n    readonly #text = this.select('text');\n    readonly #size = this.select('size');\n    readonly #height = this.select('height');\n    readonly #bevelThickness = this.select('bevelThickness');\n    readonly #bevelSize = this.select('bevelSize');\n    readonly #bevelEnabled = this.select('bevelEnabled');\n    readonly #bevelSegments = this.select('bevelSegments');\n    readonly #bevelOffset = this.select('bevelOffset');\n    readonly #curveSegments = this.select('curveSegments');\n    readonly #letterSpacing = this.select('letterSpacing');\n    readonly #lineHeight = this.select('lineHeight');\n    readonly geometryArgs = computed(() => {\n        const fontData = this.#fontData();\n        if (!fontData) return null;\n\n        return [\n            this.#text(),\n            {\n                font: fontData,\n                size: this.#size(),\n                height: this.#height(),\n                bevelThickness: this.#bevelThickness(),\n                bevelSize: this.#bevelSize(),\n                bevelSegments: this.#bevelSegments(),\n                bevelEnabled: this.#bevelEnabled(),\n                bevelOffset: this.#bevelOffset(),\n                curveSegments: this.#curveSegments(),\n                letterSpacing: this.#letterSpacing(),\n                lineHeight: this.#lineHeight(),\n            },\n        ];\n    });\n}\n"]}

package/esm2022/angular-three-soba.mjs

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

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

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

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

@@ -0,0 +1,21 @@
+import { Directive, inject, Input, TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+class NgtsCameraContent {
+    constructor() {
+        this.template = inject(TemplateRef);
+        this.ngtsCameraContent = '';
+    }
+    static ngTemplateContextGuard(_, ctx) {
+        return true;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsCameraContent, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: NgtsCameraContent, isStandalone: true, selector: "ng-template[ngtsCameraContent]", inputs: { ngtsCameraContent: "ngtsCameraContent" }, ngImport: i0 }); }
+}
+export { NgtsCameraContent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsCameraContent, decorators: [{
+            type: Directive,
+            args: [{ selector: 'ng-template[ngtsCameraContent]', standalone: true }]
+        }], propDecorators: { ngtsCameraContent: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FtZXJhLWNvbnRlbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL3NvYmEvY2FtZXJhcy9zcmMvY2FtZXJhL2NhbWVyYS1jb250ZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxFQUFFLEtBQUssRUFBRSxXQUFXLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBR3RFLE1BQ2EsaUJBQWlCO0lBRDlCO1FBRWEsYUFBUSxHQUFHLE1BQU0sQ0FBQyxXQUFXLENBQUMsQ0FBQztRQUMvQixzQkFBaUIsR0FBYyxFQUFFLENBQUM7S0FROUM7SUFORyxNQUFNLENBQUMsc0JBQXNCLENBQ3pCLENBQW9CLEVBQ3BCLEdBQVk7UUFFWixPQUFPLElBQUksQ0FBQztJQUNoQixDQUFDOzhHQVRRLGlCQUFpQjtrR0FBakIsaUJBQWlCOztTQUFqQixpQkFBaUI7MkZBQWpCLGlCQUFpQjtrQkFEN0IsU0FBUzttQkFBQyxFQUFFLFFBQVEsRUFBRSxnQ0FBZ0MsRUFBRSxVQUFVLEVBQUUsSUFBSSxFQUFFOzhCQUc5RCxpQkFBaUI7c0JBQXpCLEtBQUsiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIGluamVjdCwgSW5wdXQsIFRlbXBsYXRlUmVmIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgKiBhcyBUSFJFRSBmcm9tICd0aHJlZSc7XG5cbkBEaXJlY3RpdmUoeyBzZWxlY3RvcjogJ25nLXRlbXBsYXRlW25ndHNDYW1lcmFDb250ZW50XScsIHN0YW5kYWxvbmU6IHRydWUgfSlcbmV4cG9ydCBjbGFzcyBOZ3RzQ2FtZXJhQ29udGVudCB7XG4gICAgcmVhZG9ubHkgdGVtcGxhdGUgPSBpbmplY3QoVGVtcGxhdGVSZWYpO1xuICAgIEBJbnB1dCgpIG5ndHNDYW1lcmFDb250ZW50OiB0cnVlIHwgJycgPSAnJztcblxuICAgIHN0YXRpYyBuZ1RlbXBsYXRlQ29udGV4dEd1YXJkKFxuICAgICAgICBfOiBOZ3RzQ2FtZXJhQ29udGVudCxcbiAgICAgICAgY3R4OiB1bmtub3duXG4gICAgKTogY3R4IGlzIHsgZmJvOiBUSFJFRS5XZWJHTFJlbmRlclRhcmdldDsgZ3JvdXA/OiBUSFJFRS5Hcm91cCB9IHtcbiAgICAgICAgcmV0dXJuIHRydWU7XG4gICAgfVxufVxuIl19

package/esm2022/cameras/camera/camera.mjs

@@ -0,0 +1,71 @@
+import { Directive, effect, inject, Input } from '@angular/core';
+import { injectNgtRef, NgtSignalStore, NgtStore, requestAnimationInInjectionContext, } from 'angular-three';
+import { injectNgtsFBO } from 'angular-three-soba/misc';
+import * as i0 from "@angular/core";
+class NgtsCamera extends NgtSignalStore {
+    set makeDefault(makeDefault) {
+        this.set({ makeDefault });
+    }
+    set manual(manual) {
+        this.set({ manual });
+    }
+    set frames(frames) {
+        this.set({ frames });
+    }
+    set resolution(resolution) {
+        this.set({ resolution });
+    }
+    set envMap(envMap) {
+        this.set({ envMap });
+    }
+    #resolution;
+    constructor() {
+        super({ resolution: 256, frames: Infinity, makeDefault: false, manual: false });
+        this.cameraRef = injectNgtRef();
+        this.store = inject(NgtStore);
+        this.#resolution = this.select('resolution');
+        this.fboRef = injectNgtsFBO(() => ({ width: this.#resolution() }));
+        requestAnimationInInjectionContext(() => {
+            this.#setDefaultCamera();
+            this.#updateProjectionMatrix();
+        });
+    }
+    #setDefaultCamera() {
+        const makeDefault = this.select('makeDefault');
+        effect((onCleanup) => {
+            const camera = this.cameraRef.nativeElement;
+            if (camera && makeDefault()) {
+                const { camera: oldCamera } = this.store.get();
+                this.store.set({ camera });
+                onCleanup(() => this.store.set({ camera: oldCamera }));
+            }
+        }, { allowSignalWrites: true });
+    }
+    #updateProjectionMatrix() {
+        const manual = this.select('manual');
+        effect(() => {
+            const camera = this.cameraRef.nativeElement;
+            if (!manual() && camera)
+                camera.updateProjectionMatrix();
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsCamera, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: NgtsCamera, inputs: { makeDefault: "makeDefault", manual: "manual", frames: "frames", resolution: "resolution", envMap: "envMap", cameraRef: "cameraRef" }, usesInheritance: true, ngImport: i0 }); }
+}
+export { NgtsCamera };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsCamera, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return []; }, propDecorators: { makeDefault: [{
+                type: Input
+            }], manual: [{
+                type: Input
+            }], frames: [{
+                type: Input
+            }], resolution: [{
+                type: Input
+            }], envMap: [{
+                type: Input
+            }], cameraRef: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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":"AAAA,OAAO,EAAE,IAAI,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,EACH,sBAAsB,EACtB,SAAS,EACT,YAAY,EACZ,UAAU,EACV,KAAK,EACL,SAAS,EACT,QAAQ,EACR,MAAM,GACT,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC5G,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAC1C,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;;AAE7D,MAAM,CAAC,EAAE,KAAK,EAAE,UAAU,EAAE,CAAC,CAAC;AAiB9B,MAkBa,cAAe,SAAQ,cAAmC;IAMnE,2CAA2C;IAC3C,IAAa,MAAM,CAAC,MAAc;QAC9B,IAAI,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC;IACzB,CAAC;IACD,iCAAiC;IACjC,IAAa,UAAU,CAAC,UAAkB;QACtC,IAAI,CAAC,GAAG,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC;IAC7B,CAAC;IACD,uBAAuB;IACvB,IAAa,IAAI,CAAC,IAAY;QAC1B,IAAI,CAAC,GAAG,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC;IACvB,CAAC;IACD,uBAAuB;IACvB,IAAa,GAAG,CAAC,GAAW;QACxB,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC;IACtB,CAAC;IACD,8EAA8E;IAC9E,IAAa,MAAM,CAAC,MAAqB;QACrC,IAAI,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC;IACzB,CAAC;IACD,2DAA2D;IAC3D,IAAa,GAAG,CAAC,GAA8B;QAC3C,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC;IACtB,CAAC;IAEQ,MAAM,CAAoB;IAE1B,WAAW,CAA6B;IACxC,KAAK,CAAuB;IAC5B,IAAI,CAAsB;IAYnC;QACI,KAAK,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC,CAAC;QA5C9D,cAAS,GAAG,YAAY,EAAoB,CAAC;QA2B7C,WAAM,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;QAE1B,gBAAW,GAAG,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;QACxC,UAAK,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAC5B,SAAI,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAE1B,QAAG,GAAG,QAAQ,CAAC,GAAG,EAAE;YACzB,MAAM,UAAU,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;YACtC,MAAM,GAAG,GAAG,IAAI,KAAK,CAAC,qBAAqB,CAAC,UAAU,CAAC,CAAC;YACxD,GAAG,CAAC,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,cAAc,CAAC;YAC5D,GAAG,CAAC,OAAO,CAAC,IAAI,GAAG,KAAK,CAAC,aAAa,CAAC;YACvC,OAAO,GAAG,CAAC;QACf,CAAC,CAAC,CAAC;QAEM,eAAU,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,EAAE,IAAI,CAAC,IAAI,EAAE,EAAE,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;QAK1E,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,IAAI,WAA+B,CAAC;QACpC,IAAI,kBAA6C,CAAC;QAClD,kBAAkB,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,EAAE,EAAE;YACjC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;YAC3C,IACI,MAAM;gBACN,IAAI,CAAC,SAAS,CAAC,aAAa;gBAC5B,IAAI,CAAC,QAAQ,CAAC,aAAa;gBAC3B,CAAC,MAAM,KAAK,QAAQ,IAAI,KAAK,GAAG,MAAM,CAAC,EACzC;gBACE,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,OAAO,GAAG,KAAK,CAAC;gBAC5C,WAAW,GAAG,KAAK,CAAC,GAAG,CAAC;gBACxB,kBAAkB,GAAG,KAAK,CAAC,UAAU,CAAC;gBACtC,KAAK,CAAC,UAAU,GAAG,MAAM,IAAI,kBAAkB,CAAC;gBAChD,KAAK,CAAC,GAAG,GAAG,GAAG,IAAI,WAAW,CAAC;gBAC/B,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,MAAM,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;gBAC/C,KAAK,CAAC,GAAG,GAAG,WAAW,CAAC;gBACxB,KAAK,CAAC,UAAU,GAAG,kBAAkB,CAAC;gBACtC,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,OAAO,GAAG,IAAI,CAAC;gBAC3C,KAAK,EAAE,CAAC;aACX;QACL,CAAC,CAAC,CAAC;IACP,CAAC;8GAzEQ,cAAc;kGAAd,cAAc,+PAET,iBAAiB,wLAjBrB;;;;;;;;;;;KAWT,4DACS,IAAI,6FAAE,gBAAgB,oJAAE,OAAO;;SAGhC,cAAc;2FAAd,cAAc;kBAlB1B,SAAS;mBAAC;oBACP,QAAQ,EAAE,kBAAkB;oBAC5B,UAAU,EAAE,IAAI;oBAChB,QAAQ,EAAE;;;;;;;;;;;KAWT;oBACD,OAAO,EAAE,CAAC,IAAI,EAAE,gBAAgB,EAAE,OAAO,CAAC;oBAC1C,OAAO,EAAE,CAAC,sBAAsB,CAAC;iBACpC;0EAEyC,QAAQ;sBAA7C,SAAS;uBAAC,OAAO,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE;gBACH,aAAa;sBAA7C,YAAY;uBAAC,iBAAiB;gBAEtB,SAAS;sBAAjB,KAAK;gBAGO,MAAM;sBAAlB,KAAK;gBAIO,UAAU;sBAAtB,KAAK;gBAIO,IAAI;sBAAhB,KAAK;gBAIO,GAAG;sBAAf,KAAK;gBAIO,MAAM;sBAAlB,KAAK;gBAIO,GAAG;sBAAf,KAAK","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

@@ -1,5 +1,6 @@
-export * from './lib/camera/camera-content';
-export * from './lib/cube-camera/cube-camera';
-export * from './lib/orthographic-camera/orthographic-camera';
-export * from './lib/perspective-camera/perspective-camera';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXItdGhyZWUtc29iYS9jYW1lcmFzL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYywrQ0FBK0MsQ0FBQztBQUM5RCxjQUFjLDZDQUE2QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9saWIvY2FtZXJhL2NhbWVyYS1jb250ZW50JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2N1YmUtY2FtZXJhL2N1YmUtY2FtZXJhJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL29ydGhvZ3JhcGhpYy1jYW1lcmEvb3J0aG9ncmFwaGljLWNhbWVyYSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9wZXJzcGVjdGl2ZS1jYW1lcmEvcGVyc3BlY3RpdmUtY2FtZXJhJztcbiJdfQ==
+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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