angular-three-soba 1.0.2 → 1.2.0

package/esm2020/staging/lib/center/center.mjs

@@ -0,0 +1,142 @@
+import { Component, CUSTOM_ELEMENTS_SCHEMA, EventEmitter, Input, Output } from '@angular/core';
+import { extend, injectNgtRef, NgtRxStore } from 'angular-three';
+import { combineLatest } from 'rxjs';
+import { Box3, Group, Sphere, Vector3 } from 'three';
+import * as i0 from "@angular/core";
+extend({ Group });
+export class NgtsCenter extends NgtRxStore {
+    constructor() {
+        super(...arguments);
+        this.centerRef = injectNgtRef();
+        this.outerRef = injectNgtRef();
+        this.innerRef = injectNgtRef();
+        this.centered = new EventEmitter();
+    }
+    set top(top) {
+        this.set({ top });
+    }
+    set right(right) {
+        this.set({ right });
+    }
+    set bottom(bottom) {
+        this.set({ bottom });
+    }
+    set left(left) {
+        this.set({ left });
+    }
+    set front(front) {
+        this.set({ front });
+    }
+    set back(back) {
+        this.set({ back });
+    }
+    set disableX(disableX) {
+        this.set({ disableX });
+    }
+    set disableY(disableY) {
+        this.set({ disableY });
+    }
+    set disableZ(disableZ) {
+        this.set({ disableZ });
+    }
+    set disabled(disabled) {
+        this.set({ disabled });
+    }
+    set precise(precise) {
+        this.set({ precise });
+    }
+    initialize() {
+        super.initialize();
+        this.set({ precise: true });
+    }
+    ngOnInit() {
+        this.setPosition();
+    }
+    setPosition() {
+        this.hold(combineLatest([this.innerRef.$, this.innerRef.children$()]), ([innerGroup]) => {
+            const { precise, top, left, front, disabled, disableX, disableY, disableZ, back, bottom, right } = this.get();
+            this.outerRef.nativeElement.matrixWorld.identity();
+            const box3 = new Box3().setFromObject(innerGroup, precise);
+            const center = new Vector3();
+            const sphere = new 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;
+            this.outerRef.nativeElement.position.set(disabled || disableX ? 0 : -center.x + hAlign, disabled || disableY ? 0 : -center.y + vAlign, disabled || disableZ ? 0 : -center.z + dAlign);
+            if (this.centered.observed) {
+                this.centered.emit({
+                    parent: this.centerRef.nativeElement.parent,
+                    container: this.centerRef.nativeElement,
+                    width,
+                    height,
+                    depth,
+                    boundingBox: box3,
+                    boundingSphere: sphere,
+                    center: center,
+                    verticalAlignment: vAlign,
+                    horizontalAlignment: hAlign,
+                    depthAlignment: dAlign,
+                });
+            }
+        });
+    }
+}
+NgtsCenter.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.3", ngImport: i0, type: NgtsCenter, deps: null, target: i0.ɵɵFactoryTarget.Component });
+NgtsCenter.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.1.3", type: NgtsCenter, isStandalone: true, selector: "ngts-center", inputs: { centerRef: "centerRef", top: "top", right: "right", bottom: "bottom", left: "left", front: "front", back: "back", disableX: "disableX", disableY: "disableY", disableZ: "disableZ", disabled: "disabled", precise: "precise" }, outputs: { centered: "centered" }, usesInheritance: true, ngImport: i0, template: `
+        <ngt-group ngtCompound [ref]="centerRef">
+            <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: "15.1.3", ngImport: i0, type: NgtsCenter, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-center',
+                    standalone: true,
+                    template: `
+        <ngt-group ngtCompound [ref]="centerRef">
+            <ngt-group [ref]="outerRef">
+                <ngt-group [ref]="innerRef">
+                    <ng-content />
+                </ngt-group>
+            </ngt-group>
+        </ngt-group>
+    `,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], propDecorators: { centerRef: [{
+                type: Input
+            }], top: [{
+                type: Input
+            }], right: [{
+                type: Input
+            }], bottom: [{
+                type: Input
+            }], left: [{
+                type: Input
+            }], front: [{
+                type: Input
+            }], back: [{
+                type: Input
+            }], disableX: [{
+                type: Input
+            }], disableY: [{
+                type: Input
+            }], disableZ: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], precise: [{
+                type: Input
+            }], centered: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"center.js","sourceRoot":"","sources":["../../../../../../../libs/angular-three-soba/staging/src/lib/center/center.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, CUSTOM_ELEMENTS_SCHEMA, EventEmitter, Input, OnInit, Output } from '@angular/core';\nimport { extend, injectNgtRef, NgtRxStore } from 'angular-three';\nimport { combineLatest } from 'rxjs';\nimport { Box3, Group, Sphere, Vector3 } from 'three';\n\nextend({ Group });\n\n@Component({\n    selector: 'ngts-center',\n    standalone: true,\n    template: `\n        <ngt-group ngtCompound [ref]=\"centerRef\">\n            <ngt-group [ref]=\"outerRef\">\n                <ngt-group [ref]=\"innerRef\">\n                    <ng-content />\n                </ngt-group>\n            </ngt-group>\n        </ngt-group>\n    `,\n    schemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsCenter extends NgtRxStore implements OnInit {\n    @Input() centerRef = injectNgtRef<Group>();\n\n    readonly outerRef = injectNgtRef<Group>();\n    readonly innerRef = injectNgtRef<Group>();\n\n    @Input() set top(top: boolean) {\n        this.set({ top });\n    }\n\n    @Input() set right(right: boolean) {\n        this.set({ right });\n    }\n\n    @Input() set bottom(bottom: boolean) {\n        this.set({ bottom });\n    }\n\n    @Input() set left(left: boolean) {\n        this.set({ left });\n    }\n\n    @Input() set front(front: boolean) {\n        this.set({ front });\n    }\n\n    @Input() set back(back: boolean) {\n        this.set({ back });\n    }\n\n    @Input() set disableX(disableX: boolean) {\n        this.set({ disableX });\n    }\n\n    @Input() set disableY(disableY: boolean) {\n        this.set({ disableY });\n    }\n\n    @Input() set disableZ(disableZ: boolean) {\n        this.set({ disableZ });\n    }\n\n    @Input() set disabled(disabled: boolean) {\n        this.set({ disabled });\n    }\n\n    @Input() set precise(precise: boolean) {\n        this.set({ precise });\n    }\n\n    @Output() centered = new EventEmitter<{\n        /** The next parent above <Center> */\n        parent: THREE.Object3D;\n        /** The outmost container group of the <Center> component */\n        container: THREE.Object3D;\n        width: number;\n        height: number;\n        depth: number;\n        boundingBox: THREE.Box3;\n        boundingSphere: THREE.Sphere;\n        center: THREE.Vector3;\n        verticalAlignment: number;\n        horizontalAlignment: number;\n        depthAlignment: number;\n    }>();\n\n    override initialize(): void {\n        super.initialize();\n        this.set({ precise: true });\n    }\n\n    ngOnInit(): void {\n        this.setPosition();\n    }\n\n    private setPosition() {\n        this.hold(combineLatest([this.innerRef.$, this.innerRef.children$()]), ([innerGroup]) => {\n            const { precise, top, left, front, disabled, disableX, disableY, disableZ, back, bottom, right } =\n                this.get();\n            this.outerRef.nativeElement.matrixWorld.identity();\n            const box3 = new Box3().setFromObject(innerGroup, precise);\n            const center = new Vector3();\n            const sphere = new Sphere();\n            const width = box3.max.x - box3.min.x;\n            const height = box3.max.y - box3.min.y;\n            const depth = box3.max.z - box3.min.z;\n\n            box3.getCenter(center);\n            box3.getBoundingSphere(sphere);\n\n            const vAlign = top ? height / 2 : bottom ? -height / 2 : 0;\n            const hAlign = left ? -width / 2 : right ? width / 2 : 0;\n            const dAlign = front ? depth / 2 : back ? -depth / 2 : 0;\n\n            this.outerRef.nativeElement.position.set(\n                disabled || disableX ? 0 : -center.x + hAlign,\n                disabled || disableY ? 0 : -center.y + vAlign,\n                disabled || disableZ ? 0 : -center.z + dAlign\n            );\n\n            if (this.centered.observed) {\n                this.centered.emit({\n                    parent: this.centerRef.nativeElement.parent!,\n                    container: this.centerRef.nativeElement,\n                    width,\n                    height,\n                    depth,\n                    boundingBox: box3,\n                    boundingSphere: sphere,\n                    center: center,\n                    verticalAlignment: vAlign,\n                    horizontalAlignment: hAlign,\n                    depthAlignment: dAlign,\n                });\n            }\n        });\n    }\n}\n"]}

package/esm2020/staging/lib/contact-shadows/contact-shadows.mjs

@@ -0,0 +1,227 @@
+import { NgIf } from '@angular/common';
+import { Component, CUSTOM_ELEMENTS_SCHEMA, inject, Input } from '@angular/core';
+import { extend, injectBeforeRender, injectNgtRef, NgtArgs, NgtPush, NgtRxStore, NgtStore, } 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 extends NgtRxStore {
+    set opacity(opacity) {
+        this.set({ opacity });
+    }
+    set width(width) {
+        this.set({ width });
+    }
+    set height(height) {
+        this.set({ height });
+    }
+    set blur(blur) {
+        this.set({ blur });
+    }
+    set far(far) {
+        this.set({ far });
+    }
+    set smooth(smooth) {
+        this.set({ smooth });
+    }
+    set resolution(resolution) {
+        this.set({ resolution });
+    }
+    set frames(frames) {
+        this.set({ frames });
+    }
+    set scale(scale) {
+        this.set({ scale });
+    }
+    set color(color) {
+        this.set({ color });
+    }
+    set depthWrite(depthWrite) {
+        this.set({ depthWrite });
+    }
+    set renderOrder(renderOrder) {
+        this.set({ renderOrder });
+    }
+    constructor() {
+        super();
+        this.store = inject(NgtStore);
+        this.shadowCameraRef = injectNgtRef();
+        this.encoding = this.store.get('gl', 'outputEncoding');
+        this.contactShadows$ = this.select('contactShadows');
+        this.Math = Math;
+        this.contactShadowsRef = injectNgtRef();
+        injectBeforeRender(this.onBeforeRender.bind(this, 0));
+    }
+    initialize() {
+        super.initialize();
+        this.set({
+            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.connect('scaledWidth', this.select(['width', 'scale'], ({ width, scale }) => width * (Array.isArray(scale) ? scale[0] : scale || 1)));
+        this.connect('scaledHeight', this.select(['height', 'scale'], ({ height, scale }) => height * (Array.isArray(scale) ? scale[1] : scale || 1)));
+        this.connect('cameraArgs', this.select(['scaledWidth', 'scaledHeight', 'far'], ({ scaledWidth: width, scaledHeight: height, far }) => {
+            return [-width / 2, width / 2, height / 2, -height / 2, 0, far];
+        }));
+        this.connect('contactShadows', this.select(['resolution', 'scaledWidth', 'scaledHeight', 'scale', 'color'], ({ resolution, scaledWidth: width, scaledHeight: height, color }) => {
+            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(width, height).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,
+            };
+        }));
+    }
+    onBeforeRender(count, { scene, gl }) {
+        const { frames, blur, contactShadows: { depthMaterial, renderTarget }, smooth, } = this.get();
+        if (this.shadowCameraRef.nativeElement && (frames === Infinity || count < frames)) {
+            const initialBackground = scene.background;
+            scene.background = null;
+            const initialOverrideMaterial = scene.overrideMaterial;
+            scene.overrideMaterial = depthMaterial;
+            gl.setRenderTarget(renderTarget);
+            gl.render(scene, this.shadowCameraRef.nativeElement);
+            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.get('contactShadows');
+        const gl = this.store.get('gl');
+        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, this.shadowCameraRef.nativeElement);
+        blurPlane.material = verticalBlurMaterial;
+        verticalBlurMaterial.uniforms.tDiffuse.value = renderTargetBlur.texture;
+        verticalBlurMaterial.uniforms.v.value = (blur * 1) / 256;
+        gl.setRenderTarget(renderTarget);
+        gl.render(blurPlane, this.shadowCameraRef.nativeElement);
+        blurPlane.visible = false;
+    }
+}
+NgtsContactShadows.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.3", ngImport: i0, type: NgtsContactShadows, deps: [], target: i0.ɵɵFactoryTarget.Component });
+NgtsContactShadows.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.1.3", type: NgtsContactShadows, isStandalone: true, selector: "ngts-contact-shadows", inputs: { contactShadowsRef: "contactShadowsRef", opacity: "opacity", width: "width", height: "height", blur: "blur", far: "far", smooth: "smooth", resolution: "resolution", frames: "frames", scale: "scale", color: "color", depthWrite: "depthWrite", renderOrder: "renderOrder" }, usesInheritance: true, ngImport: i0, template: `
+        <ngt-group ngtCompound [ref]="contactShadowsRef" [rotation]="[Math.PI / 2, 0, 0]">
+            <ng-container *ngIf="contactShadows$ | ngtPush : null as contactShadows">
+                <ngt-mesh
+                    [renderOrder]="get('renderOrder')"
+                    [geometry]="contactShadows.planeGeometry"
+                    [scale]="[1, -1, 1]"
+                    [rotation]="[-Math.PI / 2, 0, 0]"
+                >
+                    <ngt-mesh-basic-material
+                        [map]="contactShadows.renderTarget.texture"
+                        transparent
+                        [opacity]="get('opacity')"
+                        [depthWrite]="get('depthWrite')"
+                    >
+                        <ngt-value [rawValue]="encoding" attach="map.encoding" />
+                    </ngt-mesh-basic-material>
+                </ngt-mesh>
+                <ngt-orthographic-camera *args="get('cameraArgs')" [ref]="shadowCameraRef" />
+            </ng-container>
+        </ngt-group>
+    `, isInline: true, dependencies: [{ kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: NgtPush, name: "ngtPush" }, { kind: "directive", type: NgtArgs, selector: "[args]", inputs: ["args"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.3", 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]">
+            <ng-container *ngIf="contactShadows$ | ngtPush : null as contactShadows">
+                <ngt-mesh
+                    [renderOrder]="get('renderOrder')"
+                    [geometry]="contactShadows.planeGeometry"
+                    [scale]="[1, -1, 1]"
+                    [rotation]="[-Math.PI / 2, 0, 0]"
+                >
+                    <ngt-mesh-basic-material
+                        [map]="contactShadows.renderTarget.texture"
+                        transparent
+                        [opacity]="get('opacity')"
+                        [depthWrite]="get('depthWrite')"
+                    >
+                        <ngt-value [rawValue]="encoding" attach="map.encoding" />
+                    </ngt-mesh-basic-material>
+                </ngt-mesh>
+                <ngt-orthographic-camera *args="get('cameraArgs')" [ref]="shadowCameraRef" />
+            </ng-container>
+        </ngt-group>
+    `,
+                    imports: [NgIf, NgtPush, NgtArgs],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { contactShadowsRef: [{
+                type: Input
+            }], opacity: [{
+                type: Input
+            }], width: [{
+                type: Input
+            }], height: [{
+                type: Input
+            }], blur: [{
+                type: Input
+            }], far: [{
+                type: Input
+            }], smooth: [{
+                type: Input
+            }], resolution: [{
+                type: Input
+            }], frames: [{
+                type: Input
+            }], scale: [{
+                type: Input
+            }], color: [{
+                type: Input
+            }], depthWrite: [{
+                type: Input
+            }], renderOrder: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"contact-shadows.js","sourceRoot":"","sources":["../../../../../../../libs/angular-three-soba/staging/src/lib/contact-shadows/contact-shadows.ts"],"names":[],"mappings":"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","sourcesContent":["import { NgIf } from '@angular/common';\nimport { Component, CUSTOM_ELEMENTS_SCHEMA, inject, Input } from '@angular/core';\nimport {\n    extend,\n    injectBeforeRender,\n    injectNgtRef,\n    NgtArgs,\n    NgtPush,\n    NgtRenderState,\n    NgtRxStore,\n    NgtStore,\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\n@Component({\n    selector: 'ngts-contact-shadows',\n    standalone: true,\n    template: `\n        <ngt-group ngtCompound [ref]=\"contactShadowsRef\" [rotation]=\"[Math.PI / 2, 0, 0]\">\n            <ng-container *ngIf=\"contactShadows$ | ngtPush : null as contactShadows\">\n                <ngt-mesh\n                    [renderOrder]=\"get('renderOrder')\"\n                    [geometry]=\"contactShadows.planeGeometry\"\n                    [scale]=\"[1, -1, 1]\"\n                    [rotation]=\"[-Math.PI / 2, 0, 0]\"\n                >\n                    <ngt-mesh-basic-material\n                        [map]=\"contactShadows.renderTarget.texture\"\n                        transparent\n                        [opacity]=\"get('opacity')\"\n                        [depthWrite]=\"get('depthWrite')\"\n                    >\n                        <ngt-value [rawValue]=\"encoding\" attach=\"map.encoding\" />\n                    </ngt-mesh-basic-material>\n                </ngt-mesh>\n                <ngt-orthographic-camera *args=\"get('cameraArgs')\" [ref]=\"shadowCameraRef\" />\n            </ng-container>\n        </ngt-group>\n    `,\n    imports: [NgIf, NgtPush, NgtArgs],\n    schemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsContactShadows extends NgtRxStore {\n    private readonly store = inject(NgtStore);\n    readonly shadowCameraRef = injectNgtRef<OrthographicCamera>();\n    readonly encoding = this.store.get('gl', 'outputEncoding');\n    readonly contactShadows$ = this.select('contactShadows');\n    readonly Math = Math;\n\n    @Input() contactShadowsRef = injectNgtRef<Group>();\n\n    @Input() set opacity(opacity: number) {\n        this.set({ opacity });\n    }\n\n    @Input() set width(width: number) {\n        this.set({ width });\n    }\n\n    @Input() set height(height: number) {\n        this.set({ height });\n    }\n\n    @Input() set blur(blur: number) {\n        this.set({ blur });\n    }\n\n    @Input() set far(far: number) {\n        this.set({ far });\n    }\n\n    @Input() set smooth(smooth: boolean) {\n        this.set({ smooth });\n    }\n\n    @Input() set resolution(resolution: number) {\n        this.set({ resolution });\n    }\n\n    @Input() set frames(frames: number) {\n        this.set({ frames });\n    }\n\n    @Input() set scale(scale: number | [x: number, y: number]) {\n        this.set({ scale });\n    }\n\n    @Input() set color(color: THREE.ColorRepresentation) {\n        this.set({ color });\n    }\n\n    @Input() set depthWrite(depthWrite: boolean) {\n        this.set({ depthWrite });\n    }\n\n    @Input() set renderOrder(renderOrder: number) {\n        this.set({ renderOrder });\n    }\n\n    constructor() {\n        super();\n        injectBeforeRender(this.onBeforeRender.bind(this, 0));\n    }\n\n    override initialize() {\n        super.initialize();\n        this.set({\n            scale: 10,\n            frames: Infinity,\n            opacity: 1,\n            width: 1,\n            height: 1,\n            blur: 1,\n            far: 10,\n            resolution: 512,\n            smooth: true,\n            color: '#000000',\n            depthWrite: false,\n            renderOrder: 0,\n        });\n        this.connect(\n            'scaledWidth',\n            this.select(\n                ['width', 'scale'],\n                ({ width, scale }) => width * (Array.isArray(scale) ? scale[0] : scale || 1)\n            )\n        );\n        this.connect(\n            'scaledHeight',\n            this.select(\n                ['height', 'scale'],\n                ({ height, scale }) => height * (Array.isArray(scale) ? scale[1] : scale || 1)\n            )\n        );\n        this.connect(\n            'cameraArgs',\n            this.select(['scaledWidth', 'scaledHeight', 'far'], ({ scaledWidth: width, scaledHeight: height, far }) => {\n                return [-width / 2, width / 2, height / 2, -height / 2, 0, far];\n            })\n        );\n        this.connect(\n            'contactShadows',\n            this.select(\n                ['resolution', 'scaledWidth', 'scaledHeight', 'scale', 'color'],\n                ({ resolution, scaledWidth: width, scaledHeight: height, color }) => {\n                    const renderTarget = new THREE.WebGLRenderTarget(resolution, resolution);\n                    const renderTargetBlur = new THREE.WebGLRenderTarget(resolution, resolution);\n                    renderTargetBlur.texture.generateMipmaps = renderTarget.texture.generateMipmaps = false;\n                    const planeGeometry = new THREE.PlaneGeometry(width, height).rotateX(Math.PI / 2);\n                    const blurPlane = new Mesh(planeGeometry);\n                    const depthMaterial = new THREE.MeshDepthMaterial();\n                    depthMaterial.depthTest = depthMaterial.depthWrite = false;\n                    depthMaterial.onBeforeCompile = (shader) => {\n                        shader.uniforms = {\n                            ...shader.uniforms,\n                            ucolor: { value: new THREE.Color(color) },\n                        };\n                        shader.fragmentShader = shader.fragmentShader.replace(\n                            `void main() {`, //\n                            `uniform vec3 ucolor;\n                             void main() {\n                            `\n                        );\n                        shader.fragmentShader = shader.fragmentShader.replace(\n                            'vec4( vec3( 1.0 - fragCoordZ ), opacity );',\n                            // Colorize the shadow, multiply by the falloff so that the center can remain darker\n                            'vec4( ucolor * fragCoordZ * 2.0, ( 1.0 - fragCoordZ ) * 1.0 );'\n                        );\n                    };\n\n                    const horizontalBlurMaterial = new THREE.ShaderMaterial(HorizontalBlurShader);\n                    const verticalBlurMaterial = new THREE.ShaderMaterial(VerticalBlurShader);\n                    verticalBlurMaterial.depthTest = horizontalBlurMaterial.depthTest = false;\n\n                    return {\n                        renderTarget,\n                        planeGeometry,\n                        depthMaterial,\n                        blurPlane,\n                        horizontalBlurMaterial,\n                        verticalBlurMaterial,\n                        renderTargetBlur,\n                    };\n                }\n            )\n        );\n    }\n\n    private onBeforeRender(count: number, { scene, gl }: NgtRenderState) {\n        const {\n            frames,\n            blur,\n            contactShadows: { depthMaterial, renderTarget },\n            smooth,\n        } = this.get();\n\n        if (this.shadowCameraRef.nativeElement && (frames === Infinity || count < frames)) {\n            const initialBackground = scene.background;\n            scene.background = null;\n            const initialOverrideMaterial = scene.overrideMaterial;\n            scene.overrideMaterial = depthMaterial;\n            gl.setRenderTarget(renderTarget);\n            gl.render(scene, this.shadowCameraRef.nativeElement);\n            scene.overrideMaterial = initialOverrideMaterial;\n\n            this.blurShadows(blur);\n            if (smooth) this.blurShadows(blur * 0.4);\n\n            gl.setRenderTarget(null);\n            scene.background = initialBackground;\n            count++;\n        }\n    }\n\n    private blurShadows(blur: number) {\n        const { blurPlane, horizontalBlurMaterial, verticalBlurMaterial, renderTargetBlur, renderTarget } =\n            this.get('contactShadows');\n        const gl = this.store.get('gl');\n\n        blurPlane.visible = true;\n\n        blurPlane.material = horizontalBlurMaterial;\n        horizontalBlurMaterial.uniforms.tDiffuse.value = renderTarget.texture;\n        horizontalBlurMaterial.uniforms.h.value = (blur * 1) / 256;\n\n        gl.setRenderTarget(renderTargetBlur);\n        gl.render(blurPlane, this.shadowCameraRef.nativeElement);\n\n        blurPlane.material = verticalBlurMaterial;\n        verticalBlurMaterial.uniforms.tDiffuse.value = renderTargetBlur.texture;\n        verticalBlurMaterial.uniforms.v.value = (blur * 1) / 256;\n\n        gl.setRenderTarget(renderTarget);\n        gl.render(blurPlane, this.shadowCameraRef.nativeElement);\n\n        blurPlane.visible = false;\n    }\n}\n"]}

package/esm2020/staging/lib/environment/assets.mjs

@@ -0,0 +1,13 @@
+export const ngtsEnvironmentPresetsObj = {
+    sunset: 'venice/venice_sunset_1k.hdr',
+    dawn: 'kiara/kiara_1_dawn_1k.hdr',
+    night: 'dikhololo/dikhololo_night_1k.hdr',
+    warehouse: 'empty-wharehouse/empty_warehouse_01_1k.hdr',
+    forest: 'forrest-slope/forest_slope_1k.hdr',
+    apartment: 'lebombo/lebombo_1k.hdr',
+    studio: 'studio-small-3/studio_small_03_1k.hdr',
+    city: 'potsdamer-platz/potsdamer_platz_1k.hdr',
+    park: 'rooitou/rooitou_park_1k.hdr',
+    lobby: 'st-fagans/st_fagans_interior_1k.hdr',
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXNzZXRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9hbmd1bGFyLXRocmVlLXNvYmEvc3RhZ2luZy9zcmMvbGliL2Vudmlyb25tZW50L2Fzc2V0cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQUMsTUFBTSx5QkFBeUIsR0FBRztJQUNyQyxNQUFNLEVBQUUsNkJBQTZCO0lBQ3JDLElBQUksRUFBRSwyQkFBMkI7SUFDakMsS0FBSyxFQUFFLGtDQUFrQztJQUN6QyxTQUFTLEVBQUUsNENBQTRDO0lBQ3ZELE1BQU0sRUFBRSxtQ0FBbUM7SUFDM0MsU0FBUyxFQUFFLHdCQUF3QjtJQUNuQyxNQUFNLEVBQUUsdUNBQXVDO0lBQy9DLElBQUksRUFBRSx3Q0FBd0M7SUFDOUMsSUFBSSxFQUFFLDZCQUE2QjtJQUNuQyxLQUFLLEVBQUUscUNBQXFDO0NBQy9DLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY29uc3Qgbmd0c0Vudmlyb25tZW50UHJlc2V0c09iaiA9IHtcbiAgICBzdW5zZXQ6ICd2ZW5pY2UvdmVuaWNlX3N1bnNldF8xay5oZHInLFxuICAgIGRhd246ICdraWFyYS9raWFyYV8xX2Rhd25fMWsuaGRyJyxcbiAgICBuaWdodDogJ2Rpa2hvbG9sby9kaWtob2xvbG9fbmlnaHRfMWsuaGRyJyxcbiAgICB3YXJlaG91c2U6ICdlbXB0eS13aGFyZWhvdXNlL2VtcHR5X3dhcmVob3VzZV8wMV8xay5oZHInLFxuICAgIGZvcmVzdDogJ2ZvcnJlc3Qtc2xvcGUvZm9yZXN0X3Nsb3BlXzFrLmhkcicsXG4gICAgYXBhcnRtZW50OiAnbGVib21iby9sZWJvbWJvXzFrLmhkcicsXG4gICAgc3R1ZGlvOiAnc3R1ZGlvLXNtYWxsLTMvc3R1ZGlvX3NtYWxsXzAzXzFrLmhkcicsXG4gICAgY2l0eTogJ3BvdHNkYW1lci1wbGF0ei9wb3RzZGFtZXJfcGxhdHpfMWsuaGRyJyxcbiAgICBwYXJrOiAncm9vaXRvdS9yb29pdG91X3BhcmtfMWsuaGRyJyxcbiAgICBsb2JieTogJ3N0LWZhZ2Fucy9zdF9mYWdhbnNfaW50ZXJpb3JfMWsuaGRyJyxcbn07XG5cbmV4cG9ydCB0eXBlIE5ndHNFbnZpcm9ubWVudFByZXNldHNUeXBlID0ga2V5b2YgdHlwZW9mIG5ndHNFbnZpcm9ubWVudFByZXNldHNPYmo7XG4iXX0=

package/esm2020/staging/lib/environment/environment-cube.mjs

@@ -0,0 +1,40 @@
+import { Directive } from '@angular/core';
+import { startWithUndefined } from 'angular-three';
+import { combineLatest, startWith } from 'rxjs';
+import { NgtsEnvironmentInputs } from './environment-inputs';
+import { injectNgtsEnvironment, setEnvProps } from './utils';
+import * as i0 from "@angular/core";
+export class NgtsEnvironmentCube extends NgtsEnvironmentInputs {
+    constructor() {
+        super(...arguments);
+        this.textureRef = injectNgtsEnvironment((params) => this.select().pipe(startWith(params)));
+    }
+    initialize() {
+        super.initialize();
+        this.set({ background: false });
+    }
+    ngOnInit() {
+        this.setEnvProps();
+    }
+    setEnvProps() {
+        this.effect(combineLatest([
+            this.store.select('scene'),
+            this.select('scene').pipe(startWithUndefined()),
+            this.select('background'),
+            this.select('blur').pipe(startWithUndefined()),
+            this.textureRef.$,
+        ]), ([defaultScene, scene, background, blur, texture]) => {
+            return setEnvProps(background, scene, defaultScene, texture, blur);
+        });
+    }
+}
+NgtsEnvironmentCube.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.3", ngImport: i0, type: NgtsEnvironmentCube, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+NgtsEnvironmentCube.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.1.3", type: NgtsEnvironmentCube, isStandalone: true, selector: "ngts-environment-cube", usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.3", ngImport: i0, type: NgtsEnvironmentCube, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'ngts-environment-cube',
+                    standalone: true,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/staging/lib/environment/environment-ground.mjs

@@ -0,0 +1,66 @@
+import { NgIf } from '@angular/common';
+import { Component, CUSTOM_ELEMENTS_SCHEMA } from '@angular/core';
+import { extend, NgtArgs, startWithUndefined } from 'angular-three';
+import { combineLatest, map, startWith } from 'rxjs';
+import { GroundProjectedEnv } from 'three-stdlib';
+import { NgtsEnvironmentInputs } from './environment-inputs';
+import { NgtsEnvironmentMap } from './environment-map';
+import { injectNgtsEnvironment } from './utils';
+import * as i0 from "@angular/core";
+extend({ GroundProjectedEnv });
+export class NgtsEnvironmentGround extends NgtsEnvironmentInputs {
+    constructor() {
+        super(...arguments);
+        this.defaultTexture = injectNgtsEnvironment((params) => this.select().pipe(startWith(params)));
+    }
+    ngOnInit() {
+        this.connect('texture', combineLatest([this.select('map').pipe(startWithUndefined()), this.defaultTexture.$]).pipe(map(([map, texture]) => map || texture)));
+        this.connect('groundArgs', this.select('texture').pipe(map((texture) => [texture])));
+        this.connect('groundHeight', this.select(['ground'], ({ ground }) => ground?.height));
+        this.connect('groundRadius', this.select(['ground'], ({ ground }) => ground?.radius));
+        this.connect('groundScale', this.select(['ground'], ({ ground }) => ground?.scale ?? 1000));
+    }
+}
+NgtsEnvironmentGround.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.3", ngImport: i0, type: NgtsEnvironmentGround, deps: null, target: i0.ɵɵFactoryTarget.Component });
+NgtsEnvironmentGround.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.1.3", type: NgtsEnvironmentGround, isStandalone: true, selector: "ngts-environment-ground", usesInheritance: true, ngImport: i0, template: `
+        <ngts-environment-map
+            [background]="get('background')"
+            [blur]="get('blur')"
+            [scene]="get('scene')"
+            [map]="get('texture')"
+        />
+        <ng-container *ngIf="get('groundArgs') as groundArgs">
+            <ngt-ground-projected-env
+                *args="groundArgs"
+                [scale]="get('groundScale')"
+                [height]="get('groundHeight')"
+                [radius]="get('groundRadius')"
+            />
+        </ng-container>
+    `, isInline: true, dependencies: [{ kind: "directive", type: NgtsEnvironmentMap, selector: "ngts-environment-map" }, { kind: "directive", type: NgtArgs, selector: "[args]", inputs: ["args"] }, { kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.3", ngImport: i0, type: NgtsEnvironmentGround, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-environment-ground',
+                    standalone: true,
+                    template: `
+        <ngts-environment-map
+            [background]="get('background')"
+            [blur]="get('blur')"
+            [scene]="get('scene')"
+            [map]="get('texture')"
+        />
+        <ng-container *ngIf="get('groundArgs') as groundArgs">
+            <ngt-ground-projected-env
+                *args="groundArgs"
+                [scale]="get('groundScale')"
+                [height]="get('groundHeight')"
+                [radius]="get('groundRadius')"
+            />
+        </ng-container>
+    `,
+                    imports: [NgtsEnvironmentMap, NgtArgs, NgIf],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW52aXJvbm1lbnQtZ3JvdW5kLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9hbmd1bGFyLXRocmVlLXNvYmEvc3RhZ2luZy9zcmMvbGliL2Vudmlyb25tZW50L2Vudmlyb25tZW50LWdyb3VuZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDdkMsT0FBTyxFQUFFLFNBQVMsRUFBRSxzQkFBc0IsRUFBVSxNQUFNLGVBQWUsQ0FBQztBQUMxRSxPQUFPLEVBQUUsTUFBTSxFQUFFLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUNwRSxPQUFPLEVBQUUsYUFBYSxFQUFFLEdBQUcsRUFBRSxTQUFTLEVBQUUsTUFBTSxNQUFNLENBQUM7QUFDckQsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sY0FBYyxDQUFDO0FBQ2xELE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQzdELE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQ3ZELE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLFNBQVMsQ0FBQzs7QUFFaEQsTUFBTSxDQUFDLEVBQUUsa0JBQWtCLEVBQUUsQ0FBQyxDQUFDO0FBd0IvQixNQUFNLE9BQU8scUJBQXNCLFNBQVEscUJBQXFCO0lBdEJoRTs7UUF1QmEsbUJBQWMsR0FBRyxxQkFBcUIsQ0FBQyxDQUFDLE1BQU0sRUFBRSxFQUFFLENBQUMsSUFBSSxDQUFDLE1BQU0sRUFBRSxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFDO0tBdUJ0RztJQXJCRyxRQUFRO1FBQ0osSUFBSSxDQUFDLE9BQU8sQ0FDUixTQUFTLEVBQ1QsYUFBYSxDQUFDLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQyxJQUFJLENBQUMsa0JBQWtCLEVBQUUsQ0FBQyxFQUFFLElBQUksQ0FBQyxjQUFjLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQ3RGLEdBQUcsQ0FBQyxDQUFDLENBQUMsR0FBRyxFQUFFLE9BQU8sQ0FBQyxFQUFFLEVBQUUsQ0FBQyxHQUFHLElBQUksT0FBTyxDQUFDLENBQzFDLENBQ0osQ0FBQztRQUNGLElBQUksQ0FBQyxPQUFPLENBQUMsWUFBWSxFQUFFLElBQUksQ0FBQyxNQUFNLENBQUMsU0FBUyxDQUFDLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDLE9BQU8sRUFBRSxFQUFFLENBQUMsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUNyRixJQUFJLENBQUMsT0FBTyxDQUNSLGNBQWMsRUFDZCxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUMsUUFBUSxDQUFDLEVBQUUsQ0FBQyxFQUFFLE1BQU0sRUFBRSxFQUFFLEVBQUUsQ0FBQyxNQUFNLEVBQUUsTUFBTSxDQUFDLENBQzFELENBQUM7UUFDRixJQUFJLENBQUMsT0FBTyxDQUNSLGNBQWMsRUFDZCxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUMsUUFBUSxDQUFDLEVBQUUsQ0FBQyxFQUFFLE1BQU0sRUFBRSxFQUFFLEVBQUUsQ0FBQyxNQUFNLEVBQUUsTUFBTSxDQUFDLENBQzFELENBQUM7UUFDRixJQUFJLENBQUMsT0FBTyxDQUNSLGFBQWEsRUFDYixJQUFJLENBQUMsTUFBTSxDQUFDLENBQUMsUUFBUSxDQUFDLEVBQUUsQ0FBQyxFQUFFLE1BQU0sRUFBRSxFQUFFLEVBQUUsQ0FBQyxNQUFNLEVBQUUsS0FBSyxJQUFJLElBQUksQ0FBQyxDQUNqRSxDQUFDO0lBQ04sQ0FBQzs7a0hBdkJRLHFCQUFxQjtzR0FBckIscUJBQXFCLDBHQW5CcEI7Ozs7Ozs7Ozs7Ozs7OztLQWVULDREQUNTLGtCQUFrQixpRUFBRSxPQUFPLHFFQUFFLElBQUk7MkZBR2xDLHFCQUFxQjtrQkF0QmpDLFNBQVM7bUJBQUM7b0JBQ1AsUUFBUSxFQUFFLHlCQUF5QjtvQkFDbkMsVUFBVSxFQUFFLElBQUk7b0JBQ2hCLFFBQVEsRUFBRTs7Ozs7Ozs7Ozs7Ozs7O0tBZVQ7b0JBQ0QsT0FBTyxFQUFFLENBQUMsa0JBQWtCLEVBQUUsT0FBTyxFQUFFLElBQUksQ0FBQztvQkFDNUMsT0FBTyxFQUFFLENBQUMsc0JBQXNCLENBQUM7aUJBQ3BDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdJZiB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQgeyBDb21wb25lbnQsIENVU1RPTV9FTEVNRU5UU19TQ0hFTUEsIE9uSW5pdCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgZXh0ZW5kLCBOZ3RBcmdzLCBzdGFydFdpdGhVbmRlZmluZWQgfSBmcm9tICdhbmd1bGFyLXRocmVlJztcbmltcG9ydCB7IGNvbWJpbmVMYXRlc3QsIG1hcCwgc3RhcnRXaXRoIH0gZnJvbSAncnhqcyc7XG5pbXBvcnQgeyBHcm91bmRQcm9qZWN0ZWRFbnYgfSBmcm9tICd0aHJlZS1zdGRsaWInO1xuaW1wb3J0IHsgTmd0c0Vudmlyb25tZW50SW5wdXRzIH0gZnJvbSAnLi9lbnZpcm9ubWVudC1pbnB1dHMnO1xuaW1wb3J0IHsgTmd0c0Vudmlyb25tZW50TWFwIH0gZnJvbSAnLi9lbnZpcm9ubWVudC1tYXAnO1xuaW1wb3J0IHsgaW5qZWN0Tmd0c0Vudmlyb25tZW50IH0gZnJvbSAnLi91dGlscyc7XG5cbmV4dGVuZCh7IEdyb3VuZFByb2plY3RlZEVudiB9KTtcblxuQENvbXBvbmVudCh7XG4gICAgc2VsZWN0b3I6ICduZ3RzLWVudmlyb25tZW50LWdyb3VuZCcsXG4gICAgc3RhbmRhbG9uZTogdHJ1ZSxcbiAgICB0ZW1wbGF0ZTogYFxuICAgICAgICA8bmd0cy1lbnZpcm9ubWVudC1tYXBcbiAgICAgICAgICAgIFtiYWNrZ3JvdW5kXT1cImdldCgnYmFja2dyb3VuZCcpXCJcbiAgICAgICAgICAgIFtibHVyXT1cImdldCgnYmx1cicpXCJcbiAgICAgICAgICAgIFtzY2VuZV09XCJnZXQoJ3NjZW5lJylcIlxuICAgICAgICAgICAgW21hcF09XCJnZXQoJ3RleHR1cmUnKVwiXG4gICAgICAgIC8+XG4gICAgICAgIDxuZy1jb250YWluZXIgKm5nSWY9XCJnZXQoJ2dyb3VuZEFyZ3MnKSBhcyBncm91bmRBcmdzXCI+XG4gICAgICAgICAgICA8bmd0LWdyb3VuZC1wcm9qZWN0ZWQtZW52XG4gICAgICAgICAgICAgICAgKmFyZ3M9XCJncm91bmRBcmdzXCJcbiAgICAgICAgICAgICAgICBbc2NhbGVdPVwiZ2V0KCdncm91bmRTY2FsZScpXCJcbiAgICAgICAgICAgICAgICBbaGVpZ2h0XT1cImdldCgnZ3JvdW5kSGVpZ2h0JylcIlxuICAgICAgICAgICAgICAgIFtyYWRpdXNdPVwiZ2V0KCdncm91bmRSYWRpdXMnKVwiXG4gICAgICAgICAgICAvPlxuICAgICAgICA8L25nLWNvbnRhaW5lcj5cbiAgICBgLFxuICAgIGltcG9ydHM6IFtOZ3RzRW52aXJvbm1lbnRNYXAsIE5ndEFyZ3MsIE5nSWZdLFxuICAgIHNjaGVtYXM6IFtDVVNUT01fRUxFTUVOVFNfU0NIRU1BXSxcbn0pXG5leHBvcnQgY2xhc3MgTmd0c0Vudmlyb25tZW50R3JvdW5kIGV4dGVuZHMgTmd0c0Vudmlyb25tZW50SW5wdXRzIGltcGxlbWVudHMgT25Jbml0IHtcbiAgICByZWFkb25seSBkZWZhdWx0VGV4dHVyZSA9IGluamVjdE5ndHNFbnZpcm9ubWVudCgocGFyYW1zKSA9PiB0aGlzLnNlbGVjdCgpLnBpcGUoc3RhcnRXaXRoKHBhcmFtcykpKTtcblxuICAgIG5nT25Jbml0KCkge1xuICAgICAgICB0aGlzLmNvbm5lY3QoXG4gICAgICAgICAgICAndGV4dHVyZScsXG4gICAgICAgICAgICBjb21iaW5lTGF0ZXN0KFt0aGlzLnNlbGVjdCgnbWFwJykucGlwZShzdGFydFdpdGhVbmRlZmluZWQoKSksIHRoaXMuZGVmYXVsdFRleHR1cmUuJF0pLnBpcGUoXG4gICAgICAgICAgICAgICAgbWFwKChbbWFwLCB0ZXh0dXJlXSkgPT4gbWFwIHx8IHRleHR1cmUpXG4gICAgICAgICAgICApXG4gICAgICAgICk7XG4gICAgICAgIHRoaXMuY29ubmVjdCgnZ3JvdW5kQXJncycsIHRoaXMuc2VsZWN0KCd0ZXh0dXJlJykucGlwZShtYXAoKHRleHR1cmUpID0+IFt0ZXh0dXJlXSkpKTtcbiAgICAgICAgdGhpcy5jb25uZWN0KFxuICAgICAgICAgICAgJ2dyb3VuZEhlaWdodCcsXG4gICAgICAgICAgICB0aGlzLnNlbGVjdChbJ2dyb3VuZCddLCAoeyBncm91bmQgfSkgPT4gZ3JvdW5kPy5oZWlnaHQpXG4gICAgICAgICk7XG4gICAgICAgIHRoaXMuY29ubmVjdChcbiAgICAgICAgICAgICdncm91bmRSYWRpdXMnLFxuICAgICAgICAgICAgdGhpcy5zZWxlY3QoWydncm91bmQnXSwgKHsgZ3JvdW5kIH0pID0+IGdyb3VuZD8ucmFkaXVzKVxuICAgICAgICApO1xuICAgICAgICB0aGlzLmNvbm5lY3QoXG4gICAgICAgICAgICAnZ3JvdW5kU2NhbGUnLFxuICAgICAgICAgICAgdGhpcy5zZWxlY3QoWydncm91bmQnXSwgKHsgZ3JvdW5kIH0pID0+IGdyb3VuZD8uc2NhbGUgPz8gMTAwMClcbiAgICAgICAgKTtcbiAgICB9XG59XG4iXX0=