angular-three-soba 2.0.0-beta.7 → 2.0.0-beta.8

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"]}

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

@@ -1,75 +1,84 @@
 import { Directive, Input } from '@angular/core';
-import { NgtSignalStore } from 'angular-three';
+import { signalStore } from 'angular-three';
 import * as i0 from "@angular/core";
-class NgtsSpotLightInput extends NgtSignalStore {
+export class NgtsSpotLightInput {
     constructor() {
-        super(...arguments);
-        this.lightDebug = this.select('debug');
-        this.lightColor = this.select('color');
-        this.lightOpacity = this.select('opacity');
-        this.lightRadiusBottom = this.select('radiusBottom');
-        this.lightRadiusTop = this.select('radiusTop');
-        this.lightAnglePower = this.select('anglePower');
-        this.lightAttenuation = this.select('attenuation');
-        this.lightDistance = this.select('distance');
-        this.lightAngle = this.select('angle');
-        this.lightDepthBuffer = this.select('depthBuffer');
+        this.inputs = signalStore({});
+        this.debug = this.inputs.select('debug');
+        this.color = this.inputs.select('color');
+        this.opacity = this.inputs.select('opacity');
+        this.radiusBottom = this.inputs.select('radiusBottom');
+        this.radiusTop = this.inputs.select('radiusTop');
+        this.anglePower = this.inputs.select('anglePower');
+        this.attenuation = this.inputs.select('attenuation');
+        this.distance = this.inputs.select('distance');
+        this.angle = this.inputs.select('angle');
+        this.depthBuffer = this.inputs.select('depthBuffer');
     }
-    set depthBuffer(depthBuffer) {
-        this.set({ depthBuffer });
+    set _depthBuffer(depthBuffer) {
+        this.inputs.set({ depthBuffer });
     }
-    set angle(angle) {
-        this.set({ angle });
+    set _angle(angle) {
+        this.inputs.set({ angle });
     }
-    set distance(distance) {
-        this.set({ distance });
+    set _distance(distance) {
+        this.inputs.set({ distance });
     }
-    set attenuation(attenuation) {
-        this.set({ attenuation });
+    set _attenuation(attenuation) {
+        this.inputs.set({ attenuation });
     }
-    set anglePower(anglePower) {
-        this.set({ anglePower });
+    set _anglePower(anglePower) {
+        this.inputs.set({ anglePower });
     }
-    set radiusTop(radiusTop) {
-        this.set({ radiusTop });
+    set _radiusTop(radiusTop) {
+        this.inputs.set({ radiusTop });
     }
-    set radiusBottom(radiusBottom) {
-        this.set({ radiusBottom });
+    set _radiusBottom(radiusBottom) {
+        this.inputs.set({ radiusBottom });
     }
-    set opacity(opacity) {
-        this.set({ opacity });
+    set _opacity(opacity) {
+        this.inputs.set({ opacity });
     }
-    set color(color) {
-        this.set({ color });
+    set _color(color) {
+        this.inputs.set({ color });
     }
-    set debug(debug) {
-        this.set({ debug });
+    set _debug(debug) {
+        this.inputs.set({ debug });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.3", ngImport: i0, type: NgtsSpotLightInput, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.3", type: NgtsSpotLightInput, inputs: { depthBuffer: "depthBuffer", angle: "angle", distance: "distance", attenuation: "attenuation", anglePower: "anglePower", radiusTop: "radiusTop", radiusBottom: "radiusBottom", opacity: "opacity", color: "color", debug: "debug" }, usesInheritance: true, ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsSpotLightInput, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.7", type: NgtsSpotLightInput, inputs: { _depthBuffer: ["depthBuffer", "_depthBuffer"], _angle: ["angle", "_angle"], _distance: ["distance", "_distance"], _attenuation: ["attenuation", "_attenuation"], _anglePower: ["anglePower", "_anglePower"], _radiusTop: ["radiusTop", "_radiusTop"], _radiusBottom: ["radiusBottom", "_radiusBottom"], _opacity: ["opacity", "_opacity"], _color: ["color", "_color"], _debug: ["debug", "_debug"] }, ngImport: i0 }); }
 }
-export { NgtsSpotLightInput };
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.3", ngImport: i0, type: NgtsSpotLightInput, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsSpotLightInput, decorators: [{
             type: Directive
-        }], propDecorators: { depthBuffer: [{
-                type: Input
-            }], angle: [{
-                type: Input
-            }], distance: [{
-                type: Input
-            }], attenuation: [{
-                type: Input
-            }], anglePower: [{
-                type: Input
-            }], radiusTop: [{
-                type: Input
-            }], radiusBottom: [{
-                type: Input
-            }], opacity: [{
-                type: Input
-            }], color: [{
-                type: Input
-            }], debug: [{
-                type: Input
+        }], propDecorators: { _depthBuffer: [{
+                type: Input,
+                args: [{ alias: 'depthBuffer' }]
+            }], _angle: [{
+                type: Input,
+                args: [{ alias: 'angle' }]
+            }], _distance: [{
+                type: Input,
+                args: [{ alias: 'distance' }]
+            }], _attenuation: [{
+                type: Input,
+                args: [{ alias: 'attenuation' }]
+            }], _anglePower: [{
+                type: Input,
+                args: [{ alias: 'anglePower' }]
+            }], _radiusTop: [{
+                type: Input,
+                args: [{ alias: 'radiusTop' }]
+            }], _radiusBottom: [{
+                type: Input,
+                args: [{ alias: 'radiusBottom' }]
+            }], _opacity: [{
+                type: Input,
+                args: [{ alias: 'opacity' }]
+            }], _color: [{
+                type: Input,
+                args: [{ alias: 'color' }]
+            }], _debug: [{
+                type: Input,
+                args: [{ alias: 'debug' }]
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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