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

package/esm2022/staging/stars/stars.mjs

@@ -0,0 +1,148 @@
+import { Component, computed, CUSTOM_ELEMENTS_SCHEMA, Input } from '@angular/core';
+import { extend, injectBeforeRender, injectNgtRef, NgtArgs, NgtSignalStore } from 'angular-three';
+import { StarFieldMaterial } from 'angular-three-soba/shaders';
+import * as THREE from 'three';
+import { BufferAttribute, BufferGeometry, Points } from 'three';
+import * as i0 from "@angular/core";
+extend({ Points, BufferGeometry, BufferAttribute });
+const genStar = (r) => {
+    return new THREE.Vector3().setFromSpherical(new THREE.Spherical(r, Math.acos(1 - Math.random() * 2), Math.random() * 2 * Math.PI));
+};
+class NgtsStars extends NgtSignalStore {
+    set radius(radius) {
+        this.set({ radius });
+    }
+    set depth(depth) {
+        this.set({ depth });
+    }
+    set count(count) {
+        this.set({ count });
+    }
+    set factor(factor) {
+        this.set({ factor });
+    }
+    set saturation(saturation) {
+        this.set({ saturation });
+    }
+    set starsFade(fade) {
+        this.set({ fade });
+    }
+    set speed(speed) {
+        this.set({ speed });
+    }
+    #count;
+    #depth;
+    #factor;
+    #radius;
+    #saturation;
+    constructor() {
+        super({
+            radius: 100,
+            depth: 50,
+            count: 5000,
+            saturation: 0,
+            factor: 4,
+            fade: false,
+            speed: 1,
+        });
+        this.AdditiveBlending = THREE.AdditiveBlending;
+        this.material = new StarFieldMaterial();
+        this.starsRef = injectNgtRef();
+        this.#count = this.select('count');
+        this.#depth = this.select('depth');
+        this.#factor = this.select('factor');
+        this.#radius = this.select('radius');
+        this.#saturation = this.select('saturation');
+        this.fade = this.select('fade');
+        this.bufferAttributes = computed(() => {
+            const positions = [];
+            const colors = [];
+            const sizes = Array.from({ length: this.#count() }, () => (0.5 + 0.5 * Math.random()) * this.#factor());
+            const color = new THREE.Color();
+            let r = this.#radius() + this.#depth();
+            const increment = this.#depth() / this.#count();
+            for (let i = 0; i < this.#count(); i++) {
+                r -= increment * Math.random();
+                positions.push(...genStar(r).toArray());
+                color.setHSL(i / this.#count(), this.#saturation(), 0.9);
+                colors.push(color.r, color.g, color.b);
+            }
+            return {
+                positions: new Float32Array(positions),
+                colors: new Float32Array(colors),
+                sizes: new Float32Array(sizes),
+            };
+        });
+        injectBeforeRender(this.#onBeforeRender.bind(this));
+    }
+    #onBeforeRender({ clock }) {
+        this.material.uniforms['time'].value = clock.getElapsedTime() * this.get('speed');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsStars, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: NgtsStars, isStandalone: true, selector: "ngts-stars", inputs: { starsRef: "starsRef", radius: "radius", depth: "depth", count: "count", factor: "factor", saturation: "saturation", starsFade: ["fade", "starsFade"], speed: "speed" }, usesInheritance: true, ngImport: i0, template: `
+        <ngt-points [ref]="starsRef">
+            <ngt-buffer-geometry>
+                <ngt-buffer-attribute attach="attributes.position" *args="[bufferAttributes().positions, 3]" />
+                <ngt-buffer-attribute attach="attributes.color" *args="[bufferAttributes().colors, 3]" />
+                <ngt-buffer-attribute attach="attributes.size" *args="[bufferAttributes().sizes, 1]" />
+            </ngt-buffer-geometry>
+            <ngt-primitive
+                *args="[material]"
+                attach="material"
+                [blending]="AdditiveBlending"
+                [depthWrite]="false"
+                [transparent]="true"
+                [vertexColors]="true"
+            >
+                <ngt-value attach="uniforms.fade.value" [rawValue]="fade()" />
+            </ngt-primitive>
+        </ngt-points>
+    `, isInline: true, dependencies: [{ kind: "directive", type: NgtArgs, selector: "[args]", inputs: ["args"] }] }); }
+}
+export { NgtsStars };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsStars, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-stars',
+                    standalone: true,
+                    template: `
+        <ngt-points [ref]="starsRef">
+            <ngt-buffer-geometry>
+                <ngt-buffer-attribute attach="attributes.position" *args="[bufferAttributes().positions, 3]" />
+                <ngt-buffer-attribute attach="attributes.color" *args="[bufferAttributes().colors, 3]" />
+                <ngt-buffer-attribute attach="attributes.size" *args="[bufferAttributes().sizes, 1]" />
+            </ngt-buffer-geometry>
+            <ngt-primitive
+                *args="[material]"
+                attach="material"
+                [blending]="AdditiveBlending"
+                [depthWrite]="false"
+                [transparent]="true"
+                [vertexColors]="true"
+            >
+                <ngt-value attach="uniforms.fade.value" [rawValue]="fade()" />
+            </ngt-primitive>
+        </ngt-points>
+    `,
+                    imports: [NgtArgs],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { starsRef: [{
+                type: Input
+            }], radius: [{
+                type: Input
+            }], depth: [{
+                type: Input
+            }], count: [{
+                type: Input
+            }], factor: [{
+                type: Input
+            }], saturation: [{
+                type: Input
+            }], starsFade: [{
+                type: Input,
+                args: ['fade']
+            }], speed: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stars.js","sourceRoot":"","sources":["../../../../../../libs/soba/staging/src/stars/stars.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, computed, CUSTOM_ELEMENTS_SCHEMA, Input } from '@angular/core';\nimport { extend, injectBeforeRender, injectNgtRef, NgtArgs, NgtSignalStore, type NgtRenderState } from 'angular-three';\nimport { StarFieldMaterial } from 'angular-three-soba/shaders';\nimport * as THREE from 'three';\nimport { BufferAttribute, BufferGeometry, Points } from 'three';\n\nextend({ Points, BufferGeometry, BufferAttribute });\n\nconst genStar = (r: number) => {\n    return new THREE.Vector3().setFromSpherical(\n        new THREE.Spherical(r, Math.acos(1 - Math.random() * 2), Math.random() * 2 * Math.PI)\n    );\n};\n\nexport interface NgtsStarsState {\n    radius: number;\n    depth: number;\n    count: number;\n    factor: number;\n    saturation: number;\n    fade: boolean;\n    speed: number;\n}\n\n@Component({\n    selector: 'ngts-stars',\n    standalone: true,\n    template: `\n        <ngt-points [ref]=\"starsRef\">\n            <ngt-buffer-geometry>\n                <ngt-buffer-attribute attach=\"attributes.position\" *args=\"[bufferAttributes().positions, 3]\" />\n                <ngt-buffer-attribute attach=\"attributes.color\" *args=\"[bufferAttributes().colors, 3]\" />\n                <ngt-buffer-attribute attach=\"attributes.size\" *args=\"[bufferAttributes().sizes, 1]\" />\n            </ngt-buffer-geometry>\n            <ngt-primitive\n                *args=\"[material]\"\n                attach=\"material\"\n                [blending]=\"AdditiveBlending\"\n                [depthWrite]=\"false\"\n                [transparent]=\"true\"\n                [vertexColors]=\"true\"\n            >\n                <ngt-value attach=\"uniforms.fade.value\" [rawValue]=\"fade()\" />\n            </ngt-primitive>\n        </ngt-points>\n    `,\n    imports: [NgtArgs],\n    schemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsStars extends NgtSignalStore<NgtsStarsState> {\n    readonly AdditiveBlending = THREE.AdditiveBlending;\n    readonly material = new StarFieldMaterial();\n\n    @Input() starsRef = injectNgtRef<Points>();\n\n    @Input() set radius(radius: number) {\n        this.set({ radius });\n    }\n\n    @Input() set depth(depth: number) {\n        this.set({ depth });\n    }\n\n    @Input() set count(count: number) {\n        this.set({ count });\n    }\n\n    @Input() set factor(factor: number) {\n        this.set({ factor });\n    }\n\n    @Input() set saturation(saturation: number) {\n        this.set({ saturation });\n    }\n\n    @Input('fade') set starsFade(fade: boolean) {\n        this.set({ fade });\n    }\n\n    @Input() set speed(speed: number) {\n        this.set({ speed });\n    }\n\n    readonly #count = this.select('count');\n    readonly #depth = this.select('depth');\n    readonly #factor = this.select('factor');\n    readonly #radius = this.select('radius');\n    readonly #saturation = this.select('saturation');\n\n    readonly fade = this.select('fade');\n    readonly bufferAttributes = computed(() => {\n        const positions: number[] = [];\n        const colors: number[] = [];\n        const sizes = Array.from({ length: this.#count() }, () => (0.5 + 0.5 * Math.random()) * this.#factor());\n        const color = new THREE.Color();\n        let r = this.#radius() + this.#depth();\n        const increment = this.#depth() / this.#count();\n        for (let i = 0; i < this.#count(); i++) {\n            r -= increment * Math.random();\n            positions.push(...genStar(r).toArray());\n            color.setHSL(i / this.#count(), this.#saturation(), 0.9);\n            colors.push(color.r, color.g, color.b);\n        }\n        return {\n            positions: new Float32Array(positions),\n            colors: new Float32Array(colors),\n            sizes: new Float32Array(sizes),\n        };\n    });\n\n    constructor() {\n        super({\n            radius: 100,\n            depth: 50,\n            count: 5000,\n            saturation: 0,\n            factor: 4,\n            fade: false,\n            speed: 1,\n        });\n        injectBeforeRender(this.#onBeforeRender.bind(this));\n    }\n\n    #onBeforeRender({ clock }: NgtRenderState) {\n        this.material.uniforms['time'].value = clock.getElapsedTime() * this.get('speed');\n    }\n}\n"]}