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

package/esm2022/staging/environment/assets.mjs

@@ -0,0 +1,13 @@
+export const ENVIRONMENT_PRESETS = {
+    apartment: 'lebombo_1k.hdr',
+    city: 'potsdamer_platz_1k.hdr',
+    dawn: 'kiara_1_dawn_1k.hdr',
+    forest: 'forest_slope_1k.hdr',
+    lobby: 'st_fagans_interior_1k.hdr',
+    night: 'dikhololo_night_1k.hdr',
+    park: 'rooitou_park_1k.hdr',
+    studio: 'studio_small_03_1k.hdr',
+    sunset: 'venice_sunset_1k.hdr',
+    warehouse: 'empty_warehouse_01_1k.hdr',
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXNzZXRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9zb2JhL3N0YWdpbmcvc3JjL2Vudmlyb25tZW50L2Fzc2V0cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQUMsTUFBTSxtQkFBbUIsR0FBRztJQUNsQyxTQUFTLEVBQUUsZ0JBQWdCO0lBQzNCLElBQUksRUFBRSx3QkFBd0I7SUFDOUIsSUFBSSxFQUFFLHFCQUFxQjtJQUMzQixNQUFNLEVBQUUscUJBQXFCO0lBQzdCLEtBQUssRUFBRSwyQkFBMkI7SUFDbEMsS0FBSyxFQUFFLHdCQUF3QjtJQUMvQixJQUFJLEVBQUUscUJBQXFCO0lBQzNCLE1BQU0sRUFBRSx3QkFBd0I7SUFDaEMsTUFBTSxFQUFFLHNCQUFzQjtJQUM5QixTQUFTLEVBQUUsMkJBQTJCO0NBQ3RDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY29uc3QgRU5WSVJPTk1FTlRfUFJFU0VUUyA9IHtcblx0YXBhcnRtZW50OiAnbGVib21ib18xay5oZHInLFxuXHRjaXR5OiAncG90c2RhbWVyX3BsYXR6XzFrLmhkcicsXG5cdGRhd246ICdraWFyYV8xX2Rhd25fMWsuaGRyJyxcblx0Zm9yZXN0OiAnZm9yZXN0X3Nsb3BlXzFrLmhkcicsXG5cdGxvYmJ5OiAnc3RfZmFnYW5zX2ludGVyaW9yXzFrLmhkcicsXG5cdG5pZ2h0OiAnZGlraG9sb2xvX25pZ2h0XzFrLmhkcicsXG5cdHBhcms6ICdyb29pdG91X3BhcmtfMWsuaGRyJyxcblx0c3R1ZGlvOiAnc3R1ZGlvX3NtYWxsXzAzXzFrLmhkcicsXG5cdHN1bnNldDogJ3ZlbmljZV9zdW5zZXRfMWsuaGRyJyxcblx0d2FyZWhvdXNlOiAnZW1wdHlfd2FyZWhvdXNlXzAxXzFrLmhkcicsXG59O1xuXG5leHBvcnQgdHlwZSBOZ3RzRW52aXJvbm1lbnRQcmVzZXRzVHlwZSA9IGtleW9mIHR5cGVvZiBFTlZJUk9OTUVOVF9QUkVTRVRTO1xuIl19

package/esm2022/staging/environment/environment-cube.mjs

@@ -0,0 +1,47 @@
+import { Directive, Input, effect, inject } from '@angular/core';
+import { injectNgtStore, signalStore } from 'angular-three';
+import { NgtsEnvironmentInput } from './environment-input';
+import { injectNgtsEnvironment, setEnvProps } from './utils';
+import * as i0 from "@angular/core";
+export class NgtsEnvironmentCube {
+    set _background(background) {
+        this.inputs.set({ background });
+    }
+    constructor() {
+        this.environmentInput = inject(NgtsEnvironmentInput);
+        this.inputs = signalStore({ background: false });
+        this.store = injectNgtStore();
+        this.scene = this.store.select('scene');
+        this.background = this.inputs.select('background');
+        this.textureRef = injectNgtsEnvironment(this.environmentInput.params);
+        this.setEnvProps();
+    }
+    setEnvProps() {
+        effect((onCleanup) => {
+            const [defaultScene, scene, background, blur, texture] = [
+                this.scene(),
+                this.environmentInput.scene(),
+                this.background(),
+                this.environmentInput.blur(),
+                this.textureRef.nativeElement,
+            ];
+            if (!texture)
+                return;
+            const cleanUp = setEnvProps(background, scene, defaultScene, texture, blur);
+            onCleanup(cleanUp);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsEnvironmentCube, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.7", type: NgtsEnvironmentCube, isStandalone: true, selector: "ngts-environment-cube", inputs: { _background: ["background", "_background"] }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsEnvironmentCube, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'ngts-environment-cube',
+                    standalone: true,
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { _background: [{
+                type: Input,
+                args: [{ alias: 'background' }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/staging/environment/environment-ground.mjs

@@ -0,0 +1,41 @@
+import { Component, computed, CUSTOM_ELEMENTS_SCHEMA, inject } from '@angular/core';
+import { extend, NgtArgs } from 'angular-three';
+import { GroundProjectedEnv } from 'three-stdlib';
+import { NgtsEnvironmentInput } from './environment-input';
+import { NgtsEnvironmentMap } from './environment-map';
+import { injectNgtsEnvironment } from './utils';
+import * as i0 from "@angular/core";
+extend({ GroundProjectedEnv });
+export class NgtsEnvironmentGround {
+    constructor() {
+        this.environmentInput = inject(NgtsEnvironmentInput);
+        this.defaultTexture = injectNgtsEnvironment(this.environmentInput.params);
+        this.texture = computed(() => {
+            const defaultTexture = this.defaultTexture.nativeElement;
+            return this.environmentInput.map() || defaultTexture;
+        });
+        this.groundArgs = computed(() => (this.texture() ? [this.texture()] : []));
+        this.height = computed(() => this.environmentInput.ground()?.height);
+        this.radius = computed(() => this.environmentInput.ground()?.radius);
+        this.scale = computed(() => this.environmentInput.ground()?.scale ?? 1000);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsEnvironmentGround, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.7", type: NgtsEnvironmentGround, isStandalone: true, selector: "ngts-environment-ground", ngImport: i0, template: `
+		<ngts-environment-map [map]="texture()" [background]="!!environmentInput.background()" />
+		<ngt-ground-projected-env *args="groundArgs()" [scale]="scale()" [height]="height()" [radius]="radius()" />
+	`, isInline: true, dependencies: [{ kind: "directive", type: NgtsEnvironmentMap, selector: "ngts-environment-map", inputs: ["map", "background"] }, { kind: "directive", type: NgtArgs, selector: "ng-template[args]", inputs: ["args"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsEnvironmentGround, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-environment-ground',
+                    standalone: true,
+                    template: `
+		<ngts-environment-map [map]="texture()" [background]="!!environmentInput.background()" />
+		<ngt-ground-projected-env *args="groundArgs()" [scale]="scale()" [height]="height()" [radius]="radius()" />
+	`,
+                    imports: [NgtsEnvironmentMap, NgtArgs],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/staging/environment/environment-input.mjs

@@ -0,0 +1,119 @@
+import { Directive, Input, computed } from '@angular/core';
+import { signalStore } from 'angular-three';
+import * as i0 from "@angular/core";
+export class NgtsEnvironmentInput {
+    constructor() {
+        this.inputs = signalStore({});
+        this.frames = this.inputs.select('frames');
+        this.near = this.inputs.select('near');
+        this.far = this.inputs.select('far');
+        this.resolution = this.inputs.select('resolution');
+        this.background = this.inputs.select('background');
+        this.blur = this.inputs.select('blur');
+        this.map = this.inputs.select('map');
+        this.files = this.inputs.select('files');
+        this.path = this.inputs.select('path');
+        this.preset = this.inputs.select('preset');
+        this.scene = this.inputs.select('scene');
+        this.extensions = this.inputs.select('extensions');
+        this.ground = this.inputs.select('ground');
+        this.encoding = this.inputs.select('encoding');
+        this.params = computed(() => ({
+            files: this.files(),
+            path: this.path(),
+            preset: this.preset(),
+            extensions: this.extensions(),
+            encoding: this.encoding(),
+        }));
+    }
+    set _frames(frames) {
+        this.inputs.set({ frames });
+    }
+    set _near(near) {
+        this.inputs.set({ near });
+    }
+    set _far(far) {
+        this.inputs.set({ far });
+    }
+    set _resolution(resolution) {
+        this.inputs.set({ resolution });
+    }
+    set _background(background) {
+        this.inputs.set({ background });
+    }
+    set _blur(blur) {
+        this.inputs.set({ blur });
+    }
+    set _map(map) {
+        this.inputs.set({ map });
+    }
+    set _files(files) {
+        this.inputs.set({ files });
+    }
+    set _path(path) {
+        this.inputs.set({ path });
+    }
+    set _preset(preset) {
+        this.inputs.set({ preset });
+    }
+    set _scene(scene) {
+        this.inputs.set({ scene });
+    }
+    set _extensions(extensions) {
+        this.inputs.set({ extensions });
+    }
+    set _ground(ground) {
+        this.inputs.set({ ground });
+    }
+    set _encoding(encoding) {
+        this.inputs.set({ encoding });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsEnvironmentInput, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.7", type: NgtsEnvironmentInput, inputs: { _frames: ["frames", "_frames"], _near: ["near", "_near"], _far: ["far", "_far"], _resolution: ["resolution", "_resolution"], _background: ["background", "_background"], _blur: ["blur", "_blur"], _map: ["map", "_map"], _files: ["files", "_files"], _path: ["path", "_path"], _preset: ["preset", "_preset"], _scene: ["scene", "_scene"], _extensions: ["extensions", "_extensions"], _ground: ["ground", "_ground"], _encoding: ["encoding", "_encoding"] }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsEnvironmentInput, decorators: [{
+            type: Directive
+        }], propDecorators: { _frames: [{
+                type: Input,
+                args: [{ alias: 'frames' }]
+            }], _near: [{
+                type: Input,
+                args: [{ alias: 'near' }]
+            }], _far: [{
+                type: Input,
+                args: [{ alias: 'far' }]
+            }], _resolution: [{
+                type: Input,
+                args: [{ alias: 'resolution' }]
+            }], _background: [{
+                type: Input,
+                args: [{ alias: 'background' }]
+            }], _blur: [{
+                type: Input,
+                args: [{ alias: 'blur' }]
+            }], _map: [{
+                type: Input,
+                args: [{ alias: 'map' }]
+            }], _files: [{
+                type: Input,
+                args: [{ alias: 'files' }]
+            }], _path: [{
+                type: Input,
+                args: [{ alias: 'path' }]
+            }], _preset: [{
+                type: Input,
+                args: [{ alias: 'preset' }]
+            }], _scene: [{
+                type: Input,
+                args: [{ alias: 'scene' }]
+            }], _extensions: [{
+                type: Input,
+                args: [{ alias: 'extensions' }]
+            }], _ground: [{
+                type: Input,
+                args: [{ alias: 'ground' }]
+            }], _encoding: [{
+                type: Input,
+                args: [{ alias: 'encoding' }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"environment-input.js","sourceRoot":"","sources":["../../../../../../libs/soba/staging/src/environment/environment-input.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, ElementRef, Input, computed } from '@angular/core';\nimport { signalStore } from 'angular-three';\nimport type { Loader, Scene, Texture, TextureEncoding } from 'three';\nimport { NgtsEnvironmentPresetsType } from './assets';\n\nexport type NgtsEnvironmentInputState = {\n\tframes?: number;\n\tnear?: number;\n\tfar?: number;\n\tresolution?: number;\n\tbackground?: boolean | 'only';\n\tblur?: number;\n\tmap?: Texture;\n\tfiles?: string | string[];\n\tpath?: string;\n\tpreset?: NgtsEnvironmentPresetsType;\n\tscene?: Scene | ElementRef<Scene>;\n\textensions?: (loader: Loader) => void;\n\tground?: boolean | { radius?: number; height?: number; scale?: number };\n\tencoding?: TextureEncoding;\n};\n\n@Directive()\nexport abstract class NgtsEnvironmentInput {\n\tinputs = signalStore<NgtsEnvironmentInputState>({});\n\n\t@Input({ alias: 'frames' }) set _frames(frames: NgtsEnvironmentInputState['frames']) {\n\t\tthis.inputs.set({ frames });\n\t}\n\n\t@Input({ alias: 'near' }) set _near(near: NgtsEnvironmentInputState['near']) {\n\t\tthis.inputs.set({ near });\n\t}\n\n\t@Input({ alias: 'far' }) set _far(far: NgtsEnvironmentInputState['far']) {\n\t\tthis.inputs.set({ far });\n\t}\n\n\t@Input({ alias: 'resolution' }) set _resolution(resolution: NgtsEnvironmentInputState['resolution']) {\n\t\tthis.inputs.set({ resolution });\n\t}\n\n\t@Input({ alias: 'background' }) set _background(background: NgtsEnvironmentInputState['background']) {\n\t\tthis.inputs.set({ background });\n\t}\n\n\t@Input({ alias: 'blur' }) set _blur(blur: NgtsEnvironmentInputState['blur']) {\n\t\tthis.inputs.set({ blur });\n\t}\n\n\t@Input({ alias: 'map' }) set _map(map: NgtsEnvironmentInputState['map']) {\n\t\tthis.inputs.set({ map });\n\t}\n\n\t@Input({ alias: 'files' }) set _files(files: NgtsEnvironmentInputState['files']) {\n\t\tthis.inputs.set({ files });\n\t}\n\n\t@Input({ alias: 'path' }) set _path(path: NgtsEnvironmentInputState['path']) {\n\t\tthis.inputs.set({ path });\n\t}\n\n\t@Input({ alias: 'preset' }) set _preset(preset: NgtsEnvironmentInputState['preset']) {\n\t\tthis.inputs.set({ preset });\n\t}\n\n\t@Input({ alias: 'scene' }) set _scene(scene: NgtsEnvironmentInputState['scene']) {\n\t\tthis.inputs.set({ scene });\n\t}\n\n\t@Input({ alias: 'extensions' }) set _extensions(extensions: NgtsEnvironmentInputState['extensions']) {\n\t\tthis.inputs.set({ extensions });\n\t}\n\n\t@Input({ alias: 'ground' }) set _ground(ground: NgtsEnvironmentInputState['ground']) {\n\t\tthis.inputs.set({ ground });\n\t}\n\n\t@Input({ alias: 'encoding' }) set _encoding(encoding: NgtsEnvironmentInputState['encoding']) {\n\t\tthis.inputs.set({ encoding });\n\t}\n\n\tframes = this.inputs.select('frames');\n\tnear = this.inputs.select('near');\n\tfar = this.inputs.select('far');\n\tresolution = this.inputs.select('resolution');\n\tbackground = this.inputs.select('background');\n\tblur = this.inputs.select('blur');\n\tmap = this.inputs.select('map');\n\tfiles = this.inputs.select('files');\n\tpath = this.inputs.select('path');\n\tpreset = this.inputs.select('preset');\n\tscene = this.inputs.select('scene');\n\textensions = this.inputs.select('extensions');\n\tground = this.inputs.select('ground');\n\tencoding = this.inputs.select('encoding');\n\n\tparams = computed(() => ({\n\t\tfiles: this.files(),\n\t\tpath: this.path(),\n\t\tpreset: this.preset(),\n\t\textensions: this.extensions(),\n\t\tencoding: this.encoding(),\n\t}));\n}\n"]}

package/esm2022/staging/environment/environment-map.mjs

@@ -0,0 +1,53 @@
+import { Directive, Input, effect, inject } from '@angular/core';
+import { injectNgtStore, signalStore } from 'angular-three';
+import { NgtsEnvironmentInput } from './environment-input';
+import { setEnvProps } from './utils';
+import * as i0 from "@angular/core";
+export class NgtsEnvironmentMap {
+    set _map(map) {
+        this.inputs.set({ map });
+    }
+    set _background(background) {
+        this.inputs.set({ background });
+    }
+    constructor() {
+        this.environmentInput = inject(NgtsEnvironmentInput);
+        this.store = injectNgtStore();
+        this.inputs = signalStore({ background: false });
+        this.scene = this.store.select('scene');
+        this.background = this.inputs.select('background');
+        this.map = this.inputs.select('map');
+        this.setEnvProps();
+    }
+    setEnvProps() {
+        effect((onCleanup) => {
+            const [defaultScene, scene, background, blur, texture] = [
+                this.scene(),
+                this.environmentInput.scene(),
+                this.background(),
+                this.environmentInput.blur(),
+                this.map(),
+            ];
+            if (!texture)
+                return;
+            const cleanUp = setEnvProps(background, scene, defaultScene, texture, blur);
+            onCleanup(cleanUp);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsEnvironmentMap, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.7", type: NgtsEnvironmentMap, isStandalone: true, selector: "ngts-environment-map", inputs: { _map: ["map", "_map"], _background: ["background", "_background"] }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsEnvironmentMap, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'ngts-environment-map',
+                    standalone: true,
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { _map: [{
+                type: Input,
+                args: [{ alias: 'map' }]
+            }], _background: [{
+                type: Input,
+                args: [{ alias: 'background' }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/staging/environment/environment-portal.mjs

@@ -0,0 +1,113 @@
+import { NgIf } from '@angular/common';
+import { Component, computed, CUSTOM_ELEMENTS_SCHEMA, effect, inject } from '@angular/core';
+import { extend, injectBeforeRender, injectNgtRef, injectNgtStore, NgtArgs, NgtPortal, NgtPortalContent, prepare, } from 'angular-three';
+import * as THREE from 'three';
+import { CubeCamera } from 'three';
+import { NgtsEnvironmentCube } from './environment-cube';
+import { NgtsEnvironmentInput } from './environment-input';
+import { NgtsEnvironmentMap } from './environment-map';
+import { setEnvProps } from './utils';
+import * as i0 from "@angular/core";
+extend({ CubeCamera });
+export class NgtsEnvironmentPortal {
+    constructor() {
+        this.environmentInput = inject(NgtsEnvironmentInput);
+        this.store = injectNgtStore();
+        this.gl = this.store.select('gl');
+        this.scene = this.store.select('scene');
+        this.virtualSceneRef = injectNgtRef(prepare(new THREE.Scene()));
+        this.cubeCameraRef = injectNgtRef();
+        this.fbo = computed(() => {
+            const fbo = new THREE.WebGLCubeRenderTarget(this.environmentInput.resolution());
+            fbo.texture.type = THREE.HalfFloatType;
+            return fbo;
+        });
+        this.cameraArgs = computed(() => [this.environmentInput.near(), this.environmentInput.far(), this.fbo()]);
+        effect(() => {
+            this.environmentInput.inputs.patch({
+                near: 1,
+                far: 1000,
+                resolution: 256,
+                frames: 1,
+                background: false,
+                preset: undefined,
+            });
+        });
+        this.setEnvProps();
+        this.beforeRender();
+    }
+    setEnvProps() {
+        effect((onCleanup) => {
+            const [virtualScene, blur, frames, background, scene, fbo, defaultScene, gl, cubeCamera] = [
+                this.virtualSceneRef.nativeElement,
+                this.environmentInput.blur(),
+                this.environmentInput.frames(),
+                this.environmentInput.background(),
+                this.environmentInput.scene(),
+                this.fbo(),
+                this.scene(),
+                this.gl(),
+                this.cubeCameraRef.nativeElement,
+            ];
+            if (!cubeCamera || !virtualScene)
+                return;
+            if (frames === 1)
+                cubeCamera.update(gl, virtualScene);
+            const cleanUp = setEnvProps(background, scene, defaultScene, fbo.texture, blur);
+            onCleanup(cleanUp);
+        });
+    }
+    beforeRender() {
+        let count = 1;
+        injectBeforeRender(({ gl }) => {
+            const { frames } = this.environmentInput.inputs.get();
+            if (frames === Infinity || count < frames) {
+                const camera = this.cubeCameraRef.nativeElement;
+                const virtualScene = this.virtualSceneRef.nativeElement;
+                if (camera && virtualScene) {
+                    camera.update(gl, virtualScene);
+                    count++;
+                }
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsEnvironmentPortal, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.7", type: NgtsEnvironmentPortal, isStandalone: true, selector: "ngts-environment-portal", ngImport: i0, template: `
+		<ngt-portal [container]="virtualSceneRef">
+			<ng-template ngtPortalContent>
+				<ng-content />
+				<ngt-cube-camera *args="cameraArgs()" [ref]="cubeCameraRef" />
+				<ng-container *ngIf="environmentInput.files() || environmentInput.preset(); else environmentMap">
+					<ngts-environment-cube [background]="true" />
+				</ng-container>
+				<ng-template #environmentMap>
+					<ngts-environment-map *ngIf="environmentInput.map() as map" [background]="true" [map]="map" />
+				</ng-template>
+			</ng-template>
+		</ngt-portal>
+	`, isInline: true, dependencies: [{ kind: "component", type: NgtPortal, selector: "ngt-portal", inputs: ["container", "state", "autoRender", "autoRenderPriority"], outputs: ["beforeRender"] }, { kind: "directive", type: NgtPortalContent, selector: "ng-template[ngtPortalContent]" }, { kind: "directive", type: NgtsEnvironmentMap, selector: "ngts-environment-map", inputs: ["map", "background"] }, { kind: "directive", type: NgtsEnvironmentCube, selector: "ngts-environment-cube", inputs: ["background"] }, { kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: NgtArgs, selector: "ng-template[args]", inputs: ["args"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsEnvironmentPortal, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-environment-portal',
+                    standalone: true,
+                    template: `
+		<ngt-portal [container]="virtualSceneRef">
+			<ng-template ngtPortalContent>
+				<ng-content />
+				<ngt-cube-camera *args="cameraArgs()" [ref]="cubeCameraRef" />
+				<ng-container *ngIf="environmentInput.files() || environmentInput.preset(); else environmentMap">
+					<ngts-environment-cube [background]="true" />
+				</ng-container>
+				<ng-template #environmentMap>
+					<ngts-environment-map *ngIf="environmentInput.map() as map" [background]="true" [map]="map" />
+				</ng-template>
+			</ng-template>
+		</ngt-portal>
+	`,
+                    imports: [NgtPortal, NgtPortalContent, NgtsEnvironmentMap, NgtsEnvironmentCube, NgIf, NgtArgs],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"environment-portal.js","sourceRoot":"","sources":["../../../../../../libs/soba/staging/src/environment/environment-portal.ts"],"names":[],"mappings":"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","sourcesContent":["import { NgIf } from '@angular/common';\nimport { Component, computed, CUSTOM_ELEMENTS_SCHEMA, effect, inject } from '@angular/core';\nimport {\n\textend,\n\tinjectBeforeRender,\n\tinjectNgtRef,\n\tinjectNgtStore,\n\tNgtArgs,\n\tNgtPortal,\n\tNgtPortalContent,\n\tprepare,\n} from 'angular-three';\nimport * as THREE from 'three';\nimport { CubeCamera } from 'three';\nimport { NgtsEnvironmentCube } from './environment-cube';\nimport { NgtsEnvironmentInput } from './environment-input';\nimport { NgtsEnvironmentMap } from './environment-map';\nimport { setEnvProps } from './utils';\n\nextend({ CubeCamera });\n\n@Component({\n\tselector: 'ngts-environment-portal',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-portal [container]=\"virtualSceneRef\">\n\t\t\t<ng-template ngtPortalContent>\n\t\t\t\t<ng-content />\n\t\t\t\t<ngt-cube-camera *args=\"cameraArgs()\" [ref]=\"cubeCameraRef\" />\n\t\t\t\t<ng-container *ngIf=\"environmentInput.files() || environmentInput.preset(); else environmentMap\">\n\t\t\t\t\t<ngts-environment-cube [background]=\"true\" />\n\t\t\t\t</ng-container>\n\t\t\t\t<ng-template #environmentMap>\n\t\t\t\t\t<ngts-environment-map *ngIf=\"environmentInput.map() as map\" [background]=\"true\" [map]=\"map\" />\n\t\t\t\t</ng-template>\n\t\t\t</ng-template>\n\t\t</ngt-portal>\n\t`,\n\timports: [NgtPortal, NgtPortalContent, NgtsEnvironmentMap, NgtsEnvironmentCube, NgIf, NgtArgs],\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsEnvironmentPortal {\n\tenvironmentInput = inject(NgtsEnvironmentInput);\n\tprivate store = injectNgtStore();\n\tprivate gl = this.store.select('gl');\n\tprivate scene = this.store.select('scene');\n\n\tvirtualSceneRef = injectNgtRef<THREE.Scene>(prepare(new THREE.Scene()));\n\tcubeCameraRef = injectNgtRef<THREE.CubeCamera>();\n\n\tprivate fbo = computed(() => {\n\t\tconst fbo = new THREE.WebGLCubeRenderTarget(this.environmentInput.resolution());\n\t\tfbo.texture.type = THREE.HalfFloatType;\n\t\treturn fbo;\n\t});\n\tcameraArgs = computed(() => [this.environmentInput.near()!, this.environmentInput.far()!, this.fbo()]);\n\n\tconstructor() {\n\t\teffect(() => {\n\t\t\tthis.environmentInput.inputs.patch({\n\t\t\t\tnear: 1,\n\t\t\t\tfar: 1000,\n\t\t\t\tresolution: 256,\n\t\t\t\tframes: 1,\n\t\t\t\tbackground: false,\n\t\t\t\tpreset: undefined,\n\t\t\t});\n\t\t});\n\t\tthis.setEnvProps();\n\t\tthis.beforeRender();\n\t}\n\n\tprivate setEnvProps() {\n\t\teffect((onCleanup) => {\n\t\t\tconst [virtualScene, blur, frames, background, scene, fbo, defaultScene, gl, cubeCamera] = [\n\t\t\t\tthis.virtualSceneRef.nativeElement,\n\t\t\t\tthis.environmentInput.blur(),\n\t\t\t\tthis.environmentInput.frames(),\n\t\t\t\tthis.environmentInput.background(),\n\t\t\t\tthis.environmentInput.scene(),\n\t\t\t\tthis.fbo(),\n\t\t\t\tthis.scene(),\n\t\t\t\tthis.gl(),\n\t\t\t\tthis.cubeCameraRef.nativeElement,\n\t\t\t];\n\t\t\tif (!cubeCamera || !virtualScene) return;\n\t\t\tif (frames === 1) cubeCamera.update(gl, virtualScene);\n\t\t\tconst cleanUp = setEnvProps(background!, scene, defaultScene, fbo.texture, blur);\n\t\t\tonCleanup(cleanUp);\n\t\t});\n\t}\n\n\tprivate beforeRender() {\n\t\tlet count = 1;\n\t\tinjectBeforeRender(({ gl }) => {\n\t\t\tconst { frames } = this.environmentInput.inputs.get();\n\t\t\tif (frames === Infinity || count < frames!) {\n\t\t\t\tconst camera = this.cubeCameraRef.nativeElement;\n\t\t\t\tconst virtualScene = this.virtualSceneRef.nativeElement;\n\t\t\t\tif (camera && virtualScene) {\n\t\t\t\t\tcamera.update(gl, virtualScene);\n\t\t\t\t\tcount++;\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\t}\n}\n"]}

package/esm2022/staging/environment/environment.mjs

@@ -0,0 +1,61 @@
+import { NgIf, NgTemplateOutlet } from '@angular/common';
+import { CUSTOM_ELEMENTS_SCHEMA, Component, ContentChild, TemplateRef } from '@angular/core';
+import { NgtsSobaContent } from 'angular-three-soba/utils';
+import { NgtsEnvironmentCube } from './environment-cube';
+import { NgtsEnvironmentGround } from './environment-ground';
+import { NgtsEnvironmentInput } from './environment-input';
+import { NgtsEnvironmentMap } from './environment-map';
+import { NgtsEnvironmentPortal } from './environment-portal';
+import * as i0 from "@angular/core";
+export class NgtsEnvironment extends NgtsEnvironmentInput {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsEnvironment, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.7", type: NgtsEnvironment, isStandalone: true, selector: "ngts-environment", providers: [{ provide: NgtsEnvironmentInput, useExisting: NgtsEnvironment }], queries: [{ propertyName: "content", first: true, predicate: NgtsSobaContent, descendants: true, read: TemplateRef }], usesInheritance: true, ngImport: i0, template: `
+		<ngts-environment-ground *ngIf="ground(); else noGround" />
+		<ng-template #noGround>
+			<ngts-environment-map *ngIf="map() as map; else noMap" [map]="map" [background]="!!background()" />
+			<ng-template #noMap>
+				<ngts-environment-portal *ngIf="content; else noPortal">
+					<ng-container *ngTemplateOutlet="content" />
+				</ngts-environment-portal>
+				<ng-template #noPortal>
+					<ngts-environment-cube [background]="!!background()" />
+				</ng-template>
+			</ng-template>
+		</ng-template>
+	`, isInline: true, dependencies: [{ kind: "directive", type: NgtsEnvironmentMap, selector: "ngts-environment-map", inputs: ["map", "background"] }, { kind: "component", type: NgtsEnvironmentGround, selector: "ngts-environment-ground" }, { kind: "directive", type: NgtsEnvironmentCube, selector: "ngts-environment-cube", inputs: ["background"] }, { kind: "component", type: NgtsEnvironmentPortal, selector: "ngts-environment-portal" }, { 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: "16.1.7", ngImport: i0, type: NgtsEnvironment, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-environment',
+                    standalone: true,
+                    template: `
+		<ngts-environment-ground *ngIf="ground(); else noGround" />
+		<ng-template #noGround>
+			<ngts-environment-map *ngIf="map() as map; else noMap" [map]="map" [background]="!!background()" />
+			<ng-template #noMap>
+				<ngts-environment-portal *ngIf="content; else noPortal">
+					<ng-container *ngTemplateOutlet="content" />
+				</ngts-environment-portal>
+				<ng-template #noPortal>
+					<ngts-environment-cube [background]="!!background()" />
+				</ng-template>
+			</ng-template>
+		</ng-template>
+	`,
+                    imports: [
+                        NgtsEnvironmentMap,
+                        NgtsEnvironmentGround,
+                        NgtsEnvironmentCube,
+                        NgtsEnvironmentPortal,
+                        NgIf,
+                        NgTemplateOutlet,
+                    ],
+                    providers: [{ provide: NgtsEnvironmentInput, useExisting: NgtsEnvironment }],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], propDecorators: { content: [{
+                type: ContentChild,
+                args: [NgtsSobaContent, { read: TemplateRef }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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