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

package/esm2022/staging/environment/utils.mjs

@@ -0,0 +1,84 @@
+import { ChangeDetectorRef, DestroyRef, computed, effect, inject, runInInjectionContext, } from '@angular/core';
+import { assertInjectionContext, injectNgtLoader, injectNgtRef, is, safeDetectChanges } from 'angular-three';
+import { CubeReflectionMapping, CubeTextureLoader, EquirectangularReflectionMapping, LinearEncoding, sRGBEncoding, } from 'three';
+import { RGBELoader } from 'three-stdlib';
+import { ngtsEnvironmentPresetsObj } from './assets';
+function resolveScene(scene) {
+    return is.ref(scene) ? scene.nativeElement : scene;
+}
+export function setEnvProps(background, scene, defaultScene, texture, blur = 0) {
+    const target = resolveScene(scene || defaultScene);
+    const oldbg = target.background;
+    const oldenv = target.environment;
+    const oldBlur = target.backgroundBlurriness || 0;
+    if (background !== 'only')
+        target.environment = texture;
+    if (background)
+        target.background = texture;
+    if (background && target.backgroundBlurriness !== undefined)
+        target.backgroundBlurriness = blur;
+    return () => {
+        if (background !== 'only')
+            target.environment = oldenv;
+        if (background)
+            target.background = oldbg;
+        if (background && target.backgroundBlurriness !== undefined)
+            target.backgroundBlurriness = oldBlur;
+    };
+}
+const CUBEMAP_ROOT = 'https://market-assets.fra1.cdn.digitaloceanspaces.com/market-assets/hdris/';
+export function injectNgtsEnvironment(paramsFactory, injector) {
+    injector = assertInjectionContext(injectNgtsEnvironment, injector);
+    return runInInjectionContext(injector, () => {
+        const cdr = inject(ChangeDetectorRef);
+        const textureRef = injectNgtRef();
+        inject(DestroyRef).onDestroy(() => {
+            textureRef.untracked.dispose();
+        });
+        const params = computed(() => {
+            let { files, preset, encoding, path, extensions } = paramsFactory();
+            if (files == null) {
+                files = ['/px.png', '/nx.png', '/py.png', '/ny.png', '/pz.png', '/nz.png'];
+            }
+            if (path == null) {
+                path = '';
+            }
+            if (preset) {
+                if (!(preset in ngtsEnvironmentPresetsObj))
+                    throw new Error('Preset must be one of: ' + Object.keys(ngtsEnvironmentPresetsObj).join(', '));
+                files = ngtsEnvironmentPresetsObj[preset];
+                path = CUBEMAP_ROOT;
+            }
+            return { files, preset, encoding, path, extensions };
+        });
+        const loaderResult = injectNgtLoader(
+        // @ts-expect-error
+        () => {
+            const { files } = params();
+            return Array.isArray(files) ? CubeTextureLoader : RGBELoader;
+        }, () => {
+            const { files } = params();
+            return Array.isArray(files) ? [files] : files;
+        }, {
+            extensions: (loader) => {
+                const { path, extensions } = params();
+                loader.setPath(path);
+                if (extensions)
+                    extensions(loader);
+            },
+        });
+        effect(() => {
+            const result = loaderResult();
+            if (!result)
+                return;
+            const { files, encoding } = params();
+            const texture = Array.isArray(files) ? result[0] : result;
+            texture.mapping = Array.isArray(files) ? CubeReflectionMapping : EquirectangularReflectionMapping;
+            texture.encoding = encoding ?? Array.isArray(files) ? sRGBEncoding : LinearEncoding;
+            textureRef.nativeElement = texture;
+            safeDetectChanges(cdr);
+        }, { allowSignalWrites: true });
+        return textureRef;
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../../../libs/soba/staging/src/environment/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    ChangeDetectorRef,\n    DestroyRef,\n    ElementRef,\n    Injector,\n    computed,\n    effect,\n    inject,\n    runInInjectionContext,\n} from '@angular/core';\nimport { assertInjectionContext, injectNgtLoader, injectNgtRef, is, safeDetectChanges } from 'angular-three';\nimport {\n    CubeReflectionMapping,\n    CubeTexture,\n    CubeTextureLoader,\n    EquirectangularReflectionMapping,\n    LinearEncoding,\n    sRGBEncoding,\n} from 'three';\nimport { RGBELoader } from 'three-stdlib';\nimport { ngtsEnvironmentPresetsObj } from './assets';\nimport { type NgtsEnvironmentInput } from './environment-input';\n\nfunction resolveScene(scene: THREE.Scene | ElementRef<THREE.Scene>) {\n    return is.ref(scene) ? scene.nativeElement : scene;\n}\n\nexport function setEnvProps(\n    background: boolean | 'only',\n    scene: THREE.Scene | ElementRef<THREE.Scene> | undefined,\n    defaultScene: THREE.Scene,\n    texture: THREE.Texture,\n    blur = 0\n) {\n    const target = resolveScene(scene || defaultScene);\n    const oldbg = target.background;\n    const oldenv = target.environment;\n    const oldBlur = target.backgroundBlurriness || 0;\n\n    if (background !== 'only') target.environment = texture;\n    if (background) target.background = texture;\n    if (background && target.backgroundBlurriness !== undefined) target.backgroundBlurriness = blur;\n\n    return () => {\n        if (background !== 'only') target.environment = oldenv;\n        if (background) target.background = oldbg;\n        if (background && target.backgroundBlurriness !== undefined) target.backgroundBlurriness = oldBlur;\n    };\n}\n\ntype NgtsInjectEnvironmentParams = Partial<\n    Pick<NgtsEnvironmentInput, 'files' | 'path' | 'preset' | 'extensions' | 'encoding'>\n>;\n\nconst CUBEMAP_ROOT = 'https://market-assets.fra1.cdn.digitaloceanspaces.com/market-assets/hdris/';\nexport function injectNgtsEnvironment(paramsFactory: () => Partial<NgtsInjectEnvironmentParams>, injector?: Injector) {\n    injector = assertInjectionContext(injectNgtsEnvironment, injector);\n    return runInInjectionContext(injector, () => {\n        const cdr = inject(ChangeDetectorRef);\n        const textureRef = injectNgtRef<THREE.Texture | CubeTexture>();\n\n        inject(DestroyRef).onDestroy(() => {\n            textureRef.untracked.dispose();\n        });\n\n        const params = computed(() => {\n            let { files, preset, encoding, path, extensions } = paramsFactory() as NgtsInjectEnvironmentParams;\n\n            if (files == null) {\n                files = ['/px.png', '/nx.png', '/py.png', '/ny.png', '/pz.png', '/nz.png'];\n            }\n\n            if (path == null) {\n                path = '';\n            }\n\n            if (preset) {\n                if (!(preset in ngtsEnvironmentPresetsObj))\n                    throw new Error('Preset must be one of: ' + Object.keys(ngtsEnvironmentPresetsObj).join(', '));\n                files = ngtsEnvironmentPresetsObj[preset];\n                path = CUBEMAP_ROOT;\n            }\n\n            return { files, preset, encoding, path, extensions } as NgtsInjectEnvironmentParams;\n        });\n\n        const loaderResult = injectNgtLoader(\n            // @ts-expect-error\n            () => {\n                const { files } = params();\n                return Array.isArray(files) ? CubeTextureLoader : RGBELoader;\n            },\n            () => {\n                const { files } = params();\n                return Array.isArray(files) ? [files] : files;\n            },\n            {\n                extensions: (loader) => {\n                    const { path, extensions } = params();\n                    loader.setPath(path);\n                    if (extensions) extensions(loader);\n                },\n            }\n        );\n\n        effect(\n            () => {\n                const result = loaderResult();\n                if (!result) return;\n                const { files, encoding } = params();\n                const texture: THREE.Texture | THREE.CubeTexture = Array.isArray(files) ? result[0] : result;\n                texture.mapping = Array.isArray(files) ? CubeReflectionMapping : EquirectangularReflectionMapping;\n                texture.encoding = encoding ?? Array.isArray(files) ? sRGBEncoding : LinearEncoding;\n\n                textureRef.nativeElement = texture;\n                safeDetectChanges(cdr);\n            },\n            { allowSignalWrites: true }\n        );\n\n        return textureRef;\n    });\n}\n"]}

package/esm2022/staging/float/float.mjs

@@ -0,0 +1,82 @@
+import { Component, CUSTOM_ELEMENTS_SCHEMA, Input } from '@angular/core';
+import { extend, injectBeforeRender, injectNgtRef, NgtSignalStore } from 'angular-three';
+import * as THREE from 'three';
+import { Group } from 'three';
+import * as i0 from "@angular/core";
+extend({ Group });
+class NgtsFloat extends NgtSignalStore {
+    #offset;
+    set enabled(enabled) {
+        this.set({ enabled });
+    }
+    set speed(speed) {
+        this.set({ speed });
+    }
+    set rotationIntensity(rotationIntensity) {
+        this.set({ rotationIntensity });
+    }
+    set floatIntensity(floatIntensity) {
+        this.set({ floatIntensity });
+    }
+    set floatingRange(floatingRange) {
+        this.set({ floatingRange });
+    }
+    constructor() {
+        super({ speed: 1, rotationIntensity: 1, floatIntensity: 1, floatingRange: [-0.1, 0.1], enabled: true });
+        this.#offset = Math.random() * 10000;
+        this.floatRef = injectNgtRef();
+        injectBeforeRender(this.#onBeforeRender.bind(this));
+    }
+    #onBeforeRender({ clock }) {
+        const float = this.floatRef.untracked;
+        if (!float)
+            return;
+        const { enabled, speed, floatingRange, floatIntensity, rotationIntensity } = this.get();
+        if (!enabled || speed === 0)
+            return;
+        const t = this.#offset + clock.getElapsedTime();
+        float.rotation.x = (Math.cos((t / 4) * speed) / 8) * rotationIntensity;
+        float.rotation.y = (Math.sin((t / 4) * speed) / 8) * rotationIntensity;
+        float.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);
+        float.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", enabled: "enabled", 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
+            }], enabled: [{
+                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/index.mjs

@@ -1,18 +1,18 @@
-export { NgtsAccumulativeShadows } from './lib/accumulative-shadows/accumulative-shadows';
-export { NgtsRandomizedLights } from './lib/accumulative-shadows/randomized-lights';
-export * from './lib/bounds/bounds';
-export * from './lib/camera-shake/camera-shake';
-export * from './lib/caustics/caustics';
-export * from './lib/center/center';
-export * from './lib/cloud/cloud';
-export * from './lib/contact-shadows/contact-shadows';
-export * from './lib/environment/assets';
-export * from './lib/environment/environment';
-export * from './lib/float/float';
-export * from './lib/sky/sky';
-export * from './lib/sparkles/sparkles';
-export * from './lib/spot-light/spot-light';
-export * from './lib/spot-light/spot-light-shadow';
-export * from './lib/stage/stage';
-export * from './lib/stars/stars';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXItdGhyZWUtc29iYS9zdGFnaW5nL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSxpREFBaUQsQ0FBQztBQUMxRixPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSw4Q0FBOEMsQ0FBQztBQUNwRixjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsaUNBQWlDLENBQUM7QUFDaEQsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyx1Q0FBdUMsQ0FBQztBQUN0RCxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYyxvQ0FBb0MsQ0FBQztBQUNuRCxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsbUJBQW1CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBOZ3RzQWNjdW11bGF0aXZlU2hhZG93cyB9IGZyb20gJy4vbGliL2FjY3VtdWxhdGl2ZS1zaGFkb3dzL2FjY3VtdWxhdGl2ZS1zaGFkb3dzJztcbmV4cG9ydCB7IE5ndHNSYW5kb21pemVkTGlnaHRzIH0gZnJvbSAnLi9saWIvYWNjdW11bGF0aXZlLXNoYWRvd3MvcmFuZG9taXplZC1saWdodHMnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvYm91bmRzL2JvdW5kcyc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jYW1lcmEtc2hha2UvY2FtZXJhLXNoYWtlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NhdXN0aWNzL2NhdXN0aWNzJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NlbnRlci9jZW50ZXInO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY2xvdWQvY2xvdWQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY29udGFjdC1zaGFkb3dzL2NvbnRhY3Qtc2hhZG93cyc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9lbnZpcm9ubWVudC9hc3NldHMnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvZW52aXJvbm1lbnQvZW52aXJvbm1lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvZmxvYXQvZmxvYXQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvc2t5L3NreSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9zcGFya2xlcy9zcGFya2xlcyc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9zcG90LWxpZ2h0L3Nwb3QtbGlnaHQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvc3BvdC1saWdodC9zcG90LWxpZ2h0LXNoYWRvdyc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9zdGFnZS9zdGFnZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9zdGFycy9zdGFycyc7XG4iXX0=
+export * from './accumulative-shadows/accumulative-shadows';
+export * from './accumulative-shadows/randomized-lights';
+export * from './bounds/bounds';
+export * from './camera-shake/camera-shake';
+export * from './caustics/caustisc';
+export * from './center/center';
+export * from './cloud/cloud';
+export * from './contact-shadows/contact-shadows';
+export * from './environment/assets';
+export * from './environment/environment';
+export * from './float/float';
+export * from './sky/sky';
+export * from './sparkles/sparkles';
+export * from './spot-light/spot-light';
+export { NgtsSpotLightShadow } from './spot-light/spot-light-shadow-mesh';
+export * from './stage/stage';
+export * from './stars/stars';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL3NvYmEvc3RhZ2luZy9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyw2Q0FBNkMsQ0FBQztBQUM1RCxjQUFjLDBDQUEwQyxDQUFDO0FBQ3pELGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyxtQ0FBbUMsQ0FBQztBQUNsRCxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLHFDQUFxQyxDQUFDO0FBQzFFLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsZUFBZSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9hY2N1bXVsYXRpdmUtc2hhZG93cy9hY2N1bXVsYXRpdmUtc2hhZG93cyc7XG5leHBvcnQgKiBmcm9tICcuL2FjY3VtdWxhdGl2ZS1zaGFkb3dzL3JhbmRvbWl6ZWQtbGlnaHRzJztcbmV4cG9ydCAqIGZyb20gJy4vYm91bmRzL2JvdW5kcyc7XG5leHBvcnQgKiBmcm9tICcuL2NhbWVyYS1zaGFrZS9jYW1lcmEtc2hha2UnO1xuZXhwb3J0ICogZnJvbSAnLi9jYXVzdGljcy9jYXVzdGlzYyc7XG5leHBvcnQgKiBmcm9tICcuL2NlbnRlci9jZW50ZXInO1xuZXhwb3J0ICogZnJvbSAnLi9jbG91ZC9jbG91ZCc7XG5leHBvcnQgKiBmcm9tICcuL2NvbnRhY3Qtc2hhZG93cy9jb250YWN0LXNoYWRvd3MnO1xuZXhwb3J0ICogZnJvbSAnLi9lbnZpcm9ubWVudC9hc3NldHMnO1xuZXhwb3J0ICogZnJvbSAnLi9lbnZpcm9ubWVudC9lbnZpcm9ubWVudCc7XG5leHBvcnQgKiBmcm9tICcuL2Zsb2F0L2Zsb2F0JztcbmV4cG9ydCAqIGZyb20gJy4vc2t5L3NreSc7XG5leHBvcnQgKiBmcm9tICcuL3NwYXJrbGVzL3NwYXJrbGVzJztcbmV4cG9ydCAqIGZyb20gJy4vc3BvdC1saWdodC9zcG90LWxpZ2h0JztcbmV4cG9ydCB7IE5ndHNTcG90TGlnaHRTaGFkb3cgfSBmcm9tICcuL3Nwb3QtbGlnaHQvc3BvdC1saWdodC1zaGFkb3ctbWVzaCc7XG5leHBvcnQgKiBmcm9tICcuL3N0YWdlL3N0YWdlJztcbmV4cG9ydCAqIGZyb20gJy4vc3RhcnMvc3RhcnMnO1xuIl19

package/esm2022/staging/sky/sky.mjs

@@ -0,0 +1,114 @@
+import { Component, computed, CUSTOM_ELEMENTS_SCHEMA, Input } from '@angular/core';
+import { injectNgtRef, NgtArgs, NgtSignalStore } from 'angular-three';
+import * as THREE from 'three';
+import { Sky } from 'three-stdlib';
+import * as i0 from "@angular/core";
+function calcPosFromAngles(inclination, azimuth, vector = new THREE.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 NgtSignalStore {
+    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 });
+    }
+    #inclination;
+    #azimuth;
+    #sunPosition;
+    #distance;
+    constructor() {
+        super({
+            inclination: 0.6,
+            azimuth: 0.1,
+            distance: 1000,
+            mieCoefficient: 0.005,
+            mieDirectionalG: 0.8,
+            rayleigh: 0.5,
+            turbidity: 10,
+        });
+        this.skyRef = injectNgtRef();
+        this.#inclination = this.select('inclination');
+        this.#azimuth = this.select('azimuth');
+        this.#sunPosition = this.select('sunPosition');
+        this.#distance = this.select('distance');
+        this.sky = new Sky();
+        this.skyMieCoefficient = this.select('mieCoefficient');
+        this.skyMieDirectionalG = this.select('mieDirectionalG');
+        this.skyRayleigh = this.select('rayleigh');
+        this.skyTurbidity = this.select('turbidity');
+        this.calculatedSunPosition = computed(() => this.#sunPosition() || calcPosFromAngles(this.#inclination(), this.#azimuth()));
+        this.scale = computed(() => new THREE.Vector3().setScalar(this.#distance()));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsSky, deps: [], 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]="scale()">
+            <ngt-value [rawValue]="skyMieCoefficient()" attach="material.uniforms.mieCoefficient.value" />
+            <ngt-value [rawValue]="skyMieDirectionalG()" attach="material.uniforms.mieDirectionalG.value" />
+            <ngt-value [rawValue]="skyRayleigh()" attach="material.uniforms.rayleigh.value" />
+            <ngt-value [rawValue]="calculatedSunPosition()" attach="material.uniforms.sunPosition.value" />
+            <ngt-value [rawValue]="skyTurbidity()" 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]="scale()">
+            <ngt-value [rawValue]="skyMieCoefficient()" attach="material.uniforms.mieCoefficient.value" />
+            <ngt-value [rawValue]="skyMieDirectionalG()" attach="material.uniforms.mieDirectionalG.value" />
+            <ngt-value [rawValue]="skyRayleigh()" attach="material.uniforms.rayleigh.value" />
+            <ngt-value [rawValue]="calculatedSunPosition()" attach="material.uniforms.sunPosition.value" />
+            <ngt-value [rawValue]="skyTurbidity()" attach="material.uniforms.turbidity.value" />
+        </ngt-primitive>
+    `,
+                    imports: [NgtArgs],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: function () { return []; }, 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,{"version":3,"file":"sky.js","sourceRoot":"","sources":["../../../../../../libs/soba/staging/src/sky/sky.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, computed, CUSTOM_ELEMENTS_SCHEMA, Input } from '@angular/core';\nimport { injectNgtRef, NgtArgs, NgtSignalStore } from 'angular-three';\nimport * as THREE from 'three';\nimport { Sky } from 'three-stdlib';\n\nfunction calcPosFromAngles(inclination: number, azimuth: number, vector = new THREE.Vector3()) {\n    const theta = Math.PI * (inclination - 0.5);\n    const phi = 2 * Math.PI * (azimuth - 0.5);\n\n    vector.x = Math.cos(phi);\n    vector.y = Math.sin(theta);\n    vector.z = Math.sin(phi);\n\n    return vector;\n}\n\nexport interface NgtsSkyState {\n    distance: number;\n    sunPosition: THREE.Vector3 | Parameters<THREE.Vector3['set']>;\n    inclination: number;\n    azimuth: number;\n    mieCoefficient: number;\n    mieDirectionalG: number;\n    rayleigh: number;\n    turbidity: number;\n}\n\ndeclare global {\n    interface HTMLElementTagNameMap {\n        'ngts-sky': NgtsSkyState & Sky;\n    }\n}\n\n@Component({\n    selector: 'ngts-sky',\n    standalone: true,\n    template: `\n        <ngt-primitive ngtCompound *args=\"[sky]\" [ref]=\"skyRef\" [scale]=\"scale()\">\n            <ngt-value [rawValue]=\"skyMieCoefficient()\" attach=\"material.uniforms.mieCoefficient.value\" />\n            <ngt-value [rawValue]=\"skyMieDirectionalG()\" attach=\"material.uniforms.mieDirectionalG.value\" />\n            <ngt-value [rawValue]=\"skyRayleigh()\" attach=\"material.uniforms.rayleigh.value\" />\n            <ngt-value [rawValue]=\"calculatedSunPosition()\" attach=\"material.uniforms.sunPosition.value\" />\n            <ngt-value [rawValue]=\"skyTurbidity()\" attach=\"material.uniforms.turbidity.value\" />\n        </ngt-primitive>\n    `,\n    imports: [NgtArgs],\n    schemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsSky extends NgtSignalStore<NgtsSkyState> {\n    @Input() skyRef = injectNgtRef<Sky>();\n\n    @Input() set distance(distance: number) {\n        this.set({ distance });\n    }\n\n    @Input() set sunPosition(sunPosition: THREE.Vector3 | Parameters<THREE.Vector3['set']>) {\n        this.set({ sunPosition });\n    }\n\n    @Input() set inclination(inclination: number) {\n        this.set({ inclination });\n    }\n\n    @Input() set azimuth(azimuth: number) {\n        this.set({ azimuth });\n    }\n\n    @Input() set mieCoefficient(mieCoefficient: number) {\n        this.set({ mieCoefficient });\n    }\n\n    @Input() set mieDirectionalG(mieDirectionalG: number) {\n        this.set({ mieDirectionalG });\n    }\n\n    @Input() set rayleigh(rayleigh: number) {\n        this.set({ rayleigh });\n    }\n\n    @Input() set turbidity(turbidity: number) {\n        this.set({ turbidity });\n    }\n\n    readonly #inclination = this.select('inclination');\n    readonly #azimuth = this.select('azimuth');\n    readonly #sunPosition = this.select('sunPosition');\n    readonly #distance = this.select('distance');\n\n    readonly sky = new Sky();\n\n    readonly skyMieCoefficient = this.select('mieCoefficient');\n    readonly skyMieDirectionalG = this.select('mieDirectionalG');\n    readonly skyRayleigh = this.select('rayleigh');\n    readonly skyTurbidity = this.select('turbidity');\n\n    readonly calculatedSunPosition = computed(\n        () => this.#sunPosition() || calcPosFromAngles(this.#inclination(), this.#azimuth())\n    );\n    readonly scale = computed(() => new THREE.Vector3().setScalar(this.#distance()));\n\n    constructor() {\n        super({\n            inclination: 0.6,\n            azimuth: 0.1,\n            distance: 1000,\n            mieCoefficient: 0.005,\n            mieDirectionalG: 0.8,\n            rayleigh: 0.5,\n            turbidity: 10,\n        });\n    }\n}\n"]}

package/esm2022/staging/sparkles/sparkles.mjs

@@ -0,0 +1,161 @@
+import { Component, computed, CUSTOM_ELEMENTS_SCHEMA, inject, Input, isSignal } from '@angular/core';
+import { extend, injectBeforeRender, injectNgtRef, NgtArgs, NgtSignalStore, NgtStore, } from 'angular-three';
+import { SparklesMaterial } from 'angular-three-soba/shaders';
+import * as THREE from 'three';
+import { BufferAttribute, BufferGeometry, Color, MathUtils, Points, Vector2, Vector3, Vector4 } from 'three';
+import * as i0 from "@angular/core";
+extend({ SparklesMaterial, Points, BufferGeometry, BufferAttribute });
+const isFloat32Array = (def) => def && def.constructor === Float32Array;
+const expandColor = (v) => [v.r, v.g, v.b];
+const isVector = (v) => v instanceof Vector2 || v instanceof Vector3 || v instanceof Vector4;
+const normalizeVector = (v) => {
+    if (Array.isArray(v))
+        return v;
+    else if (isVector(v))
+        return v.toArray();
+    return [v, v, v];
+};
+function usePropAsIsOrAsAttribute(count, prop, setDefault) {
+    if (prop !== undefined) {
+        if (isFloat32Array(prop)) {
+            return prop;
+        }
+        else {
+            if (prop instanceof Color) {
+                const a = Array.from({ length: count * 3 }, () => expandColor(prop)).flat();
+                return Float32Array.from(a);
+            }
+            else if (isVector(prop) || Array.isArray(prop)) {
+                const a = Array.from({ length: count * 3 }, () => normalizeVector(prop)).flat();
+                return Float32Array.from(a);
+            }
+            return Float32Array.from({ length: count }, () => prop);
+        }
+    }
+    return Float32Array.from({ length: count }, setDefault);
+}
+class NgtsSparkles extends NgtSignalStore {
+    /** Number of particles (default: 100) */
+    set count(count) {
+        this.set({ count });
+    }
+    /** Speed of particles (default: 1) */
+    set speed(speed) {
+        this.set({ speed });
+    }
+    /** Opacity of particles (default: 1) */
+    set opacity(opacity) {
+        this.set({ opacity });
+    }
+    /** Color of particles (default: 100) */
+    set color(color) {
+        this.set({ color });
+    }
+    /** Size of particles (default: randomized between 0 and 1) */
+    set size(size) {
+        this.set({ size });
+    }
+    /** The space the particles occupy (default: 1) */
+    set scale(scale) {
+        this.set({ scale });
+    }
+    /** Movement factor (default: 1) */
+    set noise(noise) {
+        this.set({ noise });
+    }
+    #store;
+    #count;
+    #scale;
+    #color;
+    #getComputed(nameOrComputed, count, setDefault) {
+        const value = typeof nameOrComputed !== 'string' && isSignal(nameOrComputed)
+            ? nameOrComputed
+            : this.select(nameOrComputed);
+        return computed(() => usePropAsIsOrAsAttribute(count(), value(), setDefault));
+    }
+    constructor() {
+        super({
+            noise: 1,
+            count: 100,
+            speed: 1,
+            opacity: 1,
+            scale: 1,
+        });
+        this.pointsRef = injectNgtRef();
+        this.#store = inject(NgtStore);
+        this.#count = this.select('count');
+        this.#scale = this.select('scale');
+        this.#color = this.select('color');
+        this.materialRef = injectNgtRef();
+        this.dpr = this.#store.select('viewport', 'dpr');
+        this.positions = computed(() => Float32Array.from(Array.from({ length: this.#count() }, () => normalizeVector(this.#scale()).map(MathUtils.randFloatSpread)).flat()));
+        this.sizes = this.#getComputed('size', this.#count, Math.random);
+        this.opacities = this.#getComputed('opacity', this.#count);
+        this.speeds = this.#getComputed('speed', this.#count);
+        this.noises = this.#getComputed('noise', () => this.#count() * 3);
+        this.colors = this.#getComputed(computed(() => {
+            const color = this.#color();
+            return !isFloat32Array(color) ? new THREE.Color(color) : color;
+        }), () => (this.#color() === undefined ? this.#count() * 3 : this.#count()), () => 1);
+        injectBeforeRender(this.#onBeforeRender.bind(this));
+    }
+    #onBeforeRender({ clock }) {
+        if (!this.materialRef.nativeElement)
+            return;
+        this.materialRef.nativeElement.uniforms['time'].value = clock.elapsedTime;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsSparkles, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: NgtsSparkles, isStandalone: true, selector: "ngts-sparkles", inputs: { pointsRef: "pointsRef", count: "count", speed: "speed", opacity: "opacity", color: "color", size: "size", scale: "scale", noise: "noise" }, usesInheritance: true, ngImport: i0, template: `
+        <ngt-points ngtCompount [ref]="pointsRef">
+            <ngt-buffer-geometry>
+                <ngt-buffer-attribute *args="[positions(), 3]" attach="attributes.position" />
+                <ngt-buffer-attribute *args="[sizes(), 1]" attach="attributes.size" />
+                <ngt-buffer-attribute *args="[opacities(), 1]" attach="attributes.opacity" />
+                <ngt-buffer-attribute *args="[speeds(), 1]" attach="attributes.speed" />
+                <ngt-buffer-attribute *args="[colors(), 3]" attach="attributes.color" />
+                <ngt-buffer-attribute *args="[noises(), 3]" attach="attributes.noise" />
+            </ngt-buffer-geometry>
+            <ngt-sparkles-material [ref]="materialRef" [transparent]="true" [depthWrite]="false" [pixelRatio]="dpr()" />
+        </ngt-points>
+    `, isInline: true, dependencies: [{ kind: "directive", type: NgtArgs, selector: "[args]", inputs: ["args"] }] }); }
+}
+export { NgtsSparkles };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsSparkles, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-sparkles',
+                    standalone: true,
+                    template: `
+        <ngt-points ngtCompount [ref]="pointsRef">
+            <ngt-buffer-geometry>
+                <ngt-buffer-attribute *args="[positions(), 3]" attach="attributes.position" />
+                <ngt-buffer-attribute *args="[sizes(), 1]" attach="attributes.size" />
+                <ngt-buffer-attribute *args="[opacities(), 1]" attach="attributes.opacity" />
+                <ngt-buffer-attribute *args="[speeds(), 1]" attach="attributes.speed" />
+                <ngt-buffer-attribute *args="[colors(), 3]" attach="attributes.color" />
+                <ngt-buffer-attribute *args="[noises(), 3]" attach="attributes.noise" />
+            </ngt-buffer-geometry>
+            <ngt-sparkles-material [ref]="materialRef" [transparent]="true" [depthWrite]="false" [pixelRatio]="dpr()" />
+        </ngt-points>
+    `,
+                    imports: [NgtArgs],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { pointsRef: [{
+                type: Input
+            }], count: [{
+                type: Input
+            }], speed: [{
+                type: Input
+            }], opacity: [{
+                type: Input
+            }], color: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], scale: [{
+                type: Input
+            }], noise: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sparkles.js","sourceRoot":"","sources":["../../../../../../libs/soba/staging/src/sparkles/sparkles.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, computed, CUSTOM_ELEMENTS_SCHEMA, inject, Input, isSignal, Signal } from '@angular/core';\nimport {\n    extend,\n    injectBeforeRender,\n    injectNgtRef,\n    NgtArgs,\n    NgtSignalStore,\n    NgtStore,\n    type NgtRenderState,\n} from 'angular-three';\nimport { SparklesMaterial } from 'angular-three-soba/shaders';\nimport * as THREE from 'three';\nimport { BufferAttribute, BufferGeometry, Color, MathUtils, Points, Vector2, Vector3, Vector4 } from 'three';\n\nextend({ SparklesMaterial, Points, BufferGeometry, BufferAttribute });\n\nconst isFloat32Array = (def: any): def is Float32Array => def && (def as Float32Array).constructor === Float32Array;\nconst expandColor = (v: THREE.Color) => [v.r, v.g, v.b];\nconst isVector = (v: any): v is THREE.Vector2 | THREE.Vector3 | THREE.Vector4 =>\n    v instanceof Vector2 || v instanceof Vector3 || v instanceof Vector4;\nconst normalizeVector = (v: any): number[] => {\n    if (Array.isArray(v)) return v;\n    else if (isVector(v)) return v.toArray();\n    return [v, v, v] as number[];\n};\n\nfunction usePropAsIsOrAsAttribute<T = any>(count: number, prop?: T | Float32Array, setDefault?: (v: T) => number) {\n    if (prop !== undefined) {\n        if (isFloat32Array(prop)) {\n            return prop as Float32Array;\n        } else {\n            if (prop instanceof Color) {\n                const a = Array.from({ length: count * 3 }, () => expandColor(prop)).flat();\n                return Float32Array.from(a);\n            } else if (isVector(prop) || Array.isArray(prop)) {\n                const a = Array.from({ length: count * 3 }, () => normalizeVector(prop)).flat();\n                return Float32Array.from(a);\n            }\n            return Float32Array.from({ length: count }, () => prop as unknown as number);\n        }\n    }\n    return Float32Array.from({ length: count }, setDefault!);\n}\n\nexport interface NgtsSparklesState {\n    /** Number of particles (default: 100) */\n    count: number;\n    /** Speed of particles (default: 1) */\n    speed: number | Float32Array;\n    /** Opacity of particles (default: 1) */\n    opacity: number | Float32Array;\n    /** Color of particles (default: 100) */\n    color?: THREE.ColorRepresentation | Float32Array;\n    /** Size of particles (default: randomized between 0 and 1) */\n    size?: number | Float32Array;\n    /** The space the particles occupy (default: 1) */\n    scale: number | [number, number, number] | THREE.Vector3;\n    /** Movement factor (default: 1) */\n    noise: number | [number, number, number] | THREE.Vector3 | Float32Array;\n}\n\n@Component({\n    selector: 'ngts-sparkles',\n    standalone: true,\n    template: `\n        <ngt-points ngtCompount [ref]=\"pointsRef\">\n            <ngt-buffer-geometry>\n                <ngt-buffer-attribute *args=\"[positions(), 3]\" attach=\"attributes.position\" />\n                <ngt-buffer-attribute *args=\"[sizes(), 1]\" attach=\"attributes.size\" />\n                <ngt-buffer-attribute *args=\"[opacities(), 1]\" attach=\"attributes.opacity\" />\n                <ngt-buffer-attribute *args=\"[speeds(), 1]\" attach=\"attributes.speed\" />\n                <ngt-buffer-attribute *args=\"[colors(), 3]\" attach=\"attributes.color\" />\n                <ngt-buffer-attribute *args=\"[noises(), 3]\" attach=\"attributes.noise\" />\n            </ngt-buffer-geometry>\n            <ngt-sparkles-material [ref]=\"materialRef\" [transparent]=\"true\" [depthWrite]=\"false\" [pixelRatio]=\"dpr()\" />\n        </ngt-points>\n    `,\n    imports: [NgtArgs],\n    schemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsSparkles extends NgtSignalStore<NgtsSparklesState> {\n    @Input() pointsRef = injectNgtRef<Points>();\n\n    /** Number of particles (default: 100) */\n    @Input() set count(count: number) {\n        this.set({ count });\n    }\n\n    /** Speed of particles (default: 1) */\n    @Input() set speed(speed: number | Float32Array) {\n        this.set({ speed });\n    }\n\n    /** Opacity of particles (default: 1) */\n    @Input() set opacity(opacity: number | Float32Array) {\n        this.set({ opacity });\n    }\n\n    /** Color of particles (default: 100) */\n    @Input() set color(color: THREE.ColorRepresentation | Float32Array) {\n        this.set({ color });\n    }\n\n    /** Size of particles (default: randomized between 0 and 1) */\n    @Input() set size(size: number | Float32Array) {\n        this.set({ size });\n    }\n\n    /** The space the particles occupy (default: 1) */\n    @Input() set scale(scale: number | [number, number, number] | THREE.Vector3) {\n        this.set({ scale });\n    }\n\n    /** Movement factor (default: 1) */\n    @Input() set noise(noise: number | [number, number, number] | THREE.Vector3 | Float32Array) {\n        this.set({ noise });\n    }\n\n    readonly #store = inject(NgtStore);\n\n    readonly #count = this.select('count');\n    readonly #scale = this.select('scale');\n    readonly #color = this.select('color');\n\n    readonly materialRef = injectNgtRef<InstanceType<typeof SparklesMaterial>>();\n\n    readonly dpr = this.#store.select('viewport', 'dpr');\n    readonly positions = computed(() =>\n        Float32Array.from(\n            Array.from({ length: this.#count() }, () =>\n                normalizeVector(this.#scale()).map(MathUtils.randFloatSpread)\n            ).flat()\n        )\n    );\n\n    readonly sizes = this.#getComputed('size', this.#count, Math.random);\n    readonly opacities = this.#getComputed('opacity', this.#count);\n    readonly speeds = this.#getComputed('speed', this.#count);\n    readonly noises = this.#getComputed('noise', () => this.#count() * 3);\n    readonly colors = this.#getComputed(\n        computed(() => {\n            const color = this.#color();\n            return !isFloat32Array(color) ? new THREE.Color(color) : color;\n        }),\n        () => (this.#color() === undefined ? this.#count() * 3 : this.#count()),\n        () => 1\n    );\n\n    #getComputed<TKey extends keyof NgtsSparklesState>(\n        nameOrComputed: TKey | Signal<NgtsSparklesState[TKey]>,\n        count: () => number,\n        setDefault?: (value: NgtsSparklesState[TKey]) => number\n    ) {\n        const value =\n            typeof nameOrComputed !== 'string' && isSignal(nameOrComputed)\n                ? nameOrComputed\n                : this.select(nameOrComputed);\n        return computed(() => usePropAsIsOrAsAttribute(count(), value(), setDefault));\n    }\n\n    constructor() {\n        super({\n            noise: 1,\n            count: 100,\n            speed: 1,\n            opacity: 1,\n            scale: 1,\n        });\n        injectBeforeRender(this.#onBeforeRender.bind(this));\n    }\n\n    #onBeforeRender({ clock }: NgtRenderState) {\n        if (!this.materialRef.nativeElement) return;\n        this.materialRef.nativeElement.uniforms['time'].value = clock.elapsedTime;\n    }\n}\n"]}