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

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

@@ -0,0 +1,57 @@
+import { Directive, Input } from '@angular/core';
+import { NgtSignalStore } from 'angular-three';
+import * as i0 from "@angular/core";
+class NgtsSpotLightShadowMeshInput extends NgtSignalStore {
+    constructor() {
+        super(...arguments);
+        this.shadowMeshDistance = this.select('distance');
+        this.shadowMeshAlphaTest = this.select('alphaTest');
+        this.shadowMeshScale = this.select('scale');
+        this.shadowMeshMap = this.select('map');
+        this.shadowMeshShader = this.select('shader');
+        this.shadowMeshWidth = this.select('width');
+        this.shadowMeshHeight = this.select('height');
+    }
+    set distance(distance) {
+        this.set({ distance });
+    }
+    set alphaTest(alphaTest) {
+        this.set({ alphaTest });
+    }
+    set scale(scale) {
+        this.set({ scale });
+    }
+    set map(map) {
+        this.set({ map });
+    }
+    set shader(shader) {
+        this.set({ shader });
+    }
+    set width(width) {
+        this.set({ width });
+    }
+    set height(height) {
+        this.set({ height });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsSpotLightShadowMeshInput, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: NgtsSpotLightShadowMeshInput, inputs: { distance: "distance", alphaTest: "alphaTest", scale: "scale", map: "map", shader: "shader", width: "width", height: "height" }, usesInheritance: true, ngImport: i0 }); }
+}
+export { NgtsSpotLightShadowMeshInput };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsSpotLightShadowMeshInput, decorators: [{
+            type: Directive
+        }], propDecorators: { distance: [{
+                type: Input
+            }], alphaTest: [{
+                type: Input
+            }], scale: [{
+                type: Input
+            }], map: [{
+                type: Input
+            }], shader: [{
+                type: Input
+            }], width: [{
+                type: Input
+            }], height: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,256 @@
+import { NgIf } from '@angular/common';
+import { CUSTOM_ELEMENTS_SCHEMA, Component, computed, effect, inject, runInInjectionContext, } from '@angular/core';
+import { assertInjectionContext, checkUpdate, extend, injectBeforeRender, injectNgtRef, requestAnimationInInjectionContext, } from 'angular-three';
+import * as THREE from 'three';
+import { Mesh, MeshBasicMaterial, PlaneGeometry } from 'three';
+import { FullScreenQuad } from 'three-stdlib';
+import { NGTS_SPOT_LIGHT_API } from './spot-light';
+import { NgtsSpotLightShadowMeshInput } from './spot-light-shadow-mesh-input';
+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();
+        requestAnimationInInjectionContext(() => {
+            effect(() => {
+                const spotLight = spotLightRef.nativeElement;
+                if (!spotLight)
+                    return;
+                if (isSpotLight(spotLight)) {
+                    spotLight.shadow.mapSize.set(width(), height());
+                    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 });
+class NgtsSpotLightShadowMeshNoShader {
+    #spotLightApi;
+    constructor() {
+        this.shadowMeshInput = inject(NgtsSpotLightShadowMeshInput);
+        this.#spotLightApi = inject(NGTS_SPOT_LIGHT_API);
+        this.meshRef = injectNgtRef();
+        this.DoubleSide = THREE.DoubleSide;
+        this.debug = this.#spotLightApi.debug;
+        this.shadowMeshInput.patch({ distance: 0.4, alphaTest: 0.5, width: 512, height: 512, scale: 1 });
+        requestAnimationInInjectionContext(() => {
+            effect(() => {
+                const map = this.shadowMeshInput.shadowMeshMap();
+                if (map) {
+                    map.wrapS = map.wrapT = THREE.RepeatWrapping;
+                    checkUpdate(map);
+                }
+            });
+        });
+        injectShadowMeshCommon(this.#spotLightApi.spotLight, this.meshRef, this.shadowMeshInput.shadowMeshWidth, this.shadowMeshInput.shadowMeshHeight, this.shadowMeshInput.shadowMeshDistance);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsSpotLightShadowMeshNoShader, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: NgtsSpotLightShadowMeshNoShader, isStandalone: true, selector: "ngts-spot-light-shadow-mesh-no-shader", ngImport: i0, template: `
+        <ngt-mesh [ref]="meshRef" [scale]="shadowMeshInput.shadowMeshScale()" [castShadow]="true">
+            <ngt-plane-geometry />
+            <ngt-mesh-basic-material
+                [transparent]="true"
+                [side]="DoubleSide"
+                [alphaTest]="shadowMeshInput.shadowMeshAlphaTest()"
+                [alphaMap]="shadowMeshInput.shadowMeshMap()"
+                [opacity]="debug() ? 1 : 0"
+            >
+                <ng-content />
+            </ngt-mesh-basic-material>
+        </ngt-mesh>
+    `, isInline: true }); }
+}
+export { NgtsSpotLightShadowMeshNoShader };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", 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.shadowMeshScale()" [castShadow]="true">
+            <ngt-plane-geometry />
+            <ngt-mesh-basic-material
+                [transparent]="true"
+                [side]="DoubleSide"
+                [alphaTest]="shadowMeshInput.shadowMeshAlphaTest()"
+                [alphaMap]="shadowMeshInput.shadowMeshMap()"
+                [opacity]="debug() ? 1 : 0"
+            >
+                <ng-content />
+            </ngt-mesh-basic-material>
+        </ngt-mesh>
+    `,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: function () { return []; } });
+class NgtsSpotLightShadowMeshShader {
+    #spotLightApi;
+    #fsQuad;
+    constructor() {
+        this.shadowMeshInput = inject(NgtsSpotLightShadowMeshInput);
+        this.meshRef = injectNgtRef();
+        this.#spotLightApi = inject(NGTS_SPOT_LIGHT_API);
+        this.DoubleSide = THREE.DoubleSide;
+        this.RepeatWrapping = THREE.RepeatWrapping;
+        this.debug = this.#spotLightApi.debug;
+        this.renderTarget = computed(() => {
+            const width = this.shadowMeshInput.shadowMeshWidth();
+            const height = this.shadowMeshInput.shadowMeshHeight();
+            return new THREE.WebGLRenderTarget(width, height, {
+                format: THREE.RGBAFormat,
+                encoding: THREE.LinearEncoding,
+                stencilBuffer: false,
+                // depthTexture: null!
+            });
+        });
+        this.uniforms = {
+            uShadowMap: { value: this.shadowMeshInput.shadowMeshMap() },
+            uTime: { value: 0 },
+        };
+        this.#fsQuad = computed(() => {
+            const shader = this.shadowMeshInput.shadowMeshShader();
+            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,
+            }));
+        });
+        this.shadowMeshInput.patch({ distance: 0.4, alphaTest: 0.5, width: 512, height: 512, scale: 4 });
+        injectShadowMeshCommon(this.#spotLightApi.spotLight, this.meshRef, this.shadowMeshInput.shadowMeshWidth, this.shadowMeshInput.shadowMeshHeight, this.shadowMeshInput.shadowMeshDistance);
+        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);
+            }
+        });
+        requestAnimationInInjectionContext(() => {
+            effect(() => {
+                const map = this.shadowMeshInput.shadowMeshMap();
+                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.0.0", ngImport: i0, type: NgtsSpotLightShadowMeshShader, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: NgtsSpotLightShadowMeshShader, isStandalone: true, selector: "ngts-spot-light-shadow-mesh-shader", ngImport: i0, template: `
+        <ngt-mesh [ref]="meshRef" [scale]="shadowMeshInput.shadowMeshScale()" [castShadow]="true">
+            <ngt-plane-geometry />
+            <ngt-mesh-basic-material
+                [transparent]="true"
+                [side]="DoubleSide"
+                [alphaTest]="shadowMeshInput.shadowMeshAlphaTest()"
+                [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 }); }
+}
+export { NgtsSpotLightShadowMeshShader };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsSpotLightShadowMeshShader, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-spot-light-shadow-mesh-shader',
+                    standalone: true,
+                    template: `
+        <ngt-mesh [ref]="meshRef" [scale]="shadowMeshInput.shadowMeshScale()" [castShadow]="true">
+            <ngt-plane-geometry />
+            <ngt-mesh-basic-material
+                [transparent]="true"
+                [side]="DoubleSide"
+                [alphaTest]="shadowMeshInput.shadowMeshAlphaTest()"
+                [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 []; } });
+class NgtsSpotLightShadow extends NgtsSpotLightShadowMeshInput {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsSpotLightShadow, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", 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="shadowMeshShader(); 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"] }] }); }
+}
+export { NgtsSpotLightShadow };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsSpotLightShadow, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-spot-light-shadow',
+                    standalone: true,
+                    template: `
+        <ngts-spot-light-shadow-mesh-shader *ngIf="shadowMeshShader(); 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":"spot-light-shadow-mesh.js","sourceRoot":"","sources":["../../../../../../libs/soba/staging/src/spot-light/spot-light-shadow-mesh.ts"],"names":[],"mappings":"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","sourcesContent":["import { NgIf } from '@angular/common';\nimport {\n    CUSTOM_ELEMENTS_SCHEMA,\n    Component,\n    Injector,\n    computed,\n    effect,\n    inject,\n    runInInjectionContext,\n} from '@angular/core';\nimport {\n    NgtInjectedRef,\n    assertInjectionContext,\n    checkUpdate,\n    extend,\n    injectBeforeRender,\n    injectNgtRef,\n    requestAnimationInInjectionContext,\n} from 'angular-three';\nimport * as THREE from 'three';\nimport { Mesh, MeshBasicMaterial, PlaneGeometry } from 'three';\nimport { FullScreenQuad } from 'three-stdlib';\nimport { NGTS_SPOT_LIGHT_API } from './spot-light';\nimport { NgtsSpotLightShadowMeshInput } from './spot-light-shadow-mesh-input';\n\nconst isSpotLight = (child: THREE.Object3D | null): child is THREE.SpotLight => {\n    return (child as THREE.SpotLight)?.isSpotLight;\n};\n\nfunction injectShadowMeshCommon(\n    spotLightRef: NgtInjectedRef<THREE.SpotLight>,\n    meshRef: NgtInjectedRef<THREE.Mesh>,\n    width: () => number,\n    height: () => number,\n    distance: () => number,\n    injector?: Injector\n) {\n    injector = assertInjectionContext(injectShadowMeshCommon, injector);\n    runInInjectionContext(injector, () => {\n        const pos = new THREE.Vector3();\n        const dir = new THREE.Vector3();\n\n        requestAnimationInInjectionContext(() => {\n            effect(() => {\n                const spotLight = spotLightRef.nativeElement;\n                if (!spotLight) return;\n                if (isSpotLight(spotLight)) {\n                    spotLight.shadow.mapSize.set(width(), height());\n                    spotLight.shadow.map.setSize(width(), height());\n                    spotLight.shadow.needsUpdate = true;\n                } else {\n                    throw new Error('<ngts-spot-light-shadow> must be a child of a <ngts-spot-light>');\n                }\n            });\n        });\n\n        injectBeforeRender(() => {\n            const spotLight = spotLightRef.nativeElement;\n            const mesh = meshRef.nativeElement;\n\n            if (!spotLight) return;\n\n            const A = spotLight.position;\n            const B = spotLight.target.position;\n\n            dir.copy(B).sub(A);\n            const len = dir.length();\n            dir.normalize().multiplyScalar(len * distance());\n            pos.copy(A).add(dir);\n\n            if (mesh) {\n                mesh.position.copy(pos);\n                mesh.lookAt(spotLight.target.position);\n            }\n        });\n    });\n}\n\nextend({ Mesh, PlaneGeometry, MeshBasicMaterial });\n\n@Component({\n    selector: 'ngts-spot-light-shadow-mesh-no-shader',\n    standalone: true,\n    template: `\n        <ngt-mesh [ref]=\"meshRef\" [scale]=\"shadowMeshInput.shadowMeshScale()\" [castShadow]=\"true\">\n            <ngt-plane-geometry />\n            <ngt-mesh-basic-material\n                [transparent]=\"true\"\n                [side]=\"DoubleSide\"\n                [alphaTest]=\"shadowMeshInput.shadowMeshAlphaTest()\"\n                [alphaMap]=\"shadowMeshInput.shadowMeshMap()\"\n                [opacity]=\"debug() ? 1 : 0\"\n            >\n                <ng-content />\n            </ngt-mesh-basic-material>\n        </ngt-mesh>\n    `,\n    schemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsSpotLightShadowMeshNoShader {\n    protected readonly shadowMeshInput = inject(NgtsSpotLightShadowMeshInput);\n    readonly #spotLightApi = inject(NGTS_SPOT_LIGHT_API);\n\n    readonly meshRef = injectNgtRef<THREE.Mesh>();\n    readonly DoubleSide = THREE.DoubleSide;\n\n    readonly debug = this.#spotLightApi.debug;\n\n    constructor() {\n        this.shadowMeshInput.patch({ distance: 0.4, alphaTest: 0.5, width: 512, height: 512, scale: 1 });\n\n        requestAnimationInInjectionContext(() => {\n            effect(() => {\n                const map = this.shadowMeshInput.shadowMeshMap();\n                if (map) {\n                    map.wrapS = map.wrapT = THREE.RepeatWrapping;\n                    checkUpdate(map);\n                }\n            });\n        });\n\n        injectShadowMeshCommon(\n            this.#spotLightApi.spotLight,\n            this.meshRef,\n            this.shadowMeshInput.shadowMeshWidth,\n            this.shadowMeshInput.shadowMeshHeight,\n            this.shadowMeshInput.shadowMeshDistance\n        );\n    }\n}\n\n@Component({\n    selector: 'ngts-spot-light-shadow-mesh-shader',\n    standalone: true,\n    template: `\n        <ngt-mesh [ref]=\"meshRef\" [scale]=\"shadowMeshInput.shadowMeshScale()\" [castShadow]=\"true\">\n            <ngt-plane-geometry />\n            <ngt-mesh-basic-material\n                [transparent]=\"true\"\n                [side]=\"DoubleSide\"\n                [alphaTest]=\"shadowMeshInput.shadowMeshAlphaTest()\"\n                [alphaMap]=\"renderTarget().texture\"\n                [opacity]=\"debug() ? 1 : 0\"\n            >\n                <ngt-value [rawValue]=\"RepeatWrapping\" attach=\"alphaMap.wrapS\" />\n                <ngt-value [rawValue]=\"RepeatWrapping\" attach=\"alphaMap.wrapT\" />\n                <ng-content />\n            </ngt-mesh-basic-material>\n        </ngt-mesh>\n    `,\n    schemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsSpotLightShadowMeshShader {\n    protected readonly shadowMeshInput = inject(NgtsSpotLightShadowMeshInput);\n    readonly meshRef = injectNgtRef<THREE.Mesh>();\n    readonly #spotLightApi = inject(NGTS_SPOT_LIGHT_API);\n\n    readonly DoubleSide = THREE.DoubleSide;\n    readonly RepeatWrapping = THREE.RepeatWrapping;\n\n    readonly debug = this.#spotLightApi.debug;\n    readonly renderTarget = computed(() => {\n        const width = this.shadowMeshInput.shadowMeshWidth();\n        const height = this.shadowMeshInput.shadowMeshHeight();\n\n        return new THREE.WebGLRenderTarget(width, height, {\n            format: THREE.RGBAFormat,\n            encoding: THREE.LinearEncoding,\n            stencilBuffer: false,\n            // depthTexture: null!\n        });\n    });\n    readonly uniforms = {\n        uShadowMap: { value: this.shadowMeshInput.shadowMeshMap() },\n        uTime: { value: 0 },\n    };\n\n    readonly #fsQuad = computed(() => {\n        const shader = this.shadowMeshInput.shadowMeshShader();\n        if (!shader) return null;\n        return new FullScreenQuad(\n            new THREE.ShaderMaterial({\n                uniforms: this.uniforms,\n                vertexShader: /* glsl */ `\n                  varying vec2 vUv;\n\n                  void main() {\n                    vUv = uv;\n                    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);\n                  }\n                `,\n                fragmentShader: shader,\n            })\n        );\n    });\n\n    constructor() {\n        this.shadowMeshInput.patch({ distance: 0.4, alphaTest: 0.5, width: 512, height: 512, scale: 4 });\n\n        injectShadowMeshCommon(\n            this.#spotLightApi.spotLight,\n            this.meshRef,\n            this.shadowMeshInput.shadowMeshWidth,\n            this.shadowMeshInput.shadowMeshHeight,\n            this.shadowMeshInput.shadowMeshDistance\n        );\n\n        injectBeforeRender(({ delta, gl }) => {\n            this.uniforms.uTime.value += delta;\n            const fsQuad = this.#fsQuad();\n            const renderTarget = this.renderTarget();\n            if (fsQuad && renderTarget) {\n                gl.setRenderTarget(renderTarget);\n                fsQuad.render(gl);\n                gl.setRenderTarget(null);\n            }\n        });\n\n        requestAnimationInInjectionContext(() => {\n            effect(() => {\n                const map = this.shadowMeshInput.shadowMeshMap();\n                if (map) {\n                    this.uniforms.uShadowMap.value = map;\n                }\n            });\n\n            effect((onCleanup) => {\n                const fsQuad = this.#fsQuad();\n                onCleanup(() => {\n                    if (fsQuad) {\n                        fsQuad.dispose();\n                        fsQuad.material.dispose();\n                    }\n                });\n            });\n\n            effect((onCleanup) => {\n                const renderTarget = this.renderTarget();\n                onCleanup(() => {\n                    renderTarget.dispose();\n                });\n            });\n        });\n    }\n}\n\n@Component({\n    selector: 'ngts-spot-light-shadow',\n    standalone: true,\n    template: `\n        <ngts-spot-light-shadow-mesh-shader *ngIf=\"shadowMeshShader(); else noShader\" />\n        <ng-template #noShader>\n            <ngts-spot-light-shadow-mesh-no-shader />\n        </ng-template>\n    `,\n    imports: [NgtsSpotLightShadowMeshShader, NgtsSpotLightShadowMeshNoShader, NgIf],\n    providers: [{ provide: NgtsSpotLightShadowMeshInput, useExisting: NgtsSpotLightShadow }],\n})\nexport class NgtsSpotLightShadow extends NgtsSpotLightShadowMeshInput {}\n"]}

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

@@ -0,0 +1,94 @@
+import { NgIf } from '@angular/common';
+import { CUSTOM_ELEMENTS_SCHEMA, Component, InjectionToken, Input } from '@angular/core';
+import { NgtArgs, extend, injectNgtRef } from 'angular-three';
+import { Group, SpotLight, SpotLightHelper } from 'three';
+import { NgtsSpotLightInput } from './spot-light-input';
+import { NgtsVolumetricMesh } from './volumetric-mesh';
+import * as i0 from "@angular/core";
+extend({ SpotLight, SpotLightHelper, Group });
+export const NGTS_SPOT_LIGHT_API = new InjectionToken('NgtsSpotLight API');
+function spotLightApiFactory(spotLight) {
+    return {
+        spotLight: spotLight.spotLightRef,
+        debug: spotLight.lightDebug,
+    };
+}
+class NgtsSpotLight extends NgtsSpotLightInput {
+    set volumetric(volumetric) {
+        this.set({ volumetric });
+    }
+    constructor() {
+        super();
+        this.spotLightRef = injectNgtRef();
+        this.showVolumetric = this.select('volumetric');
+        this.set({
+            opacity: 1,
+            color: 'white',
+            distance: 5,
+            angle: 0.15,
+            attenuation: 5,
+            anglePower: 5,
+            volumetric: true,
+            debug: false,
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsSpotLight, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: NgtsSpotLight, isStandalone: true, selector: "ngts-spot-light", inputs: { spotLightRef: "spotLightRef", volumetric: "volumetric" }, providers: [
+            { provide: NGTS_SPOT_LIGHT_API, useFactory: spotLightApiFactory, deps: [NgtsSpotLight] },
+            { provide: NgtsSpotLightInput, useExisting: NgtsSpotLight },
+        ], usesInheritance: true, ngImport: i0, template: `
+        <ngt-group>
+            <ng-container *ngIf="lightDebug() && spotLightRef.nativeElement">
+                <ngt-spot-light-helper *args="[spotLightRef.nativeElement]" />
+            </ng-container>
+            <ngt-spot-light
+                [ref]="spotLightRef"
+                [color]="lightColor()"
+                [distance]="lightDistance()"
+                [angle]="lightAngle()"
+                [castShadow]="true"
+                ngtCompound
+            >
+                <ngts-volumetric-mesh *ngIf="showVolumetric()" />
+            </ngt-spot-light>
+            <ng-content />
+        </ngt-group>
+    `, isInline: true, dependencies: [{ kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: NgtArgs, selector: "[args]", inputs: ["args"] }, { kind: "component", type: NgtsVolumetricMesh, selector: "ngts-volumetric-mesh" }] }); }
+}
+export { NgtsSpotLight };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsSpotLight, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-spot-light',
+                    standalone: true,
+                    template: `
+        <ngt-group>
+            <ng-container *ngIf="lightDebug() && spotLightRef.nativeElement">
+                <ngt-spot-light-helper *args="[spotLightRef.nativeElement]" />
+            </ng-container>
+            <ngt-spot-light
+                [ref]="spotLightRef"
+                [color]="lightColor()"
+                [distance]="lightDistance()"
+                [angle]="lightAngle()"
+                [castShadow]="true"
+                ngtCompound
+            >
+                <ngts-volumetric-mesh *ngIf="showVolumetric()" />
+            </ngt-spot-light>
+            <ng-content />
+        </ngt-group>
+    `,
+                    providers: [
+                        { provide: NGTS_SPOT_LIGHT_API, useFactory: spotLightApiFactory, deps: [NgtsSpotLight] },
+                        { provide: NgtsSpotLightInput, useExisting: NgtsSpotLight },
+                    ],
+                    imports: [NgIf, NgtArgs, NgtsVolumetricMesh],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { spotLightRef: [{
+                type: Input
+            }], volumetric: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,101 @@
+import { Component, computed, CUSTOM_ELEMENTS_SCHEMA, inject } from '@angular/core';
+import { extend, injectBeforeRender, injectNgtRef, NgtArgs, NgtStore } from 'angular-three';
+import { SpotLightMaterial } from 'angular-three-soba/shaders';
+import * as THREE from 'three';
+import { Mesh } from 'three';
+import { NgtsSpotLightInput } from './spot-light-input';
+import * as i0 from "@angular/core";
+extend({ Mesh });
+class NgtsVolumetricMesh {
+    #vec;
+    #store;
+    #camera;
+    #size;
+    #dpr;
+    #normalizedRadiusTop;
+    #normalizedRadiusBottom;
+    constructor() {
+        this.spotLightInput = inject(NgtsSpotLightInput);
+        this.mesh = injectNgtRef();
+        this.material = new SpotLightMaterial();
+        this.nullRaycast = () => null;
+        this.#vec = new THREE.Vector3();
+        this.#store = inject(NgtStore);
+        this.#camera = this.#store.select('camera');
+        this.#size = this.#store.select('size');
+        this.#dpr = this.#store.select('viewport', 'dpr');
+        this.#normalizedRadiusTop = computed(() => this.spotLightInput.lightRadiusTop() === undefined ? 0.1 : this.spotLightInput.lightRadiusTop());
+        this.#normalizedRadiusBottom = computed(() => this.spotLightInput.lightRadiusBottom() === undefined
+            ? this.spotLightInput.lightAngle() * 7
+            : this.spotLightInput.lightRadiusBottom());
+        this.geometry = computed(() => {
+            const distance = this.spotLightInput.lightDistance();
+            const radiusTop = this.#normalizedRadiusTop();
+            const radiusBottom = this.#normalizedRadiusBottom();
+            const geometry = new THREE.CylinderGeometry(radiusTop, radiusBottom, distance, 128, 64, true);
+            geometry.applyMatrix4(new THREE.Matrix4().makeTranslation(0, -distance / 2, 0));
+            geometry.applyMatrix4(new THREE.Matrix4().makeRotationX(-Math.PI / 2));
+            return geometry;
+        });
+        this.near = computed(() => this.#camera().near);
+        this.far = computed(() => this.#camera().far);
+        this.resolution = computed(() => this.spotLightInput.lightDepthBuffer()
+            ? [this.#size().width * this.#dpr(), this.#size().height * this.#dpr()]
+            : [0, 0]);
+        this.spotLightInput.patch({
+            opacity: 1,
+            color: 'white',
+            distance: 5,
+            angle: 0.15,
+            attenuation: 5,
+            anglePower: 5,
+        });
+        injectBeforeRender(() => {
+            const mesh = this.mesh.nativeElement;
+            if (!mesh)
+                return;
+            this.material.uniforms['spotPosition'].value.copy(mesh.getWorldPosition(this.#vec));
+            mesh.lookAt(mesh.parent.target.getWorldPosition(this.#vec));
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsVolumetricMesh, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: NgtsVolumetricMesh, isStandalone: true, selector: "ngts-volumetric-mesh", ngImport: i0, template: `
+        <ngt-mesh [ref]="mesh" [geometry]="geometry()" [raycast]="nullRaycast">
+            <ngt-primitive *args="[material]" attach="material">
+                <ngt-value [rawValue]="spotLightInput.lightOpacity()" attach="uniforms.opacity.value" />
+                <ngt-value [rawValue]="spotLightInput.lightColor()" attach="uniforms.lightColor.value" />
+                <ngt-value [rawValue]="spotLightInput.lightAttenuation()" attach="uniforms.attenuation.value" />
+                <ngt-value [rawValue]="spotLightInput.lightAnglePower()" attach="uniforms.anglePower.value" />
+                <ngt-value [rawvalue]="spotLightInput.lightDepthBuffer()" attach="uniforms.depth.value" />
+                <ngt-value [rawvalue]="near()" attach="uniforms.cameraNear.value" />
+                <ngt-value [rawvalue]="far()" attach="uniforms.cameraFar.value" />
+                <ngt-value [rawvalue]="resolution()" attach="uniforms.resolution.value" />
+            </ngt-primitive>
+        </ngt-mesh>
+    `, isInline: true, dependencies: [{ kind: "directive", type: NgtArgs, selector: "[args]", inputs: ["args"] }] }); }
+}
+export { NgtsVolumetricMesh };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsVolumetricMesh, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-volumetric-mesh',
+                    standalone: true,
+                    template: `
+        <ngt-mesh [ref]="mesh" [geometry]="geometry()" [raycast]="nullRaycast">
+            <ngt-primitive *args="[material]" attach="material">
+                <ngt-value [rawValue]="spotLightInput.lightOpacity()" attach="uniforms.opacity.value" />
+                <ngt-value [rawValue]="spotLightInput.lightColor()" attach="uniforms.lightColor.value" />
+                <ngt-value [rawValue]="spotLightInput.lightAttenuation()" attach="uniforms.attenuation.value" />
+                <ngt-value [rawValue]="spotLightInput.lightAnglePower()" attach="uniforms.anglePower.value" />
+                <ngt-value [rawvalue]="spotLightInput.lightDepthBuffer()" attach="uniforms.depth.value" />
+                <ngt-value [rawvalue]="near()" attach="uniforms.cameraNear.value" />
+                <ngt-value [rawvalue]="far()" attach="uniforms.cameraFar.value" />
+                <ngt-value [rawvalue]="resolution()" attach="uniforms.resolution.value" />
+            </ngt-primitive>
+        </ngt-mesh>
+    `,
+                    imports: [NgtArgs],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"volumetric-mesh.js","sourceRoot":"","sources":["../../../../../../libs/soba/staging/src/spot-light/volumetric-mesh.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, computed, CUSTOM_ELEMENTS_SCHEMA, inject } from '@angular/core';\nimport { extend, injectBeforeRender, injectNgtRef, NgtArgs, NgtStore } from 'angular-three';\nimport { SpotLightMaterial } from 'angular-three-soba/shaders';\nimport * as THREE from 'three';\nimport { Mesh } from 'three';\nimport { NgtsSpotLightInput } from './spot-light-input';\n\nextend({ Mesh });\n\n@Component({\n    selector: 'ngts-volumetric-mesh',\n    standalone: true,\n    template: `\n        <ngt-mesh [ref]=\"mesh\" [geometry]=\"geometry()\" [raycast]=\"nullRaycast\">\n            <ngt-primitive *args=\"[material]\" attach=\"material\">\n                <ngt-value [rawValue]=\"spotLightInput.lightOpacity()\" attach=\"uniforms.opacity.value\" />\n                <ngt-value [rawValue]=\"spotLightInput.lightColor()\" attach=\"uniforms.lightColor.value\" />\n                <ngt-value [rawValue]=\"spotLightInput.lightAttenuation()\" attach=\"uniforms.attenuation.value\" />\n                <ngt-value [rawValue]=\"spotLightInput.lightAnglePower()\" attach=\"uniforms.anglePower.value\" />\n                <ngt-value [rawvalue]=\"spotLightInput.lightDepthBuffer()\" attach=\"uniforms.depth.value\" />\n                <ngt-value [rawvalue]=\"near()\" attach=\"uniforms.cameraNear.value\" />\n                <ngt-value [rawvalue]=\"far()\" attach=\"uniforms.cameraFar.value\" />\n                <ngt-value [rawvalue]=\"resolution()\" attach=\"uniforms.resolution.value\" />\n            </ngt-primitive>\n        </ngt-mesh>\n    `,\n    imports: [NgtArgs],\n    schemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsVolumetricMesh {\n    protected readonly spotLightInput = inject(NgtsSpotLightInput);\n    readonly mesh = injectNgtRef<THREE.Mesh>();\n    readonly material = new SpotLightMaterial();\n    readonly nullRaycast = () => null;\n\n    readonly #vec = new THREE.Vector3();\n    readonly #store = inject(NgtStore);\n    readonly #camera = this.#store.select('camera');\n    readonly #size = this.#store.select('size');\n    readonly #dpr = this.#store.select('viewport', 'dpr');\n\n    readonly #normalizedRadiusTop = computed(() =>\n        this.spotLightInput.lightRadiusTop() === undefined ? 0.1 : this.spotLightInput.lightRadiusTop()\n    );\n    readonly #normalizedRadiusBottom = computed(() =>\n        this.spotLightInput.lightRadiusBottom() === undefined\n            ? this.spotLightInput.lightAngle() * 7\n            : this.spotLightInput.lightRadiusBottom()\n    );\n    readonly geometry = computed(() => {\n        const distance = this.spotLightInput.lightDistance();\n        const radiusTop = this.#normalizedRadiusTop();\n        const radiusBottom = this.#normalizedRadiusBottom();\n\n        const geometry = new THREE.CylinderGeometry(radiusTop, radiusBottom, distance, 128, 64, true);\n        geometry.applyMatrix4(new THREE.Matrix4().makeTranslation(0, -distance / 2, 0));\n        geometry.applyMatrix4(new THREE.Matrix4().makeRotationX(-Math.PI / 2));\n        return geometry;\n    });\n    readonly near = computed(() => this.#camera().near);\n    readonly far = computed(() => this.#camera().far);\n    readonly resolution = computed(() =>\n        this.spotLightInput.lightDepthBuffer()\n            ? [this.#size().width * this.#dpr(), this.#size().height * this.#dpr()]\n            : [0, 0]\n    );\n\n    constructor() {\n        this.spotLightInput.patch({\n            opacity: 1,\n            color: 'white',\n            distance: 5,\n            angle: 0.15,\n            attenuation: 5,\n            anglePower: 5,\n        });\n        injectBeforeRender(() => {\n            const mesh = this.mesh.nativeElement;\n            if (!mesh) return;\n            this.material.uniforms['spotPosition'].value.copy(mesh.getWorldPosition(this.#vec));\n            mesh.lookAt((mesh.parent as THREE.SpotLight).target.getWorldPosition(this.#vec));\n        });\n    }\n}\n"]}