angular-three-soba 1.13.0 → 1.14.1

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

@@ -0,0 +1,87 @@
+import { Directive, inject, Input } from '@angular/core';
+import { NgtRxStore, NgtStore } from 'angular-three';
+import { Texture } from 'three';
+import * as i0 from "@angular/core";
+class NgtsEnvironmentInputs extends NgtRxStore {
+    constructor() {
+        super(...arguments);
+        this.store = inject(NgtStore);
+    }
+    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: NgtsEnvironmentInputs, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: NgtsEnvironmentInputs, 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 { NgtsEnvironmentInputs };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsEnvironmentInputs, 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,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

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

@@ -0,0 +1,39 @@
+import { Directive } from '@angular/core';
+import { startWithUndefined } from 'angular-three';
+import { combineLatest } from 'rxjs';
+import { NgtsEnvironmentInputs } from './environment-inputs';
+import { setEnvProps } from './utils';
+import * as i0 from "@angular/core";
+class NgtsEnvironmentMap extends NgtsEnvironmentInputs {
+    initialize() {
+        super.initialize();
+        this.set({ background: false });
+    }
+    ngOnInit() {
+        this.setEnvProps();
+    }
+    setEnvProps() {
+        this.effect(combineLatest([
+            this.store.select('scene'),
+            this.select('map'),
+            this.select('scene').pipe(startWithUndefined()),
+            this.select('background'),
+            this.select('blur').pipe(startWithUndefined()),
+        ]), ([defaultScene, map, scene, background, blur]) => {
+            if (map) {
+                return setEnvProps(background, scene, defaultScene, map, blur);
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsEnvironmentMap, deps: null, 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", usesInheritance: true, 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,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,111 @@
+import { NgIf } from '@angular/common';
+import { Component, CUSTOM_ELEMENTS_SCHEMA } from '@angular/core';
+import { extend, injectBeforeRender, injectNgtRef, NgtArgs, NgtPortal, NgtPortalContent, prepare, } from 'angular-three';
+import { combineLatest } from 'rxjs';
+import * as THREE from 'three';
+import { CubeCamera, HalfFloatType } from 'three';
+import { NgtsEnvironmentCube } from './environment-cube';
+import { NgtsEnvironmentInputs } from './environment-inputs';
+import { NgtsEnvironmentMap } from './environment-map';
+import { setEnvProps } from './utils';
+import * as i0 from "@angular/core";
+extend({ CubeCamera });
+class NgtsEnvironmentPortal extends NgtsEnvironmentInputs {
+    initialize() {
+        super.initialize();
+        this.set({ near: 1, far: 1000, resolution: 256, frames: 1, background: false, preset: undefined });
+        this.connect('fbo', this.select(['resolution'], ({ resolution }) => {
+            const fbo = new THREE.WebGLCubeRenderTarget(resolution);
+            fbo.texture.type = HalfFloatType;
+            return fbo;
+        }));
+        this.connect('cameraArgs', this.select(['fbo', 'near', 'far'], ({ near, far, fbo }) => [near, far, fbo]));
+    }
+    constructor() {
+        super();
+        this.virtualSceneRef = injectNgtRef(prepare(new THREE.Scene()));
+        this.cubeCameraRef = injectNgtRef();
+        injectBeforeRender(this.onBeforeRender.bind(this, 1));
+    }
+    ngOnInit() {
+        this.setEnvProps();
+    }
+    setEnvProps() {
+        this.effect(combineLatest([
+            this.store.select('gl'),
+            this.store.select('scene'),
+            this.select('fbo'),
+            this.select('scene'),
+            this.select('background'),
+            this.select('frames'),
+            this.select('blur'),
+            this.virtualSceneRef.$,
+            this.cubeCameraRef.$,
+        ]), ([gl, defaultScene, fbo, scene, background, frames, blur, virtualScene, camera]) => {
+            if (frames === 1)
+                camera.update(gl, virtualScene);
+            return setEnvProps(background, scene, defaultScene, fbo.texture, blur);
+        });
+    }
+    onBeforeRender(count, { gl }) {
+        const { frames } = this.get();
+        if (frames === Infinity || count < frames) {
+            if (this.cubeCameraRef.nativeElement) {
+                this.cubeCameraRef.nativeElement.update(gl, this.virtualSceneRef.nativeElement);
+                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", usesInheritance: true, ngImport: i0, template: `
+        <ngt-portal [container]="virtualSceneRef">
+            <ng-template ngtPortalContent>
+                <ng-content />
+                <ngt-cube-camera *args="get('cameraArgs')" [ref]="cubeCameraRef" />
+                <ng-container *ngIf="get('files') || get('preset'); else environmentMap">
+                    <ngts-environment-cube
+                        [background]="true"
+                        [files]="get('files')"
+                        [preset]="get('preset')"
+                        [path]="get('path')"
+                        [extensions]="get('extensions')"
+                    />
+                </ng-container>
+                <ng-template #environmentMap>
+                    <ngts-environment-map [background]="true" [map]="get('map')" [extensions]="get('extensions')" />
+                </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" }, { kind: "directive", type: NgtsEnvironmentCube, selector: "ngts-environment-cube" }, { 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="get('cameraArgs')" [ref]="cubeCameraRef" />
+                <ng-container *ngIf="get('files') || get('preset'); else environmentMap">
+                    <ngts-environment-cube
+                        [background]="true"
+                        [files]="get('files')"
+                        [preset]="get('preset')"
+                        [path]="get('path')"
+                        [extensions]="get('extensions')"
+                    />
+                </ng-container>
+                <ng-template #environmentMap>
+                    <ngts-environment-map [background]="true" [map]="get('map')" [extensions]="get('extensions')" />
+                </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/angular-three-soba/staging/src/lib/environment/environment-portal.ts"],"names":[],"mappings":"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","sourcesContent":["import { NgIf } from '@angular/common';\nimport { Component, CUSTOM_ELEMENTS_SCHEMA, OnInit } from '@angular/core';\nimport {\n    extend,\n    injectBeforeRender,\n    injectNgtRef,\n    NgtArgs,\n    NgtPortal,\n    NgtPortalContent,\n    NgtRenderState,\n    prepare,\n} from 'angular-three';\nimport { combineLatest } from 'rxjs';\nimport * as THREE from 'three';\nimport { CubeCamera, HalfFloatType } from 'three';\nimport { NgtsEnvironmentCube } from './environment-cube';\nimport { NgtsEnvironmentInputs } from './environment-inputs';\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=\"get('cameraArgs')\" [ref]=\"cubeCameraRef\" />\n                <ng-container *ngIf=\"get('files') || get('preset'); else environmentMap\">\n                    <ngts-environment-cube\n                        [background]=\"true\"\n                        [files]=\"get('files')\"\n                        [preset]=\"get('preset')\"\n                        [path]=\"get('path')\"\n                        [extensions]=\"get('extensions')\"\n                    />\n                </ng-container>\n                <ng-template #environmentMap>\n                    <ngts-environment-map [background]=\"true\" [map]=\"get('map')\" [extensions]=\"get('extensions')\" />\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 extends NgtsEnvironmentInputs implements OnInit {\n    readonly virtualSceneRef = injectNgtRef<THREE.Scene>(prepare(new THREE.Scene()));\n    readonly cubeCameraRef = injectNgtRef<THREE.CubeCamera>();\n\n    override initialize(): void {\n        super.initialize();\n        this.set({ near: 1, far: 1000, resolution: 256, frames: 1, background: false, preset: undefined });\n        this.connect(\n            'fbo',\n            this.select(['resolution'], ({ resolution }) => {\n                const fbo = new THREE.WebGLCubeRenderTarget(resolution);\n                fbo.texture.type = HalfFloatType;\n                return fbo;\n            })\n        );\n        this.connect(\n            'cameraArgs',\n            this.select(['fbo', 'near', 'far'], ({ near, far, fbo }) => [near, far, fbo])\n        );\n    }\n\n    constructor() {\n        super();\n        injectBeforeRender(this.onBeforeRender.bind(this, 1));\n    }\n\n    ngOnInit(): void {\n        this.setEnvProps();\n    }\n\n    private setEnvProps() {\n        this.effect(\n            combineLatest([\n                this.store.select('gl'),\n                this.store.select('scene'),\n                this.select('fbo'),\n                this.select('scene'),\n                this.select('background'),\n                this.select('frames'),\n                this.select('blur'),\n                this.virtualSceneRef.$,\n                this.cubeCameraRef.$,\n            ]),\n            ([gl, defaultScene, fbo, scene, background, frames, blur, virtualScene, camera]) => {\n                if (frames === 1) camera.update(gl, virtualScene);\n                return setEnvProps(background, scene, defaultScene, fbo.texture, blur);\n            }\n        );\n    }\n\n    private onBeforeRender(count: number, { gl }: NgtRenderState) {\n        const { frames } = this.get();\n        if (frames === Infinity || count < frames) {\n            if (this.cubeCameraRef.nativeElement) {\n                this.cubeCameraRef.nativeElement.update(gl, this.virtualSceneRef.nativeElement);\n                count++;\n            }\n        }\n    }\n}\n"]}

package/{esm2020 → esm2022}/staging/lib/environment/environment.mjs

@@ -6,18 +6,18 @@ import { NgtsEnvironmentInputs } from './environment-inputs';
 import { NgtsEnvironmentMap } from './environment-map';
 import { NgtsEnvironmentPortal } from './environment-portal';
 import * as i0 from "@angular/core";
-export class NgtsEnvironmentContent {
+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 }); }
 }
-NgtsEnvironmentContent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.5", ngImport: i0, type: NgtsEnvironmentContent, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-NgtsEnvironmentContent.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.5", type: NgtsEnvironmentContent, isStandalone: true, selector: "ng-template[ngtsEnvironmentContent]", ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.5", ngImport: i0, type: NgtsEnvironmentContent, decorators: [{
+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 }]
         }] });
-export class NgtsEnvironment extends NgtsEnvironmentInputs {
-}
-NgtsEnvironment.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.5", ngImport: i0, type: NgtsEnvironment, deps: null, target: i0.ɵɵFactoryTarget.Component });
-NgtsEnvironment.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.5", type: NgtsEnvironment, isStandalone: true, selector: "ngts-environment", queries: [{ propertyName: "content", first: true, predicate: NgtsEnvironmentContent, descendants: true, read: TemplateRef }], usesInheritance: true, ngImport: i0, template: `
+class NgtsEnvironment extends NgtsEnvironmentInputs {
+    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", queries: [{ propertyName: "content", first: true, predicate: NgtsEnvironmentContent, descendants: true, read: TemplateRef }], usesInheritance: true, ngImport: i0, template: `
         <ngts-environment-ground
             *ngIf="get('ground'); else noGround"
             [ground]="get('ground')"
@@ -78,8 +78,10 @@ NgtsEnvironment.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", versio
                 </ng-template>
             </ng-template>
         </ng-template>
-    `, isInline: true, dependencies: [{ kind: "directive", type: NgtsEnvironmentMap, selector: "ngts-environment-map" }, { kind: "component", type: NgtsEnvironmentGround, selector: "ngts-environment-ground" }, { kind: "directive", type: NgtsEnvironmentCube, selector: "ngts-environment-cube" }, { 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: "15.2.5", ngImport: i0, type: NgtsEnvironment, decorators: [{
+    `, isInline: true, dependencies: [{ kind: "directive", type: NgtsEnvironmentMap, selector: "ngts-environment-map" }, { kind: "component", type: NgtsEnvironmentGround, selector: "ngts-environment-ground" }, { kind: "directive", type: NgtsEnvironmentCube, selector: "ngts-environment-cube" }, { 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',
@@ -160,4 +162,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.5", ngImpor
                 type: ContentChild,
                 args: [NgtsEnvironmentContent, { read: TemplateRef }]
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/staging/lib/float/float.mjs

@@ -0,0 +1,77 @@
+import { Component, CUSTOM_ELEMENTS_SCHEMA, Input } from '@angular/core';
+import { extend, injectBeforeRender, injectNgtRef, NgtRxStore } from 'angular-three';
+import * as THREE from 'three';
+import { Group } from 'three';
+import * as i0 from "@angular/core";
+extend({ Group });
+class NgtsFloat extends NgtRxStore {
+    set speed(speed) {
+        this.set({ speed });
+    }
+    set rotationIntensity(rotationIntensity) {
+        this.set({ rotationIntensity });
+    }
+    set floatIntensity(floatIntensity) {
+        this.set({ floatIntensity });
+    }
+    set floatingRange(floatingRange) {
+        this.set({ floatingRange });
+    }
+    initialize() {
+        super.initialize();
+        this.set({ speed: 1, rotationIntensity: 1, floatIntensity: 1, floatingRange: [-0.1, 0.1] });
+    }
+    constructor() {
+        super();
+        this.offset = Math.random() * 10000;
+        this.floatRef = injectNgtRef();
+        injectBeforeRender(this.onBeforeRender.bind(this));
+    }
+    onBeforeRender({ clock }) {
+        if (!this.floatRef.nativeElement)
+            return;
+        const { speed, floatingRange, floatIntensity, rotationIntensity } = this.get();
+        const t = this.offset + clock.getElapsedTime();
+        this.floatRef.nativeElement.rotation.x = (Math.cos((t / 4) * speed) / 8) * rotationIntensity;
+        this.floatRef.nativeElement.rotation.y = (Math.sin((t / 4) * speed) / 8) * rotationIntensity;
+        this.floatRef.nativeElement.rotation.z = (Math.sin((t / 4) * speed) / 20) * rotationIntensity;
+        let yPosition = Math.sin((t / 4) * speed) / 10;
+        yPosition = THREE.MathUtils.mapLinear(yPosition, -0.1, 0.1, floatingRange[0] ?? -0.1, floatingRange[1] ?? 0.1);
+        this.floatRef.nativeElement.position.y = yPosition * floatIntensity;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsFloat, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: NgtsFloat, isStandalone: true, selector: "ngts-float", inputs: { floatRef: "floatRef", speed: "speed", rotationIntensity: "rotationIntensity", floatIntensity: "floatIntensity", floatingRange: "floatingRange" }, usesInheritance: true, ngImport: i0, template: `
+        <ngt-group ngtCompound>
+            <ngt-group [ref]="floatRef">
+                <ng-content />
+            </ngt-group>
+        </ngt-group>
+    `, isInline: true }); }
+}
+export { NgtsFloat };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsFloat, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-float',
+                    standalone: true,
+                    template: `
+        <ngt-group ngtCompound>
+            <ngt-group [ref]="floatRef">
+                <ng-content />
+            </ngt-group>
+        </ngt-group>
+    `,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { floatRef: [{
+                type: Input
+            }], speed: [{
+                type: Input
+            }], rotationIntensity: [{
+                type: Input
+            }], floatIntensity: [{
+                type: Input
+            }], floatingRange: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/staging/lib/sky/sky.mjs

@@ -0,0 +1,109 @@
+import { Component, CUSTOM_ELEMENTS_SCHEMA, Input } from '@angular/core';
+import { injectNgtRef, NgtArgs, NgtRxStore } from 'angular-three';
+import { Vector3 } from 'three';
+import { Sky } from 'three-stdlib';
+import * as i0 from "@angular/core";
+export function calcPosFromAngles(inclination, azimuth, vector = new Vector3()) {
+    const theta = Math.PI * (inclination - 0.5);
+    const phi = 2 * Math.PI * (azimuth - 0.5);
+    vector.x = Math.cos(phi);
+    vector.y = Math.sin(theta);
+    vector.z = Math.sin(phi);
+    return vector;
+}
+class NgtsSky extends NgtRxStore {
+    constructor() {
+        super(...arguments);
+        this.skyRef = injectNgtRef();
+        this.sky = new Sky();
+    }
+    set distance(distance) {
+        this.set({ distance });
+    }
+    set sunPosition(sunPosition) {
+        this.set({ sunPosition });
+    }
+    set inclination(inclination) {
+        this.set({ inclination });
+    }
+    set azimuth(azimuth) {
+        this.set({ azimuth });
+    }
+    set mieCoefficient(mieCoefficient) {
+        this.set({ mieCoefficient });
+    }
+    set mieDirectionalG(mieDirectionalG) {
+        this.set({ mieDirectionalG });
+    }
+    set rayleigh(rayleigh) {
+        this.set({ rayleigh });
+    }
+    set turbidity(turbidity) {
+        this.set({ turbidity });
+    }
+    initialize() {
+        super.initialize();
+        const inclination = 0.6;
+        const azimuth = 0.1;
+        this.set({
+            inclination,
+            azimuth,
+            distance: 1000,
+            mieCoefficient: 0.005,
+            mieDirectionalG: 0.8,
+            rayleigh: 0.5,
+            turbidity: 10,
+            sunPosition: calcPosFromAngles(inclination, azimuth),
+        });
+        this.connect('sunPosition', this.select(['inclination', 'azimuth'], ({ inclination, azimuth }) => calcPosFromAngles(inclination, azimuth)));
+        this.connect('scale', this.select(['distance'], ({ distance }) => new Vector3().setScalar(distance)));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsSky, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: NgtsSky, isStandalone: true, selector: "ngts-sky", inputs: { skyRef: "skyRef", distance: "distance", sunPosition: "sunPosition", inclination: "inclination", azimuth: "azimuth", mieCoefficient: "mieCoefficient", mieDirectionalG: "mieDirectionalG", rayleigh: "rayleigh", turbidity: "turbidity" }, usesInheritance: true, ngImport: i0, template: `
+        <ngt-primitive ngtCompound *args="[sky]" [ref]="skyRef" [scale]="get('scale')">
+            <ngt-value [rawValue]="get('mieCoefficient')" attach="material.uniforms.mieCoefficient.value" />
+            <ngt-value [rawValue]="get('mieDirectionalG')" attach="material.uniforms.mieDirectionalG.value" />
+            <ngt-value [rawValue]="get('rayleigh')" attach="material.uniforms.rayleigh.value" />
+            <ngt-value [rawValue]="get('sunPosition')" attach="material.uniforms.sunPosition.value" />
+            <ngt-value [rawValue]="get('turbidity')" attach="material.uniforms.turbidity.value" />
+        </ngt-primitive>
+    `, isInline: true, dependencies: [{ kind: "directive", type: NgtArgs, selector: "[args]", inputs: ["args"] }] }); }
+}
+export { NgtsSky };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsSky, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-sky',
+                    standalone: true,
+                    template: `
+        <ngt-primitive ngtCompound *args="[sky]" [ref]="skyRef" [scale]="get('scale')">
+            <ngt-value [rawValue]="get('mieCoefficient')" attach="material.uniforms.mieCoefficient.value" />
+            <ngt-value [rawValue]="get('mieDirectionalG')" attach="material.uniforms.mieDirectionalG.value" />
+            <ngt-value [rawValue]="get('rayleigh')" attach="material.uniforms.rayleigh.value" />
+            <ngt-value [rawValue]="get('sunPosition')" attach="material.uniforms.sunPosition.value" />
+            <ngt-value [rawValue]="get('turbidity')" attach="material.uniforms.turbidity.value" />
+        </ngt-primitive>
+    `,
+                    imports: [NgtArgs],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], propDecorators: { skyRef: [{
+                type: Input
+            }], distance: [{
+                type: Input
+            }], sunPosition: [{
+                type: Input
+            }], inclination: [{
+                type: Input
+            }], azimuth: [{
+                type: Input
+            }], mieCoefficient: [{
+                type: Input
+            }], mieDirectionalG: [{
+                type: Input
+            }], rayleigh: [{
+                type: Input
+            }], turbidity: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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