angular-three-soba 1.0.2 → 1.2.0

package/esm2020/staging/lib/sky/sky.mjs

@@ -0,0 +1,111 @@
+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;
+}
+export class NgtsSky extends NgtRxStore {
+    constructor() {
+        super(...arguments);
+        this.skyRef = injectNgtRef();
+    }
+    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)));
+    }
+    ngOnInit() {
+        if (!this.skyRef.nativeElement)
+            this.skyRef.nativeElement = new Sky();
+    }
+}
+NgtsSky.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.3", ngImport: i0, type: NgtsSky, deps: null, target: i0.ɵɵFactoryTarget.Component });
+NgtsSky.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.1.3", 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 *args="[skyRef.nativeElement]" ngtCompound [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"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.3", ngImport: i0, type: NgtsSky, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-sky',
+                    standalone: true,
+                    template: `
+        <ngt-primitive *args="[skyRef.nativeElement]" ngtCompound [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,{"version":3,"file":"sky.js","sourceRoot":"","sources":["../../../../../../../libs/angular-three-soba/staging/src/lib/sky/sky.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, CUSTOM_ELEMENTS_SCHEMA, Input, OnInit } from '@angular/core';\nimport { injectNgtRef, NgtArgs, NgtRxStore } from 'angular-three';\nimport { Vector3 } from 'three';\nimport { Sky } from 'three-stdlib';\n\nexport function calcPosFromAngles(inclination: number, azimuth: number, vector: Vector3 = new 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\n@Component({\n    selector: 'ngts-sky',\n    standalone: true,\n    template: `\n        <ngt-primitive *args=\"[skyRef.nativeElement]\" ngtCompound [ref]=\"skyRef\" [scale]=\"get('scale')\">\n            <ngt-value [rawValue]=\"get('mieCoefficient')\" attach=\"material.uniforms.mieCoefficient.value\" />\n            <ngt-value [rawValue]=\"get('mieDirectionalG')\" attach=\"material.uniforms.mieDirectionalG.value\" />\n            <ngt-value [rawValue]=\"get('rayleigh')\" attach=\"material.uniforms.rayleigh.value\" />\n            <ngt-value [rawValue]=\"get('sunPosition')\" attach=\"material.uniforms.sunPosition.value\" />\n            <ngt-value [rawValue]=\"get('turbidity')\" attach=\"material.uniforms.turbidity.value\" />\n        </ngt-primitive>\n    `,\n    imports: [NgtArgs],\n    schemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsSky extends NgtRxStore implements OnInit {\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    override initialize(): void {\n        super.initialize();\n        const inclination = 0.6;\n        const azimuth = 0.1;\n        this.set({\n            inclination,\n            azimuth,\n            distance: 1000,\n            mieCoefficient: 0.005,\n            mieDirectionalG: 0.8,\n            rayleigh: 0.5,\n            turbidity: 10,\n            sunPosition: calcPosFromAngles(inclination, azimuth),\n        });\n        this.connect(\n            'sunPosition',\n            this.select(['inclination', 'azimuth'], ({ inclination, azimuth }) =>\n                calcPosFromAngles(inclination, azimuth)\n            )\n        );\n        this.connect(\n            'scale',\n            this.select(['distance'], ({ distance }) => new Vector3().setScalar(distance))\n        );\n    }\n\n    ngOnInit() {\n        if (!this.skyRef.nativeElement) this.skyRef.nativeElement = new Sky();\n    }\n}\n"]}

package/esm2020/staging/lib/sparkles/sparkles.mjs

@@ -0,0 +1,209 @@
+import { Component, CUSTOM_ELEMENTS_SCHEMA, inject, Input } from '@angular/core';
+import { extend, injectBeforeRender, injectNgtRef, NgtArgs, NgtRxStore, NgtStore } from 'angular-three';
+import { shaderMaterial } from 'angular-three-soba/shaders';
+import { map, startWith, withLatestFrom } from 'rxjs';
+import { BufferAttribute, BufferGeometry, Color, MathUtils, Points, Vector2, Vector3, Vector4 } from 'three';
+import * as i0 from "@angular/core";
+const SparklesMaterial = shaderMaterial({ time: 0, pixelRatio: 1 }, 
+// language=GLSL
+`
+uniform float pixelRatio;
+uniform float time;
+
+attribute float size;
+attribute float speed;
+attribute float opacity;
+attribute vec3 noise;
+attribute vec3 color;
+
+varying vec3 vColor;
+varying float vOpacity;
+
+void main() {
+  vec4 modelPosition = modelMatrix * vec4(position, 1.0);
+
+  modelPosition.y += sin(time * speed + modelPosition.x * noise.x * 100.0) * 0.2;
+  modelPosition.z += cos(time * speed + modelPosition.x * noise.y * 100.0) * 0.2;
+  modelPosition.x += cos(time * speed + modelPosition.x * noise.z * 100.0) * 0.2;
+
+  vec4 viewPosition = viewMatrix * modelPosition;
+  vec4 projectionPostion = projectionMatrix * viewPosition;
+
+  gl_Position = projectionPostion;
+  gl_PointSize = size * 25. * pixelRatio;
+  gl_PointSize *= (1.0 / - viewPosition.z);
+
+  vColor = color;
+  vOpacity = opacity;
+}
+  `, 
+// language=GLSL
+`
+varying vec3 vColor;
+varying float vOpacity;
+
+void main() {
+  float distanceToCenter = distance(gl_PointCoord, vec2(0.5));
+  float strength = 0.05 / distanceToCenter - 0.1;
+
+  gl_FragColor = vec4(vColor, strength * vOpacity);
+}
+  `);
+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);
+}
+export class NgtsSparkles extends NgtRxStore {
+    /** 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 });
+    }
+    initialize() {
+        super.initialize();
+        this.set({
+            noise: 1,
+            count: 100,
+            speed: 1,
+            opacity: 1,
+            scale: 1,
+        });
+        this.connect('positions', this.select(['count', 'scale'], ({ count, scale }) => Float32Array.from(Array.from({ length: count }, () => normalizeVector(scale).map(MathUtils.randFloatSpread)).flat())));
+        this.connect('sizes', this.getAttribute$('size', { setDefault: Math.random }));
+        this.connect('opacities', this.getAttribute$('opacity'));
+        this.connect('speeds', this.getAttribute$('speed'));
+        this.connect('noises', this.getAttribute$('noise', {
+            countValue: (_, count) => count * 3,
+        }));
+        this.connect('colors', this.getAttribute$('color', {
+            keyValue: (color) => (!isFloat32Array(color) ? new Color(color) : color),
+            countValue: (color, count) => (color === undefined ? count * 3 : count),
+            setDefault: () => 1,
+        }));
+    }
+    constructor() {
+        super();
+        this.store = inject(NgtStore);
+        this.dpr = this.store.get('viewport', 'dpr');
+        this.materialRef = injectNgtRef();
+        this.pointsRef = injectNgtRef();
+        injectBeforeRender(this.onBeforeRender.bind(this));
+    }
+    onBeforeRender({ clock }) {
+        if (!this.materialRef.nativeElement)
+            return;
+        this.materialRef.nativeElement.uniforms['time'].value = clock.elapsedTime;
+    }
+    getAttribute$(key, options) {
+        options ?? (options = {});
+        if (!options.keyValue) {
+            options.keyValue = (value) => value;
+        }
+        if (!options.countValue) {
+            options.countValue = (_, count) => count;
+        }
+        return this.select(key).pipe(startWith(this.get(key) || undefined), withLatestFrom(this.select('count')), map(([value, count]) => usePropAsIsOrAsAttribute(options.countValue(value, count), options.keyValue(value, count), options?.setDefault)));
+    }
+}
+NgtsSparkles.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.3", ngImport: i0, type: NgtsSparkles, deps: [], target: i0.ɵɵFactoryTarget.Component });
+NgtsSparkles.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.1.3", 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="[get('positions'), 3]" attach="attributes.position" />
+                <ngt-buffer-attribute *args="[get('sizes'), 1]" attach="attributes.size" />
+                <ngt-buffer-attribute *args="[get('opacities'), 1]" attach="attributes.opacity" />
+                <ngt-buffer-attribute *args="[get('speeds'), 1]" attach="attributes.speed" />
+                <ngt-buffer-attribute *args="[get('colors'), 3]" attach="attributes.color" />
+                <ngt-buffer-attribute *args="[get('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"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.3", 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="[get('positions'), 3]" attach="attributes.position" />
+                <ngt-buffer-attribute *args="[get('sizes'), 1]" attach="attributes.size" />
+                <ngt-buffer-attribute *args="[get('opacities'), 1]" attach="attributes.opacity" />
+                <ngt-buffer-attribute *args="[get('speeds'), 1]" attach="attributes.speed" />
+                <ngt-buffer-attribute *args="[get('colors'), 3]" attach="attributes.color" />
+                <ngt-buffer-attribute *args="[get('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/angular-three-soba/staging/src/lib/sparkles/sparkles.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, CUSTOM_ELEMENTS_SCHEMA, inject, Input } from '@angular/core';\nimport { extend, injectBeforeRender, injectNgtRef, NgtArgs, NgtRenderState, NgtRxStore, NgtStore } from 'angular-three';\nimport { shaderMaterial } from 'angular-three-soba/shaders';\nimport { map, Observable, startWith, withLatestFrom } from 'rxjs';\nimport { BufferAttribute, BufferGeometry, Color, MathUtils, Points, Vector2, Vector3, Vector4 } from 'three';\n\nconst SparklesMaterial = shaderMaterial(\n    { time: 0, pixelRatio: 1 },\n    // language=GLSL\n    `\nuniform float pixelRatio;\nuniform float time;\n\nattribute float size;\nattribute float speed;\nattribute float opacity;\nattribute vec3 noise;\nattribute vec3 color;\n\nvarying vec3 vColor;\nvarying float vOpacity;\n\nvoid main() {\n  vec4 modelPosition = modelMatrix * vec4(position, 1.0);\n\n  modelPosition.y += sin(time * speed + modelPosition.x * noise.x * 100.0) * 0.2;\n  modelPosition.z += cos(time * speed + modelPosition.x * noise.y * 100.0) * 0.2;\n  modelPosition.x += cos(time * speed + modelPosition.x * noise.z * 100.0) * 0.2;\n\n  vec4 viewPosition = viewMatrix * modelPosition;\n  vec4 projectionPostion = projectionMatrix * viewPosition;\n\n  gl_Position = projectionPostion;\n  gl_PointSize = size * 25. * pixelRatio;\n  gl_PointSize *= (1.0 / - viewPosition.z);\n\n  vColor = color;\n  vOpacity = opacity;\n}\n  `,\n    // language=GLSL\n    `\nvarying vec3 vColor;\nvarying float vOpacity;\n\nvoid main() {\n  float distanceToCenter = distance(gl_PointCoord, vec2(0.5));\n  float strength = 0.05 / distanceToCenter - 0.1;\n\n  gl_FragColor = vec4(vColor, strength * vOpacity);\n}\n  `\n);\n\nextend({ SparklesMaterial, Points, BufferGeometry, BufferAttribute });\n\nconst isFloat32Array = (def: any): def is Float32Array => def && (def as Float32Array).constructor === Float32Array;\n\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;\n\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\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=\"[get('positions'), 3]\" attach=\"attributes.position\" />\n                <ngt-buffer-attribute *args=\"[get('sizes'), 1]\" attach=\"attributes.size\" />\n                <ngt-buffer-attribute *args=\"[get('opacities'), 1]\" attach=\"attributes.opacity\" />\n                <ngt-buffer-attribute *args=\"[get('speeds'), 1]\" attach=\"attributes.speed\" />\n                <ngt-buffer-attribute *args=\"[get('colors'), 3]\" attach=\"attributes.color\" />\n                <ngt-buffer-attribute *args=\"[get('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 NgtRxStore {\n    private readonly store = inject(NgtStore);\n    readonly dpr = this.store.get('viewport', 'dpr');\n    readonly materialRef = injectNgtRef<typeof SparklesMaterial.prototype>();\n\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    override initialize() {\n        super.initialize();\n        this.set({\n            noise: 1,\n            count: 100,\n            speed: 1,\n            opacity: 1,\n            scale: 1,\n        });\n        this.connect(\n            'positions',\n            this.select(['count', 'scale'], ({ count, scale }) =>\n                Float32Array.from(\n                    Array.from({ length: count }, () => normalizeVector(scale).map(MathUtils.randFloatSpread)).flat()\n                )\n            )\n        );\n\n        this.connect('sizes', this.getAttribute$<number>('size', { setDefault: Math.random }));\n        this.connect('opacities', this.getAttribute$<number>('opacity'));\n        this.connect('speeds', this.getAttribute$<number>('speed'));\n        this.connect(\n            'noises',\n            this.getAttribute$<number | [number, number, number] | THREE.Vector3 | Float32Array>('noise', {\n                countValue: (_, count) => count * 3,\n            })\n        );\n        this.connect(\n            'colors',\n            this.getAttribute$<THREE.ColorRepresentation>('color', {\n                keyValue: (color) => (!isFloat32Array(color) ? new Color(color) : color),\n                countValue: (color, count) => (color === undefined ? count * 3 : count),\n                setDefault: () => 1,\n            })\n        );\n    }\n\n    constructor() {\n        super();\n        injectBeforeRender(this.onBeforeRender.bind(this));\n    }\n\n    private onBeforeRender({ clock }: NgtRenderState) {\n        if (!this.materialRef.nativeElement) return;\n        this.materialRef.nativeElement.uniforms['time'].value = clock.elapsedTime;\n    }\n\n    private getAttribute$<TValue>(\n        key: string,\n        options?: {\n            keyValue?: (value: TValue, count: number) => TValue;\n            countValue?: (value: TValue, count: number) => number;\n            setDefault?: (value: TValue) => number;\n        }\n    ): Observable<Float32Array> {\n        options ??= {};\n        if (!options.keyValue) {\n            options.keyValue = (value) => value;\n        }\n\n        if (!options.countValue) {\n            options.countValue = (_, count) => count;\n        }\n        return this.select(key).pipe(\n            startWith(this.get(key) || undefined),\n            withLatestFrom(this.select('count')),\n            map(([value, count]) =>\n                usePropAsIsOrAsAttribute(\n                    options!.countValue!(value, count),\n                    options!.keyValue!(value, count),\n                    options?.setDefault\n                )\n            )\n        );\n    }\n}\n"]}