angular-three-soba 1.13.0 → 1.14.1

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

@@ -0,0 +1,145 @@
+import { Component, CUSTOM_ELEMENTS_SCHEMA, Input } from '@angular/core';
+import { extend, NgtArgs, NgtPush, NgtRxStore } from 'angular-three';
+import { combineLatest, 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 NgtRxStore {
+    constructor() {
+        super(...arguments);
+        this.font$ = 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.geometryArgs$ = combineLatest([
+            this.font$,
+            this.select('text'),
+            this.select('size'),
+            this.select('height'),
+            this.select('bevelThickness'),
+            this.select('bevelSize'),
+            this.select('bevelEnabled'),
+            this.select('bevelSegments'),
+            this.select('bevelOffset'),
+            this.select('curveSegments'),
+            this.select('letterSpacing'),
+            this.select('lineHeight'),
+        ]).pipe(map(([font, text, size, height, bevelThickness, bevelSize, bevelEnabled, bevelSegments, bevelOffset, curveSegments, letterSpacing, lineHeight,]) => [
+            text,
+            {
+                font,
+                size,
+                height,
+                bevelThickness,
+                bevelSize,
+                bevelSegments,
+                bevelEnabled,
+                bevelOffset,
+                curveSegments,
+                letterSpacing,
+                lineHeight,
+            },
+        ]));
+    }
+    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 });
+    }
+    initialize() {
+        super.initialize();
+        this.set({
+            letterSpacing: 0,
+            lineHeight: 1,
+            size: 1,
+            height: 0.2,
+            bevelThickness: 0.1,
+            bevelSize: 0.01,
+            bevelEnabled: false,
+            bevelOffset: 0,
+            bevelSegments: 4,
+            curveSegments: 8,
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsText3D, deps: null, 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[font]", inputs: { font: "font", text: "text", bevelEnabled: "bevelEnabled", bevelOffset: "bevelOffset", bevelSize: "bevelSize", bevelThickness: "bevelThickness", curveSegments: "curveSegments", bevelSegments: "bevelSegments", height: "height", size: "size", lineHeight: "lineHeight", letterSpacing: "letterSpacing" }, usesInheritance: true, ngImport: i0, template: `
+        <ngt-mesh ngtCompound>
+            <ngt-text-geometry *args="geometryArgs$ | ngtPush : null" />
+            <ng-content />
+        </ngt-mesh>
+    `, isInline: true, dependencies: [{ kind: "directive", type: NgtArgs, selector: "[args]", inputs: ["args"] }, { kind: "pipe", type: NgtPush, name: "ngtPush" }] }); }
+}
+export { NgtsText3D };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsText3D, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-text-3d[font]',
+                    standalone: true,
+                    template: `
+        <ngt-mesh ngtCompound>
+            <ngt-text-geometry *args="geometryArgs$ | ngtPush : null" />
+            <ng-content />
+        </ngt-mesh>
+    `,
+                    imports: [NgtArgs, NgtPush],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], propDecorators: { font: [{
+                type: Input
+            }], text: [{
+                type: Input
+            }], 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
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"text-3d.js","sourceRoot":"","sources":["../../../../../../../libs/angular-three-soba/abstractions/src/lib/text-3d/text-3d.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, CUSTOM_ELEMENTS_SCHEMA, Input } from '@angular/core';\nimport { extend, NgtArgs, NgtPush, NgtRxStore } from 'angular-three';\nimport { combineLatest, 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\n@Component({\n    selector: 'ngts-text-3d[font]',\n    standalone: true,\n    template: `\n        <ngt-mesh ngtCompound>\n            <ngt-text-geometry *args=\"geometryArgs$ | ngtPush : null\" />\n            <ng-content />\n        </ngt-mesh>\n    `,\n    imports: [NgtArgs, NgtPush],\n    schemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsText3D extends NgtRxStore {\n    @Input() set font(font: FontData | string) {\n        this.set({ font });\n    }\n\n    @Input() 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    override initialize(): void {\n        super.initialize();\n        this.set({\n            letterSpacing: 0,\n            lineHeight: 1,\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    private readonly font$ = 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    readonly geometryArgs$ = combineLatest([\n        this.font$,\n        this.select('text'),\n        this.select('size'),\n        this.select('height'),\n        this.select('bevelThickness'),\n        this.select('bevelSize'),\n        this.select('bevelEnabled'),\n        this.select('bevelSegments'),\n        this.select('bevelOffset'),\n        this.select('curveSegments'),\n        this.select('letterSpacing'),\n        this.select('lineHeight'),\n    ]).pipe(\n        map(\n            ([\n                font,\n                text,\n                size,\n                height,\n                bevelThickness,\n                bevelSize,\n                bevelEnabled,\n                bevelSegments,\n                bevelOffset,\n                curveSegments,\n                letterSpacing,\n                lineHeight,\n            ]) => [\n                text,\n                {\n                    font,\n                    size,\n                    height,\n                    bevelThickness,\n                    bevelSize,\n                    bevelSegments,\n                    bevelEnabled,\n                    bevelOffset,\n                    curveSegments,\n                    letterSpacing,\n                    lineHeight,\n                },\n            ]\n        )\n    );\n}\n"]}

package/esm2022/cameras/lib/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FtZXJhLWNvbnRlbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXItdGhyZWUtc29iYS9jYW1lcmFzL3NyYy9saWIvY2FtZXJhL2NhbWVyYS1jb250ZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxFQUFFLEtBQUssRUFBRSxXQUFXLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBR3RFLE1BQ2EsaUJBQWlCO0lBRDlCO1FBRWEsYUFBUSxHQUFHLE1BQU0sQ0FBQyxXQUFXLENBQUMsQ0FBQztRQUMvQixzQkFBaUIsR0FBaUIsRUFBRSxDQUFDO0tBUWpEO0lBTkcsTUFBTSxDQUFDLHNCQUFzQixDQUN6QixDQUFvQixFQUNwQixHQUFZO1FBRVosT0FBTyxJQUFJLENBQUM7SUFDaEIsQ0FBQzs4R0FUUSxpQkFBaUI7a0dBQWpCLGlCQUFpQjs7U0FBakIsaUJBQWlCOzJGQUFqQixpQkFBaUI7a0JBRDdCLFNBQVM7bUJBQUMsRUFBRSxRQUFRLEVBQUUsZ0NBQWdDLEVBQUUsVUFBVSxFQUFFLElBQUksRUFBRTs4QkFHOUQsaUJBQWlCO3NCQUF6QixLQUFLIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGlyZWN0aXZlLCBpbmplY3QsIElucHV0LCBUZW1wbGF0ZVJlZiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0ICogYXMgVEhSRUUgZnJvbSAndGhyZWUnO1xuXG5ARGlyZWN0aXZlKHsgc2VsZWN0b3I6ICduZy10ZW1wbGF0ZVtuZ3RzQ2FtZXJhQ29udGVudF0nLCBzdGFuZGFsb25lOiB0cnVlIH0pXG5leHBvcnQgY2xhc3MgTmd0c0NhbWVyYUNvbnRlbnQge1xuICAgIHJlYWRvbmx5IHRlbXBsYXRlID0gaW5qZWN0KFRlbXBsYXRlUmVmKTtcbiAgICBASW5wdXQoKSBuZ3RzQ2FtZXJhQ29udGVudDogYm9vbGVhbiB8ICcnID0gJyc7XG5cbiAgICBzdGF0aWMgbmdUZW1wbGF0ZUNvbnRleHRHdWFyZChcbiAgICAgICAgXzogTmd0c0NhbWVyYUNvbnRlbnQsXG4gICAgICAgIGN0eDogdW5rbm93blxuICAgICk6IGN0eCBpcyB7IGZibzogVEhSRUUuV2ViR0xSZW5kZXJUYXJnZXQ7IGdyb3VwPzogVEhSRUUuR3JvdXAgfSB7XG4gICAgICAgIHJldHVybiB0cnVlO1xuICAgIH1cbn1cbiJdfQ==

package/esm2022/cameras/lib/camera/camera.mjs

@@ -0,0 +1,75 @@
+import { Directive, inject, Input } from '@angular/core';
+import { injectNgtRef, NgtRxStore, NgtStore } from 'angular-three';
+import { injectNgtsFBO } from 'angular-three-soba/misc';
+import { combineLatest, map } from 'rxjs';
+import * as i0 from "@angular/core";
+class NgtsCamera extends NgtRxStore {
+    constructor() {
+        super(...arguments);
+        this.cameraRef = injectNgtRef();
+        this.store = inject(NgtStore);
+        this.fboRef = injectNgtsFBO(() => this.select('resolution').pipe(map((resolution) => ({ width: resolution }))));
+    }
+    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 });
+    }
+    initialize() {
+        super.initialize();
+        this.set({ resolution: 256, frames: Infinity, makeDefault: false, manual: false });
+    }
+    ngOnInit() {
+        this.hold(this.cameraRef.$, (camera) => {
+            camera.updateProjectionMatrix();
+            this.setDefaultCamera();
+            this.updateProjectionMatrix();
+        });
+    }
+    setDefaultCamera() {
+        this.effect(combineLatest([this.cameraRef.$, this.select('makeDefault')]), ([camera, makeDefault]) => {
+            if (makeDefault) {
+                const { camera: oldCamera } = this.store.get();
+                this.store.set({ camera });
+                return () => {
+                    this.store.set({ camera: oldCamera });
+                };
+            }
+        });
+    }
+    updateProjectionMatrix() {
+        this.effect(combineLatest([this.cameraRef.$, this.select('manual')]), ([camera, manual]) => {
+            if (!manual && camera)
+                camera.updateProjectionMatrix();
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsCamera, deps: null, 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
+        }], 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/lib/cube-camera/cube-camera.mjs

@@ -0,0 +1,131 @@
+import { NgIf, NgTemplateOutlet } from '@angular/common';
+import { Component, ContentChild, CUSTOM_ELEMENTS_SCHEMA, ElementRef, inject, Input, ViewChild } from '@angular/core';
+import { extend, injectBeforeRender, injectNgtRef, NgtArgs, NgtRxStore, NgtStore } from 'angular-three';
+import { combineLatest, map } from 'rxjs';
+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 NgtRxStore {
+    /** 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 });
+    }
+    initialize() {
+        super.initialize();
+        this.set({
+            frames: Infinity,
+            resolution: 256,
+            near: 0.1,
+            far: 1000,
+        });
+    }
+    constructor() {
+        super();
+        this.cameraRef = injectNgtRef();
+        this.store = inject(NgtStore);
+        this.connect('fbo', this.select('resolution').pipe(map((resolution) => {
+            const fbo = new THREE.WebGLCubeRenderTarget(resolution);
+            fbo.texture.encoding = this.store.get('gl').outputEncoding;
+            fbo.texture.type = THREE.HalfFloatType;
+            return fbo;
+        })));
+        this.connect('cameraArgs', combineLatest([this.select('near'), this.select('far'), this.select('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: { 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="get('cameraArgs')" />
+            <ngt-group #group>
+                <ng-container
+                    *ngIf="cameraContent && cameraContent.ngtsCameraContent && get('fbo')"
+                    [ngTemplateOutlet]="cameraContent.template"
+                    [ngTemplateOutletContext]="{ fbo: get('fbo').texture, 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="get('cameraArgs')" />
+            <ngt-group #group>
+                <ng-container
+                    *ngIf="cameraContent && cameraContent.ngtsCameraContent && get('fbo')"
+                    [ngTemplateOutlet]="cameraContent.template"
+                    [ngTemplateOutletContext]="{ fbo: get('fbo').texture, 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]
+            }], 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/angular-three-soba/cameras/src/lib/cube-camera/cube-camera.ts"],"names":[],"mappings":"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","sourcesContent":["import { NgIf, NgTemplateOutlet } from '@angular/common';\nimport { Component, ContentChild, CUSTOM_ELEMENTS_SCHEMA, ElementRef, inject, Input, ViewChild } from '@angular/core';\nimport { extend, injectBeforeRender, injectNgtRef, NgtArgs, NgtRxStore, NgtStore } from 'angular-three';\nimport { combineLatest, map } from 'rxjs';\nimport * as THREE from 'three';\nimport { CubeCamera, Group } from 'three';\nimport { NgtsCameraContent } from '../camera/camera-content';\n\nextend({ Group, CubeCamera });\n\n@Component({\n    selector: 'ngts-cube-camera',\n    standalone: true,\n    template: `\n        <ngt-group ngtCompound>\n            <ngt-cube-camera [ref]=\"cameraRef\" *args=\"get('cameraArgs')\" />\n            <ngt-group #group>\n                <ng-container\n                    *ngIf=\"cameraContent && cameraContent.ngtsCameraContent && get('fbo')\"\n                    [ngTemplateOutlet]=\"cameraContent.template\"\n                    [ngTemplateOutletContext]=\"{ fbo: get('fbo').texture, group }\"\n                />\n            </ngt-group>\n        </ngt-group>\n    `,\n    imports: [NgIf, NgTemplateOutlet, NgtArgs],\n    schemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsCubeCamera extends NgtRxStore {\n    @ViewChild('group', { static: true }) groupRef!: ElementRef<THREE.Group>;\n    @ContentChild(NgtsCameraContent) cameraContent?: NgtsCameraContent;\n\n    readonly 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    private readonly store = inject(NgtStore);\n\n    override initialize(): void {\n        super.initialize();\n        this.set({\n            frames: Infinity,\n            resolution: 256,\n            near: 0.1,\n            far: 1000,\n        });\n    }\n\n    constructor() {\n        super();\n        this.connect(\n            'fbo',\n            this.select('resolution').pipe(\n                map((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        );\n        this.connect('cameraArgs', combineLatest([this.select('near'), this.select('far'), this.select('fbo')]));\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/lib/orthographic-camera/orthographic-camera.mjs

@@ -0,0 +1,93 @@
+import { NgIf, NgTemplateOutlet } from '@angular/common';
+import { Component, ContentChild, CUSTOM_ELEMENTS_SCHEMA, Input } from '@angular/core';
+import { extend, NgtPush } from 'angular-three';
+import { combineLatest, map } from 'rxjs';
+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 {
+    constructor() {
+        super(...arguments);
+        this.left$ = combineLatest([this.select('left'), this.store.select('size')]).pipe(map(([left, size]) => left || size.width / -2));
+        this.right$ = combineLatest([this.select('right'), this.store.select('size')]).pipe(map(([right, size]) => right || size.width / 2));
+        this.top$ = combineLatest([this.select('top'), this.store.select('size')]).pipe(map(([top, size]) => top || size.height / 2));
+        this.bottom$ = combineLatest([this.select('bottom'), this.store.select('size')]).pipe(map(([bottom, size]) => bottom || size.height / -2));
+    }
+    set left(left) {
+        this.set({ left });
+    }
+    set right(right) {
+        this.set({ right });
+    }
+    set top(top) {
+        this.set({ top });
+    }
+    set bottom(bottom) {
+        this.set({ bottom });
+    }
+    initialize() {
+        super.initialize();
+        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: null, 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]="left$ | ngtPush"
+            [right]="right$ | ngtPush"
+            [top]="top$ | ngtPush"
+            [bottom]="bottom$ | ngtPush"
+        >
+            <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.nativeElement, 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: "pipe", type: NgtPush, name: "ngtPush" }] }); }
+}
+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]="left$ | ngtPush"
+            [right]="right$ | ngtPush"
+            [top]="top$ | ngtPush"
+            [bottom]="bottom$ | ngtPush"
+        >
+            <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.nativeElement, group }" />
+        </ngt-group>
+    `,
+                    imports: [NgIf, NgTemplateOutlet, NgtPush],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], 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/{esm2020 → esm2022}/cameras/lib/perspective-camera/perspective-camera.mjs

@@ -6,10 +6,9 @@ import { NgtsCamera } from '../camera/camera';
 import { NgtsCameraContent } from '../camera/camera-content';
 import * as i0 from "@angular/core";
 extend({ PerspectiveCamera, Group });
-export class NgtsPerspectiveCamera extends NgtsCamera {
-}
-NgtsPerspectiveCamera.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.5", ngImport: i0, type: NgtsPerspectiveCamera, deps: null, target: i0.ɵɵFactoryTarget.Component });
-NgtsPerspectiveCamera.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.5", type: NgtsPerspectiveCamera, isStandalone: true, selector: "ngts-perspective-camera", queries: [{ propertyName: "cameraContent", first: true, predicate: NgtsCameraContent, descendants: true }], usesInheritance: true, ngImport: i0, template: `
+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"
@@ -19,8 +18,10 @@ NgtsPerspectiveCamera.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0",
         <ngt-group #group *ngIf="cameraContent && cameraContent.ngtsCameraContent">
             <ng-container *ngTemplateOutlet="cameraContent.template; context: { fbo: fboRef.nativeElement, 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"] }] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.5", ngImport: i0, type: NgtsPerspectiveCamera, decorators: [{
+    `, 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',
@@ -43,4 +44,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.5", ngImpor
                 type: ContentChild,
                 args: [NgtsCameraContent]
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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