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

package/esm2022/staging/center/center.mjs

@@ -0,0 +1,148 @@
+import { Component, computed, CUSTOM_ELEMENTS_SCHEMA, effect, EventEmitter, Input, Output } from '@angular/core';
+import { extend, injectNgtRef, NgtSignalStore, requestAnimationInInjectionContext } from 'angular-three';
+import { Box3, Group, Sphere, Vector3 } from 'three';
+import * as i0 from "@angular/core";
+extend({ Group });
+class NgtsCenter extends NgtSignalStore {
+    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 disable(disable) {
+        this.set({ disable });
+    }
+    set precise(precise) {
+        this.set({ precise });
+    }
+    constructor() {
+        super({ precise: true });
+        this.centerRef = injectNgtRef();
+        this.outerRef = injectNgtRef();
+        this.innerRef = injectNgtRef();
+        this.centered = new EventEmitter();
+        requestAnimationInInjectionContext(() => {
+            this.#setPosition();
+        });
+    }
+    #setPosition() {
+        const trigger = computed(() => {
+            const center = this.centerRef.nativeElement;
+            const outer = this.outerRef.nativeElement;
+            const inner = this.innerRef.nativeElement;
+            const innerChildren = this.innerRef.children();
+            return { center, outer, inner, innerChildren: innerChildren() };
+        });
+        effect(() => {
+            const { center: centerGroup, outer, inner } = trigger();
+            if (!outer || !inner)
+                return;
+            const { precise, top, left, front, disable, disableX, disableY, disableZ, back, bottom, right } = this.get();
+            outer.matrixWorld.identity();
+            const box3 = new Box3().setFromObject(inner, 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;
+            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: centerGroup.parent,
+                    container: centerGroup,
+                    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.0.0", ngImport: i0, type: NgtsCenter, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", 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", disable: "disable", 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 }); }
+}
+export { NgtsCenter };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", 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],
+                }]
+        }], ctorParameters: function () { return []; }, 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
+            }], disable: [{
+                type: Input
+            }], precise: [{
+                type: Input
+            }], 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 { Component, computed, CUSTOM_ELEMENTS_SCHEMA, effect, EventEmitter, Input, Output } from '@angular/core';\nimport { extend, injectNgtRef, NgtSignalStore, requestAnimationInInjectionContext, type NgtGroup } from 'angular-three';\nimport { Box3, Group, Sphere, Vector3 } from 'three';\n\nexport type NgtsCenterState = {\n    top?: boolean;\n    right?: boolean;\n    bottom?: boolean;\n    left?: boolean;\n    front?: boolean;\n    back?: boolean;\n    /** Disable all axes */\n    disable?: boolean;\n    /** Disable x-axis centering */\n    disableX?: boolean;\n    /** Disable y-axis centering */\n    disableY?: boolean;\n    /** Disable z-axis centering */\n    disableZ?: boolean;\n    /** See https://threejs.org/docs/index.html?q=box3#api/en/math/Box3.setFromObject */\n    precise: boolean;\n};\n\nextend({ Group });\n\ndeclare global {\n    interface HTMLElementTagNameMap {\n        'ngts-center': NgtsCenterState & NgtGroup;\n    }\n}\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 NgtSignalStore<NgtsCenterState> {\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 disable(disable: boolean) {\n        this.set({ disable });\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    constructor() {\n        super({ precise: true });\n        requestAnimationInInjectionContext(() => {\n            this.#setPosition();\n        });\n    }\n\n    #setPosition() {\n        const trigger = computed(() => {\n            const center = this.centerRef.nativeElement;\n            const outer = this.outerRef.nativeElement;\n            const inner = this.innerRef.nativeElement;\n            const innerChildren = this.innerRef.children();\n            return { center, outer, inner, innerChildren: innerChildren() };\n        });\n\n        effect(() => {\n            const { center: centerGroup, outer, inner } = trigger();\n            if (!outer || !inner) return;\n            const { precise, top, left, front, disable, disableX, disableY, disableZ, back, bottom, right } =\n                this.get();\n            outer.matrixWorld.identity();\n            const box3 = new Box3().setFromObject(inner, 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            outer.position.set(\n                disable || disableX ? 0 : -center.x + hAlign,\n                disable || disableY ? 0 : -center.y + vAlign,\n                disable || disableZ ? 0 : -center.z + dAlign\n            );\n\n            if (this.centered.observed) {\n                this.centered.emit({\n                    parent: centerGroup.parent!,\n                    container: centerGroup,\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/esm2022/staging/cloud/cloud.mjs

@@ -0,0 +1,164 @@
+import { NgFor, NgIf } from '@angular/common';
+import { CUSTOM_ELEMENTS_SCHEMA, Component, Input, computed, inject } from '@angular/core';
+import { NgtSignalStore, NgtStore, extend, injectNgtRef, } 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 });
+class NgtsCloud extends NgtSignalStore {
+    set opacity(opacity) {
+        this.set({ opacity });
+    }
+    set speed(speed) {
+        this.set({ speed });
+    }
+    set width(width) {
+        this.set({ width });
+    }
+    set depth(depth) {
+        this.set({ depth });
+    }
+    set segments(segments) {
+        this.set({ segments });
+    }
+    set texture(texture) {
+        this.set({ texture });
+    }
+    set color(color) {
+        this.set({ color });
+    }
+    set depthTest(depthTest) {
+        this.set({ depthTest });
+    }
+    #store;
+    #width;
+    #speed;
+    constructor() {
+        super({
+            opacity: 0.5,
+            speed: 0.4,
+            width: 10,
+            depth: 1.5,
+            segments: 20,
+            texture: CLOUD_URL,
+            color: '#ffffff',
+            depthTest: true,
+        });
+        this.groupRef = injectNgtRef();
+        this.#store = inject(NgtStore);
+        this.#width = this.select('width');
+        this.#speed = this.select('speed');
+        this.cloudSegments = this.select('segments');
+        this.cloudDepth = this.select('depth');
+        this.cloudDepthTest = this.select('depthTest');
+        this.cloudOpacity = this.select('opacity');
+        this.cloudColor = this.select('color');
+        this.encoding = this.#store.select('gl', 'outputEncoding');
+        this.cloudTexture = injectNgtsTextureLoader(this.select('texture'));
+        this.clouds = computed(() => [...new Array(this.cloudSegments())].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.cloudSegments()) * 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(),
+        })));
+    }
+    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.0.0", ngImport: i0, type: NgtsCloud, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: NgtsCloud, isStandalone: true, selector: "ngts-cloud", inputs: { groupRef: "groupRef", opacity: "opacity", speed: "speed", width: "width", depth: "depth", segments: "segments", texture: "texture", color: "color", depthTest: "depthTest" }, usesInheritance: true, ngImport: i0, template: `
+        <ngt-group ngtCompound [ref]="groupRef">
+            <ngt-group
+                [position]="[0, 0, (cloudSegments() / 2) * cloudDepth()]"
+                (beforeRender)="onBeforeRender($event)"
+            >
+                <ngts-billboard
+                    *ngFor="let cloud of clouds(); let i = index"
+                    [position]="[cloud.x, cloud.y, -i * cloudDepth()]"
+                >
+                    <ngt-mesh [scale]="cloud.scale" [rotation]="[0, 0, 0]">
+                        <ngt-plane-geometry />
+                        <!-- we use ngIf here for texture because by the time ngt-value is initialized -->
+                        <!-- [map] has not been resolved yet. we ngIf it so that texture is available before hand -->
+                        <ngt-mesh-standard-material
+                            *ngIf="cloudTexture() as cloudTexture"
+                            [transparent]="true"
+                            [map]="cloudTexture"
+                            [depthTest]="cloudDepthTest()"
+                            [opacity]="(cloud.scale / 6) * cloud.density * cloudOpacity()"
+                            [color]="cloudColor()"
+                        >
+                            <ngt-value [rawValue]="encoding()" attach="map.encoding" />
+                        </ngt-mesh-standard-material>
+                    </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"] }, { kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] }); }
+}
+export { NgtsCloud };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsCloud, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-cloud',
+                    standalone: true,
+                    template: `
+        <ngt-group ngtCompound [ref]="groupRef">
+            <ngt-group
+                [position]="[0, 0, (cloudSegments() / 2) * cloudDepth()]"
+                (beforeRender)="onBeforeRender($event)"
+            >
+                <ngts-billboard
+                    *ngFor="let cloud of clouds(); let i = index"
+                    [position]="[cloud.x, cloud.y, -i * cloudDepth()]"
+                >
+                    <ngt-mesh [scale]="cloud.scale" [rotation]="[0, 0, 0]">
+                        <ngt-plane-geometry />
+                        <!-- we use ngIf here for texture because by the time ngt-value is initialized -->
+                        <!-- [map] has not been resolved yet. we ngIf it so that texture is available before hand -->
+                        <ngt-mesh-standard-material
+                            *ngIf="cloudTexture() as cloudTexture"
+                            [transparent]="true"
+                            [map]="cloudTexture"
+                            [depthTest]="cloudDepthTest()"
+                            [opacity]="(cloud.scale / 6) * cloud.density * cloudOpacity()"
+                            [color]="cloudColor()"
+                        >
+                            <ngt-value [rawValue]="encoding()" attach="map.encoding" />
+                        </ngt-mesh-standard-material>
+                    </ngt-mesh>
+                </ngts-billboard>
+            </ngt-group>
+        </ngt-group>
+    `,
+                    imports: [NgFor, NgtsBillboard, NgIf],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { groupRef: [{
+                type: Input
+            }], opacity: [{
+                type: Input
+            }], speed: [{
+                type: Input
+            }], width: [{
+                type: Input
+            }], depth: [{
+                type: Input
+            }], segments: [{
+                type: Input
+            }], texture: [{
+                type: Input
+            }], color: [{
+                type: Input
+            }], depthTest: [{
+                type: Input
+            }] } });
+//# 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, inject } from '@angular/core';\nimport {\n    NgtSignalStore,\n    NgtStore,\n    extend,\n    injectNgtRef,\n    type NgtBeforeRenderEvent,\n    type NgtGroup,\n} 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 interface NgtsCloudState {\n    opacity: number;\n    speed: number;\n    width: number;\n    depth: number;\n    segments: number;\n    texture: string;\n    color: THREE.ColorRepresentation;\n    depthTest: boolean;\n}\n\ndeclare global {\n    interface HTMLElementTagNameMap {\n        'ngts-cloud': NgtsCloudState & NgtGroup;\n    }\n}\n\n@Component({\n    selector: 'ngts-cloud',\n    standalone: true,\n    template: `\n        <ngt-group ngtCompound [ref]=\"groupRef\">\n            <ngt-group\n                [position]=\"[0, 0, (cloudSegments() / 2) * cloudDepth()]\"\n                (beforeRender)=\"onBeforeRender($event)\"\n            >\n                <ngts-billboard\n                    *ngFor=\"let cloud of clouds(); let i = index\"\n                    [position]=\"[cloud.x, cloud.y, -i * cloudDepth()]\"\n                >\n                    <ngt-mesh [scale]=\"cloud.scale\" [rotation]=\"[0, 0, 0]\">\n                        <ngt-plane-geometry />\n                        <!-- we use ngIf here for texture because by the time ngt-value is initialized -->\n                        <!-- [map] has not been resolved yet. we ngIf it so that texture is available before hand -->\n                        <ngt-mesh-standard-material\n                            *ngIf=\"cloudTexture() as cloudTexture\"\n                            [transparent]=\"true\"\n                            [map]=\"cloudTexture\"\n                            [depthTest]=\"cloudDepthTest()\"\n                            [opacity]=\"(cloud.scale / 6) * cloud.density * cloudOpacity()\"\n                            [color]=\"cloudColor()\"\n                        >\n                            <ngt-value [rawValue]=\"encoding()\" attach=\"map.encoding\" />\n                        </ngt-mesh-standard-material>\n                    </ngt-mesh>\n                </ngts-billboard>\n            </ngt-group>\n        </ngt-group>\n    `,\n    imports: [NgFor, NgtsBillboard, NgIf],\n    schemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsCloud extends NgtSignalStore<NgtsCloudState> {\n    @Input() groupRef = injectNgtRef<Group>();\n\n    @Input() set opacity(opacity: number) {\n        this.set({ opacity });\n    }\n\n    @Input() set speed(speed: number) {\n        this.set({ speed });\n    }\n\n    @Input() set width(width: number) {\n        this.set({ width });\n    }\n\n    @Input() set depth(depth: number) {\n        this.set({ depth });\n    }\n\n    @Input() set segments(segments: number) {\n        this.set({ segments });\n    }\n\n    @Input() set texture(texture: string) {\n        this.set({ texture });\n    }\n\n    @Input() set color(color: THREE.ColorRepresentation) {\n        this.set({ color });\n    }\n\n    @Input() set depthTest(depthTest: boolean) {\n        this.set({ depthTest });\n    }\n\n    readonly #store = inject(NgtStore);\n\n    readonly #width = this.select('width');\n    readonly #speed = this.select('speed');\n\n    readonly cloudSegments = this.select('segments');\n    readonly cloudDepth = this.select('depth');\n    readonly cloudDepthTest = this.select('depthTest');\n    readonly cloudOpacity = this.select('opacity');\n    readonly cloudColor = this.select('color');\n    readonly encoding = this.#store.select('gl', 'outputEncoding');\n\n    readonly cloudTexture = injectNgtsTextureLoader(this.select('texture'));\n    readonly clouds = computed(() =>\n        [...new Array(this.cloudSegments())].map((_, index) => ({\n            x: this.#width() / 2 - Math.random() * this.#width(),\n            y: this.#width() / 2 - Math.random() * this.#width(),\n            scale: 0.4 + Math.sin(((index + 1) / this.cloudSegments()) * Math.PI) * ((0.2 + Math.random()) * 10),\n            density: Math.max(0.2, Math.random()),\n            rotation: Math.max(0.002, 0.005 * Math.random()) * this.#speed(),\n        }))\n    );\n\n    constructor() {\n        super({\n            opacity: 0.5,\n            speed: 0.4,\n            width: 10,\n            depth: 1.5,\n            segments: 20,\n            texture: CLOUD_URL,\n            color: '#ffffff',\n            depthTest: true,\n        });\n    }\n\n    onBeforeRender({ state, object }: NgtBeforeRenderEvent<Group>) {\n        const clouds = this.clouds();\n        object.children.forEach((cloud, index) => {\n            cloud.children[0].rotation.z += clouds[index].rotation;\n            cloud.children[0].scale.setScalar(\n                clouds[index].scale + (((1 + Math.sin(state.clock.getElapsedTime() / 10)) / 2) * index) / 10\n            );\n        });\n    }\n}\n"]}

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

@@ -0,0 +1,249 @@
+import { Component, computed, CUSTOM_ELEMENTS_SCHEMA, inject, Input } from '@angular/core';
+import { extend, injectBeforeRender, injectNgtRef, NgtArgs, NgtSignalStore, 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 });
+class NgtsContactShadows extends NgtSignalStore {
+    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 });
+    }
+    #store;
+    #scale;
+    #width;
+    #height;
+    #far;
+    #resolution;
+    #color;
+    #scaledWidth;
+    #scaledHeight;
+    constructor() {
+        super({
+            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 = inject(NgtStore);
+        this.shadowCameraRef = injectNgtRef();
+        this.#scale = this.select('scale');
+        this.#width = this.select('width');
+        this.#height = this.select('height');
+        this.#far = this.select('far');
+        this.#resolution = this.select('resolution');
+        this.#color = this.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.encoding = this.#store.select('gl', 'outputEncoding');
+        this.shadowRenderOrder = this.select('renderOrder');
+        this.shadowOpacity = this.select('opacity');
+        this.shadowDepthWrite = this.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.#onBeforeRender.bind(this, 0));
+    }
+    #onBeforeRender(count, { scene, gl }) {
+        const { frames = Infinity, blur = 1, smooth = true } = this.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.0.0", ngImport: i0, type: NgtsContactShadows, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", 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]">
+            <ngt-mesh
+                [renderOrder]="shadowRenderOrder() ?? 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]="shadowOpacity() ?? 1"
+                    [depthWrite]="shadowDepthWrite() ?? false"
+                >
+                    <ngt-value [rawValue]="encoding()" attach="map.encoding" />
+                </ngt-mesh-basic-material>
+            </ngt-mesh>
+            <ngt-orthographic-camera *args="cameraArgs()" [ref]="shadowCameraRef" />
+        </ngt-group>
+    `, isInline: true, dependencies: [{ kind: "directive", type: NgtArgs, selector: "[args]", inputs: ["args"] }] }); }
+}
+export { NgtsContactShadows };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.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]="shadowRenderOrder() ?? 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]="shadowOpacity() ?? 1"
+                    [depthWrite]="shadowDepthWrite() ?? false"
+                >
+                    <ngt-value [rawValue]="encoding()" attach="map.encoding" />
+                </ngt-mesh-basic-material>
+            </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
+            }], 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/soba/staging/src/contact-shadows/contact-shadows.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, computed, CUSTOM_ELEMENTS_SCHEMA, inject, Input } from '@angular/core';\nimport {\n    extend,\n    injectBeforeRender,\n    injectNgtRef,\n    NgtArgs,\n    NgtSignalStore,\n    NgtStore,\n    type NgtGroup,\n    type 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 interface NgtsContactShadowsState {\n    opacity: number;\n    width: number;\n    height: number;\n    blur: number;\n    far: number;\n    smooth: boolean;\n    resolution: number;\n    frames: number;\n    scale: number | [x: number, y: number];\n    color: THREE.ColorRepresentation;\n    depthWrite: boolean;\n    renderOrder: number;\n}\n\ndeclare global {\n    interface HTMLElementTagNameMap {\n        'ngts-contact-shadows': NgtsContactShadowsState & NgtGroup;\n    }\n}\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            <ngt-mesh\n                [renderOrder]=\"shadowRenderOrder() ?? 0\"\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]=\"true\"\n                    [opacity]=\"shadowOpacity() ?? 1\"\n                    [depthWrite]=\"shadowDepthWrite() ?? false\"\n                >\n                    <ngt-value [rawValue]=\"encoding()\" attach=\"map.encoding\" />\n                </ngt-mesh-basic-material>\n            </ngt-mesh>\n            <ngt-orthographic-camera *args=\"cameraArgs()\" [ref]=\"shadowCameraRef\" />\n        </ngt-group>\n    `,\n    imports: [NgtArgs],\n    schemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsContactShadows extends NgtSignalStore<NgtsContactShadowsState> {\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    readonly Math = Math;\n    readonly #store = inject(NgtStore);\n\n    readonly shadowCameraRef = injectNgtRef<OrthographicCamera>();\n\n    readonly #scale = this.select('scale');\n    readonly #width = this.select('width');\n    readonly #height = this.select('height');\n    readonly #far = this.select('far');\n    readonly #resolution = this.select('resolution');\n    readonly #color = this.select('color');\n\n    readonly #scaledWidth = computed(() => {\n        const scale = this.#scale();\n        return this.#width() * (Array.isArray(scale) ? scale[0] : scale || 1);\n    });\n    readonly #scaledHeight = computed(() => {\n        const scale = this.#scale();\n        return this.#height() * (Array.isArray(scale) ? scale[1] : scale || 1);\n    });\n\n    readonly encoding = this.#store.select('gl', 'outputEncoding');\n    readonly shadowRenderOrder = this.select('renderOrder');\n    readonly shadowOpacity = this.select('opacity');\n    readonly shadowDepthWrite = this.select('depthWrite');\n\n    readonly cameraArgs = computed(() => {\n        const width = this.#scaledWidth();\n        const height = this.#scaledHeight();\n        return [-width / 2, width / 2, height / 2, -height / 2, 0, this.#far()];\n    });\n    readonly contactShadows = computed(() => {\n        const color = this.#color();\n        const resolution = this.#resolution();\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(this.#scaledWidth(), this.#scaledHeight()).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    constructor() {\n        super({\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        injectBeforeRender(this.#onBeforeRender.bind(this, 0));\n    }\n\n    #onBeforeRender(count: number, { scene, gl }: NgtRenderState) {\n        const { frames = Infinity, blur = 1, smooth = true } = this.get();\n        const { depthMaterial, renderTarget } = this.contactShadows();\n        const shadowCamera = this.shadowCameraRef.nativeElement;\n        if (shadowCamera && (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, shadowCamera);\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    #blurShadows(blur: number) {\n        const { blurPlane, horizontalBlurMaterial, verticalBlurMaterial, renderTargetBlur, renderTarget } =\n            this.contactShadows();\n        const gl = this.#store.get('gl');\n        const shadowCamera = this.shadowCameraRef.nativeElement;\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, shadowCamera);\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, shadowCamera);\n\n        blurPlane.visible = false;\n    }\n}\n"]}