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

package/esm2022/staging/center/center.mjs

@@ -0,0 +1,163 @@
+import { CUSTOM_ELEMENTS_SCHEMA, Component, EventEmitter, Input, Output, effect } from '@angular/core';
+import { extend, injectNgtRef, signalStore } from 'angular-three';
+import * as THREE from 'three';
+import { Group } from 'three';
+import * as i0 from "@angular/core";
+extend({ Group });
+export class NgtsCenter {
+    set _top(top) {
+        this.inputs.set({ top });
+    }
+    set _right(right) {
+        this.inputs.set({ right });
+    }
+    set _bottom(bottom) {
+        this.inputs.set({ bottom });
+    }
+    set _left(left) {
+        this.inputs.set({ left });
+    }
+    set _front(front) {
+        this.inputs.set({ front });
+    }
+    set _back(back) {
+        this.inputs.set({ back });
+    }
+    set _disableX(disableX) {
+        this.inputs.set({ disableX });
+    }
+    set _disableY(disableY) {
+        this.inputs.set({ disableY });
+    }
+    set _disableZ(disableZ) {
+        this.inputs.set({ disableZ });
+    }
+    set _disable(disable) {
+        this.inputs.set({ disable });
+    }
+    set _precise(precise) {
+        this.inputs.set({ precise });
+    }
+    set _cacheKey(cacheKey) {
+        this.inputs.set({ cacheKey });
+    }
+    constructor() {
+        this.inputs = signalStore({
+            precise: true,
+            cacheKey: 0,
+        });
+        this.centerRef = injectNgtRef();
+        this.outerRef = injectNgtRef();
+        this.innerRef = injectNgtRef();
+        this.centered = new EventEmitter();
+        this.setPosition();
+    }
+    setPosition() {
+        const innerChildren = this.innerRef.children();
+        effect(() => {
+            const [outer, inner, centerRef, { precise, top, bottom, left, front, right, back, disable, disableX, disableY, disableZ },] = [
+                this.outerRef.nativeElement,
+                this.innerRef.nativeElement,
+                this.centerRef.nativeElement,
+                this.inputs.state(),
+                innerChildren(),
+            ];
+            outer.matrixWorld.identity();
+            const box3 = new THREE.Box3().setFromObject(inner, precise);
+            const center = new THREE.Vector3();
+            const sphere = new THREE.Sphere();
+            const width = box3.max.x - box3.min.x;
+            const height = box3.max.y - box3.min.y;
+            const depth = box3.max.z - box3.min.z;
+            box3.getCenter(center);
+            box3.getBoundingSphere(sphere);
+            const vAlign = top ? height / 2 : bottom ? -height / 2 : 0;
+            const hAlign = left ? -width / 2 : right ? width / 2 : 0;
+            const dAlign = front ? depth / 2 : back ? -depth / 2 : 0;
+            outer.position.set(disable || disableX ? 0 : -center.x + hAlign, disable || disableY ? 0 : -center.y + vAlign, disable || disableZ ? 0 : -center.z + dAlign);
+            if (this.centered.observed) {
+                this.centered.emit({
+                    parent: centerRef.parent,
+                    container: centerRef,
+                    width,
+                    height,
+                    depth,
+                    boundingBox: box3,
+                    boundingSphere: sphere,
+                    center: center,
+                    verticalAlignment: vAlign,
+                    horizontalAlignment: hAlign,
+                    depthAlignment: dAlign,
+                });
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.0", ngImport: i0, type: NgtsCenter, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.0", type: NgtsCenter, isStandalone: true, selector: "ngts-center", inputs: { centerRef: "centerRef", _top: ["top", "_top"], _right: ["right", "_right"], _bottom: ["bottom", "_bottom"], _left: ["left", "_left"], _front: ["front", "_front"], _back: ["back", "_back"], _disableX: ["disableX", "_disableX"], _disableY: ["disableY", "_disableY"], _disableZ: ["disableZ", "_disableZ"], _disable: ["disable", "_disable"], _precise: ["precise", "_precise"], _cacheKey: ["cacheKey", "_cacheKey"] }, outputs: { centered: "centered" }, ngImport: i0, template: `
+		<ngt-group [ref]="centerRef" ngtCompount>
+			<ngt-group [ref]="outerRef">
+				<ngt-group [ref]="innerRef">
+					<ng-content />
+				</ngt-group>
+			</ngt-group>
+		</ngt-group>
+	`, isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.0", ngImport: i0, type: NgtsCenter, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-center',
+                    standalone: true,
+                    template: `
+		<ngt-group [ref]="centerRef" ngtCompount>
+			<ngt-group [ref]="outerRef">
+				<ngt-group [ref]="innerRef">
+					<ng-content />
+				</ngt-group>
+			</ngt-group>
+		</ngt-group>
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { centerRef: [{
+                type: Input
+            }], _top: [{
+                type: Input,
+                args: [{ alias: 'top' }]
+            }], _right: [{
+                type: Input,
+                args: [{ alias: 'right' }]
+            }], _bottom: [{
+                type: Input,
+                args: [{ alias: 'bottom' }]
+            }], _left: [{
+                type: Input,
+                args: [{ alias: 'left' }]
+            }], _front: [{
+                type: Input,
+                args: [{ alias: 'front' }]
+            }], _back: [{
+                type: Input,
+                args: [{ alias: 'back' }]
+            }], _disableX: [{
+                type: Input,
+                args: [{ alias: 'disableX' }]
+            }], _disableY: [{
+                type: Input,
+                args: [{ alias: 'disableY' }]
+            }], _disableZ: [{
+                type: Input,
+                args: [{ alias: 'disableZ' }]
+            }], _disable: [{
+                type: Input,
+                args: [{ alias: 'disable' }]
+            }], _precise: [{
+                type: Input,
+                args: [{ alias: 'precise' }]
+            }], _cacheKey: [{
+                type: Input,
+                args: [{ alias: 'cacheKey' }]
+            }], centered: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"center.js","sourceRoot":"","sources":["../../../../../../libs/soba/staging/src/center/center.ts"],"names":[],"mappings":"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","sourcesContent":["import { CUSTOM_ELEMENTS_SCHEMA, Component, EventEmitter, Input, Output, effect } from '@angular/core';\nimport { extend, injectNgtRef, signalStore, type NgtGroup } from 'angular-three';\nimport * as THREE from 'three';\nimport { Group } from 'three';\n\nextend({ Group });\n\nexport type NgtsCenteredEvent = {\n\t/** The next parent above <Center> */\n\tparent: THREE.Object3D;\n\t/** The outmost container group of the <Center> component */\n\tcontainer: THREE.Object3D;\n\twidth: number;\n\theight: number;\n\tdepth: number;\n\tboundingBox: THREE.Box3;\n\tboundingSphere: THREE.Sphere;\n\tcenter: THREE.Vector3;\n\tverticalAlignment: number;\n\thorizontalAlignment: number;\n\tdepthAlignment: number;\n};\n\nexport type NgtsCenterState = {\n\ttop?: boolean;\n\tright?: boolean;\n\tbottom?: boolean;\n\tleft?: boolean;\n\tfront?: boolean;\n\tback?: boolean;\n\t/** Disable all axes */\n\tdisable?: boolean;\n\t/** Disable x-axis centering */\n\tdisableX?: boolean;\n\t/** Disable y-axis centering */\n\tdisableY?: boolean;\n\t/** Disable z-axis centering */\n\tdisableZ?: boolean;\n\t/** See https://threejs.org/docs/index.html?q=box3#api/en/math/Box3.setFromObject */\n\tprecise?: boolean;\n\t/** Optional cacheKey to keep the component from recalculating on every render */\n\tcacheKey?: any;\n};\n\ndeclare global {\n\tinterface HTMLElementTagNameMap {\n\t\t/**\n\t\t * @extends ngt-group\n\t\t */\n\t\t'ngts-center': NgtsCenterState & NgtGroup;\n\t}\n}\n\n@Component({\n\tselector: 'ngts-center',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-group [ref]=\"centerRef\" ngtCompount>\n\t\t\t<ngt-group [ref]=\"outerRef\">\n\t\t\t\t<ngt-group [ref]=\"innerRef\">\n\t\t\t\t\t<ng-content />\n\t\t\t\t</ngt-group>\n\t\t\t</ngt-group>\n\t\t</ngt-group>\n\t`,\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsCenter {\n\tprivate inputs = signalStore<NgtsCenterState>({\n\t\tprecise: true,\n\t\tcacheKey: 0,\n\t});\n\n\t@Input() centerRef = injectNgtRef<Group>();\n\touterRef = injectNgtRef<Group>();\n\tinnerRef = injectNgtRef<Group>();\n\n\t@Input({ alias: 'top' }) set _top(top: boolean) {\n\t\tthis.inputs.set({ top });\n\t}\n\n\t@Input({ alias: 'right' }) set _right(right: boolean) {\n\t\tthis.inputs.set({ right });\n\t}\n\n\t@Input({ alias: 'bottom' }) set _bottom(bottom: boolean) {\n\t\tthis.inputs.set({ bottom });\n\t}\n\n\t@Input({ alias: 'left' }) set _left(left: boolean) {\n\t\tthis.inputs.set({ left });\n\t}\n\n\t@Input({ alias: 'front' }) set _front(front: boolean) {\n\t\tthis.inputs.set({ front });\n\t}\n\n\t@Input({ alias: 'back' }) set _back(back: boolean) {\n\t\tthis.inputs.set({ back });\n\t}\n\n\t@Input({ alias: 'disableX' }) set _disableX(disableX: boolean) {\n\t\tthis.inputs.set({ disableX });\n\t}\n\n\t@Input({ alias: 'disableY' }) set _disableY(disableY: boolean) {\n\t\tthis.inputs.set({ disableY });\n\t}\n\n\t@Input({ alias: 'disableZ' }) set _disableZ(disableZ: boolean) {\n\t\tthis.inputs.set({ disableZ });\n\t}\n\n\t@Input({ alias: 'disable' }) set _disable(disable: boolean) {\n\t\tthis.inputs.set({ disable });\n\t}\n\n\t@Input({ alias: 'precise' }) set _precise(precise: boolean) {\n\t\tthis.inputs.set({ precise });\n\t}\n\n\t@Input({ alias: 'cacheKey' }) set _cacheKey(cacheKey: any) {\n\t\tthis.inputs.set({ cacheKey });\n\t}\n\n\t@Output() centered = new EventEmitter<NgtsCenteredEvent>();\n\n\tconstructor() {\n\t\tthis.setPosition();\n\t}\n\n\tprivate setPosition() {\n\t\tconst innerChildren = this.innerRef.children();\n\n\t\teffect(() => {\n\t\t\tconst [\n\t\t\t\touter,\n\t\t\t\tinner,\n\t\t\t\tcenterRef,\n\t\t\t\t{ precise, top, bottom, left, front, right, back, disable, disableX, disableY, disableZ },\n\t\t\t] = [\n\t\t\t\tthis.outerRef.nativeElement,\n\t\t\t\tthis.innerRef.nativeElement,\n\t\t\t\tthis.centerRef.nativeElement,\n\t\t\t\tthis.inputs.state(),\n\t\t\t\tinnerChildren(),\n\t\t\t];\n\n\t\t\touter.matrixWorld.identity();\n\t\t\tconst box3 = new THREE.Box3().setFromObject(inner, precise);\n\t\t\tconst center = new THREE.Vector3();\n\t\t\tconst sphere = new THREE.Sphere();\n\t\t\tconst width = box3.max.x - box3.min.x;\n\t\t\tconst height = box3.max.y - box3.min.y;\n\t\t\tconst depth = box3.max.z - box3.min.z;\n\t\t\tbox3.getCenter(center);\n\t\t\tbox3.getBoundingSphere(sphere);\n\t\t\tconst vAlign = top ? height / 2 : bottom ? -height / 2 : 0;\n\t\t\tconst hAlign = left ? -width / 2 : right ? width / 2 : 0;\n\t\t\tconst dAlign = front ? depth / 2 : back ? -depth / 2 : 0;\n\n\t\t\touter.position.set(\n\t\t\t\tdisable || disableX ? 0 : -center.x + hAlign,\n\t\t\t\tdisable || disableY ? 0 : -center.y + vAlign,\n\t\t\t\tdisable || disableZ ? 0 : -center.z + dAlign,\n\t\t\t);\n\n\t\t\tif (this.centered.observed) {\n\t\t\t\tthis.centered.emit({\n\t\t\t\t\tparent: centerRef.parent!,\n\t\t\t\t\tcontainer: centerRef,\n\t\t\t\t\twidth,\n\t\t\t\t\theight,\n\t\t\t\t\tdepth,\n\t\t\t\t\tboundingBox: box3,\n\t\t\t\t\tboundingSphere: sphere,\n\t\t\t\t\tcenter: center,\n\t\t\t\t\tverticalAlignment: vAlign,\n\t\t\t\t\thorizontalAlignment: hAlign,\n\t\t\t\t\tdepthAlignment: dAlign,\n\t\t\t\t});\n\t\t\t}\n\t\t});\n\t}\n}\n"]}

package/esm2022/staging/cloud/cloud.mjs

@@ -0,0 +1,158 @@
+import { NgFor, NgIf } from '@angular/common';
+import { CUSTOM_ELEMENTS_SCHEMA, Component, Input, computed } from '@angular/core';
+import { extend, injectNgtRef, signalStore } from 'angular-three';
+import { NgtsBillboard } from 'angular-three-soba/abstractions';
+import { injectNgtsTextureLoader } from 'angular-three-soba/loaders';
+import { Group, Mesh, MeshStandardMaterial, PlaneGeometry } from 'three';
+import * as i0 from "@angular/core";
+const CLOUD_URL = 'https://rawcdn.githack.com/pmndrs/drei-assets/9225a9f1fbd449d9411125c2f419b843d0308c9f/cloud.png';
+injectNgtsTextureLoader.preload(() => CLOUD_URL);
+extend({ Group, Mesh, PlaneGeometry, MeshStandardMaterial });
+export class NgtsCloud {
+    constructor() {
+        this.inputs = signalStore({
+            opacity: 0.5,
+            speed: 0.4,
+            width: 10,
+            depth: 1.5,
+            segments: 20,
+            texture: CLOUD_URL,
+            color: '#ffffff',
+            depthTest: true,
+        });
+        this.groupRef = injectNgtRef();
+        this.width = this.inputs.select('width');
+        this.speed = this.inputs.select('speed');
+        this.segments = this.inputs.select('segments');
+        this.depth = this.inputs.select('depth');
+        this.depthTest = this.inputs.select('depthTest');
+        this.opacity = this.inputs.select('opacity');
+        this.color = this.inputs.select('color');
+        this.texture = injectNgtsTextureLoader(this.inputs.select('texture'));
+        this.clouds = computed(() => [...new Array(this.segments())].map((_, index) => ({
+            x: this.width() / 2 - Math.random() * this.width(),
+            y: this.width() / 2 - Math.random() * this.width(),
+            scale: 0.4 + Math.sin(((index + 1) / this.segments()) * Math.PI) * ((0.2 + Math.random()) * 10),
+            density: Math.max(0.2, Math.random()),
+            rotation: Math.max(0.002, 0.005 * Math.random()) * this.speed(),
+        })));
+    }
+    set _opacity(opacity) {
+        this.inputs.set({ opacity });
+    }
+    set _speed(speed) {
+        this.inputs.set({ speed });
+    }
+    set _width(width) {
+        this.inputs.set({ width });
+    }
+    set _depth(depth) {
+        this.inputs.set({ depth });
+    }
+    set _segments(segments) {
+        this.inputs.set({ segments });
+    }
+    set _texture(texture) {
+        this.inputs.set({ texture });
+    }
+    set _color(color) {
+        this.inputs.set({ color });
+    }
+    set _depthTest(depthTest) {
+        this.inputs.set({ depthTest });
+    }
+    onBeforeRender({ state, object }) {
+        const clouds = this.clouds();
+        object.children.forEach((cloud, index) => {
+            cloud.children[0].rotation.z += clouds[index].rotation;
+            cloud.children[0].scale.setScalar(clouds[index].scale + (((1 + Math.sin(state.clock.getElapsedTime() / 10)) / 2) * index) / 10);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.0", ngImport: i0, type: NgtsCloud, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.0", type: NgtsCloud, isStandalone: true, selector: "ngts-cloud", inputs: { groupRef: "groupRef", _opacity: ["opacity", "_opacity"], _speed: ["speed", "_speed"], _width: ["width", "_width"], _depth: ["depth", "_depth"], _segments: ["segments", "_segments"], _texture: ["texture", "_texture"], _color: ["color", "_color"], _depthTest: ["depthTest", "_depthTest"] }, ngImport: i0, template: `
+		<ngt-group ngtCompound>
+			<ngt-group
+				[position]="[0, 0, (segments() / 2) * depth()]"
+				[ref]="groupRef"
+				(beforeRender)="onBeforeRender($event)"
+			>
+				<ngts-billboard
+					*ngFor="let cloud of clouds(); let i = index"
+					[position]="[cloud.x, cloud.y, -i * depth()]"
+				>
+					<ngt-mesh [scale]="cloud.scale" [rotation]="[0, 0, 0]">
+						<ngt-plane-geometry />
+						<ngt-mesh-standard-material
+							[map]="texture()"
+							[transparent]="true"
+							[opacity]="(cloud.scale / 6) * cloud.density * opacity()"
+							[depthTest]="depthTest()"
+							[color]="color()"
+						/>
+					</ngt-mesh>
+				</ngts-billboard>
+			</ngt-group>
+		</ngt-group>
+	`, isInline: true, dependencies: [{ kind: "directive", type: NgFor, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "component", type: NgtsBillboard, selector: "ngts-billboard", inputs: ["billboardRef", "follow", "lockX", "lockY", "lockZ"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.0", ngImport: i0, type: NgtsCloud, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-cloud',
+                    standalone: true,
+                    template: `
+		<ngt-group ngtCompound>
+			<ngt-group
+				[position]="[0, 0, (segments() / 2) * depth()]"
+				[ref]="groupRef"
+				(beforeRender)="onBeforeRender($event)"
+			>
+				<ngts-billboard
+					*ngFor="let cloud of clouds(); let i = index"
+					[position]="[cloud.x, cloud.y, -i * depth()]"
+				>
+					<ngt-mesh [scale]="cloud.scale" [rotation]="[0, 0, 0]">
+						<ngt-plane-geometry />
+						<ngt-mesh-standard-material
+							[map]="texture()"
+							[transparent]="true"
+							[opacity]="(cloud.scale / 6) * cloud.density * opacity()"
+							[depthTest]="depthTest()"
+							[color]="color()"
+						/>
+					</ngt-mesh>
+				</ngts-billboard>
+			</ngt-group>
+		</ngt-group>
+	`,
+                    imports: [NgFor, NgtsBillboard, NgIf],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], propDecorators: { groupRef: [{
+                type: Input
+            }], _opacity: [{
+                type: Input,
+                args: [{ alias: 'opacity' }]
+            }], _speed: [{
+                type: Input,
+                args: [{ alias: 'speed' }]
+            }], _width: [{
+                type: Input,
+                args: [{ alias: 'width' }]
+            }], _depth: [{
+                type: Input,
+                args: [{ alias: 'depth' }]
+            }], _segments: [{
+                type: Input,
+                args: [{ alias: 'segments' }]
+            }], _texture: [{
+                type: Input,
+                args: [{ alias: 'texture' }]
+            }], _color: [{
+                type: Input,
+                args: [{ alias: 'color' }]
+            }], _depthTest: [{
+                type: Input,
+                args: [{ alias: 'depthTest' }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cloud.js","sourceRoot":"","sources":["../../../../../../libs/soba/staging/src/cloud/cloud.ts"],"names":[],"mappings":"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","sourcesContent":["import { NgFor, NgIf } from '@angular/common';\nimport { CUSTOM_ELEMENTS_SCHEMA, Component, Input, computed } from '@angular/core';\nimport { extend, injectNgtRef, signalStore, type NgtBeforeRenderEvent, type NgtGroup } from 'angular-three';\nimport { NgtsBillboard } from 'angular-three-soba/abstractions';\nimport { injectNgtsTextureLoader } from 'angular-three-soba/loaders';\nimport { Group, Mesh, MeshStandardMaterial, PlaneGeometry } from 'three';\n\nconst CLOUD_URL = 'https://rawcdn.githack.com/pmndrs/drei-assets/9225a9f1fbd449d9411125c2f419b843d0308c9f/cloud.png';\n(injectNgtsTextureLoader as any).preload(() => CLOUD_URL);\n\nextend({ Group, Mesh, PlaneGeometry, MeshStandardMaterial });\n\nexport type NgtsCloudState = {\n\topacity: number;\n\tspeed: number;\n\twidth: number;\n\tdepth: number;\n\tsegments: number;\n\ttexture: string;\n\tcolor: THREE.ColorRepresentation;\n\tdepthTest: boolean;\n};\n\ndeclare global {\n\tinterface HTMLElementTagNameMap {\n\t\t/**\n\t\t * @extends ngt-group\n\t\t */\n\t\t'ngts-cloud': NgtsCloudState & NgtGroup;\n\t}\n}\n\n@Component({\n\tselector: 'ngts-cloud',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-group ngtCompound>\n\t\t\t<ngt-group\n\t\t\t\t[position]=\"[0, 0, (segments() / 2) * depth()]\"\n\t\t\t\t[ref]=\"groupRef\"\n\t\t\t\t(beforeRender)=\"onBeforeRender($event)\"\n\t\t\t>\n\t\t\t\t<ngts-billboard\n\t\t\t\t\t*ngFor=\"let cloud of clouds(); let i = index\"\n\t\t\t\t\t[position]=\"[cloud.x, cloud.y, -i * depth()]\"\n\t\t\t\t>\n\t\t\t\t\t<ngt-mesh [scale]=\"cloud.scale\" [rotation]=\"[0, 0, 0]\">\n\t\t\t\t\t\t<ngt-plane-geometry />\n\t\t\t\t\t\t<ngt-mesh-standard-material\n\t\t\t\t\t\t\t[map]=\"texture()\"\n\t\t\t\t\t\t\t[transparent]=\"true\"\n\t\t\t\t\t\t\t[opacity]=\"(cloud.scale / 6) * cloud.density * opacity()\"\n\t\t\t\t\t\t\t[depthTest]=\"depthTest()\"\n\t\t\t\t\t\t\t[color]=\"color()\"\n\t\t\t\t\t\t/>\n\t\t\t\t\t</ngt-mesh>\n\t\t\t\t</ngts-billboard>\n\t\t\t</ngt-group>\n\t\t</ngt-group>\n\t`,\n\timports: [NgFor, NgtsBillboard, NgIf],\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsCloud {\n\tprivate inputs = signalStore<NgtsCloudState>({\n\t\topacity: 0.5,\n\t\tspeed: 0.4,\n\t\twidth: 10,\n\t\tdepth: 1.5,\n\t\tsegments: 20,\n\t\ttexture: CLOUD_URL,\n\t\tcolor: '#ffffff',\n\t\tdepthTest: true,\n\t});\n\n\t@Input() groupRef = injectNgtRef<Group>();\n\n\t@Input({ alias: 'opacity' }) set _opacity(opacity: number) {\n\t\tthis.inputs.set({ opacity });\n\t}\n\n\t@Input({ alias: 'speed' }) set _speed(speed: number) {\n\t\tthis.inputs.set({ speed });\n\t}\n\n\t@Input({ alias: 'width' }) set _width(width: number) {\n\t\tthis.inputs.set({ width });\n\t}\n\n\t@Input({ alias: 'depth' }) set _depth(depth: number) {\n\t\tthis.inputs.set({ depth });\n\t}\n\n\t@Input({ alias: 'segments' }) set _segments(segments: number) {\n\t\tthis.inputs.set({ segments });\n\t}\n\n\t@Input({ alias: 'texture' }) set _texture(texture: string) {\n\t\tthis.inputs.set({ texture });\n\t}\n\n\t@Input({ alias: 'color' }) set _color(color: THREE.ColorRepresentation) {\n\t\tthis.inputs.set({ color });\n\t}\n\n\t@Input({ alias: 'depthTest' }) set _depthTest(depthTest: boolean) {\n\t\tthis.inputs.set({ depthTest });\n\t}\n\n\tprivate width = this.inputs.select('width');\n\tprivate speed = this.inputs.select('speed');\n\n\tsegments = this.inputs.select('segments');\n\tdepth = this.inputs.select('depth');\n\tdepthTest = this.inputs.select('depthTest');\n\topacity = this.inputs.select('opacity');\n\tcolor = this.inputs.select('color');\n\ttexture = injectNgtsTextureLoader(this.inputs.select('texture'));\n\n\tclouds = computed(() =>\n\t\t[...new Array(this.segments())].map((_, index) => ({\n\t\t\tx: this.width() / 2 - Math.random() * this.width(),\n\t\t\ty: this.width() / 2 - Math.random() * this.width(),\n\t\t\tscale: 0.4 + Math.sin(((index + 1) / this.segments()) * Math.PI) * ((0.2 + Math.random()) * 10),\n\t\t\tdensity: Math.max(0.2, Math.random()),\n\t\t\trotation: Math.max(0.002, 0.005 * Math.random()) * this.speed(),\n\t\t})),\n\t);\n\tonBeforeRender({ state, object }: NgtBeforeRenderEvent<Group>) {\n\t\tconst clouds = this.clouds();\n\t\tobject.children.forEach((cloud, index) => {\n\t\t\tcloud.children[0].rotation.z += clouds[index].rotation;\n\t\t\tcloud.children[0].scale.setScalar(\n\t\t\t\tclouds[index].scale + (((1 + Math.sin(state.clock.getElapsedTime() / 10)) / 2) * index) / 10,\n\t\t\t);\n\t\t});\n\t}\n}\n"]}

package/esm2022/staging/contact-shadows/contact-shadows.mjs

@@ -0,0 +1,246 @@
+import { Component, computed, CUSTOM_ELEMENTS_SCHEMA, Input } from '@angular/core';
+import { extend, injectBeforeRender, injectNgtRef, injectNgtStore, NgtArgs, signalStore, } from 'angular-three';
+import * as THREE from 'three';
+import { Group, Mesh, MeshBasicMaterial, OrthographicCamera } from 'three';
+import { HorizontalBlurShader, VerticalBlurShader } from 'three-stdlib';
+import * as i0 from "@angular/core";
+extend({ Group, Mesh, MeshBasicMaterial, OrthographicCamera });
+export class NgtsContactShadows {
+    set _opacity(opacity) {
+        this.inputs.set({ opacity });
+    }
+    set _width(width) {
+        this.inputs.set({ width });
+    }
+    set _height(height) {
+        this.inputs.set({ height });
+    }
+    set _blur(blur) {
+        this.inputs.set({ blur });
+    }
+    set _far(far) {
+        this.inputs.set({ far });
+    }
+    set _smooth(smooth) {
+        this.inputs.set({ smooth });
+    }
+    set _resolution(resolution) {
+        this.inputs.set({ resolution });
+    }
+    set _frames(frames) {
+        this.inputs.set({ frames });
+    }
+    set _scale(scale) {
+        this.inputs.set({ scale });
+    }
+    set _color(color) {
+        this.inputs.set({ color });
+    }
+    set _depthWrite(depthWrite) {
+        this.inputs.set({ depthWrite });
+    }
+    set _renderOrder(renderOrder) {
+        this.inputs.set({ renderOrder });
+    }
+    constructor() {
+        this.inputs = signalStore({
+            scale: 10,
+            frames: Infinity,
+            opacity: 1,
+            width: 1,
+            height: 1,
+            blur: 1,
+            far: 10,
+            resolution: 512,
+            smooth: true,
+            color: '#000000',
+            depthWrite: false,
+            renderOrder: 0,
+        });
+        this.contactShadowsRef = injectNgtRef();
+        this.Math = Math;
+        this.store = injectNgtStore();
+        this.shadowCameraRef = injectNgtRef();
+        this.scale = this.inputs.select('scale');
+        this.width = this.inputs.select('width');
+        this.height = this.inputs.select('height');
+        this.far = this.inputs.select('far');
+        this.resolution = this.inputs.select('resolution');
+        this.color = this.inputs.select('color');
+        this.scaledWidth = computed(() => {
+            const scale = this.scale();
+            return this.width() * (Array.isArray(scale) ? scale[0] : scale || 1);
+        });
+        this.scaledHeight = computed(() => {
+            const scale = this.scale();
+            return this.height() * (Array.isArray(scale) ? scale[1] : scale || 1);
+        });
+        this.renderOrder = this.inputs.select('renderOrder');
+        this.opacity = this.inputs.select('opacity');
+        this.depthWrite = this.inputs.select('depthWrite');
+        this.cameraArgs = computed(() => {
+            const width = this.scaledWidth();
+            const height = this.scaledHeight();
+            return [-width / 2, width / 2, height / 2, -height / 2, 0, this.far()];
+        });
+        this.contactShadows = computed(() => {
+            const color = this.color();
+            const resolution = this.resolution();
+            const renderTarget = new THREE.WebGLRenderTarget(resolution, resolution);
+            const renderTargetBlur = new THREE.WebGLRenderTarget(resolution, resolution);
+            renderTargetBlur.texture.generateMipmaps = renderTarget.texture.generateMipmaps = false;
+            const planeGeometry = new THREE.PlaneGeometry(this.scaledWidth(), this.scaledHeight()).rotateX(Math.PI / 2);
+            const blurPlane = new Mesh(planeGeometry);
+            const depthMaterial = new THREE.MeshDepthMaterial();
+            depthMaterial.depthTest = depthMaterial.depthWrite = false;
+            depthMaterial.onBeforeCompile = (shader) => {
+                shader.uniforms = {
+                    ...shader.uniforms,
+                    ucolor: { value: new THREE.Color(color) },
+                };
+                shader.fragmentShader = shader.fragmentShader.replace(`void main() {`, //
+                `uniform vec3 ucolor;
+                 void main() {
+                `);
+                shader.fragmentShader = shader.fragmentShader.replace('vec4( vec3( 1.0 - fragCoordZ ), opacity );', 
+                // Colorize the shadow, multiply by the falloff so that the center can remain darker
+                'vec4( ucolor * fragCoordZ * 2.0, ( 1.0 - fragCoordZ ) * 1.0 );');
+            };
+            const horizontalBlurMaterial = new THREE.ShaderMaterial(HorizontalBlurShader);
+            const verticalBlurMaterial = new THREE.ShaderMaterial(VerticalBlurShader);
+            verticalBlurMaterial.depthTest = horizontalBlurMaterial.depthTest = false;
+            return {
+                renderTarget,
+                planeGeometry,
+                depthMaterial,
+                blurPlane,
+                horizontalBlurMaterial,
+                verticalBlurMaterial,
+                renderTargetBlur,
+            };
+        });
+        injectBeforeRender(this.beforeRender.bind(this, 0));
+    }
+    beforeRender(count, { scene, gl }) {
+        const { frames = Infinity, blur = 1, smooth = true } = this.inputs.get();
+        const { depthMaterial, renderTarget } = this.contactShadows();
+        const shadowCamera = this.shadowCameraRef.nativeElement;
+        if (shadowCamera && (frames === Infinity || count < frames)) {
+            const initialBackground = scene.background;
+            scene.background = null;
+            const initialOverrideMaterial = scene.overrideMaterial;
+            scene.overrideMaterial = depthMaterial;
+            gl.setRenderTarget(renderTarget);
+            gl.render(scene, shadowCamera);
+            scene.overrideMaterial = initialOverrideMaterial;
+            this.blurShadows(blur);
+            if (smooth)
+                this.blurShadows(blur * 0.4);
+            gl.setRenderTarget(null);
+            scene.background = initialBackground;
+            count++;
+        }
+    }
+    blurShadows(blur) {
+        const { blurPlane, horizontalBlurMaterial, verticalBlurMaterial, renderTargetBlur, renderTarget } = this.contactShadows();
+        const gl = this.store.get('gl');
+        const shadowCamera = this.shadowCameraRef.nativeElement;
+        blurPlane.visible = true;
+        blurPlane.material = horizontalBlurMaterial;
+        horizontalBlurMaterial.uniforms['tDiffuse'].value = renderTarget.texture;
+        horizontalBlurMaterial.uniforms['h'].value = (blur * 1) / 256;
+        gl.setRenderTarget(renderTargetBlur);
+        gl.render(blurPlane, shadowCamera);
+        blurPlane.material = verticalBlurMaterial;
+        verticalBlurMaterial.uniforms['tDiffuse'].value = renderTargetBlur.texture;
+        verticalBlurMaterial.uniforms['v'].value = (blur * 1) / 256;
+        gl.setRenderTarget(renderTarget);
+        gl.render(blurPlane, shadowCamera);
+        blurPlane.visible = false;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.0", ngImport: i0, type: NgtsContactShadows, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.0", type: NgtsContactShadows, isStandalone: true, selector: "ngts-contact-shadows", inputs: { contactShadowsRef: "contactShadowsRef", _opacity: ["opacity", "_opacity"], _width: ["width", "_width"], _height: ["height", "_height"], _blur: ["blur", "_blur"], _far: ["far", "_far"], _smooth: ["smooth", "_smooth"], _resolution: ["resolution", "_resolution"], _frames: ["frames", "_frames"], _scale: ["scale", "_scale"], _color: ["color", "_color"], _depthWrite: ["depthWrite", "_depthWrite"], _renderOrder: ["renderOrder", "_renderOrder"] }, ngImport: i0, template: `
+		<ngt-group ngtCompound [ref]="contactShadowsRef" [rotation]="[Math.PI / 2, 0, 0]">
+			<ngt-mesh
+				[renderOrder]="renderOrder() ?? 0"
+				[geometry]="contactShadows().planeGeometry"
+				[scale]="[1, -1, 1]"
+				[rotation]="[-Math.PI / 2, 0, 0]"
+			>
+				<ngt-mesh-basic-material
+					[map]="contactShadows().renderTarget.texture"
+					[transparent]="true"
+					[opacity]="opacity() ?? 1"
+					[depthWrite]="depthWrite() ?? false"
+				/>
+			</ngt-mesh>
+			<ngt-orthographic-camera *args="cameraArgs()" [ref]="shadowCameraRef" />
+		</ngt-group>
+	`, isInline: true, dependencies: [{ kind: "directive", type: NgtArgs, selector: "ng-template[args]", inputs: ["args"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.0", ngImport: i0, type: NgtsContactShadows, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-contact-shadows',
+                    standalone: true,
+                    template: `
+		<ngt-group ngtCompound [ref]="contactShadowsRef" [rotation]="[Math.PI / 2, 0, 0]">
+			<ngt-mesh
+				[renderOrder]="renderOrder() ?? 0"
+				[geometry]="contactShadows().planeGeometry"
+				[scale]="[1, -1, 1]"
+				[rotation]="[-Math.PI / 2, 0, 0]"
+			>
+				<ngt-mesh-basic-material
+					[map]="contactShadows().renderTarget.texture"
+					[transparent]="true"
+					[opacity]="opacity() ?? 1"
+					[depthWrite]="depthWrite() ?? false"
+				/>
+			</ngt-mesh>
+			<ngt-orthographic-camera *args="cameraArgs()" [ref]="shadowCameraRef" />
+		</ngt-group>
+	`,
+                    imports: [NgtArgs],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { contactShadowsRef: [{
+                type: Input
+            }], _opacity: [{
+                type: Input,
+                args: [{ alias: 'opacity' }]
+            }], _width: [{
+                type: Input,
+                args: [{ alias: 'width' }]
+            }], _height: [{
+                type: Input,
+                args: [{ alias: 'height' }]
+            }], _blur: [{
+                type: Input,
+                args: [{ alias: 'blur' }]
+            }], _far: [{
+                type: Input,
+                args: [{ alias: 'far' }]
+            }], _smooth: [{
+                type: Input,
+                args: [{ alias: 'smooth' }]
+            }], _resolution: [{
+                type: Input,
+                args: [{ alias: 'resolution' }]
+            }], _frames: [{
+                type: Input,
+                args: [{ alias: 'frames' }]
+            }], _scale: [{
+                type: Input,
+                args: [{ alias: 'scale' }]
+            }], _color: [{
+                type: Input,
+                args: [{ alias: 'color' }]
+            }], _depthWrite: [{
+                type: Input,
+                args: [{ alias: 'depthWrite' }]
+            }], _renderOrder: [{
+                type: Input,
+                args: [{ alias: 'renderOrder' }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"contact-shadows.js","sourceRoot":"","sources":["../../../../../../libs/soba/staging/src/contact-shadows/contact-shadows.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, computed, CUSTOM_ELEMENTS_SCHEMA, Input } from '@angular/core';\nimport {\n\textend,\n\tinjectBeforeRender,\n\tinjectNgtRef,\n\tinjectNgtStore,\n\tNgtArgs,\n\tsignalStore,\n\ttype NgtGroup,\n\ttype NgtRenderState,\n} from 'angular-three';\nimport * as THREE from 'three';\nimport { Group, Mesh, MeshBasicMaterial, OrthographicCamera } from 'three';\nimport { HorizontalBlurShader, VerticalBlurShader } from 'three-stdlib';\n\nextend({ Group, Mesh, MeshBasicMaterial, OrthographicCamera });\n\nexport type NgtsContactShadowsState = {\n\topacity: number;\n\twidth: number;\n\theight: number;\n\tblur: number;\n\tfar: number;\n\tsmooth: boolean;\n\tresolution: number;\n\tframes: number;\n\tscale: number | [x: number, y: number];\n\tcolor: THREE.ColorRepresentation;\n\tdepthWrite: boolean;\n\trenderOrder: number;\n};\n\ndeclare global {\n\tinterface HTMLElementTagNameMap {\n\t\t/**\n\t\t * @extends ngt-group\n\t\t */\n\t\t'ngts-contact-shadows': NgtsContactShadowsState & NgtGroup;\n\t}\n}\n\n@Component({\n\tselector: 'ngts-contact-shadows',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-group ngtCompound [ref]=\"contactShadowsRef\" [rotation]=\"[Math.PI / 2, 0, 0]\">\n\t\t\t<ngt-mesh\n\t\t\t\t[renderOrder]=\"renderOrder() ?? 0\"\n\t\t\t\t[geometry]=\"contactShadows().planeGeometry\"\n\t\t\t\t[scale]=\"[1, -1, 1]\"\n\t\t\t\t[rotation]=\"[-Math.PI / 2, 0, 0]\"\n\t\t\t>\n\t\t\t\t<ngt-mesh-basic-material\n\t\t\t\t\t[map]=\"contactShadows().renderTarget.texture\"\n\t\t\t\t\t[transparent]=\"true\"\n\t\t\t\t\t[opacity]=\"opacity() ?? 1\"\n\t\t\t\t\t[depthWrite]=\"depthWrite() ?? false\"\n\t\t\t\t/>\n\t\t\t</ngt-mesh>\n\t\t\t<ngt-orthographic-camera *args=\"cameraArgs()\" [ref]=\"shadowCameraRef\" />\n\t\t</ngt-group>\n\t`,\n\timports: [NgtArgs],\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsContactShadows {\n\tprivate inputs = signalStore<NgtsContactShadowsState>({\n\t\tscale: 10,\n\t\tframes: Infinity,\n\t\topacity: 1,\n\t\twidth: 1,\n\t\theight: 1,\n\t\tblur: 1,\n\t\tfar: 10,\n\t\tresolution: 512,\n\t\tsmooth: true,\n\t\tcolor: '#000000',\n\t\tdepthWrite: false,\n\t\trenderOrder: 0,\n\t});\n\n\t@Input() contactShadowsRef = injectNgtRef<Group>();\n\n\t@Input({ alias: 'opacity' }) set _opacity(opacity: number) {\n\t\tthis.inputs.set({ opacity });\n\t}\n\n\t@Input({ alias: 'width' }) set _width(width: number) {\n\t\tthis.inputs.set({ width });\n\t}\n\n\t@Input({ alias: 'height' }) set _height(height: number) {\n\t\tthis.inputs.set({ height });\n\t}\n\n\t@Input({ alias: 'blur' }) set _blur(blur: number) {\n\t\tthis.inputs.set({ blur });\n\t}\n\n\t@Input({ alias: 'far' }) set _far(far: number) {\n\t\tthis.inputs.set({ far });\n\t}\n\n\t@Input({ alias: 'smooth' }) set _smooth(smooth: boolean) {\n\t\tthis.inputs.set({ smooth });\n\t}\n\n\t@Input({ alias: 'resolution' }) set _resolution(resolution: number) {\n\t\tthis.inputs.set({ resolution });\n\t}\n\n\t@Input({ alias: 'frames' }) set _frames(frames: number) {\n\t\tthis.inputs.set({ frames });\n\t}\n\n\t@Input({ alias: 'scale' }) set _scale(scale: number | [x: number, y: number]) {\n\t\tthis.inputs.set({ scale });\n\t}\n\n\t@Input({ alias: 'color' }) set _color(color: THREE.ColorRepresentation) {\n\t\tthis.inputs.set({ color });\n\t}\n\n\t@Input({ alias: 'depthWrite' }) set _depthWrite(depthWrite: boolean) {\n\t\tthis.inputs.set({ depthWrite });\n\t}\n\n\t@Input({ alias: 'renderOrder' }) set _renderOrder(renderOrder: number) {\n\t\tthis.inputs.set({ renderOrder });\n\t}\n\n\tMath = Math;\n\n\tprivate store = injectNgtStore();\n\n\tshadowCameraRef = injectNgtRef<OrthographicCamera>();\n\n\tprivate scale = this.inputs.select('scale');\n\tprivate width = this.inputs.select('width');\n\tprivate height = this.inputs.select('height');\n\tprivate far = this.inputs.select('far');\n\tprivate resolution = this.inputs.select('resolution');\n\tprivate color = this.inputs.select('color');\n\n\tprivate scaledWidth = computed(() => {\n\t\tconst scale = this.scale();\n\t\treturn this.width() * (Array.isArray(scale) ? scale[0] : scale || 1);\n\t});\n\tprivate scaledHeight = computed(() => {\n\t\tconst scale = this.scale();\n\t\treturn this.height() * (Array.isArray(scale) ? scale[1] : scale || 1);\n\t});\n\n\trenderOrder = this.inputs.select('renderOrder');\n\topacity = this.inputs.select('opacity');\n\tdepthWrite = this.inputs.select('depthWrite');\n\n\tcameraArgs = computed(() => {\n\t\tconst width = this.scaledWidth();\n\t\tconst height = this.scaledHeight();\n\t\treturn [-width / 2, width / 2, height / 2, -height / 2, 0, this.far()];\n\t});\n\tcontactShadows = computed(() => {\n\t\tconst color = this.color();\n\t\tconst resolution = this.resolution();\n\t\tconst renderTarget = new THREE.WebGLRenderTarget(resolution, resolution);\n\t\tconst renderTargetBlur = new THREE.WebGLRenderTarget(resolution, resolution);\n\t\trenderTargetBlur.texture.generateMipmaps = renderTarget.texture.generateMipmaps = false;\n\t\tconst planeGeometry = new THREE.PlaneGeometry(this.scaledWidth(), this.scaledHeight()).rotateX(Math.PI / 2);\n\t\tconst blurPlane = new Mesh(planeGeometry);\n\t\tconst depthMaterial = new THREE.MeshDepthMaterial();\n\t\tdepthMaterial.depthTest = depthMaterial.depthWrite = false;\n\t\tdepthMaterial.onBeforeCompile = (shader) => {\n\t\t\tshader.uniforms = {\n\t\t\t\t...shader.uniforms,\n\t\t\t\tucolor: { value: new THREE.Color(color) },\n\t\t\t};\n\t\t\tshader.fragmentShader = shader.fragmentShader.replace(\n\t\t\t\t`void main() {`, //\n\t\t\t\t`uniform vec3 ucolor;\n                 void main() {\n                `,\n\t\t\t);\n\t\t\tshader.fragmentShader = shader.fragmentShader.replace(\n\t\t\t\t'vec4( vec3( 1.0 - fragCoordZ ), opacity );',\n\t\t\t\t// Colorize the shadow, multiply by the falloff so that the center can remain darker\n\t\t\t\t'vec4( ucolor * fragCoordZ * 2.0, ( 1.0 - fragCoordZ ) * 1.0 );',\n\t\t\t);\n\t\t};\n\n\t\tconst horizontalBlurMaterial = new THREE.ShaderMaterial(HorizontalBlurShader);\n\t\tconst verticalBlurMaterial = new THREE.ShaderMaterial(VerticalBlurShader);\n\t\tverticalBlurMaterial.depthTest = horizontalBlurMaterial.depthTest = false;\n\n\t\treturn {\n\t\t\trenderTarget,\n\t\t\tplaneGeometry,\n\t\t\tdepthMaterial,\n\t\t\tblurPlane,\n\t\t\thorizontalBlurMaterial,\n\t\t\tverticalBlurMaterial,\n\t\t\trenderTargetBlur,\n\t\t};\n\t});\n\n\tconstructor() {\n\t\tinjectBeforeRender(this.beforeRender.bind(this, 0));\n\t}\n\n\tprivate beforeRender(count: number, { scene, gl }: NgtRenderState) {\n\t\tconst { frames = Infinity, blur = 1, smooth = true } = this.inputs.get();\n\t\tconst { depthMaterial, renderTarget } = this.contactShadows();\n\t\tconst shadowCamera = this.shadowCameraRef.nativeElement;\n\t\tif (shadowCamera && (frames === Infinity || count < frames)) {\n\t\t\tconst initialBackground = scene.background;\n\t\t\tscene.background = null;\n\t\t\tconst initialOverrideMaterial = scene.overrideMaterial;\n\t\t\tscene.overrideMaterial = depthMaterial;\n\t\t\tgl.setRenderTarget(renderTarget);\n\t\t\tgl.render(scene, shadowCamera);\n\t\t\tscene.overrideMaterial = initialOverrideMaterial;\n\n\t\t\tthis.blurShadows(blur);\n\t\t\tif (smooth) this.blurShadows(blur * 0.4);\n\n\t\t\tgl.setRenderTarget(null);\n\t\t\tscene.background = initialBackground;\n\t\t\tcount++;\n\t\t}\n\t}\n\n\tprivate blurShadows(blur: number) {\n\t\tconst { blurPlane, horizontalBlurMaterial, verticalBlurMaterial, renderTargetBlur, renderTarget } =\n\t\t\tthis.contactShadows();\n\t\tconst gl = this.store.get('gl');\n\t\tconst shadowCamera = this.shadowCameraRef.nativeElement;\n\n\t\tblurPlane.visible = true;\n\n\t\tblurPlane.material = horizontalBlurMaterial;\n\t\thorizontalBlurMaterial.uniforms['tDiffuse'].value = renderTarget.texture;\n\t\thorizontalBlurMaterial.uniforms['h'].value = (blur * 1) / 256;\n\n\t\tgl.setRenderTarget(renderTargetBlur);\n\t\tgl.render(blurPlane, shadowCamera);\n\n\t\tblurPlane.material = verticalBlurMaterial;\n\t\tverticalBlurMaterial.uniforms['tDiffuse'].value = renderTargetBlur.texture;\n\t\tverticalBlurMaterial.uniforms['v'].value = (blur * 1) / 256;\n\n\t\tgl.setRenderTarget(renderTarget);\n\t\tgl.render(blurPlane, shadowCamera);\n\n\t\tblurPlane.visible = false;\n\t}\n}\n"]}