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

package/esm2022/staging/environment/assets.mjs

@@ -0,0 +1,13 @@
+export const ngtsEnvironmentPresetsObj = {
+    sunset: 'venice/venice_sunset_1k.hdr',
+    dawn: 'kiara/kiara_1_dawn_1k.hdr',
+    night: 'dikhololo/dikhololo_night_1k.hdr',
+    warehouse: 'empty-wharehouse/empty_warehouse_01_1k.hdr',
+    forest: 'forrest-slope/forest_slope_1k.hdr',
+    apartment: 'lebombo/lebombo_1k.hdr',
+    studio: 'studio-small-3/studio_small_03_1k.hdr',
+    city: 'potsdamer-platz/potsdamer_platz_1k.hdr',
+    park: 'rooitou/rooitou_park_1k.hdr',
+    lobby: 'st-fagans/st_fagans_interior_1k.hdr',
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXNzZXRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9zb2JhL3N0YWdpbmcvc3JjL2Vudmlyb25tZW50L2Fzc2V0cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQUMsTUFBTSx5QkFBeUIsR0FBRztJQUNyQyxNQUFNLEVBQUUsNkJBQTZCO0lBQ3JDLElBQUksRUFBRSwyQkFBMkI7SUFDakMsS0FBSyxFQUFFLGtDQUFrQztJQUN6QyxTQUFTLEVBQUUsNENBQTRDO0lBQ3ZELE1BQU0sRUFBRSxtQ0FBbUM7SUFDM0MsU0FBUyxFQUFFLHdCQUF3QjtJQUNuQyxNQUFNLEVBQUUsdUNBQXVDO0lBQy9DLElBQUksRUFBRSx3Q0FBd0M7SUFDOUMsSUFBSSxFQUFFLDZCQUE2QjtJQUNuQyxLQUFLLEVBQUUscUNBQXFDO0NBQy9DLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY29uc3Qgbmd0c0Vudmlyb25tZW50UHJlc2V0c09iaiA9IHtcbiAgICBzdW5zZXQ6ICd2ZW5pY2UvdmVuaWNlX3N1bnNldF8xay5oZHInLFxuICAgIGRhd246ICdraWFyYS9raWFyYV8xX2Rhd25fMWsuaGRyJyxcbiAgICBuaWdodDogJ2Rpa2hvbG9sby9kaWtob2xvbG9fbmlnaHRfMWsuaGRyJyxcbiAgICB3YXJlaG91c2U6ICdlbXB0eS13aGFyZWhvdXNlL2VtcHR5X3dhcmVob3VzZV8wMV8xay5oZHInLFxuICAgIGZvcmVzdDogJ2ZvcnJlc3Qtc2xvcGUvZm9yZXN0X3Nsb3BlXzFrLmhkcicsXG4gICAgYXBhcnRtZW50OiAnbGVib21iby9sZWJvbWJvXzFrLmhkcicsXG4gICAgc3R1ZGlvOiAnc3R1ZGlvLXNtYWxsLTMvc3R1ZGlvX3NtYWxsXzAzXzFrLmhkcicsXG4gICAgY2l0eTogJ3BvdHNkYW1lci1wbGF0ei9wb3RzZGFtZXJfcGxhdHpfMWsuaGRyJyxcbiAgICBwYXJrOiAncm9vaXRvdS9yb29pdG91X3BhcmtfMWsuaGRyJyxcbiAgICBsb2JieTogJ3N0LWZhZ2Fucy9zdF9mYWdhbnNfaW50ZXJpb3JfMWsuaGRyJyxcbn07XG5cbmV4cG9ydCB0eXBlIE5ndHNFbnZpcm9ubWVudFByZXNldHNUeXBlID0ga2V5b2YgdHlwZW9mIG5ndHNFbnZpcm9ubWVudFByZXNldHNPYmo7XG4iXX0=

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

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

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

@@ -0,0 +1,43 @@
+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 });
+class NgtsEnvironmentGround {
+    constructor() {
+        this.environmentInput = inject(NgtsEnvironmentInput);
+        this.#defaultTexture = injectNgtsEnvironment(this.environmentInput.environmentParams);
+        this.texture = computed(() => {
+            const defaultTexture = this.#defaultTexture.nativeElement;
+            return this.environmentInput.environmentMap() || defaultTexture;
+        });
+        this.groundArgs = computed(() => (this.texture() ? [this.texture()] : []));
+        this.height = computed(() => this.environmentInput.environmentGround()?.height);
+        this.radius = computed(() => this.environmentInput.environmentGround()?.radius);
+        this.scale = computed(() => this.environmentInput.environmentGround()?.scale ?? 1000);
+    }
+    #defaultTexture;
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsEnvironmentGround, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: NgtsEnvironmentGround, isStandalone: true, selector: "ngts-environment-ground", ngImport: i0, template: `
+        <ngts-environment-map [map]="texture()" [background]="!!environmentInput.environmentBackground()" />
+        <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: "[args]", inputs: ["args"] }] }); }
+}
+export { NgtsEnvironmentGround };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsEnvironmentGround, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-environment-ground',
+                    standalone: true,
+                    template: `
+        <ngts-environment-map [map]="texture()" [background]="!!environmentInput.environmentBackground()" />
+        <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,106 @@
+import { Directive, Input, computed } from '@angular/core';
+import { NgtSignalStore } from 'angular-three';
+import * as i0 from "@angular/core";
+class NgtsEnvironmentInput extends NgtSignalStore {
+    constructor() {
+        super(...arguments);
+        this.environmentFrames = this.select('frames');
+        this.environmentNear = this.select('near');
+        this.environmentFar = this.select('far');
+        this.environmentResolution = this.select('resolution');
+        this.environmentBackground = this.select('background');
+        this.environmentBlur = this.select('blur');
+        this.environmentMap = this.select('map');
+        this.environmentFiles = this.select('files');
+        this.environmentPath = this.select('path');
+        this.environmentPreset = this.select('preset');
+        this.environmentScene = this.select('scene');
+        this.environmentExtensions = this.select('extensions');
+        this.environmentGround = this.select('ground');
+        this.environmentEncoding = this.select('encoding');
+        this.environmentParams = computed(() => ({
+            files: this.environmentFiles(),
+            path: this.environmentPath(),
+            preset: this.environmentPreset(),
+            extensions: this.environmentExtensions(),
+            encoding: this.environmentEncoding(),
+        }));
+    }
+    set frames(frames) {
+        this.set({ frames });
+    }
+    set near(near) {
+        this.set({ near });
+    }
+    set far(far) {
+        this.set({ far });
+    }
+    set resolution(resolution) {
+        this.set({ resolution });
+    }
+    set background(background) {
+        this.set({ background });
+    }
+    set blur(blur) {
+        this.set({ blur });
+    }
+    set map(map) {
+        this.set({ map });
+    }
+    set files(files) {
+        this.set({ files });
+    }
+    set path(path) {
+        this.set({ path });
+    }
+    set preset(preset) {
+        this.set({ preset });
+    }
+    set scene(scene) {
+        this.set({ scene });
+    }
+    set extensions(extensions) {
+        this.set({ extensions });
+    }
+    set ground(ground) {
+        this.set({ ground });
+    }
+    set encoding(encoding) {
+        this.set({ encoding });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsEnvironmentInput, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: NgtsEnvironmentInput, inputs: { frames: "frames", near: "near", far: "far", resolution: "resolution", background: "background", blur: "blur", map: "map", files: "files", path: "path", preset: "preset", scene: "scene", extensions: "extensions", ground: "ground", encoding: "encoding" }, usesInheritance: true, ngImport: i0 }); }
+}
+export { NgtsEnvironmentInput };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsEnvironmentInput, decorators: [{
+            type: Directive
+        }], propDecorators: { frames: [{
+                type: Input
+            }], near: [{
+                type: Input
+            }], far: [{
+                type: Input
+            }], resolution: [{
+                type: Input
+            }], background: [{
+                type: Input
+            }], blur: [{
+                type: Input
+            }], map: [{
+                type: Input
+            }], files: [{
+                type: Input
+            }], path: [{
+                type: Input
+            }], preset: [{
+                type: Input
+            }], scene: [{
+                type: Input
+            }], extensions: [{
+                type: Input
+            }], ground: [{
+                type: Input
+            }], encoding: [{
+                type: Input
+            }] } });
+//# 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 { NgtSignalStore } from 'angular-three';\nimport { Loader, Scene, Texture, TextureEncoding } from 'three';\nimport { NgtsEnvironmentPresetsType } from './assets';\n\nexport interface NgtsEnvironmentInputState {\n    frames?: number;\n    near?: number;\n    far?: number;\n    resolution?: number;\n    background?: boolean | 'only';\n    blur?: number;\n    map?: Texture;\n    files?: string | string[];\n    path?: string;\n    preset?: NgtsEnvironmentPresetsType;\n    scene?: Scene | ElementRef<Scene>;\n    extensions?: (loader: Loader) => void;\n    ground?: boolean | { radius?: number; height?: number; scale?: number };\n    encoding?: TextureEncoding;\n}\n\n@Directive()\nexport abstract class NgtsEnvironmentInput extends NgtSignalStore<NgtsEnvironmentInputState> {\n    @Input() set frames(frames: NgtsEnvironmentInputState['frames']) {\n        this.set({ frames });\n    }\n\n    @Input() set near(near: NgtsEnvironmentInputState['near']) {\n        this.set({ near });\n    }\n\n    @Input() set far(far: NgtsEnvironmentInputState['far']) {\n        this.set({ far });\n    }\n\n    @Input() set resolution(resolution: NgtsEnvironmentInputState['resolution']) {\n        this.set({ resolution });\n    }\n\n    @Input() set background(background: NgtsEnvironmentInputState['background']) {\n        this.set({ background });\n    }\n\n    @Input() set blur(blur: NgtsEnvironmentInputState['blur']) {\n        this.set({ blur });\n    }\n\n    @Input() set map(map: NgtsEnvironmentInputState['map']) {\n        this.set({ map });\n    }\n\n    @Input() set files(files: NgtsEnvironmentInputState['files']) {\n        this.set({ files });\n    }\n\n    @Input() set path(path: NgtsEnvironmentInputState['path']) {\n        this.set({ path });\n    }\n\n    @Input() set preset(preset: NgtsEnvironmentInputState['preset']) {\n        this.set({ preset });\n    }\n\n    @Input() set scene(scene: NgtsEnvironmentInputState['scene']) {\n        this.set({ scene });\n    }\n\n    @Input() set extensions(extensions: NgtsEnvironmentInputState['extensions']) {\n        this.set({ extensions });\n    }\n\n    @Input() set ground(ground: NgtsEnvironmentInputState['ground']) {\n        this.set({ ground });\n    }\n\n    @Input() set encoding(encoding: NgtsEnvironmentInputState['encoding']) {\n        this.set({ encoding });\n    }\n\n    readonly environmentFrames = this.select('frames');\n    readonly environmentNear = this.select('near');\n    readonly environmentFar = this.select('far');\n    readonly environmentResolution = this.select('resolution');\n    readonly environmentBackground = this.select('background');\n    readonly environmentBlur = this.select('blur');\n    readonly environmentMap = this.select('map');\n    readonly environmentFiles = this.select('files');\n    readonly environmentPath = this.select('path');\n    readonly environmentPreset = this.select('preset');\n    readonly environmentScene = this.select('scene');\n    readonly environmentExtensions = this.select('extensions');\n    readonly environmentGround = this.select('ground');\n    readonly environmentEncoding = this.select('encoding');\n\n    readonly environmentParams = computed(() => ({\n        files: this.environmentFiles(),\n        path: this.environmentPath(),\n        preset: this.environmentPreset(),\n        extensions: this.environmentExtensions(),\n        encoding: this.environmentEncoding(),\n    }));\n}\n"]}

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

@@ -0,0 +1,53 @@
+import { Directive, Input, computed, effect, inject } from '@angular/core';
+import { NgtStore, requestAnimationInInjectionContext } from 'angular-three';
+import { NgtsEnvironmentInput } from './environment-input';
+import { setEnvProps } from './utils';
+import * as i0 from "@angular/core";
+class NgtsEnvironmentMap {
+    #store;
+    set map(map) {
+        this.environmentInput.set({ map });
+    }
+    set background(background) {
+        this.environmentInput.set({ background });
+    }
+    constructor() {
+        this.environmentInput = inject(NgtsEnvironmentInput);
+        this.#store = inject(NgtStore);
+        this.environmentInput.patch({ background: false });
+        requestAnimationInInjectionContext(() => {
+            this.#setEnvProps();
+        });
+    }
+    #setEnvProps() {
+        const scene = this.#store.select('scene');
+        const trigger = computed(() => ({
+            defaultScene: scene(),
+            scene: this.environmentInput.environmentScene(),
+            background: this.environmentInput.environmentBackground(),
+            blur: this.environmentInput.environmentBlur(),
+            texture: this.environmentInput.environmentMap(),
+        }));
+        effect((onCleanup) => {
+            const { background, defaultScene, scene, blur, texture } = trigger();
+            if (!texture)
+                return;
+            onCleanup(setEnvProps(background, scene, defaultScene, texture, blur));
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsEnvironmentMap, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: NgtsEnvironmentMap, isStandalone: true, selector: "ngts-environment-map", inputs: { map: "map", background: "background" }, ngImport: i0 }); }
+}
+export { NgtsEnvironmentMap };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsEnvironmentMap, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'ngts-environment-map',
+                    standalone: true,
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { map: [{
+                type: Input
+            }], background: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW52aXJvbm1lbnQtbWFwLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9zb2JhL3N0YWdpbmcvc3JjL2Vudmlyb25tZW50L2Vudmlyb25tZW50LW1hcC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLEtBQUssRUFBRSxRQUFRLEVBQUUsTUFBTSxFQUFFLE1BQU0sRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMzRSxPQUFPLEVBQUUsUUFBUSxFQUFFLGtDQUFrQyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzdFLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQzNELE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxTQUFTLENBQUM7O0FBRXRDLE1BSWEsa0JBQWtCO0lBRWxCLE1BQU0sQ0FBb0I7SUFFbkMsSUFBYSxHQUFHLENBQUMsR0FBa0I7UUFDL0IsSUFBSSxDQUFDLGdCQUFnQixDQUFDLEdBQUcsQ0FBQyxFQUFFLEdBQUcsRUFBRSxDQUFDLENBQUM7SUFDdkMsQ0FBQztJQUVELElBQWEsVUFBVSxDQUFDLFVBQW1CO1FBQ3ZDLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxHQUFHLENBQUMsRUFBRSxVQUFVLEVBQUUsQ0FBQyxDQUFDO0lBQzlDLENBQUM7SUFFRDtRQVhtQixxQkFBZ0IsR0FBRyxNQUFNLENBQUMsb0JBQW9CLENBQUMsQ0FBQztRQUMxRCxXQUFNLEdBQUcsTUFBTSxDQUFDLFFBQVEsQ0FBQyxDQUFDO1FBVy9CLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxLQUFLLENBQUMsRUFBRSxVQUFVLEVBQUUsS0FBSyxFQUFFLENBQUMsQ0FBQztRQUNuRCxrQ0FBa0MsQ0FBQyxHQUFHLEVBQUU7WUFDcEMsSUFBSSxDQUFDLFlBQVksRUFBRSxDQUFDO1FBQ3hCLENBQUMsQ0FBQyxDQUFDO0lBQ1AsQ0FBQztJQUVELFlBQVk7UUFDUixNQUFNLEtBQUssR0FBRyxJQUFJLENBQUMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUMxQyxNQUFNLE9BQU8sR0FBRyxRQUFRLENBQUMsR0FBRyxFQUFFLENBQUMsQ0FBQztZQUM1QixZQUFZLEVBQUUsS0FBSyxFQUFFO1lBQ3JCLEtBQUssRUFBRSxJQUFJLENBQUMsZ0JBQWdCLENBQUMsZ0JBQWdCLEVBQUU7WUFDL0MsVUFBVSxFQUFFLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxxQkFBcUIsRUFBRTtZQUN6RCxJQUFJLEVBQUUsSUFBSSxDQUFDLGdCQUFnQixDQUFDLGVBQWUsRUFBRTtZQUM3QyxPQUFPLEVBQUUsSUFBSSxDQUFDLGdCQUFnQixDQUFDLGNBQWMsRUFBRTtTQUNsRCxDQUFDLENBQUMsQ0FBQztRQUVKLE1BQU0sQ0FBQyxDQUFDLFNBQVMsRUFBRSxFQUFFO1lBQ2pCLE1BQU0sRUFBRSxVQUFVLEVBQUUsWUFBWSxFQUFFLEtBQUssRUFBRSxJQUFJLEVBQUUsT0FBTyxFQUFFLEdBQUcsT0FBTyxFQUFFLENBQUM7WUFDckUsSUFBSSxDQUFDLE9BQU87Z0JBQUUsT0FBTztZQUNyQixTQUFTLENBQUMsV0FBVyxDQUFDLFVBQVcsRUFBRSxLQUFLLEVBQUUsWUFBWSxFQUFFLE9BQU8sRUFBRSxJQUFJLENBQUMsQ0FBQyxDQUFDO1FBQzVFLENBQUMsQ0FBQyxDQUFDO0lBQ1AsQ0FBQzs4R0FsQ1Esa0JBQWtCO2tHQUFsQixrQkFBa0I7O1NBQWxCLGtCQUFrQjsyRkFBbEIsa0JBQWtCO2tCQUo5QixTQUFTO21CQUFDO29CQUNQLFFBQVEsRUFBRSxzQkFBc0I7b0JBQ2hDLFVBQVUsRUFBRSxJQUFJO2lCQUNuQjswRUFLZ0IsR0FBRztzQkFBZixLQUFLO2dCQUlPLFVBQVU7c0JBQXRCLEtBQUsiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIElucHV0LCBjb21wdXRlZCwgZWZmZWN0LCBpbmplY3QgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IE5ndFN0b3JlLCByZXF1ZXN0QW5pbWF0aW9uSW5JbmplY3Rpb25Db250ZXh0IH0gZnJvbSAnYW5ndWxhci10aHJlZSc7XG5pbXBvcnQgeyBOZ3RzRW52aXJvbm1lbnRJbnB1dCB9IGZyb20gJy4vZW52aXJvbm1lbnQtaW5wdXQnO1xuaW1wb3J0IHsgc2V0RW52UHJvcHMgfSBmcm9tICcuL3V0aWxzJztcblxuQERpcmVjdGl2ZSh7XG4gICAgc2VsZWN0b3I6ICduZ3RzLWVudmlyb25tZW50LW1hcCcsXG4gICAgc3RhbmRhbG9uZTogdHJ1ZSxcbn0pXG5leHBvcnQgY2xhc3MgTmd0c0Vudmlyb25tZW50TWFwIHtcbiAgICBwcm90ZWN0ZWQgcmVhZG9ubHkgZW52aXJvbm1lbnRJbnB1dCA9IGluamVjdChOZ3RzRW52aXJvbm1lbnRJbnB1dCk7XG4gICAgcmVhZG9ubHkgI3N0b3JlID0gaW5qZWN0KE5ndFN0b3JlKTtcblxuICAgIEBJbnB1dCgpIHNldCBtYXAobWFwOiBUSFJFRS5UZXh0dXJlKSB7XG4gICAgICAgIHRoaXMuZW52aXJvbm1lbnRJbnB1dC5zZXQoeyBtYXAgfSk7XG4gICAgfVxuXG4gICAgQElucHV0KCkgc2V0IGJhY2tncm91bmQoYmFja2dyb3VuZDogYm9vbGVhbikge1xuICAgICAgICB0aGlzLmVudmlyb25tZW50SW5wdXQuc2V0KHsgYmFja2dyb3VuZCB9KTtcbiAgICB9XG5cbiAgICBjb25zdHJ1Y3RvcigpIHtcbiAgICAgICAgdGhpcy5lbnZpcm9ubWVudElucHV0LnBhdGNoKHsgYmFja2dyb3VuZDogZmFsc2UgfSk7XG4gICAgICAgIHJlcXVlc3RBbmltYXRpb25JbkluamVjdGlvbkNvbnRleHQoKCkgPT4ge1xuICAgICAgICAgICAgdGhpcy4jc2V0RW52UHJvcHMoKTtcbiAgICAgICAgfSk7XG4gICAgfVxuXG4gICAgI3NldEVudlByb3BzKCkge1xuICAgICAgICBjb25zdCBzY2VuZSA9IHRoaXMuI3N0b3JlLnNlbGVjdCgnc2NlbmUnKTtcbiAgICAgICAgY29uc3QgdHJpZ2dlciA9IGNvbXB1dGVkKCgpID0+ICh7XG4gICAgICAgICAgICBkZWZhdWx0U2NlbmU6IHNjZW5lKCksXG4gICAgICAgICAgICBzY2VuZTogdGhpcy5lbnZpcm9ubWVudElucHV0LmVudmlyb25tZW50U2NlbmUoKSxcbiAgICAgICAgICAgIGJhY2tncm91bmQ6IHRoaXMuZW52aXJvbm1lbnRJbnB1dC5lbnZpcm9ubWVudEJhY2tncm91bmQoKSxcbiAgICAgICAgICAgIGJsdXI6IHRoaXMuZW52aXJvbm1lbnRJbnB1dC5lbnZpcm9ubWVudEJsdXIoKSxcbiAgICAgICAgICAgIHRleHR1cmU6IHRoaXMuZW52aXJvbm1lbnRJbnB1dC5lbnZpcm9ubWVudE1hcCgpLFxuICAgICAgICB9KSk7XG5cbiAgICAgICAgZWZmZWN0KChvbkNsZWFudXApID0+IHtcbiAgICAgICAgICAgIGNvbnN0IHsgYmFja2dyb3VuZCwgZGVmYXVsdFNjZW5lLCBzY2VuZSwgYmx1ciwgdGV4dHVyZSB9ID0gdHJpZ2dlcigpO1xuICAgICAgICAgICAgaWYgKCF0ZXh0dXJlKSByZXR1cm47XG4gICAgICAgICAgICBvbkNsZWFudXAoc2V0RW52UHJvcHMoYmFja2dyb3VuZCEsIHNjZW5lLCBkZWZhdWx0U2NlbmUsIHRleHR1cmUsIGJsdXIpKTtcbiAgICAgICAgfSk7XG4gICAgfVxufVxuIl19

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

@@ -0,0 +1,135 @@
+import { NgIf } from '@angular/common';
+import { Component, computed, CUSTOM_ELEMENTS_SCHEMA, effect, inject } from '@angular/core';
+import { extend, injectBeforeRender, injectNgtRef, NgtArgs, NgtPortal, NgtPortalContent, NgtStore, prepare, requestAnimationInInjectionContext, } 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 });
+class NgtsEnvironmentPortal {
+    #store;
+    #fbo;
+    constructor() {
+        this.environmentInput = inject(NgtsEnvironmentInput);
+        this.#store = inject(NgtStore);
+        this.virtualSceneRef = injectNgtRef(prepare(new THREE.Scene()));
+        this.cubeCameraRef = injectNgtRef();
+        this.#fbo = computed(() => {
+            const fbo = new THREE.WebGLCubeRenderTarget(this.environmentInput.environmentResolution());
+            fbo.texture.type = THREE.HalfFloatType;
+            return fbo;
+        });
+        this.cameraArgs = computed(() => [
+            this.environmentInput.environmentNear(),
+            this.environmentInput.environmentFar(),
+            this.#fbo(),
+        ]);
+        this.environmentInput.patch({
+            near: 1,
+            far: 1000,
+            resolution: 256,
+            frames: 1,
+            background: false,
+            preset: undefined,
+        });
+        requestAnimationInInjectionContext(() => {
+            this.#setEnvProps();
+        });
+        injectBeforeRender(this.#onBeforeRender.bind(this, 1));
+    }
+    #setEnvProps() {
+        const gl = this.#store.select('gl');
+        const scene = this.#store.select('scene');
+        const trigger = computed(() => ({
+            gl: gl(),
+            defaultScene: scene(),
+            fbo: this.#fbo(),
+            scene: this.environmentInput.environmentScene(),
+            background: this.environmentInput.environmentBackground(),
+            frames: this.environmentInput.environmentFrames(),
+            blur: this.environmentInput.environmentBlur(),
+            virtualScene: this.virtualSceneRef.nativeElement,
+            cubeCamera: this.cubeCameraRef.nativeElement,
+        }));
+        effect((onCleanup) => {
+            const { virtualScene, blur, frames, background, scene, fbo, defaultScene, gl, cubeCamera } = trigger();
+            if (!cubeCamera || !virtualScene)
+                return;
+            if (frames === 1)
+                cubeCamera.update(gl, virtualScene);
+            onCleanup(setEnvProps(background, scene, defaultScene, fbo.texture, blur));
+        });
+    }
+    #onBeforeRender(count, { gl }) {
+        const { frames } = this.environmentInput.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.0.0", ngImport: i0, type: NgtsEnvironmentPortal, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", 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.environmentFiles() || environmentInput.environmentPreset();
+                        else environmentMap
+                    "
+                >
+                    <ngts-environment-cube [background]="true" />
+                </ng-container>
+                <ng-template #environmentMap>
+                    <ngts-environment-map
+                        *ngIf="environmentInput.environmentMap() 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: "[args]", inputs: ["args"] }] }); }
+}
+export { NgtsEnvironmentPortal };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", 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.environmentFiles() || environmentInput.environmentPreset();
+                        else environmentMap
+                    "
+                >
+                    <ngts-environment-cube [background]="true" />
+                </ng-container>
+                <ng-template #environmentMap>
+                    <ngts-environment-map
+                        *ngIf="environmentInput.environmentMap() 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    extend,\n    injectBeforeRender,\n    injectNgtRef,\n    NgtArgs,\n    NgtPortal,\n    NgtPortalContent,\n    NgtRenderState,\n    NgtStore,\n    prepare,\n    requestAnimationInInjectionContext,\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    selector: 'ngts-environment-portal',\n    standalone: true,\n    template: `\n        <ngt-portal [container]=\"virtualSceneRef\">\n            <ng-template ngtPortalContent>\n                <ng-content />\n                <ngt-cube-camera *args=\"cameraArgs()\" [ref]=\"cubeCameraRef\" />\n                <ng-container\n                    *ngIf=\"\n                        environmentInput.environmentFiles() || environmentInput.environmentPreset();\n                        else environmentMap\n                    \"\n                >\n                    <ngts-environment-cube [background]=\"true\" />\n                </ng-container>\n                <ng-template #environmentMap>\n                    <ngts-environment-map\n                        *ngIf=\"environmentInput.environmentMap() as map\"\n                        [background]=\"true\"\n                        [map]=\"map\"\n                    />\n                </ng-template>\n            </ng-template>\n        </ngt-portal>\n    `,\n    imports: [NgtPortal, NgtPortalContent, NgtsEnvironmentMap, NgtsEnvironmentCube, NgIf, NgtArgs],\n    schemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsEnvironmentPortal {\n    protected readonly environmentInput = inject(NgtsEnvironmentInput);\n    readonly #store = inject(NgtStore);\n\n    readonly virtualSceneRef = injectNgtRef<THREE.Scene>(prepare(new THREE.Scene()));\n    readonly cubeCameraRef = injectNgtRef<THREE.CubeCamera>();\n\n    readonly #fbo = computed(() => {\n        const fbo = new THREE.WebGLCubeRenderTarget(this.environmentInput.environmentResolution());\n        fbo.texture.type = THREE.HalfFloatType;\n        return fbo;\n    });\n    readonly cameraArgs = computed(() => [\n        this.environmentInput.environmentNear()!,\n        this.environmentInput.environmentFar()!,\n        this.#fbo(),\n    ]);\n\n    constructor() {\n        this.environmentInput.patch({\n            near: 1,\n            far: 1000,\n            resolution: 256,\n            frames: 1,\n            background: false,\n            preset: undefined,\n        });\n        requestAnimationInInjectionContext(() => {\n            this.#setEnvProps();\n        });\n        injectBeforeRender(this.#onBeforeRender.bind(this, 1));\n    }\n\n    #setEnvProps() {\n        const gl = this.#store.select('gl');\n        const scene = this.#store.select('scene');\n\n        const trigger = computed(() => ({\n            gl: gl(),\n            defaultScene: scene(),\n            fbo: this.#fbo(),\n            scene: this.environmentInput.environmentScene(),\n            background: this.environmentInput.environmentBackground(),\n            frames: this.environmentInput.environmentFrames(),\n            blur: this.environmentInput.environmentBlur(),\n            virtualScene: this.virtualSceneRef.nativeElement,\n            cubeCamera: this.cubeCameraRef.nativeElement,\n        }));\n\n        effect((onCleanup) => {\n            const { virtualScene, blur, frames, background, scene, fbo, defaultScene, gl, cubeCamera } = trigger();\n            if (!cubeCamera || !virtualScene) return;\n            if (frames === 1) cubeCamera.update(gl, virtualScene);\n            onCleanup(setEnvProps(background!, scene, defaultScene, fbo.texture, blur));\n        });\n    }\n\n    #onBeforeRender(count: number, { gl }: NgtRenderState) {\n        const { frames } = this.environmentInput.get();\n        if (frames === Infinity || count < frames!) {\n            const camera = this.cubeCameraRef.nativeElement;\n            const virtualScene = this.virtualSceneRef.nativeElement;\n            if (camera && virtualScene) {\n                camera.update(gl, virtualScene);\n                count++;\n            }\n        }\n    }\n}\n"]}

package/esm2022/staging/environment/environment.mjs

@@ -0,0 +1,78 @@
+import { NgIf, NgTemplateOutlet } from '@angular/common';
+import { CUSTOM_ELEMENTS_SCHEMA, Component, ContentChild, Directive, TemplateRef } from '@angular/core';
+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";
+class NgtsEnvironmentContent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsEnvironmentContent, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: NgtsEnvironmentContent, isStandalone: true, selector: "ng-template[ngtsEnvironmentContent]", ngImport: i0 }); }
+}
+export { NgtsEnvironmentContent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsEnvironmentContent, decorators: [{
+            type: Directive,
+            args: [{ selector: 'ng-template[ngtsEnvironmentContent]', standalone: true }]
+        }] });
+class NgtsEnvironment extends NgtsEnvironmentInput {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsEnvironment, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: NgtsEnvironment, isStandalone: true, selector: "ngts-environment", providers: [{ provide: NgtsEnvironmentInput, useExisting: NgtsEnvironment }], queries: [{ propertyName: "content", first: true, predicate: NgtsEnvironmentContent, descendants: true, read: TemplateRef }], usesInheritance: true, ngImport: i0, template: `
+        <ngts-environment-ground *ngIf="environmentGround(); else noGround" />
+        <ng-template #noGround>
+            <ngts-environment-map
+                *ngIf="environmentMap() as map; else noMap"
+                [map]="map"
+                [background]="!!environmentBackground()"
+            />
+            <ng-template #noMap>
+                <ngts-environment-portal *ngIf="content; else noPortal">
+                    <ng-container *ngTemplateOutlet="content" />
+                </ngts-environment-portal>
+                <ng-template #noPortal>
+                    <ngts-environment-cube [background]="!!environmentBackground()" />
+                </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"] }] }); }
+}
+export { NgtsEnvironment };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsEnvironment, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-environment',
+                    standalone: true,
+                    template: `
+        <ngts-environment-ground *ngIf="environmentGround(); else noGround" />
+        <ng-template #noGround>
+            <ngts-environment-map
+                *ngIf="environmentMap() as map; else noMap"
+                [map]="map"
+                [background]="!!environmentBackground()"
+            />
+            <ng-template #noMap>
+                <ngts-environment-portal *ngIf="content; else noPortal">
+                    <ng-container *ngTemplateOutlet="content" />
+                </ngts-environment-portal>
+                <ng-template #noPortal>
+                    <ngts-environment-cube [background]="!!environmentBackground()" />
+                </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: [NgtsEnvironmentContent, { read: TemplateRef }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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