angular-three-soba 2.2.0 → 2.3.0

package/esm2022/staging/lib/center.mjs

@@ -1,6 +1,5 @@
-import { afterNextRender, ChangeDetectionStrategy, Component, CUSTOM_ELEMENTS_SCHEMA, input, output, viewChild, } from '@angular/core';
+import { ChangeDetectionStrategy, Component, CUSTOM_ELEMENTS_SCHEMA, effect, input, output, untracked, viewChild, } from '@angular/core';
 import { extend, getLocalState, omit, pick } from 'angular-three';
-import { injectAutoEffect } from 'ngxtension/auto-effect';
 import { mergeInputs } from 'ngxtension/inject-inputs';
 import { Box3, Group, Sphere, Vector3 } from 'three';
 import * as i0 from "@angular/core";
@@ -44,32 +43,29 @@ export class NgtsCenter {
             'cacheKey',
         ]);
         extend({ Group });
-        const autoEffect = injectAutoEffect();
-        afterNextRender(() => {
-            autoEffect(() => {
-                const [{ precise, top, bottom, right, left, front, back, disable, disableZ, disableY, disableX }, group, outer, inner,] = [
-                    this.centerOptions(),
-                    this.groupRef().nativeElement,
-                    this.outerRef().nativeElement,
-                    this.innerRef().nativeElement,
-                ];
-                const localState = getLocalState(inner);
-                const children = localState?.objects();
-                if (!children?.length)
-                    return;
-                outer.matrixWorld.identity();
-                const box3 = new Box3().setFromObject(inner, precise);
-                const center = new Vector3();
-                const sphere = new Sphere();
-                const width = box3.max.x - box3.min.x;
-                const height = box3.max.y - box3.min.y;
-                const depth = box3.max.z - box3.min.z;
-                box3.getCenter(center);
-                box3.getBoundingSphere(sphere);
-                const vAlign = top ? height / 2 : bottom ? -height / 2 : 0;
-                const hAlign = left ? -width / 2 : right ? width / 2 : 0;
-                const dAlign = front ? depth / 2 : back ? -depth / 2 : 0;
-                outer.position.set(disable || disableX ? 0 : -center.x + hAlign, disable || disableY ? 0 : -center.y + vAlign, disable || disableZ ? 0 : -center.z + dAlign);
+        effect(() => {
+            const inner = this.innerRef().nativeElement;
+            const localState = getLocalState(inner);
+            if (!localState)
+                return;
+            const children = [localState.objects(), localState.nonObjects()];
+            if (!children?.length)
+                return;
+            const [{ precise, top, bottom, right, left, front, back, disable, disableZ, disableY, disableX }, group, outer] = [this.centerOptions(), this.groupRef().nativeElement, this.outerRef().nativeElement];
+            outer.matrixWorld.identity();
+            const box3 = new Box3().setFromObject(inner, precise);
+            const center = new Vector3();
+            const sphere = new Sphere();
+            const width = box3.max.x - box3.min.x;
+            const height = box3.max.y - box3.min.y;
+            const depth = box3.max.z - box3.min.z;
+            box3.getCenter(center);
+            box3.getBoundingSphere(sphere);
+            const vAlign = top ? height / 2 : bottom ? -height / 2 : 0;
+            const hAlign = left ? -width / 2 : right ? width / 2 : 0;
+            const dAlign = front ? depth / 2 : back ? -depth / 2 : 0;
+            outer.position.set(disable || disableX ? 0 : -center.x + hAlign, disable || disableY ? 0 : -center.y + vAlign, disable || disableZ ? 0 : -center.z + dAlign);
+            untracked(() => {
                 this.centered.emit({
                     parent: group.parent,
                     container: group,
@@ -86,8 +82,8 @@ export class NgtsCenter {
             });
         });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsCenter, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "18.2.0", type: NgtsCenter, isStandalone: true, selector: "ngts-center", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { centered: "centered" }, viewQueries: [{ propertyName: "groupRef", first: true, predicate: ["group"], descendants: true, isSignal: true }, { propertyName: "outerRef", first: true, predicate: ["outer"], descendants: true, isSignal: true }, { propertyName: "innerRef", first: true, predicate: ["inner"], descendants: true, isSignal: true }], ngImport: i0, template: `
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NgtsCenter, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "18.2.4", type: NgtsCenter, isStandalone: true, selector: "ngts-center", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { centered: "centered" }, viewQueries: [{ propertyName: "groupRef", first: true, predicate: ["group"], descendants: true, isSignal: true }, { propertyName: "outerRef", first: true, predicate: ["outer"], descendants: true, isSignal: true }, { propertyName: "innerRef", first: true, predicate: ["inner"], descendants: true, isSignal: true }], ngImport: i0, template: `
 		<ngt-group #group [parameters]="parameters()">
 			<ngt-group #outer>
 				<ngt-group #inner>
@@ -97,7 +93,7 @@ export class NgtsCenter {
 		</ngt-group>
 	`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsCenter, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NgtsCenter, decorators: [{
             type: Component,
             args: [{
                     selector: 'ngts-center',
@@ -115,4 +111,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImpor
                     changeDetection: ChangeDetectionStrategy.OnPush,
                 }]
         }], ctorParameters: () => [] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"center.js","sourceRoot":"","sources":["../../../../../../libs/soba/staging/src/lib/center.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n\tafterNextRender,\n\tChangeDetectionStrategy,\n\tComponent,\n\tCUSTOM_ELEMENTS_SCHEMA,\n\tElementRef,\n\tinput,\n\toutput,\n\tviewChild,\n} from '@angular/core';\nimport { extend, getLocalState, NgtGroup, omit, pick } from 'angular-three';\nimport { injectAutoEffect } from 'ngxtension/auto-effect';\nimport { mergeInputs } from 'ngxtension/inject-inputs';\nimport { Box3, Group, Object3D, Sphere, Vector3 } from 'three';\n\nexport interface NgtsCenterState {\n\t/** The next parent above <Center> */\n\tparent: Object3D;\n\t/** The outmost container group of the <Center> component */\n\tcontainer: Object3D;\n\twidth: number;\n\theight: number;\n\tdepth: number;\n\tboundingBox: Box3;\n\tboundingSphere: Sphere;\n\tcenter: Vector3;\n\tverticalAlignment: number;\n\thorizontalAlignment: number;\n\tdepthAlignment: number;\n}\n\nexport interface NgtsCenterOptions {\n\ttop?: boolean;\n\tright?: boolean;\n\tbottom?: boolean;\n\tleft?: boolean;\n\tfront?: boolean;\n\tback?: boolean;\n\t/** Disable all axes */\n\tdisable?: boolean;\n\t/** Disable x-axis centering */\n\tdisableX?: boolean;\n\t/** Disable y-axis centering */\n\tdisableY?: boolean;\n\t/** Disable z-axis centering */\n\tdisableZ?: boolean;\n\t/** See https://threejs.org/docs/index.html?q=box3#api/en/math/Box3.setFromObject */\n\tprecise: boolean;\n\t/** Optional cacheKey to keep the component from recalculating on every render */\n\tcacheKey: any;\n}\n\nconst defaultOptions: Partial<NgtGroup> & NgtsCenterOptions = {\n\tprecise: true,\n\tcacheKey: 0,\n};\n\n@Component({\n\tselector: 'ngts-center',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-group #group [parameters]=\"parameters()\">\n\t\t\t<ngt-group #outer>\n\t\t\t\t<ngt-group #inner>\n\t\t\t\t\t<ng-content />\n\t\t\t\t</ngt-group>\n\t\t\t</ngt-group>\n\t\t</ngt-group>\n\t`,\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class NgtsCenter {\n\toptions = input(defaultOptions, { transform: mergeInputs(defaultOptions) });\n\tparameters = omit(this.options, [\n\t\t'top',\n\t\t'right',\n\t\t'bottom',\n\t\t'left',\n\t\t'front',\n\t\t'back',\n\t\t'disable',\n\t\t'disableX',\n\t\t'disableY',\n\t\t'disableZ',\n\t\t'precise',\n\t\t'cacheKey',\n\t]);\n\n\tcentered = output<NgtsCenterState>();\n\n\tgroupRef = viewChild.required<ElementRef<Group>>('group');\n\tprivate outerRef = viewChild.required<ElementRef<Group>>('outer');\n\tprivate innerRef = viewChild.required<ElementRef<Group>>('inner');\n\n\tcenterOptions = pick(this.options, [\n\t\t'top',\n\t\t'right',\n\t\t'bottom',\n\t\t'left',\n\t\t'front',\n\t\t'back',\n\t\t'disable',\n\t\t'disableX',\n\t\t'disableY',\n\t\t'disableZ',\n\t\t'precise',\n\t\t'cacheKey',\n\t]);\n\n\tconstructor() {\n\t\textend({ Group });\n\n\t\tconst autoEffect = injectAutoEffect();\n\n\t\tafterNextRender(() => {\n\t\t\tautoEffect(() => {\n\t\t\t\tconst [\n\t\t\t\t\t{ precise, top, bottom, right, left, front, back, disable, disableZ, disableY, disableX },\n\t\t\t\t\tgroup,\n\t\t\t\t\touter,\n\t\t\t\t\tinner,\n\t\t\t\t] = [\n\t\t\t\t\tthis.centerOptions(),\n\t\t\t\t\tthis.groupRef().nativeElement,\n\t\t\t\t\tthis.outerRef().nativeElement,\n\t\t\t\t\tthis.innerRef().nativeElement,\n\t\t\t\t];\n\n\t\t\t\tconst localState = getLocalState(inner);\n\t\t\t\tconst children = localState?.objects();\n\t\t\t\tif (!children?.length) return;\n\n\t\t\t\touter.matrixWorld.identity();\n\t\t\t\tconst box3 = new Box3().setFromObject(inner, precise);\n\t\t\t\tconst center = new Vector3();\n\t\t\t\tconst sphere = new Sphere();\n\n\t\t\t\tconst width = box3.max.x - box3.min.x;\n\t\t\t\tconst height = box3.max.y - box3.min.y;\n\t\t\t\tconst depth = box3.max.z - box3.min.z;\n\n\t\t\t\tbox3.getCenter(center);\n\t\t\t\tbox3.getBoundingSphere(sphere);\n\n\t\t\t\tconst vAlign = top ? height / 2 : bottom ? -height / 2 : 0;\n\t\t\t\tconst hAlign = left ? -width / 2 : right ? width / 2 : 0;\n\t\t\t\tconst dAlign = front ? depth / 2 : back ? -depth / 2 : 0;\n\n\t\t\t\touter.position.set(\n\t\t\t\t\tdisable || disableX ? 0 : -center.x + hAlign,\n\t\t\t\t\tdisable || disableY ? 0 : -center.y + vAlign,\n\t\t\t\t\tdisable || disableZ ? 0 : -center.z + dAlign,\n\t\t\t\t);\n\n\t\t\t\tthis.centered.emit({\n\t\t\t\t\tparent: group.parent!,\n\t\t\t\t\tcontainer: group,\n\t\t\t\t\twidth,\n\t\t\t\t\theight,\n\t\t\t\t\tdepth,\n\t\t\t\t\tboundingBox: box3,\n\t\t\t\t\tboundingSphere: sphere,\n\t\t\t\t\tcenter,\n\t\t\t\t\tverticalAlignment: vAlign,\n\t\t\t\t\thorizontalAlignment: hAlign,\n\t\t\t\t\tdepthAlignment: dAlign,\n\t\t\t\t});\n\t\t\t});\n\t\t});\n\t}\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"center.js","sourceRoot":"","sources":["../../../../../../libs/soba/staging/src/lib/center.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n\tChangeDetectionStrategy,\n\tComponent,\n\tCUSTOM_ELEMENTS_SCHEMA,\n\teffect,\n\tElementRef,\n\tinput,\n\toutput,\n\tuntracked,\n\tviewChild,\n} from '@angular/core';\nimport { extend, getLocalState, NgtGroup, omit, pick } from 'angular-three';\nimport { mergeInputs } from 'ngxtension/inject-inputs';\nimport { Box3, Group, Object3D, Sphere, Vector3 } from 'three';\n\nexport interface NgtsCenterState {\n\t/** The next parent above <Center> */\n\tparent: Object3D;\n\t/** The outmost container group of the <Center> component */\n\tcontainer: Object3D;\n\twidth: number;\n\theight: number;\n\tdepth: number;\n\tboundingBox: Box3;\n\tboundingSphere: Sphere;\n\tcenter: Vector3;\n\tverticalAlignment: number;\n\thorizontalAlignment: number;\n\tdepthAlignment: number;\n}\n\nexport interface NgtsCenterOptions {\n\ttop?: boolean;\n\tright?: boolean;\n\tbottom?: boolean;\n\tleft?: boolean;\n\tfront?: boolean;\n\tback?: boolean;\n\t/** Disable all axes */\n\tdisable?: boolean;\n\t/** Disable x-axis centering */\n\tdisableX?: boolean;\n\t/** Disable y-axis centering */\n\tdisableY?: boolean;\n\t/** Disable z-axis centering */\n\tdisableZ?: boolean;\n\t/** See https://threejs.org/docs/index.html?q=box3#api/en/math/Box3.setFromObject */\n\tprecise: boolean;\n\t/** Optional cacheKey to keep the component from recalculating on every render */\n\tcacheKey: any;\n}\n\nconst defaultOptions: Partial<NgtGroup> & NgtsCenterOptions = {\n\tprecise: true,\n\tcacheKey: 0,\n};\n\n@Component({\n\tselector: 'ngts-center',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-group #group [parameters]=\"parameters()\">\n\t\t\t<ngt-group #outer>\n\t\t\t\t<ngt-group #inner>\n\t\t\t\t\t<ng-content />\n\t\t\t\t</ngt-group>\n\t\t\t</ngt-group>\n\t\t</ngt-group>\n\t`,\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class NgtsCenter {\n\toptions = input(defaultOptions, { transform: mergeInputs(defaultOptions) });\n\tparameters = omit(this.options, [\n\t\t'top',\n\t\t'right',\n\t\t'bottom',\n\t\t'left',\n\t\t'front',\n\t\t'back',\n\t\t'disable',\n\t\t'disableX',\n\t\t'disableY',\n\t\t'disableZ',\n\t\t'precise',\n\t\t'cacheKey',\n\t]);\n\n\tcentered = output<NgtsCenterState>();\n\n\tgroupRef = viewChild.required<ElementRef<Group>>('group');\n\tprivate outerRef = viewChild.required<ElementRef<Group>>('outer');\n\tprivate innerRef = viewChild.required<ElementRef<Group>>('inner');\n\n\tcenterOptions = pick(this.options, [\n\t\t'top',\n\t\t'right',\n\t\t'bottom',\n\t\t'left',\n\t\t'front',\n\t\t'back',\n\t\t'disable',\n\t\t'disableX',\n\t\t'disableY',\n\t\t'disableZ',\n\t\t'precise',\n\t\t'cacheKey',\n\t]);\n\n\tconstructor() {\n\t\textend({ Group });\n\n\t\teffect(() => {\n\t\t\tconst inner = this.innerRef().nativeElement;\n\t\t\tconst localState = getLocalState(inner);\n\t\t\tif (!localState) return;\n\n\t\t\tconst children = [localState.objects(), localState.nonObjects()];\n\t\t\tif (!children?.length) return;\n\n\t\t\tconst [{ precise, top, bottom, right, left, front, back, disable, disableZ, disableY, disableX }, group, outer] =\n\t\t\t\t[this.centerOptions(), this.groupRef().nativeElement, this.outerRef().nativeElement];\n\n\t\t\touter.matrixWorld.identity();\n\t\t\tconst box3 = new Box3().setFromObject(inner, precise);\n\t\t\tconst center = new Vector3();\n\t\t\tconst sphere = new Sphere();\n\n\t\t\tconst width = box3.max.x - box3.min.x;\n\t\t\tconst height = box3.max.y - box3.min.y;\n\t\t\tconst depth = box3.max.z - box3.min.z;\n\n\t\t\tbox3.getCenter(center);\n\t\t\tbox3.getBoundingSphere(sphere);\n\n\t\t\tconst vAlign = top ? height / 2 : bottom ? -height / 2 : 0;\n\t\t\tconst hAlign = left ? -width / 2 : right ? width / 2 : 0;\n\t\t\tconst dAlign = front ? depth / 2 : back ? -depth / 2 : 0;\n\n\t\t\touter.position.set(\n\t\t\t\tdisable || disableX ? 0 : -center.x + hAlign,\n\t\t\t\tdisable || disableY ? 0 : -center.y + vAlign,\n\t\t\t\tdisable || disableZ ? 0 : -center.z + dAlign,\n\t\t\t);\n\n\t\t\tuntracked(() => {\n\t\t\t\tthis.centered.emit({\n\t\t\t\t\tparent: group.parent!,\n\t\t\t\t\tcontainer: group,\n\t\t\t\t\twidth,\n\t\t\t\t\theight,\n\t\t\t\t\tdepth,\n\t\t\t\t\tboundingBox: box3,\n\t\t\t\t\tboundingSphere: sphere,\n\t\t\t\t\tcenter,\n\t\t\t\t\tverticalAlignment: vAlign,\n\t\t\t\t\thorizontalAlignment: hAlign,\n\t\t\t\t\tdepthAlignment: dAlign,\n\t\t\t\t});\n\t\t\t});\n\t\t});\n\t}\n}\n"]}

package/esm2022/staging/lib/contact-shadows.mjs

@@ -163,8 +163,8 @@ export class NgtsContactShadows {
         renderTarget.texture.generateMipmaps = false;
         return renderTarget;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsContactShadows, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "18.2.0", type: NgtsContactShadows, isStandalone: true, selector: "ngts-contact-shadows", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, viewQueries: [{ propertyName: "contactShadowsRef", first: true, predicate: ["contactShadows"], descendants: true, isSignal: true }, { propertyName: "shadowsCameraRef", first: true, predicate: ["shadowsCamera"], descendants: true, isSignal: true }], ngImport: i0, template: `
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NgtsContactShadows, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "18.2.4", type: NgtsContactShadows, isStandalone: true, selector: "ngts-contact-shadows", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, viewQueries: [{ propertyName: "contactShadowsRef", first: true, predicate: ["contactShadows"], descendants: true, isSignal: true }, { propertyName: "shadowsCameraRef", first: true, predicate: ["shadowsCamera"], descendants: true, isSignal: true }], ngImport: i0, template: `
 		<ngt-group #contactShadows [rotation]="[Math.PI / 2, 0, 0]" [parameters]="parameters()">
 			<ngt-mesh
 				[scale]="[1, -1, 1]"
@@ -183,7 +183,7 @@ export class NgtsContactShadows {
 		</ngt-group>
 	`, isInline: true, dependencies: [{ kind: "directive", type: NgtArgs, selector: "ng-template[args]", inputs: ["args"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsContactShadows, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NgtsContactShadows, decorators: [{
             type: Component,
             args: [{
                     selector: 'ngts-contact-shadows',

package/esm2022/staging/lib/environment/environment.mjs

@@ -0,0 +1,338 @@
+import { NgTemplateOutlet } from '@angular/common';
+import { ChangeDetectionStrategy, Component, computed, contentChild, CUSTOM_ELEMENTS_SCHEMA, DestroyRef, Directive, effect, inject, Injector, input, output, TemplateRef, viewChild, } from '@angular/core';
+import { applyProps, extend, injectBeforeRender, injectStore, is, NgtArgs, NgtPortal, NgtPortalContent, pick, prepare, } from 'angular-three';
+import { mergeInputs } from 'ngxtension/inject-inputs';
+import { CubeCamera, HalfFloatType, Scene, WebGLCubeRenderTarget } from 'three';
+import { GroundProjectedEnv } from 'three-stdlib';
+import { injectEnvironment } from './inject-environment';
+import * as i0 from "@angular/core";
+function resolveScene(scene) {
+    return is.ref(scene) ? scene.nativeElement : scene;
+}
+function setEnvProps(background, scene, defaultScene, texture, sceneProps = {}) {
+    sceneProps.backgroundBlurriness ??= sceneProps.blur ?? 0;
+    sceneProps.backgroundIntensity ??= 1;
+    // @ts-expect-error - it's ok, we're sending through applyProps
+    sceneProps.backgroundRotation ??= [0, 0, 0];
+    sceneProps.environmentIntensity ??= 1;
+    // @ts-expect-error - it's ok, we're sending through applyProps
+    sceneProps.environmentRotation ??= [0, 0, 0];
+    const target = resolveScene(scene || defaultScene);
+    const oldbg = target.background;
+    const oldenv = target.environment;
+    const oldSceneProps = {
+        backgroundBlurriness: target.backgroundBlurriness,
+        backgroundIntensity: target.backgroundIntensity,
+        backgroundRotation: target.backgroundRotation?.clone?.() ?? [0, 0, 0],
+        environmentIntensity: target.environmentIntensity,
+        environmentRotation: target.environmentRotation?.clone?.() ?? [0, 0, 0],
+    };
+    if (background !== 'only')
+        target.environment = texture;
+    if (background)
+        target.background = texture;
+    applyProps(target, sceneProps);
+    return () => {
+        if (background !== 'only')
+            target.environment = oldenv;
+        if (background)
+            target.background = oldbg;
+        applyProps(target, oldSceneProps);
+    };
+}
+const defaultBackground = {
+    background: false,
+};
+export class NgtsEnvironmentMap {
+    constructor() {
+        this.options = input(defaultBackground, { transform: mergeInputs(defaultBackground) });
+        this.envSet = output();
+        const store = injectStore();
+        const defaultScene = store.select('scene');
+        const _map = pick(this.options, 'map');
+        const _envConfig = computed(() => {
+            const { background = false, scene, blur, backgroundBlurriness, backgroundIntensity, backgroundRotation, environmentIntensity, environmentRotation, } = this.options();
+            return {
+                background,
+                scene,
+                blur,
+                backgroundBlurriness,
+                backgroundIntensity,
+                backgroundRotation,
+                environmentIntensity,
+                environmentRotation,
+            };
+        });
+        effect((onCleanup) => {
+            const map = _map();
+            if (!map)
+                return;
+            const { background = false, scene, ...config } = _envConfig();
+            const cleanup = setEnvProps(background, scene, defaultScene(), map, config);
+            this.envSet.emit();
+            onCleanup(() => cleanup());
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NgtsEnvironmentMap, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.4", type: NgtsEnvironmentMap, isStandalone: true, selector: "ngts-environment-map", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { envSet: "envSet" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NgtsEnvironmentMap, decorators: [{
+            type: Directive,
+            args: [{ standalone: true, selector: 'ngts-environment-map' }]
+        }], ctorParameters: () => [] });
+export class NgtsEnvironmentCube {
+    constructor() {
+        this.options = input(defaultBackground, { transform: mergeInputs(defaultBackground) });
+        this.envSet = output();
+        this.store = injectStore();
+        this.defaultScene = this.store.select('scene');
+        this.envConfig = computed(() => {
+            const { background = false, scene, blur, backgroundBlurriness, backgroundIntensity, backgroundRotation, environmentIntensity, environmentRotation, } = this.options();
+            return {
+                background,
+                scene,
+                blur,
+                backgroundBlurriness,
+                backgroundIntensity,
+                backgroundRotation,
+                environmentIntensity,
+                environmentRotation,
+            };
+        });
+        const _texture = injectEnvironment(this.options);
+        effect((onCleanup) => {
+            const texture = _texture();
+            if (!texture)
+                return;
+            const { background = false, scene, ...config } = this.envConfig();
+            const cleanup = setEnvProps(background, scene, this.defaultScene(), texture, config);
+            this.envSet.emit();
+            onCleanup(() => cleanup());
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NgtsEnvironmentCube, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.4", type: NgtsEnvironmentCube, isStandalone: true, selector: "ngts-environment-cube", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { envSet: "envSet" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NgtsEnvironmentCube, decorators: [{
+            type: Directive,
+            args: [{ standalone: true, selector: 'ngts-environment-cube' }]
+        }], ctorParameters: () => [] });
+export class NgtsEnvironmentPortal {
+    constructor() {
+        this.defaultOptions = {
+            near: 1,
+            far: 1000,
+            resolution: 256,
+            frames: 1,
+            background: false,
+        };
+        this.options = input(this.defaultOptions, { transform: mergeInputs(this.defaultOptions) });
+        this.content = input.required();
+        this.envSet = output();
+        this.injector = inject(Injector);
+        this.store = injectStore();
+        this.defaultScene = this.store.select('scene');
+        this.gl = this.store.select('gl');
+        this.cameraRef = viewChild('cubeCamera');
+        this.map = pick(this.options, 'map');
+        this.files = pick(this.options, 'files');
+        this.preset = pick(this.options, 'preset');
+        this.extensions = pick(this.options, 'extensions');
+        this.path = pick(this.options, 'path');
+        this.envMapOptions = computed(() => ({ background: true, map: this.map(), extensions: this.extensions() }));
+        this.envCubeOptions = computed(() => ({
+            background: true,
+            files: this.files(),
+            preset: this.preset(),
+            extensions: this.extensions(),
+            path: this.path(),
+        }));
+        this.near = pick(this.options, 'near');
+        this.far = pick(this.options, 'far');
+        this.resolution = pick(this.options, 'resolution');
+        this.fbo = computed(() => {
+            const fbo = new WebGLCubeRenderTarget(this.resolution());
+            fbo.texture.type = HalfFloatType;
+            return fbo;
+        });
+        this.cameraArgs = computed(() => [this.near(), this.far(), this.fbo()]);
+        this.virtualScene = prepare(new Scene());
+        extend({ CubeCamera });
+        effect((onCleanup) => {
+            const [files, preset, map] = [this.files(), this.preset(), this.map()];
+            // NOTE: when there's none of this, we don't render cube or map so we need to setEnv here
+            if (!!files || !!preset || !!map)
+                return;
+            const cleanup = this.setPortalEnv();
+            onCleanup(() => cleanup?.());
+        });
+        let count = 1;
+        injectBeforeRender(() => {
+            const frames = this.options().frames;
+            if (frames === Infinity || (frames != null && count < frames)) {
+                const camera = this.cameraRef()?.nativeElement;
+                if (camera) {
+                    camera.update(this.gl(), this.virtualScene);
+                    count++;
+                }
+            }
+        });
+        inject(DestroyRef).onDestroy(() => {
+            if (this.setEnvEffectRef)
+                this.setEnvEffectRef.destroy();
+        });
+    }
+    // NOTE: we use onEnvSet here to ensure that EnvironmentCube or EnvironmentMap sets the env before the portal
+    onEnvSet() {
+        if (this.setEnvEffectRef)
+            this.setEnvEffectRef.destroy();
+        this.setEnvEffectRef = effect((onCleanup) => {
+            const cleanup = this.setPortalEnv();
+            onCleanup(() => cleanup?.());
+        }, { manualCleanup: true, injector: this.injector });
+    }
+    setPortalEnv() {
+        const camera = this.cameraRef();
+        if (!camera?.nativeElement)
+            return;
+        const [{ frames, background = false, scene, blur, backgroundBlurriness, backgroundIntensity, backgroundRotation, environmentIntensity, environmentRotation, }, gl, fbo, defaultScene,] = [this.options(), this.gl(), this.fbo(), this.defaultScene()];
+        if (frames === 1)
+            camera.nativeElement.update(gl, this.virtualScene);
+        const cleanup = setEnvProps(background, scene, defaultScene, fbo.texture, {
+            blur,
+            backgroundBlurriness,
+            backgroundIntensity,
+            backgroundRotation,
+            environmentIntensity,
+            environmentRotation,
+        });
+        this.envSet.emit();
+        return cleanup;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NgtsEnvironmentPortal, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.4", type: NgtsEnvironmentPortal, isStandalone: true, selector: "ngts-environment-portal", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null }, content: { classPropertyName: "content", publicName: "content", isSignal: true, isRequired: true, transformFunction: null } }, outputs: { envSet: "envSet" }, viewQueries: [{ propertyName: "cameraRef", first: true, predicate: ["cubeCamera"], descendants: true, isSignal: true }], ngImport: i0, template: `
+		<ngt-portal [container]="virtualScene">
+			<ng-template portalContent let-injector="injector" let-container="container">
+				<ng-container
+					[ngTemplateOutlet]="content()"
+					[ngTemplateOutletInjector]="injector"
+					[ngTemplateOutletContext]="{ injector, container }"
+				/>
+
+				<ngt-cube-camera #cubeCamera *args="cameraArgs()" />
+
+				@if (files() || preset()) {
+					<ngts-environment-cube [options]="envCubeOptions()" (envSet)="onEnvSet()" />
+				} @else if (map()) {
+					<ngts-environment-map [options]="envMapOptions()" (envSet)="onEnvSet()" />
+				}
+			</ng-template>
+		</ngt-portal>
+	`, isInline: true, dependencies: [{ kind: "directive", type: NgtsEnvironmentCube, selector: "ngts-environment-cube", inputs: ["options"], outputs: ["envSet"] }, { kind: "directive", type: NgtsEnvironmentMap, selector: "ngts-environment-map", inputs: ["options"], outputs: ["envSet"] }, { kind: "directive", type: NgtArgs, selector: "ng-template[args]", inputs: ["args"] }, { kind: "component", type: NgtPortal, selector: "ngt-portal", inputs: ["container", "state", "autoRender", "autoRenderPriority"] }, { kind: "directive", type: NgtPortalContent, selector: "ng-template[portalContent]" }, { kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NgtsEnvironmentPortal, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-environment-portal',
+                    standalone: true,
+                    template: `
+		<ngt-portal [container]="virtualScene">
+			<ng-template portalContent let-injector="injector" let-container="container">
+				<ng-container
+					[ngTemplateOutlet]="content()"
+					[ngTemplateOutletInjector]="injector"
+					[ngTemplateOutletContext]="{ injector, container }"
+				/>
+
+				<ngt-cube-camera #cubeCamera *args="cameraArgs()" />
+
+				@if (files() || preset()) {
+					<ngts-environment-cube [options]="envCubeOptions()" (envSet)="onEnvSet()" />
+				} @else if (map()) {
+					<ngts-environment-map [options]="envMapOptions()" (envSet)="onEnvSet()" />
+				}
+			</ng-template>
+		</ngt-portal>
+	`,
+                    imports: [NgtsEnvironmentCube, NgtsEnvironmentMap, NgtArgs, NgtPortal, NgtPortalContent, NgTemplateOutlet],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: () => [] });
+export class NgtsEnvironmentGround {
+    constructor() {
+        this.options = input({});
+        this.envSet = output();
+        this.defaultTexture = injectEnvironment(this.options);
+        this.height = computed(() => this.options().ground?.height);
+        this.radius = computed(() => this.options().ground?.radius);
+        this.scale = computed(() => this.options().ground?.scale ?? 1000);
+        this.args = computed(() => [this.options().map || this.defaultTexture()]);
+        this.envMapOptions = computed(() => {
+            const { map: _, ...options } = this.options();
+            const [map] = this.args();
+            return Object.assign(options, { map });
+        });
+        extend({ GroundProjectedEnv });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NgtsEnvironmentGround, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.2.4", type: NgtsEnvironmentGround, isStandalone: true, selector: "ngts-environment-ground", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { envSet: "envSet" }, ngImport: i0, template: `
+		<ngts-environment-map [options]="envMapOptions()" (envSet)="envSet.emit()" />
+		<ngt-ground-projected-env *args="args()" [scale]="scale()" [height]="height()" [radius]="radius()" />
+	`, isInline: true, dependencies: [{ kind: "directive", type: NgtsEnvironmentMap, selector: "ngts-environment-map", inputs: ["options"], outputs: ["envSet"] }, { kind: "directive", type: NgtArgs, selector: "ng-template[args]", inputs: ["args"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NgtsEnvironmentGround, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-environment-ground',
+                    standalone: true,
+                    template: `
+		<ngts-environment-map [options]="envMapOptions()" (envSet)="envSet.emit()" />
+		<ngt-ground-projected-env *args="args()" [scale]="scale()" [height]="height()" [radius]="radius()" />
+	`,
+                    imports: [NgtsEnvironmentMap, NgtArgs],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: () => [] });
+export class NgtsEnvironment {
+    constructor() {
+        this.options = input({});
+        this.content = contentChild(TemplateRef);
+        this.envSet = output();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NgtsEnvironment, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.4", type: NgtsEnvironment, isStandalone: true, selector: "ngts-environment", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { envSet: "envSet" }, queries: [{ propertyName: "content", first: true, predicate: TemplateRef, descendants: true, isSignal: true }], ngImport: i0, template: `
+		@if (options().ground) {
+			<ngts-environment-ground [options]="options()" (envSet)="envSet.emit()" />
+		} @else if (options().map) {
+			<ngts-environment-map [options]="options()" (envSet)="envSet.emit()" />
+		} @else if (content()) {
+			<ngts-environment-portal [options]="options()" [content]="$any(content())" (envSet)="envSet.emit()" />
+		} @else {
+			<ngts-environment-cube [options]="options()" (envSet)="envSet.emit()" />
+		}
+	`, isInline: true, dependencies: [{ kind: "directive", type: NgtsEnvironmentCube, selector: "ngts-environment-cube", inputs: ["options"], outputs: ["envSet"] }, { kind: "directive", type: NgtsEnvironmentMap, selector: "ngts-environment-map", inputs: ["options"], outputs: ["envSet"] }, { kind: "component", type: NgtsEnvironmentPortal, selector: "ngts-environment-portal", inputs: ["options", "content"], outputs: ["envSet"] }, { kind: "component", type: NgtsEnvironmentGround, selector: "ngts-environment-ground", inputs: ["options"], outputs: ["envSet"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NgtsEnvironment, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-environment',
+                    standalone: true,
+                    template: `
+		@if (options().ground) {
+			<ngts-environment-ground [options]="options()" (envSet)="envSet.emit()" />
+		} @else if (options().map) {
+			<ngts-environment-map [options]="options()" (envSet)="envSet.emit()" />
+		} @else if (content()) {
+			<ngts-environment-portal [options]="options()" [content]="$any(content())" (envSet)="envSet.emit()" />
+		} @else {
+			<ngts-environment-cube [options]="options()" (envSet)="envSet.emit()" />
+		}
+	`,
+                    imports: [NgtsEnvironmentCube, NgtsEnvironmentMap, NgtsEnvironmentPortal, NgtsEnvironmentGround],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"environment.js","sourceRoot":"","sources":["../../../../../../../libs/soba/staging/src/lib/environment/environment.ts"],"names":[],"mappings":"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","sourcesContent":["import { NgTemplateOutlet } from '@angular/common';\nimport {\n\tChangeDetectionStrategy,\n\tComponent,\n\tcomputed,\n\tcontentChild,\n\tCUSTOM_ELEMENTS_SCHEMA,\n\tDestroyRef,\n\tDirective,\n\teffect,\n\tEffectRef,\n\tElementRef,\n\tinject,\n\tInjector,\n\tinput,\n\toutput,\n\tTemplateRef,\n\tviewChild,\n} from '@angular/core';\nimport {\n\tapplyProps,\n\textend,\n\tinjectBeforeRender,\n\tinjectStore,\n\tis,\n\tNgtArgs,\n\tNgtPortal,\n\tNgtPortalContent,\n\tpick,\n\tprepare,\n} from 'angular-three';\nimport { mergeInputs } from 'ngxtension/inject-inputs';\nimport { CubeCamera, Euler, HalfFloatType, Scene, Texture, WebGLCubeRenderTarget } from 'three';\nimport { GroundProjectedEnv } from 'three-stdlib';\nimport { injectEnvironment, NgtsEnvironmentPresets, NgtsInjectEnvironmentOptions } from './inject-environment';\n\nfunction resolveScene(scene: Scene | ElementRef<Scene>) {\n\treturn is.ref(scene) ? scene.nativeElement : scene;\n}\n\nfunction setEnvProps(\n\tbackground: boolean | 'only',\n\tscene: Scene | ElementRef<Scene> | undefined,\n\tdefaultScene: Scene,\n\ttexture: Texture,\n\tsceneProps: Partial<NgtsEnvironmentOptions> = {},\n) {\n\tsceneProps.backgroundBlurriness ??= sceneProps.blur ?? 0;\n\tsceneProps.backgroundIntensity ??= 1;\n\t// @ts-expect-error - it's ok, we're sending through applyProps\n\tsceneProps.backgroundRotation ??= [0, 0, 0];\n\tsceneProps.environmentIntensity ??= 1;\n\t// @ts-expect-error - it's ok, we're sending through applyProps\n\tsceneProps.environmentRotation ??= [0, 0, 0];\n\n\tconst target = resolveScene(scene || defaultScene);\n\tconst oldbg = target.background;\n\tconst oldenv = target.environment;\n\tconst oldSceneProps = {\n\t\tbackgroundBlurriness: target.backgroundBlurriness,\n\t\tbackgroundIntensity: target.backgroundIntensity,\n\t\tbackgroundRotation: target.backgroundRotation?.clone?.() ?? [0, 0, 0],\n\t\tenvironmentIntensity: target.environmentIntensity,\n\t\tenvironmentRotation: target.environmentRotation?.clone?.() ?? [0, 0, 0],\n\t};\n\n\tif (background !== 'only') target.environment = texture;\n\tif (background) target.background = texture;\n\tapplyProps(target, sceneProps);\n\n\treturn () => {\n\t\tif (background !== 'only') target.environment = oldenv;\n\t\tif (background) target.background = oldbg;\n\t\tapplyProps(target, oldSceneProps);\n\t};\n}\n\nexport interface NgtsEnvironmentOptions extends Partial<NgtsInjectEnvironmentOptions> {\n\tframes?: number;\n\tnear?: number;\n\tfar?: number;\n\tresolution?: number;\n\tbackground?: boolean | 'only';\n\n\t/** deprecated, use backgroundBlurriness */\n\tblur?: number;\n\tbackgroundBlurriness?: number;\n\tbackgroundIntensity?: number;\n\tbackgroundRotation?: Euler;\n\tenvironmentIntensity?: number;\n\tenvironmentRotation?: Euler;\n\n\tmap?: Texture;\n\tpreset?: NgtsEnvironmentPresets;\n\tscene?: Scene | ElementRef<Scene>;\n\tground?: boolean | { radius?: number; height?: number; scale?: number };\n}\n\nconst defaultBackground: NgtsEnvironmentOptions = {\n\tbackground: false,\n};\n\n@Directive({ standalone: true, selector: 'ngts-environment-map' })\nexport class NgtsEnvironmentMap {\n\toptions = input(defaultBackground, { transform: mergeInputs(defaultBackground) });\n\tenvSet = output<void>();\n\n\tconstructor() {\n\t\tconst store = injectStore();\n\t\tconst defaultScene = store.select('scene');\n\n\t\tconst _map = pick(this.options, 'map');\n\t\tconst _envConfig = computed(() => {\n\t\t\tconst {\n\t\t\t\tbackground = false,\n\t\t\t\tscene,\n\t\t\t\tblur,\n\t\t\t\tbackgroundBlurriness,\n\t\t\t\tbackgroundIntensity,\n\t\t\t\tbackgroundRotation,\n\t\t\t\tenvironmentIntensity,\n\t\t\t\tenvironmentRotation,\n\t\t\t} = this.options();\n\n\t\t\treturn {\n\t\t\t\tbackground,\n\t\t\t\tscene,\n\t\t\t\tblur,\n\t\t\t\tbackgroundBlurriness,\n\t\t\t\tbackgroundIntensity,\n\t\t\t\tbackgroundRotation,\n\t\t\t\tenvironmentIntensity,\n\t\t\t\tenvironmentRotation,\n\t\t\t};\n\t\t});\n\n\t\teffect((onCleanup) => {\n\t\t\tconst map = _map();\n\t\t\tif (!map) return;\n\t\t\tconst { background = false, scene, ...config } = _envConfig();\n\t\t\tconst cleanup = setEnvProps(background, scene, defaultScene(), map, config);\n\t\t\tthis.envSet.emit();\n\t\t\tonCleanup(() => cleanup());\n\t\t});\n\t}\n}\n\n@Directive({ standalone: true, selector: 'ngts-environment-cube' })\nexport class NgtsEnvironmentCube {\n\toptions = input(defaultBackground, { transform: mergeInputs(defaultBackground) });\n\tenvSet = output<void>();\n\n\tprivate store = injectStore();\n\tprivate defaultScene = this.store.select('scene');\n\n\tprivate envConfig = computed(() => {\n\t\tconst {\n\t\t\tbackground = false,\n\t\t\tscene,\n\t\t\tblur,\n\t\t\tbackgroundBlurriness,\n\t\t\tbackgroundIntensity,\n\t\t\tbackgroundRotation,\n\t\t\tenvironmentIntensity,\n\t\t\tenvironmentRotation,\n\t\t} = this.options();\n\n\t\treturn {\n\t\t\tbackground,\n\t\t\tscene,\n\t\t\tblur,\n\t\t\tbackgroundBlurriness,\n\t\t\tbackgroundIntensity,\n\t\t\tbackgroundRotation,\n\t\t\tenvironmentIntensity,\n\t\t\tenvironmentRotation,\n\t\t};\n\t});\n\n\tconstructor() {\n\t\tconst _texture = injectEnvironment(this.options);\n\n\t\teffect((onCleanup) => {\n\t\t\tconst texture = _texture();\n\t\t\tif (!texture) return;\n\t\t\tconst { background = false, scene, ...config } = this.envConfig();\n\t\t\tconst cleanup = setEnvProps(background, scene, this.defaultScene(), texture, config);\n\t\t\tthis.envSet.emit();\n\t\t\tonCleanup(() => cleanup());\n\t\t});\n\t}\n}\n\n@Component({\n\tselector: 'ngts-environment-portal',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-portal [container]=\"virtualScene\">\n\t\t\t<ng-template portalContent let-injector=\"injector\" let-container=\"container\">\n\t\t\t\t<ng-container\n\t\t\t\t\t[ngTemplateOutlet]=\"content()\"\n\t\t\t\t\t[ngTemplateOutletInjector]=\"injector\"\n\t\t\t\t\t[ngTemplateOutletContext]=\"{ injector, container }\"\n\t\t\t\t/>\n\n\t\t\t\t<ngt-cube-camera #cubeCamera *args=\"cameraArgs()\" />\n\n\t\t\t\t@if (files() || preset()) {\n\t\t\t\t\t<ngts-environment-cube [options]=\"envCubeOptions()\" (envSet)=\"onEnvSet()\" />\n\t\t\t\t} @else if (map()) {\n\t\t\t\t\t<ngts-environment-map [options]=\"envMapOptions()\" (envSet)=\"onEnvSet()\" />\n\t\t\t\t}\n\t\t\t</ng-template>\n\t\t</ngt-portal>\n\t`,\n\timports: [NgtsEnvironmentCube, NgtsEnvironmentMap, NgtArgs, NgtPortal, NgtPortalContent, NgTemplateOutlet],\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class NgtsEnvironmentPortal {\n\tprivate defaultOptions: NgtsEnvironmentOptions = {\n\t\tnear: 1,\n\t\tfar: 1000,\n\t\tresolution: 256,\n\t\tframes: 1,\n\t\tbackground: false,\n\t};\n\toptions = input(this.defaultOptions, { transform: mergeInputs(this.defaultOptions) });\n\tcontent = input.required<TemplateRef<unknown>>();\n\tenvSet = output<void>();\n\n\tprivate injector = inject(Injector);\n\tprivate store = injectStore();\n\tprivate defaultScene = this.store.select('scene');\n\tprivate gl = this.store.select('gl');\n\n\tprivate cameraRef = viewChild<ElementRef<CubeCamera>>('cubeCamera');\n\n\tprotected map = pick(this.options, 'map');\n\tprotected files = pick(this.options, 'files');\n\tprotected preset = pick(this.options, 'preset');\n\tprivate extensions = pick(this.options, 'extensions');\n\tprivate path = pick(this.options, 'path');\n\n\tprotected envMapOptions = computed(() => ({ background: true, map: this.map(), extensions: this.extensions() }));\n\tprotected envCubeOptions = computed(() => ({\n\t\tbackground: true,\n\t\tfiles: this.files(),\n\t\tpreset: this.preset(),\n\t\textensions: this.extensions(),\n\t\tpath: this.path(),\n\t}));\n\n\tprivate near = pick(this.options, 'near');\n\tprivate far = pick(this.options, 'far');\n\tprivate resolution = pick(this.options, 'resolution');\n\tprivate fbo = computed(() => {\n\t\tconst fbo = new WebGLCubeRenderTarget(this.resolution());\n\t\tfbo.texture.type = HalfFloatType;\n\t\treturn fbo;\n\t});\n\n\tprotected cameraArgs = computed(() => [this.near(), this.far(), this.fbo()]);\n\tprotected virtualScene = prepare(new Scene());\n\n\tprivate setEnvEffectRef?: EffectRef;\n\n\tconstructor() {\n\t\textend({ CubeCamera });\n\n\t\teffect((onCleanup) => {\n\t\t\tconst [files, preset, map] = [this.files(), this.preset(), this.map()];\n\t\t\t// NOTE: when there's none of this, we don't render cube or map so we need to setEnv here\n\t\t\tif (!!files || !!preset || !!map) return;\n\t\t\tconst cleanup = this.setPortalEnv();\n\t\t\tonCleanup(() => cleanup?.());\n\t\t});\n\n\t\tlet count = 1;\n\t\tinjectBeforeRender(() => {\n\t\t\tconst frames = this.options().frames;\n\t\t\tif (frames === Infinity || (frames != null && count < frames)) {\n\t\t\t\tconst camera = this.cameraRef()?.nativeElement;\n\t\t\t\tif (camera) {\n\t\t\t\t\tcamera.update(this.gl(), this.virtualScene);\n\t\t\t\t\tcount++;\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\n\t\tinject(DestroyRef).onDestroy(() => {\n\t\t\tif (this.setEnvEffectRef) this.setEnvEffectRef.destroy();\n\t\t});\n\t}\n\n\t// NOTE: we use onEnvSet here to ensure that EnvironmentCube or EnvironmentMap sets the env before the portal\n\tonEnvSet() {\n\t\tif (this.setEnvEffectRef) this.setEnvEffectRef.destroy();\n\t\tthis.setEnvEffectRef = effect(\n\t\t\t(onCleanup) => {\n\t\t\t\tconst cleanup = this.setPortalEnv();\n\t\t\t\tonCleanup(() => cleanup?.());\n\t\t\t},\n\t\t\t{ manualCleanup: true, injector: this.injector },\n\t\t);\n\t}\n\n\tprivate setPortalEnv() {\n\t\tconst camera = this.cameraRef();\n\t\tif (!camera?.nativeElement) return;\n\n\t\tconst [\n\t\t\t{\n\t\t\t\tframes,\n\t\t\t\tbackground = false,\n\t\t\t\tscene,\n\t\t\t\tblur,\n\t\t\t\tbackgroundBlurriness,\n\t\t\t\tbackgroundIntensity,\n\t\t\t\tbackgroundRotation,\n\t\t\t\tenvironmentIntensity,\n\t\t\t\tenvironmentRotation,\n\t\t\t},\n\t\t\tgl,\n\t\t\tfbo,\n\t\t\tdefaultScene,\n\t\t] = [this.options(), this.gl(), this.fbo(), this.defaultScene()];\n\n\t\tif (frames === 1) camera.nativeElement.update(gl, this.virtualScene);\n\t\tconst cleanup = setEnvProps(background, scene, defaultScene, fbo.texture, {\n\t\t\tblur,\n\t\t\tbackgroundBlurriness,\n\t\t\tbackgroundIntensity,\n\t\t\tbackgroundRotation,\n\t\t\tenvironmentIntensity,\n\t\t\tenvironmentRotation,\n\t\t});\n\t\tthis.envSet.emit();\n\t\treturn cleanup;\n\t}\n}\n\n@Component({\n\tselector: 'ngts-environment-ground',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngts-environment-map [options]=\"envMapOptions()\" (envSet)=\"envSet.emit()\" />\n\t\t<ngt-ground-projected-env *args=\"args()\" [scale]=\"scale()\" [height]=\"height()\" [radius]=\"radius()\" />\n\t`,\n\timports: [NgtsEnvironmentMap, NgtArgs],\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class NgtsEnvironmentGround {\n\toptions = input({} as NgtsEnvironmentOptions);\n\tenvSet = output<void>();\n\n\tprivate defaultTexture = injectEnvironment(this.options);\n\n\tprotected height = computed(() => (this.options().ground as any)?.height);\n\tprotected radius = computed(() => (this.options().ground as any)?.radius);\n\tprotected scale = computed(() => (this.options().ground as any)?.scale ?? 1000);\n\tprotected args = computed(() => [this.options().map || this.defaultTexture()]);\n\tprotected envMapOptions = computed(() => {\n\t\tconst { map: _, ...options } = this.options();\n\t\tconst [map] = this.args();\n\t\treturn Object.assign(options, { map }) as NgtsEnvironmentOptions;\n\t});\n\n\tconstructor() {\n\t\textend({ GroundProjectedEnv });\n\t}\n}\n\n@Component({\n\tselector: 'ngts-environment',\n\tstandalone: true,\n\ttemplate: `\n\t\t@if (options().ground) {\n\t\t\t<ngts-environment-ground [options]=\"options()\" (envSet)=\"envSet.emit()\" />\n\t\t} @else if (options().map) {\n\t\t\t<ngts-environment-map [options]=\"options()\" (envSet)=\"envSet.emit()\" />\n\t\t} @else if (content()) {\n\t\t\t<ngts-environment-portal [options]=\"options()\" [content]=\"$any(content())\" (envSet)=\"envSet.emit()\" />\n\t\t} @else {\n\t\t\t<ngts-environment-cube [options]=\"options()\" (envSet)=\"envSet.emit()\" />\n\t\t}\n\t`,\n\timports: [NgtsEnvironmentCube, NgtsEnvironmentMap, NgtsEnvironmentPortal, NgtsEnvironmentGround],\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class NgtsEnvironment {\n\toptions = input({} as NgtsEnvironmentOptions);\n\tcontent = contentChild(TemplateRef);\n\tenvSet = output<void>();\n}\n"]}