angular-three-soba 1.14.1 → 2.0.0-beta.10

package/esm2022/staging/sparkles/sparkles.mjs

@@ -0,0 +1,164 @@
+import { CUSTOM_ELEMENTS_SCHEMA, Component, Input, computed, isSignal } from '@angular/core';
+import { NgtArgs, NgtKey, extend, injectBeforeRender, injectNgtRef, injectNgtStore, signalStore, } from 'angular-three';
+import { SparklesMaterial } from 'angular-three-soba/shaders';
+import * as THREE from 'three';
+import { BufferAttribute, BufferGeometry, Points } 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 THREE.Vector2 || v instanceof THREE.Vector3 || v instanceof THREE.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;
+        }
+        if (prop instanceof THREE.Color) {
+            const a = Array.from({ length: count * 3 }, () => expandColor(prop)).flat();
+            return Float32Array.from(a);
+        }
+        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 {
+    /** Number of particles (default: 100) */
+    set _count(count) {
+        this.inputs.set({ count });
+    }
+    /** Speed of particles (default: 1) */
+    set _speed(speed) {
+        this.inputs.set({ speed });
+    }
+    /** Opacity of particles (default: 1) */
+    set _opacity(opacity) {
+        this.inputs.set({ opacity });
+    }
+    /** Color of particles (default: 100) */
+    set _color(color) {
+        this.inputs.set({ color });
+    }
+    /** Size of particles (default: randomized between 0 and 1) */
+    set _size(size) {
+        this.inputs.set({ size });
+    }
+    /** The space the particles occupy (default: 1) */
+    set _scale(scale) {
+        this.inputs.set({ scale });
+    }
+    /** Movement factor (default: 1) */
+    set _noise(noise) {
+        this.inputs.set({ noise });
+    }
+    constructor() {
+        this.inputs = signalStore({
+            noise: 1,
+            count: 100,
+            speed: 1,
+            opacity: 1,
+            scale: 1,
+        });
+        this.sparklesRef = injectNgtRef();
+        this.store = injectNgtStore();
+        this.dpr = this.store.select('viewport', 'dpr');
+        this.scale = this.inputs.select('scale');
+        this.count = this.inputs.select('count');
+        this.color = this.inputs.select('color');
+        this.positions = computed(() => Float32Array.from(Array.from({ length: this.count() }, () => normalizeVector(this.scale()).map(THREE.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);
+        this.key = computed(() => `particle-${this.count()}-${JSON.stringify(this.scale())}`);
+        this.beforeRender();
+    }
+    beforeRender() {
+        injectBeforeRender(({ clock }) => {
+            const sparkles = this.sparklesRef.nativeElement;
+            if (!sparkles || !sparkles.material)
+                return;
+            sparkles.material.time = clock.elapsedTime;
+        });
+    }
+    getComputed(nameOrComputed, count, setDefault) {
+        const value = typeof nameOrComputed !== 'string' && isSignal(nameOrComputed)
+            ? nameOrComputed
+            : this.inputs.select(nameOrComputed);
+        return computed(() => usePropAsIsOrAsAttribute(count(), value(), setDefault));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsSparkles, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.7", type: NgtsSparkles, isStandalone: true, selector: "ngts-sparkles", inputs: { sparklesRef: "sparklesRef", _count: ["count", "_count"], _speed: ["speed", "_speed"], _opacity: ["opacity", "_opacity"], _color: ["color", "_color"], _size: ["size", "_size"], _scale: ["scale", "_scale"], _noise: ["noise", "_noise"] }, ngImport: i0, template: `
+		<ngt-points *key="key()" ngtCompound [ref]="sparklesRef">
+			<ngt-buffer-geometry>
+				<ngt-buffer-attribute attach="attributes.position" *args="[positions(), 3]" />
+				<ngt-buffer-attribute attach="attributes.size" *args="[sizes(), 1]" />
+				<ngt-buffer-attribute attach="attributes.opacity" *args="[opacities(), 1]" />
+				<ngt-buffer-attribute attach="attributes.speed" *args="[speeds(), 1]" />
+				<ngt-buffer-attribute attach="attributes.color" *args="[colors(), 3]" />
+				<ngt-buffer-attribute attach="attributes.noise" *args="[noises(), 3]" />
+			</ngt-buffer-geometry>
+			<ngt-sparkles-material [transparent]="true" [depthWrite]="false" [pixelRatio]="dpr()" />
+		</ngt-points>
+	`, isInline: true, dependencies: [{ kind: "directive", type: NgtArgs, selector: "ng-template[args]", inputs: ["args"] }, { kind: "directive", type: NgtKey, selector: "ng-template[key]", inputs: ["key"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsSparkles, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-sparkles',
+                    standalone: true,
+                    template: `
+		<ngt-points *key="key()" ngtCompound [ref]="sparklesRef">
+			<ngt-buffer-geometry>
+				<ngt-buffer-attribute attach="attributes.position" *args="[positions(), 3]" />
+				<ngt-buffer-attribute attach="attributes.size" *args="[sizes(), 1]" />
+				<ngt-buffer-attribute attach="attributes.opacity" *args="[opacities(), 1]" />
+				<ngt-buffer-attribute attach="attributes.speed" *args="[speeds(), 1]" />
+				<ngt-buffer-attribute attach="attributes.color" *args="[colors(), 3]" />
+				<ngt-buffer-attribute attach="attributes.noise" *args="[noises(), 3]" />
+			</ngt-buffer-geometry>
+			<ngt-sparkles-material [transparent]="true" [depthWrite]="false" [pixelRatio]="dpr()" />
+		</ngt-points>
+	`,
+                    imports: [NgtArgs, NgtKey],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { sparklesRef: [{
+                type: Input
+            }], _count: [{
+                type: Input,
+                args: [{ alias: 'count' }]
+            }], _speed: [{
+                type: Input,
+                args: [{ alias: 'speed' }]
+            }], _opacity: [{
+                type: Input,
+                args: [{ alias: 'opacity' }]
+            }], _color: [{
+                type: Input,
+                args: [{ alias: 'color' }]
+            }], _size: [{
+                type: Input,
+                args: [{ alias: 'size' }]
+            }], _scale: [{
+                type: Input,
+                args: [{ alias: 'scale' }]
+            }], _noise: [{
+                type: Input,
+                args: [{ alias: 'noise' }]
+            }] } });
+//# 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 { CUSTOM_ELEMENTS_SCHEMA, Component, Input, Signal, computed, isSignal } from '@angular/core';\nimport {\n\tNgtArgs,\n\tNgtKey,\n\textend,\n\tinjectBeforeRender,\n\tinjectNgtRef,\n\tinjectNgtStore,\n\tsignalStore,\n\ttype NgtPoints,\n} from 'angular-three';\nimport { NgtSparklesMaterialState, SparklesMaterial } from 'angular-three-soba/shaders';\nimport * as THREE from 'three';\nimport { BufferAttribute, BufferGeometry, Points } from 'three';\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\tv instanceof THREE.Vector2 || v instanceof THREE.Vector3 || v instanceof THREE.Vector4;\n\nconst normalizeVector = (v: any): number[] => {\n\tif (Array.isArray(v)) return v;\n\telse if (isVector(v)) return v.toArray();\n\treturn [v, v, v] as number[];\n};\n\nfunction usePropAsIsOrAsAttribute<T extends any>(\n\tcount: number,\n\tprop?: T | Float32Array,\n\tsetDefault?: (v: T) => number,\n) {\n\tif (prop !== undefined) {\n\t\tif (isFloat32Array(prop)) {\n\t\t\treturn prop as Float32Array;\n\t\t}\n\n\t\tif (prop instanceof THREE.Color) {\n\t\t\tconst a = Array.from({ length: count * 3 }, () => expandColor(prop)).flat();\n\t\t\treturn Float32Array.from(a);\n\t\t}\n\n\t\tif (isVector(prop) || Array.isArray(prop)) {\n\t\t\tconst a = Array.from({ length: count * 3 }, () => normalizeVector(prop)).flat();\n\t\t\treturn Float32Array.from(a);\n\t\t}\n\n\t\treturn Float32Array.from({ length: count }, () => prop as number);\n\t}\n\n\treturn Float32Array.from({ length: count }, setDefault!);\n}\n\nexport type NgtsSparklesState = {\n\t/** Number of particles (default: 100) */\n\tcount: number;\n\t/** Speed of particles (default: 1) */\n\tspeed: number | Float32Array;\n\t/** Opacity of particles (default: 1) */\n\topacity: number | Float32Array;\n\t/** Color of particles (default: 100) */\n\tcolor?: THREE.ColorRepresentation | Float32Array;\n\t/** Size of particles (default: randomized between 0 and 1) */\n\tsize?: number | Float32Array;\n\t/** The space the particles occupy (default: 1) */\n\tscale: number | [number, number, number] | THREE.Vector3;\n\t/** Movement factor (default: 1) */\n\tnoise: number | [number, number, number] | THREE.Vector3 | Float32Array;\n};\n\ndeclare global {\n\tinterface HTMLElementTagNameMap {\n\t\t/**\n\t\t * @extends ngt-points\n\t\t */\n\t\t'ngts-sparkles': NgtsSparklesState & NgtPoints;\n\t}\n}\n\n@Component({\n\tselector: 'ngts-sparkles',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-points *key=\"key()\" ngtCompound [ref]=\"sparklesRef\">\n\t\t\t<ngt-buffer-geometry>\n\t\t\t\t<ngt-buffer-attribute attach=\"attributes.position\" *args=\"[positions(), 3]\" />\n\t\t\t\t<ngt-buffer-attribute attach=\"attributes.size\" *args=\"[sizes(), 1]\" />\n\t\t\t\t<ngt-buffer-attribute attach=\"attributes.opacity\" *args=\"[opacities(), 1]\" />\n\t\t\t\t<ngt-buffer-attribute attach=\"attributes.speed\" *args=\"[speeds(), 1]\" />\n\t\t\t\t<ngt-buffer-attribute attach=\"attributes.color\" *args=\"[colors(), 3]\" />\n\t\t\t\t<ngt-buffer-attribute attach=\"attributes.noise\" *args=\"[noises(), 3]\" />\n\t\t\t</ngt-buffer-geometry>\n\t\t\t<ngt-sparkles-material [transparent]=\"true\" [depthWrite]=\"false\" [pixelRatio]=\"dpr()\" />\n\t\t</ngt-points>\n\t`,\n\timports: [NgtArgs, NgtKey],\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsSparkles {\n\tprivate inputs = signalStore<NgtsSparklesState>({\n\t\tnoise: 1,\n\t\tcount: 100,\n\t\tspeed: 1,\n\t\topacity: 1,\n\t\tscale: 1,\n\t});\n\n\t@Input() sparklesRef = injectNgtRef<Points>();\n\n\t/** Number of particles (default: 100) */\n\t@Input({ alias: 'count' }) set _count(count: number) {\n\t\tthis.inputs.set({ count });\n\t}\n\n\t/** Speed of particles (default: 1) */\n\t@Input({ alias: 'speed' }) set _speed(speed: number | Float32Array) {\n\t\tthis.inputs.set({ speed });\n\t}\n\n\t/** Opacity of particles (default: 1) */\n\t@Input({ alias: 'opacity' }) set _opacity(opacity: number | Float32Array) {\n\t\tthis.inputs.set({ opacity });\n\t}\n\n\t/** Color of particles (default: 100) */\n\t@Input({ alias: 'color' }) set _color(color: THREE.ColorRepresentation | Float32Array) {\n\t\tthis.inputs.set({ color });\n\t}\n\n\t/** Size of particles (default: randomized between 0 and 1) */\n\t@Input({ alias: 'size' }) set _size(size: number | Float32Array) {\n\t\tthis.inputs.set({ size });\n\t}\n\n\t/** The space the particles occupy (default: 1) */\n\t@Input({ alias: 'scale' }) set _scale(scale: number | [number, number, number] | THREE.Vector3) {\n\t\tthis.inputs.set({ scale });\n\t}\n\n\t/** Movement factor (default: 1) */\n\t@Input({ alias: 'noise' }) set _noise(noise: number | [number, number, number] | THREE.Vector3 | Float32Array) {\n\t\tthis.inputs.set({ noise });\n\t}\n\n\tprivate store = injectNgtStore();\n\n\tdpr = this.store.select('viewport', 'dpr');\n\n\tprivate scale = this.inputs.select('scale');\n\tprivate count = this.inputs.select('count');\n\tprivate color = this.inputs.select('color');\n\n\tpositions = computed(() =>\n\t\tFloat32Array.from(\n\t\t\tArray.from({ length: this.count() }, () =>\n\t\t\t\tnormalizeVector(this.scale()).map(THREE.MathUtils.randFloatSpread),\n\t\t\t).flat(),\n\t\t),\n\t);\n\tsizes = this.getComputed('size', this.count, Math.random);\n\topacities = this.getComputed('opacity', this.count);\n\tspeeds = this.getComputed('speed', this.count);\n\tnoises = this.getComputed('noise', () => this.count() * 3);\n\tcolors = this.getComputed(\n\t\tcomputed(() => {\n\t\t\tconst color = this.color();\n\t\t\treturn !isFloat32Array(color) ? new THREE.Color(color) : color;\n\t\t}),\n\t\t() => (this.color() === undefined ? this.count() * 3 : this.count()),\n\t\t() => 1,\n\t);\n\tkey = computed(() => `particle-${this.count()}-${JSON.stringify(this.scale())}`);\n\n\tconstructor() {\n\t\tthis.beforeRender();\n\t}\n\n\tprivate beforeRender() {\n\t\tinjectBeforeRender(({ clock }) => {\n\t\t\tconst sparkles = this.sparklesRef.nativeElement;\n\t\t\tif (!sparkles || !sparkles.material) return;\n\t\t\t(sparkles.material as NgtSparklesMaterialState).time = clock.elapsedTime;\n\t\t});\n\t}\n\n\tprivate getComputed<TKey extends keyof NgtsSparklesState>(\n\t\tnameOrComputed: TKey | Signal<NgtsSparklesState[TKey]>,\n\t\tcount: () => number,\n\t\tsetDefault?: (value: NgtsSparklesState[TKey]) => number,\n\t) {\n\t\tconst value =\n\t\t\ttypeof nameOrComputed !== 'string' && isSignal(nameOrComputed)\n\t\t\t\t? nameOrComputed\n\t\t\t\t: this.inputs.select(nameOrComputed);\n\t\treturn computed(() => usePropAsIsOrAsAttribute(count(), value(), setDefault));\n\t}\n}\n"]}

package/esm2022/staging/spot-light/shadow-mesh-input.mjs

@@ -0,0 +1,63 @@
+import { Directive, Input } from '@angular/core';
+import { signalStore } from 'angular-three';
+import * as i0 from "@angular/core";
+export class NgtsSpotLightShadowMeshInput {
+    constructor() {
+        this.inputs = signalStore({});
+        this.distance = this.inputs.select('distance');
+        this.alphaTest = this.inputs.select('alphaTest');
+        this.scale = this.inputs.select('scale');
+        this.map = this.inputs.select('map');
+        this.shader = this.inputs.select('shader');
+        this.width = this.inputs.select('width');
+        this.height = this.inputs.select('height');
+    }
+    set _distance(distance) {
+        this.inputs.set({ distance });
+    }
+    set _alphaTest(alphaTest) {
+        this.inputs.set({ alphaTest });
+    }
+    set _scale(scale) {
+        this.inputs.set({ scale });
+    }
+    set _map(map) {
+        this.inputs.set({ map });
+    }
+    set _shader(shader) {
+        this.inputs.set({ shader });
+    }
+    set _width(width) {
+        this.inputs.set({ width });
+    }
+    set _height(height) {
+        this.inputs.set({ height });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsSpotLightShadowMeshInput, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.7", type: NgtsSpotLightShadowMeshInput, inputs: { _distance: ["distance", "_distance"], _alphaTest: ["alphaTest", "_alphaTest"], _scale: ["scale", "_scale"], _map: ["map", "_map"], _shader: ["shader", "_shader"], _width: ["width", "_width"], _height: ["height", "_height"] }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsSpotLightShadowMeshInput, decorators: [{
+            type: Directive
+        }], propDecorators: { _distance: [{
+                type: Input,
+                args: [{ alias: 'distance' }]
+            }], _alphaTest: [{
+                type: Input,
+                args: [{ alias: 'alphaTest' }]
+            }], _scale: [{
+                type: Input,
+                args: [{ alias: 'scale' }]
+            }], _map: [{
+                type: Input,
+                args: [{ alias: 'map' }]
+            }], _shader: [{
+                type: Input,
+                args: [{ alias: 'shader' }]
+            }], _width: [{
+                type: Input,
+                args: [{ alias: 'width' }]
+            }], _height: [{
+                type: Input,
+                args: [{ alias: 'height' }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/staging/spot-light/shadow-mesh.mjs

@@ -0,0 +1,266 @@
+import { NgIf } from '@angular/common';
+import { CUSTOM_ELEMENTS_SCHEMA, Component, computed, effect, inject, runInInjectionContext, } from '@angular/core';
+import { assertInjectionContext, checkUpdate, extend, injectBeforeRender, injectNgtRef, } from 'angular-three';
+import * as THREE from 'three';
+import { Mesh, MeshBasicMaterial, PlaneGeometry } from 'three';
+import { FullScreenQuad } from 'three-stdlib';
+import { NgtsSpotLightShadowMeshInput } from './shadow-mesh-input';
+import { injectNgtsSpotLightApi } from './spot-light';
+import * as i0 from "@angular/core";
+const isSpotLight = (child) => {
+    return child?.isSpotLight;
+};
+function injectShadowMeshCommon(spotLightRef, meshRef, width, height, distance, injector) {
+    injector = assertInjectionContext(injectShadowMeshCommon, injector);
+    runInInjectionContext(injector, () => {
+        const pos = new THREE.Vector3();
+        const dir = new THREE.Vector3();
+        effect(() => {
+            const spotLight = spotLightRef.nativeElement;
+            if (!spotLight)
+                return;
+            if (isSpotLight(spotLight)) {
+                spotLight.shadow.mapSize.set(width(), height());
+                if (spotLight.shadow.map) {
+                    spotLight.shadow.map.setSize(width(), height());
+                }
+                spotLight.shadow.needsUpdate = true;
+            }
+            else {
+                throw new Error('<ngts-spot-light-shadow> must be a child of a <ngts-spot-light>');
+            }
+        });
+        injectBeforeRender(() => {
+            const spotLight = spotLightRef.nativeElement;
+            const mesh = meshRef.nativeElement;
+            if (!spotLight)
+                return;
+            const A = spotLight.position;
+            const B = spotLight.target.position;
+            dir.copy(B).sub(A);
+            const len = dir.length();
+            dir.normalize().multiplyScalar(len * distance());
+            pos.copy(A).add(dir);
+            if (mesh) {
+                mesh.position.copy(pos);
+                mesh.lookAt(spotLight.target.position);
+            }
+        });
+    });
+}
+extend({ Mesh, PlaneGeometry, MeshBasicMaterial });
+export class NgtsSpotLightShadowMeshNoShader {
+    constructor() {
+        this.shadowMeshInput = inject(NgtsSpotLightShadowMeshInput);
+        this.meshRef = injectNgtRef();
+        this.DoubleSide = THREE.DoubleSide;
+        this.spotLightApi = injectNgtsSpotLightApi();
+        this.debug = this.spotLightApi.debug;
+        effect(() => {
+            this.shadowMeshInput.inputs.patch({ distance: 0.4, alphaTest: 0.5, width: 512, height: 512, scale: 1 });
+        });
+        effect(() => {
+            const map = this.shadowMeshInput.map();
+            if (map) {
+                map.wrapS = map.wrapT = THREE.RepeatWrapping;
+                checkUpdate(map);
+            }
+        });
+        injectShadowMeshCommon(this.spotLightApi.spotLight, this.meshRef, this.shadowMeshInput.width, this.shadowMeshInput.height, this.shadowMeshInput.distance);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsSpotLightShadowMeshNoShader, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.7", type: NgtsSpotLightShadowMeshNoShader, isStandalone: true, selector: "ngts-spot-light-shadow-mesh-no-shader", ngImport: i0, template: `
+		<ngt-mesh [ref]="meshRef" [scale]="shadowMeshInput.scale()" [castShadow]="true">
+			<ngt-plane-geometry />
+			<ngt-mesh-basic-material
+				[transparent]="true"
+				[side]="DoubleSide"
+				[alphaTest]="shadowMeshInput.alphaTest()"
+				[alphaMap]="shadowMeshInput.map()"
+				[opacity]="debug() ? 1 : 0"
+			>
+				<ng-content />
+			</ngt-mesh-basic-material>
+		</ngt-mesh>
+	`, isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsSpotLightShadowMeshNoShader, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-spot-light-shadow-mesh-no-shader',
+                    standalone: true,
+                    template: `
+		<ngt-mesh [ref]="meshRef" [scale]="shadowMeshInput.scale()" [castShadow]="true">
+			<ngt-plane-geometry />
+			<ngt-mesh-basic-material
+				[transparent]="true"
+				[side]="DoubleSide"
+				[alphaTest]="shadowMeshInput.alphaTest()"
+				[alphaMap]="shadowMeshInput.map()"
+				[opacity]="debug() ? 1 : 0"
+			>
+				<ng-content />
+			</ngt-mesh-basic-material>
+		</ngt-mesh>
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: function () { return []; } });
+export class NgtsSpotLightShadowMeshShader {
+    constructor() {
+        this.shadowMeshInput = inject(NgtsSpotLightShadowMeshInput);
+        this.meshRef = injectNgtRef();
+        this.DoubleSide = THREE.DoubleSide;
+        this.RepeatWrapping = THREE.RepeatWrapping;
+        this.spotLightApi = injectNgtsSpotLightApi();
+        this.debug = this.spotLightApi.debug;
+        this.renderTarget = computed(() => {
+            const [width, height] = [this.shadowMeshInput.width(), this.shadowMeshInput.height()];
+            return new THREE.WebGLRenderTarget(width, height, {
+                format: THREE.RGBAFormat,
+                encoding: THREE.LinearEncoding,
+                stencilBuffer: false,
+                // depthTexture: null!
+            });
+        });
+        this.uniforms = {
+            uShadowMap: { value: this.shadowMeshInput.map() },
+            uTime: { value: 0 },
+        };
+        this.fsQuad = computed(() => {
+            const shader = this.shadowMeshInput.shader();
+            if (!shader)
+                return null;
+            return new FullScreenQuad(new THREE.ShaderMaterial({
+                uniforms: this.uniforms,
+                vertexShader: /* glsl */ `
+          varying vec2 vUv;
+
+          void main() {
+            vUv = uv;
+            gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+          }
+        `,
+                fragmentShader: shader,
+            }));
+        });
+        effect(() => {
+            this.shadowMeshInput.inputs.patch({
+                distance: 0.4,
+                alphaTest: 0.5,
+                width: 512,
+                height: 512,
+                scale: 4,
+                shader: /* glsl */ `
+          varying vec2 vUv;
+
+          uniform sampler2D uShadowMap;
+          uniform float uTime;
+
+          void main() {
+            vec3 color = texture2D(uShadowMap, vUv).xyz;
+            gl_FragColor = vec4(color, 1.);
+          }
+        `,
+            });
+        });
+        injectShadowMeshCommon(this.spotLightApi.spotLight, this.meshRef, this.shadowMeshInput.width, this.shadowMeshInput.height, this.shadowMeshInput.distance);
+        injectBeforeRender(({ delta, gl }) => {
+            this.uniforms.uTime.value += delta;
+            const fsQuad = this.fsQuad();
+            const renderTarget = this.renderTarget();
+            if (fsQuad && renderTarget) {
+                gl.setRenderTarget(renderTarget);
+                fsQuad.render(gl);
+                gl.setRenderTarget(null);
+            }
+        });
+        effect(() => {
+            const map = this.shadowMeshInput.map();
+            if (map) {
+                this.uniforms.uShadowMap.value = map;
+            }
+        });
+        effect((onCleanup) => {
+            const fsQuad = this.fsQuad();
+            onCleanup(() => {
+                if (fsQuad) {
+                    fsQuad.dispose();
+                    fsQuad.material.dispose();
+                }
+            });
+        });
+        effect((onCleanup) => {
+            const renderTarget = this.renderTarget();
+            onCleanup(() => {
+                renderTarget.dispose();
+            });
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsSpotLightShadowMeshShader, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.7", type: NgtsSpotLightShadowMeshShader, isStandalone: true, selector: "ngts-spot-light-shadow-mesh-shader", ngImport: i0, template: `
+		<ngt-mesh [ref]="meshRef" [scale]="shadowMeshInput.scale()" [castShadow]="true">
+			<ngt-plane-geometry />
+			<ngt-mesh-basic-material
+				[transparent]="true"
+				[side]="DoubleSide"
+				[alphaTest]="shadowMeshInput.alphaTest()"
+				[alphaMap]="renderTarget().texture"
+				[opacity]="debug() ? 1 : 0"
+			>
+				<ngt-value [rawValue]="RepeatWrapping" attach="alphaMap.wrapS" />
+				<ngt-value [rawValue]="RepeatWrapping" attach="alphaMap.wrapT" />
+				<ng-content />
+			</ngt-mesh-basic-material>
+		</ngt-mesh>
+	`, isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsSpotLightShadowMeshShader, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-spot-light-shadow-mesh-shader',
+                    standalone: true,
+                    template: `
+		<ngt-mesh [ref]="meshRef" [scale]="shadowMeshInput.scale()" [castShadow]="true">
+			<ngt-plane-geometry />
+			<ngt-mesh-basic-material
+				[transparent]="true"
+				[side]="DoubleSide"
+				[alphaTest]="shadowMeshInput.alphaTest()"
+				[alphaMap]="renderTarget().texture"
+				[opacity]="debug() ? 1 : 0"
+			>
+				<ngt-value [rawValue]="RepeatWrapping" attach="alphaMap.wrapS" />
+				<ngt-value [rawValue]="RepeatWrapping" attach="alphaMap.wrapT" />
+				<ng-content />
+			</ngt-mesh-basic-material>
+		</ngt-mesh>
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: function () { return []; } });
+export class NgtsSpotLightShadow extends NgtsSpotLightShadowMeshInput {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsSpotLightShadow, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.7", type: NgtsSpotLightShadow, isStandalone: true, selector: "ngts-spot-light-shadow", providers: [{ provide: NgtsSpotLightShadowMeshInput, useExisting: NgtsSpotLightShadow }], usesInheritance: true, ngImport: i0, template: `
+		<ngts-spot-light-shadow-mesh-shader *ngIf="shader(); else noShader" />
+		<ng-template #noShader>
+			<ngts-spot-light-shadow-mesh-no-shader />
+		</ng-template>
+	`, isInline: true, dependencies: [{ kind: "component", type: NgtsSpotLightShadowMeshShader, selector: "ngts-spot-light-shadow-mesh-shader" }, { kind: "component", type: NgtsSpotLightShadowMeshNoShader, selector: "ngts-spot-light-shadow-mesh-no-shader" }, { kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsSpotLightShadow, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-spot-light-shadow',
+                    standalone: true,
+                    template: `
+		<ngts-spot-light-shadow-mesh-shader *ngIf="shader(); else noShader" />
+		<ng-template #noShader>
+			<ngts-spot-light-shadow-mesh-no-shader />
+		</ng-template>
+	`,
+                    imports: [NgtsSpotLightShadowMeshShader, NgtsSpotLightShadowMeshNoShader, NgIf],
+                    providers: [{ provide: NgtsSpotLightShadowMeshInput, useExisting: NgtsSpotLightShadow }],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"shadow-mesh.js","sourceRoot":"","sources":["../../../../../../libs/soba/staging/src/spot-light/shadow-mesh.ts"],"names":[],"mappings":"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","sourcesContent":["import { NgIf } from '@angular/common';\nimport {\n\tCUSTOM_ELEMENTS_SCHEMA,\n\tComponent,\n\tcomputed,\n\teffect,\n\tinject,\n\trunInInjectionContext,\n\ttype Injector,\n} from '@angular/core';\nimport {\n\tassertInjectionContext,\n\tcheckUpdate,\n\textend,\n\tinjectBeforeRender,\n\tinjectNgtRef,\n\ttype NgtInjectedRef,\n} from 'angular-three';\nimport * as THREE from 'three';\nimport { Mesh, MeshBasicMaterial, PlaneGeometry } from 'three';\nimport { FullScreenQuad } from 'three-stdlib';\nimport { NgtsSpotLightShadowMeshInput, type NgtsSpotLightShadowMeshInputState } from './shadow-mesh-input';\nimport { injectNgtsSpotLightApi } from './spot-light';\n\nconst isSpotLight = (child: THREE.Object3D | null): child is THREE.SpotLight => {\n\treturn (child as THREE.SpotLight)?.isSpotLight;\n};\n\nfunction injectShadowMeshCommon(\n\tspotLightRef: NgtInjectedRef<THREE.SpotLight>,\n\tmeshRef: NgtInjectedRef<THREE.Mesh>,\n\twidth: () => number,\n\theight: () => number,\n\tdistance: () => number,\n\tinjector?: Injector,\n) {\n\tinjector = assertInjectionContext(injectShadowMeshCommon, injector);\n\trunInInjectionContext(injector, () => {\n\t\tconst pos = new THREE.Vector3();\n\t\tconst dir = new THREE.Vector3();\n\n\t\teffect(() => {\n\t\t\tconst spotLight = spotLightRef.nativeElement;\n\t\t\tif (!spotLight) return;\n\t\t\tif (isSpotLight(spotLight)) {\n\t\t\t\tspotLight.shadow.mapSize.set(width(), height());\n\t\t\t\tif (spotLight.shadow.map) {\n\t\t\t\t\tspotLight.shadow.map.setSize(width(), height());\n\t\t\t\t}\n\t\t\t\tspotLight.shadow.needsUpdate = true;\n\t\t\t} else {\n\t\t\t\tthrow new Error('<ngts-spot-light-shadow> must be a child of a <ngts-spot-light>');\n\t\t\t}\n\t\t});\n\n\t\tinjectBeforeRender(() => {\n\t\t\tconst spotLight = spotLightRef.nativeElement;\n\t\t\tconst mesh = meshRef.nativeElement;\n\n\t\t\tif (!spotLight) return;\n\n\t\t\tconst A = spotLight.position;\n\t\t\tconst B = spotLight.target.position;\n\n\t\t\tdir.copy(B).sub(A);\n\t\t\tconst len = dir.length();\n\t\t\tdir.normalize().multiplyScalar(len * distance());\n\t\t\tpos.copy(A).add(dir);\n\n\t\t\tif (mesh) {\n\t\t\t\tmesh.position.copy(pos);\n\t\t\t\tmesh.lookAt(spotLight.target.position);\n\t\t\t}\n\t\t});\n\t});\n}\n\nextend({ Mesh, PlaneGeometry, MeshBasicMaterial });\n\n@Component({\n\tselector: 'ngts-spot-light-shadow-mesh-no-shader',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-mesh [ref]=\"meshRef\" [scale]=\"shadowMeshInput.scale()\" [castShadow]=\"true\">\n\t\t\t<ngt-plane-geometry />\n\t\t\t<ngt-mesh-basic-material\n\t\t\t\t[transparent]=\"true\"\n\t\t\t\t[side]=\"DoubleSide\"\n\t\t\t\t[alphaTest]=\"shadowMeshInput.alphaTest()\"\n\t\t\t\t[alphaMap]=\"shadowMeshInput.map()\"\n\t\t\t\t[opacity]=\"debug() ? 1 : 0\"\n\t\t\t>\n\t\t\t\t<ng-content />\n\t\t\t</ngt-mesh-basic-material>\n\t\t</ngt-mesh>\n\t`,\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsSpotLightShadowMeshNoShader {\n\tshadowMeshInput = inject(NgtsSpotLightShadowMeshInput);\n\n\tmeshRef = injectNgtRef<THREE.Mesh>();\n\tDoubleSide = THREE.DoubleSide;\n\n\tprivate spotLightApi = injectNgtsSpotLightApi();\n\tdebug = this.spotLightApi.debug;\n\n\tconstructor() {\n\t\teffect(() => {\n\t\t\tthis.shadowMeshInput.inputs.patch({ distance: 0.4, alphaTest: 0.5, width: 512, height: 512, scale: 1 });\n\t\t});\n\n\t\teffect(() => {\n\t\t\tconst map = this.shadowMeshInput.map();\n\t\t\tif (map) {\n\t\t\t\tmap.wrapS = map.wrapT = THREE.RepeatWrapping;\n\t\t\t\tcheckUpdate(map);\n\t\t\t}\n\t\t});\n\n\t\tinjectShadowMeshCommon(\n\t\t\tthis.spotLightApi.spotLight,\n\t\t\tthis.meshRef,\n\t\t\tthis.shadowMeshInput.width,\n\t\t\tthis.shadowMeshInput.height,\n\t\t\tthis.shadowMeshInput.distance,\n\t\t);\n\t}\n}\n\n@Component({\n\tselector: 'ngts-spot-light-shadow-mesh-shader',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-mesh [ref]=\"meshRef\" [scale]=\"shadowMeshInput.scale()\" [castShadow]=\"true\">\n\t\t\t<ngt-plane-geometry />\n\t\t\t<ngt-mesh-basic-material\n\t\t\t\t[transparent]=\"true\"\n\t\t\t\t[side]=\"DoubleSide\"\n\t\t\t\t[alphaTest]=\"shadowMeshInput.alphaTest()\"\n\t\t\t\t[alphaMap]=\"renderTarget().texture\"\n\t\t\t\t[opacity]=\"debug() ? 1 : 0\"\n\t\t\t>\n\t\t\t\t<ngt-value [rawValue]=\"RepeatWrapping\" attach=\"alphaMap.wrapS\" />\n\t\t\t\t<ngt-value [rawValue]=\"RepeatWrapping\" attach=\"alphaMap.wrapT\" />\n\t\t\t\t<ng-content />\n\t\t\t</ngt-mesh-basic-material>\n\t\t</ngt-mesh>\n\t`,\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsSpotLightShadowMeshShader {\n\tshadowMeshInput = inject(NgtsSpotLightShadowMeshInput);\n\tmeshRef = injectNgtRef<THREE.Mesh>();\n\n\tDoubleSide = THREE.DoubleSide;\n\tRepeatWrapping = THREE.RepeatWrapping;\n\n\tprivate spotLightApi = injectNgtsSpotLightApi();\n\tdebug = this.spotLightApi.debug;\n\trenderTarget = computed(() => {\n\t\tconst [width, height] = [this.shadowMeshInput.width(), this.shadowMeshInput.height()];\n\n\t\treturn new THREE.WebGLRenderTarget(width, height, {\n\t\t\tformat: THREE.RGBAFormat,\n\t\t\tencoding: THREE.LinearEncoding,\n\t\t\tstencilBuffer: false,\n\t\t\t// depthTexture: null!\n\t\t});\n\t});\n\n\tprivate uniforms = {\n\t\tuShadowMap: { value: this.shadowMeshInput.map() },\n\t\tuTime: { value: 0 },\n\t};\n\n\tprivate fsQuad = computed(() => {\n\t\tconst shader = this.shadowMeshInput.shader();\n\t\tif (!shader) return null;\n\t\treturn new FullScreenQuad(\n\t\t\tnew THREE.ShaderMaterial({\n\t\t\t\tuniforms: this.uniforms,\n\t\t\t\tvertexShader: /* glsl */ `\n          varying vec2 vUv;\n\n          void main() {\n            vUv = uv;\n            gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);\n          }\n        `,\n\t\t\t\tfragmentShader: shader,\n\t\t\t}),\n\t\t);\n\t});\n\n\tconstructor() {\n\t\teffect(() => {\n\t\t\tthis.shadowMeshInput.inputs.patch({\n\t\t\t\tdistance: 0.4,\n\t\t\t\talphaTest: 0.5,\n\t\t\t\twidth: 512,\n\t\t\t\theight: 512,\n\t\t\t\tscale: 4,\n\t\t\t\tshader: /* glsl */ `\n          varying vec2 vUv;\n\n          uniform sampler2D uShadowMap;\n          uniform float uTime;\n\n          void main() {\n            vec3 color = texture2D(uShadowMap, vUv).xyz;\n            gl_FragColor = vec4(color, 1.);\n          }\n        `,\n\t\t\t});\n\t\t});\n\n\t\tinjectShadowMeshCommon(\n\t\t\tthis.spotLightApi.spotLight,\n\t\t\tthis.meshRef,\n\t\t\tthis.shadowMeshInput.width,\n\t\t\tthis.shadowMeshInput.height,\n\t\t\tthis.shadowMeshInput.distance,\n\t\t);\n\n\t\tinjectBeforeRender(({ delta, gl }) => {\n\t\t\tthis.uniforms.uTime.value += delta;\n\t\t\tconst fsQuad = this.fsQuad();\n\t\t\tconst renderTarget = this.renderTarget();\n\t\t\tif (fsQuad && renderTarget) {\n\t\t\t\tgl.setRenderTarget(renderTarget);\n\t\t\t\tfsQuad.render(gl);\n\t\t\t\tgl.setRenderTarget(null);\n\t\t\t}\n\t\t});\n\n\t\teffect(() => {\n\t\t\tconst map = this.shadowMeshInput.map();\n\t\t\tif (map) {\n\t\t\t\tthis.uniforms.uShadowMap.value = map;\n\t\t\t}\n\t\t});\n\n\t\teffect((onCleanup) => {\n\t\t\tconst fsQuad = this.fsQuad();\n\t\t\tonCleanup(() => {\n\t\t\t\tif (fsQuad) {\n\t\t\t\t\tfsQuad.dispose();\n\t\t\t\t\tfsQuad.material.dispose();\n\t\t\t\t}\n\t\t\t});\n\t\t});\n\n\t\teffect((onCleanup) => {\n\t\t\tconst renderTarget = this.renderTarget();\n\t\t\tonCleanup(() => {\n\t\t\t\trenderTarget.dispose();\n\t\t\t});\n\t\t});\n\t}\n}\n\ndeclare global {\n\tinterface HTMLElementTagNameMap {\n\t\t'ngts-spot-light-shadow': NgtsSpotLightShadowMeshInputState;\n\t}\n}\n\n@Component({\n\tselector: 'ngts-spot-light-shadow',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngts-spot-light-shadow-mesh-shader *ngIf=\"shader(); else noShader\" />\n\t\t<ng-template #noShader>\n\t\t\t<ngts-spot-light-shadow-mesh-no-shader />\n\t\t</ng-template>\n\t`,\n\timports: [NgtsSpotLightShadowMeshShader, NgtsSpotLightShadowMeshNoShader, NgIf],\n\tproviders: [{ provide: NgtsSpotLightShadowMeshInput, useExisting: NgtsSpotLightShadow }],\n})\nexport class NgtsSpotLightShadow extends NgtsSpotLightShadowMeshInput {}\n"]}