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

package/esm2022/staging/lib/caustics.mjs

@@ -0,0 +1,188 @@
+import { afterNextRender, ChangeDetectionStrategy, Component, computed, CUSTOM_ELEMENTS_SCHEMA, input, viewChild, } from '@angular/core';
+import { extend, getLocalState, injectBeforeRender, omit, pick, resolveRef } from 'angular-three';
+import { injectHelper, NgtsEdges } from 'angular-three-soba/abstractions';
+import { injectFBO } from 'angular-three-soba/misc';
+import { CausticsProjectionMaterial, createCausticsUpdate } from 'angular-three-soba/vanilla-exports';
+import { injectAutoEffect } from 'ngxtension/auto-effect';
+import { mergeInputs } from 'ngxtension/inject-inputs';
+import { CameraHelper, CustomBlending, FloatType, Group, LinearFilter, LinearMipmapLinearFilter, LineBasicMaterial, Mesh, OneFactor, OrthographicCamera, PlaneGeometry, Scene, SrcAlphaFactor, UnsignedByteType, Vector3, } from 'three';
+import * as i0 from "@angular/core";
+const NORMAL_OPTIONS = {
+    depth: true,
+    minFilter: LinearFilter,
+    magFilter: LinearFilter,
+    type: UnsignedByteType,
+};
+const CAUSTIC_OPTIONS = {
+    minFilter: LinearMipmapLinearFilter,
+    magFilter: LinearFilter,
+    type: FloatType,
+    generateMipmaps: true,
+};
+const defaultOptions = {
+    frames: 1,
+    debug: false,
+    causticsOnly: false,
+    backside: false,
+    ior: 1.1,
+    backsideIOR: 1.1,
+    worldRadius: 0.3125,
+    intensity: 0.05,
+    color: 'white',
+    resolution: 2024,
+    lightSource: [5, 5, 5],
+};
+export class NgtsCaustics {
+    constructor() {
+        this.Math = Math;
+        this.CustomBlending = CustomBlending;
+        this.OneFactor = OneFactor;
+        this.SrcAlphaFactor = SrcAlphaFactor;
+        this.options = input(defaultOptions, { transform: mergeInputs(defaultOptions) });
+        this.parameters = omit(this.options, [
+            'frames',
+            'debug',
+            'causticsOnly',
+            'backside',
+            'ior',
+            'backsideIOR',
+            'worldRadius',
+            'intensity',
+            'color',
+            'resolution',
+            'lightSource',
+        ]);
+        this.debug = pick(this.options, 'debug');
+        this.color = pick(this.options, 'color');
+        this.resolution = pick(this.options, 'resolution');
+        this.groupRef = viewChild.required('group');
+        this.sceneRef = viewChild.required('scene');
+        this.cameraRef = viewChild.required('camera');
+        this.planeRef = viewChild.required('plane');
+        this.normalTargetParams = computed(() => ({
+            width: this.resolution(),
+            height: this.resolution(),
+            settings: NORMAL_OPTIONS,
+        }));
+        // Buffers for front and back faces
+        this.normalTarget = injectFBO(this.normalTargetParams);
+        this.normalTargetB = injectFBO(this.normalTargetParams);
+        this.causticsTargetParams = computed(() => ({
+            width: this.resolution(),
+            height: this.resolution(),
+            settings: CAUSTIC_OPTIONS,
+        }));
+        this.causticsTarget = injectFBO(this.causticsTargetParams);
+        this.causticsTargetB = injectFBO(this.causticsTargetParams);
+        this.cameraHelper = injectHelper(() => (this.debug() ? this.cameraRef().nativeElement : null), () => CameraHelper);
+        extend({ CausticsProjectionMaterial, Group, Scene, Mesh, PlaneGeometry, LineBasicMaterial, OrthographicCamera });
+        const autoEffect = injectAutoEffect();
+        const update = createCausticsUpdate(() => {
+            const { lightSource, ...rest } = this.options();
+            return {
+                params: Object.assign(rest, {
+                    lightSource: Array.isArray(lightSource) ? new Vector3(...lightSource) : resolveRef(lightSource),
+                }),
+                normalTarget: this.normalTarget(),
+                normalTargetB: this.normalTargetB(),
+                causticsTarget: this.causticsTarget(),
+                causticsTargetB: this.causticsTargetB(),
+                camera: this.cameraRef().nativeElement,
+                scene: this.sceneRef().nativeElement,
+                group: this.groupRef().nativeElement,
+                plane: this.planeRef().nativeElement,
+                helper: this.cameraHelper(),
+            };
+        });
+        injectBeforeRender(({ gl }) => update(gl));
+        afterNextRender(() => {
+            autoEffect(() => {
+                // track all changes
+                this.options();
+                const [group, scene, plane] = [
+                    this.groupRef().nativeElement,
+                    this.sceneRef().nativeElement,
+                    this.planeRef().nativeElement,
+                ];
+                const groupLocalState = getLocalState(group);
+                const sceneLocalState = getLocalState(scene);
+                const planeLocalState = getLocalState(plane);
+                if (!groupLocalState || !sceneLocalState || !planeLocalState)
+                    return;
+                groupLocalState.objects();
+                sceneLocalState.objects();
+                planeLocalState.objects();
+                planeLocalState.nonObjects();
+                group.updateWorldMatrix(false, true);
+            });
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsCaustics, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.0", type: NgtsCaustics, isStandalone: true, selector: "ngts-caustics", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, viewQueries: [{ propertyName: "groupRef", first: true, predicate: ["group"], descendants: true, isSignal: true }, { propertyName: "sceneRef", first: true, predicate: ["scene"], descendants: true, isSignal: true }, { propertyName: "cameraRef", first: true, predicate: ["camera"], descendants: true, isSignal: true }, { propertyName: "planeRef", first: true, predicate: ["plane"], descendants: true, isSignal: true }], ngImport: i0, template: `
+		<ngt-group #group [parameters]="parameters()">
+			<ngt-scene #scene>
+				<ngt-orthographic-camera #camera [up]="[0, 1, 0]" />
+				<ng-content />
+			</ngt-scene>
+
+			<ngt-mesh #plane [renderOrder]="2" [rotation]="[-Math.PI / 2, 0, 0]">
+				<ngt-plane-geometry />
+				<ngt-caustics-projection-material
+					[transparent]="true"
+					[color]="color()"
+					[causticsTexture]="causticsTarget().texture"
+					[causticsTextureB]="causticsTargetB().texture"
+					[blending]="CustomBlending"
+					[blendSrc]="OneFactor"
+					[blendDst]="SrcAlphaFactor"
+					[depthWrite]="false"
+				/>
+
+				@if (debug()) {
+					<ngts-edges>
+						<ngt-line-basic-material color="#ffff00" [toneMapped]="false" />
+					</ngts-edges>
+				}
+			</ngt-mesh>
+		</ngt-group>
+	`, isInline: true, dependencies: [{ kind: "component", type: NgtsEdges, selector: "ngts-edges", inputs: ["options"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsCaustics, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-caustics',
+                    standalone: true,
+                    template: `
+		<ngt-group #group [parameters]="parameters()">
+			<ngt-scene #scene>
+				<ngt-orthographic-camera #camera [up]="[0, 1, 0]" />
+				<ng-content />
+			</ngt-scene>
+
+			<ngt-mesh #plane [renderOrder]="2" [rotation]="[-Math.PI / 2, 0, 0]">
+				<ngt-plane-geometry />
+				<ngt-caustics-projection-material
+					[transparent]="true"
+					[color]="color()"
+					[causticsTexture]="causticsTarget().texture"
+					[causticsTextureB]="causticsTargetB().texture"
+					[blending]="CustomBlending"
+					[blendSrc]="OneFactor"
+					[blendDst]="SrcAlphaFactor"
+					[depthWrite]="false"
+				/>
+
+				@if (debug()) {
+					<ngts-edges>
+						<ngt-line-basic-material color="#ffff00" [toneMapped]="false" />
+					</ngts-edges>
+				}
+			</ngt-mesh>
+		</ngt-group>
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [NgtsEdges],
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"caustics.js","sourceRoot":"","sources":["../../../../../../libs/soba/staging/src/lib/caustics.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,eAAe,EACf,uBAAuB,EACvB,SAAS,EACT,QAAQ,EACR,sBAAsB,EAEtB,KAAK,EACL,SAAS,GACT,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,kBAAkB,EAAY,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC5G,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAC1E,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACpD,OAAO,EAAE,0BAA0B,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AACtG,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,EACN,YAAY,EAEZ,cAAc,EACd,SAAS,EACT,KAAK,EACL,YAAY,EACZ,wBAAwB,EACxB,iBAAiB,EACjB,IAAI,EAEJ,SAAS,EACT,kBAAkB,EAClB,aAAa,EACb,KAAK,EACL,cAAc,EACd,gBAAgB,EAChB,OAAO,GACP,MAAM,OAAO,CAAC;;AAEf,MAAM,cAAc,GAAG;IACtB,KAAK,EAAE,IAAI;IACX,SAAS,EAAE,YAAY;IACvB,SAAS,EAAE,YAAY;IACvB,IAAI,EAAE,gBAAgB;CACtB,CAAC;AAEF,MAAM,eAAe,GAAG;IACvB,SAAS,EAAE,wBAAwB;IACnC,SAAS,EAAE,YAAY;IACvB,IAAI,EAAE,SAAS;IACf,eAAe,EAAE,IAAI;CACrB,CAAC;AA2BF,MAAM,cAAc,GAAwB;IAC3C,MAAM,EAAE,CAAC;IACT,KAAK,EAAE,KAAK;IACZ,YAAY,EAAE,KAAK;IACnB,QAAQ,EAAE,KAAK;IACf,GAAG,EAAE,GAAG;IACR,WAAW,EAAE,GAAG;IAChB,WAAW,EAAE,MAAM;IACnB,SAAS,EAAE,IAAI;IACf,KAAK,EAAE,OAAO;IACd,UAAU,EAAE,IAAI;IAChB,WAAW,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;CACtB,CAAC;AAqCF,MAAM,OAAO,YAAY;IAsDxB;QArDmB,SAAI,GAAG,IAAI,CAAC;QACZ,mBAAc,GAAG,cAAc,CAAC;QAChC,cAAS,GAAG,SAAS,CAAC;QACtB,mBAAc,GAAG,cAAc,CAAC;QAEnD,YAAO,GAAG,KAAK,CAAC,cAAc,EAAE,EAAE,SAAS,EAAE,WAAW,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC;QAC5E,eAAU,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE;YAC/B,QAAQ;YACR,OAAO;YACP,cAAc;YACd,UAAU;YACV,KAAK;YACL,aAAa;YACb,aAAa;YACb,WAAW;YACX,OAAO;YACP,YAAY;YACZ,aAAa;SACb,CAAC,CAAC;QAEH,UAAK,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QACpC,UAAK,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QAC5B,eAAU,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;QAEtD,aAAQ,GAAG,SAAS,CAAC,QAAQ,CAAoB,OAAO,CAAC,CAAC;QAClD,aAAQ,GAAG,SAAS,CAAC,QAAQ,CAAoB,OAAO,CAAC,CAAC;QAC1D,cAAS,GAAG,SAAS,CAAC,QAAQ,CAAiC,QAAQ,CAAC,CAAC;QACzE,aAAQ,GACf,SAAS,CAAC,QAAQ,CAAmF,OAAO,CAAC,CAAC;QAEvG,uBAAkB,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAC;YAC5C,KAAK,EAAE,IAAI,CAAC,UAAU,EAAE;YACxB,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE;YACzB,QAAQ,EAAE,cAAc;SACxB,CAAC,CAAC,CAAC;QAEJ,mCAAmC;QAC3B,iBAAY,GAAG,SAAS,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;QAClD,kBAAa,GAAG,SAAS,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;QAEnD,yBAAoB,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAC;YAC9C,KAAK,EAAE,IAAI,CAAC,UAAU,EAAE;YACxB,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE;YACzB,QAAQ,EAAE,eAAe;SACzB,CAAC,CAAC,CAAC;QACJ,mBAAc,GAAG,SAAS,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;QACtD,oBAAe,GAAG,SAAS,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;QAE/C,iBAAY,GAAG,YAAY,CAClC,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,EAC5D,GAAG,EAAE,CAAC,YAAY,CAClB,CAAC;QAGD,MAAM,CAAC,EAAE,0BAA0B,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,aAAa,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,CAAC,CAAC;QAEjH,MAAM,UAAU,GAAG,gBAAgB,EAAE,CAAC;QAEtC,MAAM,MAAM,GAAG,oBAAoB,CAAC,GAAG,EAAE;YACxC,MAAM,EAAE,WAAW,EAAE,GAAG,IAAI,EAAE,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;YAEhD,OAAO;gBACN,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE;oBAC3B,WAAW,EAAE,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,IAAI,OAAO,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,WAAW,CAAC;iBAC/F,CAAC;gBACF,YAAY,EAAE,IAAI,CAAC,YAAY,EAAE;gBACjC,aAAa,EAAE,IAAI,CAAC,aAAa,EAAE;gBACnC,cAAc,EAAE,IAAI,CAAC,cAAc,EAAE;gBACrC,eAAe,EAAE,IAAI,CAAC,eAAe,EAAE;gBACvC,MAAM,EAAE,IAAI,CAAC,SAAS,EAAE,CAAC,aAAa;gBACtC,KAAK,EAAE,IAAI,CAAC,QAAQ,EAAE,CAAC,aAAa;gBACpC,KAAK,EAAE,IAAI,CAAC,QAAQ,EAAE,CAAC,aAAa;gBACpC,KAAK,EAAE,IAAI,CAAC,QAAQ,EAAE,CAAC,aAAa;gBACpC,MAAM,EAAE,IAAI,CAAC,YAAY,EAAE;aAC3B,CAAC;QACH,CAAC,CAAC,CAAC;QAEH,kBAAkB,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC;QAE3C,eAAe,CAAC,GAAG,EAAE;YACpB,UAAU,CAAC,GAAG,EAAE;gBACf,oBAAoB;gBACpB,IAAI,CAAC,OAAO,EAAE,CAAC;gBACf,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,GAAG;oBAC7B,IAAI,CAAC,QAAQ,EAAE,CAAC,aAAa;oBAC7B,IAAI,CAAC,QAAQ,EAAE,CAAC,aAAa;oBAC7B,IAAI,CAAC,QAAQ,EAAE,CAAC,aAAa;iBAC7B,CAAC;gBACF,MAAM,eAAe,GAAG,aAAa,CAAC,KAAK,CAAC,CAAC;gBAC7C,MAAM,eAAe,GAAG,aAAa,CAAC,KAAK,CAAC,CAAC;gBAC7C,MAAM,eAAe,GAAG,aAAa,CAAC,KAAK,CAAC,CAAC;gBAE7C,IAAI,CAAC,eAAe,IAAI,CAAC,eAAe,IAAI,CAAC,eAAe;oBAAE,OAAO;gBAErE,eAAe,CAAC,OAAO,EAAE,CAAC;gBAC1B,eAAe,CAAC,OAAO,EAAE,CAAC;gBAC1B,eAAe,CAAC,OAAO,EAAE,CAAC;gBAC1B,eAAe,CAAC,UAAU,EAAE,CAAC;gBAE7B,KAAK,CAAC,iBAAiB,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;YACtC,CAAC,CAAC,CAAC;QACJ,CAAC,CAAC,CAAC;IACJ,CAAC;8GAvGW,YAAY;kGAAZ,YAAY,onBAhCd;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BT,4DAGS,SAAS;;2FAEP,YAAY;kBAnCxB,SAAS;mBAAC;oBACV,QAAQ,EAAE,eAAe;oBACzB,UAAU,EAAE,IAAI;oBAChB,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BT;oBACD,OAAO,EAAE,CAAC,sBAAsB,CAAC;oBACjC,eAAe,EAAE,uBAAuB,CAAC,MAAM;oBAC/C,OAAO,EAAE,CAAC,SAAS,CAAC;iBACpB","sourcesContent":["import {\n\tafterNextRender,\n\tChangeDetectionStrategy,\n\tComponent,\n\tcomputed,\n\tCUSTOM_ELEMENTS_SCHEMA,\n\tElementRef,\n\tinput,\n\tviewChild,\n} from '@angular/core';\nimport { extend, getLocalState, injectBeforeRender, NgtGroup, omit, pick, resolveRef } from 'angular-three';\nimport { injectHelper, NgtsEdges } from 'angular-three-soba/abstractions';\nimport { injectFBO } from 'angular-three-soba/misc';\nimport { CausticsProjectionMaterial, createCausticsUpdate } from 'angular-three-soba/vanilla-exports';\nimport { injectAutoEffect } from 'ngxtension/auto-effect';\nimport { mergeInputs } from 'ngxtension/inject-inputs';\nimport {\n\tCameraHelper,\n\tColorRepresentation,\n\tCustomBlending,\n\tFloatType,\n\tGroup,\n\tLinearFilter,\n\tLinearMipmapLinearFilter,\n\tLineBasicMaterial,\n\tMesh,\n\tObject3D,\n\tOneFactor,\n\tOrthographicCamera,\n\tPlaneGeometry,\n\tScene,\n\tSrcAlphaFactor,\n\tUnsignedByteType,\n\tVector3,\n} from 'three';\n\nconst NORMAL_OPTIONS = {\n\tdepth: true,\n\tminFilter: LinearFilter,\n\tmagFilter: LinearFilter,\n\ttype: UnsignedByteType,\n};\n\nconst CAUSTIC_OPTIONS = {\n\tminFilter: LinearMipmapLinearFilter,\n\tmagFilter: LinearFilter,\n\ttype: FloatType,\n\tgenerateMipmaps: true,\n};\n\nexport interface NgtsCausticsOptions extends Partial<NgtGroup> {\n\t/** How many frames it will render, set it to Infinity for runtime, default: 1 */\n\tframes: number;\n\t/** Enables visual cues to help you stage your scene, default: false */\n\tdebug: boolean;\n\t/** Will display caustics only and skip the models, default: false */\n\tcausticsOnly: boolean;\n\t/** Will include back faces and enable the backsideIOR prop, default: false */\n\tbackside: boolean;\n\t/** The IOR refraction index, default: 1.1 */\n\tior: number;\n\t/** The IOR refraction index for back faces (only available when backside is enabled), default: 1.1 */\n\tbacksideIOR: number;\n\t/** The texel size, default: 0.3125 */\n\tworldRadius: number;\n\t/** Intensity of the prjected caustics, default: 0.05 */\n\tintensity: number;\n\t/** Caustics color, default: white */\n\tcolor: ColorRepresentation;\n\t/** Buffer resolution, default: 2048 */\n\tresolution: number;\n\t/** Camera position, it will point towards the contents bounds center, default: [5, 5, 5] */\n\tlightSource: [x: number, y: number, z: number] | ElementRef<Object3D> | Object3D;\n}\n\nconst defaultOptions: NgtsCausticsOptions = {\n\tframes: 1,\n\tdebug: false,\n\tcausticsOnly: false,\n\tbackside: false,\n\tior: 1.1,\n\tbacksideIOR: 1.1,\n\tworldRadius: 0.3125,\n\tintensity: 0.05,\n\tcolor: 'white',\n\tresolution: 2024,\n\tlightSource: [5, 5, 5],\n};\n\n@Component({\n\tselector: 'ngts-caustics',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-group #group [parameters]=\"parameters()\">\n\t\t\t<ngt-scene #scene>\n\t\t\t\t<ngt-orthographic-camera #camera [up]=\"[0, 1, 0]\" />\n\t\t\t\t<ng-content />\n\t\t\t</ngt-scene>\n\n\t\t\t<ngt-mesh #plane [renderOrder]=\"2\" [rotation]=\"[-Math.PI / 2, 0, 0]\">\n\t\t\t\t<ngt-plane-geometry />\n\t\t\t\t<ngt-caustics-projection-material\n\t\t\t\t\t[transparent]=\"true\"\n\t\t\t\t\t[color]=\"color()\"\n\t\t\t\t\t[causticsTexture]=\"causticsTarget().texture\"\n\t\t\t\t\t[causticsTextureB]=\"causticsTargetB().texture\"\n\t\t\t\t\t[blending]=\"CustomBlending\"\n\t\t\t\t\t[blendSrc]=\"OneFactor\"\n\t\t\t\t\t[blendDst]=\"SrcAlphaFactor\"\n\t\t\t\t\t[depthWrite]=\"false\"\n\t\t\t\t/>\n\n\t\t\t\t@if (debug()) {\n\t\t\t\t\t<ngts-edges>\n\t\t\t\t\t\t<ngt-line-basic-material color=\"#ffff00\" [toneMapped]=\"false\" />\n\t\t\t\t\t</ngts-edges>\n\t\t\t\t}\n\t\t\t</ngt-mesh>\n\t\t</ngt-group>\n\t`,\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n\timports: [NgtsEdges],\n})\nexport class NgtsCaustics {\n\tprotected readonly Math = Math;\n\tprotected readonly CustomBlending = CustomBlending;\n\tprotected readonly OneFactor = OneFactor;\n\tprotected readonly SrcAlphaFactor = SrcAlphaFactor;\n\n\toptions = input(defaultOptions, { transform: mergeInputs(defaultOptions) });\n\tparameters = omit(this.options, [\n\t\t'frames',\n\t\t'debug',\n\t\t'causticsOnly',\n\t\t'backside',\n\t\t'ior',\n\t\t'backsideIOR',\n\t\t'worldRadius',\n\t\t'intensity',\n\t\t'color',\n\t\t'resolution',\n\t\t'lightSource',\n\t]);\n\n\tdebug = pick(this.options, 'debug');\n\tcolor = pick(this.options, 'color');\n\tprivate resolution = pick(this.options, 'resolution');\n\n\tgroupRef = viewChild.required<ElementRef<Group>>('group');\n\tprivate sceneRef = viewChild.required<ElementRef<Scene>>('scene');\n\tprivate cameraRef = viewChild.required<ElementRef<OrthographicCamera>>('camera');\n\tprivate planeRef =\n\t\tviewChild.required<ElementRef<Mesh<PlaneGeometry, InstanceType<typeof CausticsProjectionMaterial>>>>('plane');\n\n\tprivate normalTargetParams = computed(() => ({\n\t\twidth: this.resolution(),\n\t\theight: this.resolution(),\n\t\tsettings: NORMAL_OPTIONS,\n\t}));\n\n\t// Buffers for front and back faces\n\tprivate normalTarget = injectFBO(this.normalTargetParams);\n\tprivate normalTargetB = injectFBO(this.normalTargetParams);\n\n\tprivate causticsTargetParams = computed(() => ({\n\t\twidth: this.resolution(),\n\t\theight: this.resolution(),\n\t\tsettings: CAUSTIC_OPTIONS,\n\t}));\n\tcausticsTarget = injectFBO(this.causticsTargetParams);\n\tcausticsTargetB = injectFBO(this.causticsTargetParams);\n\n\tprivate cameraHelper = injectHelper(\n\t\t() => (this.debug() ? this.cameraRef().nativeElement : null),\n\t\t() => CameraHelper,\n\t);\n\n\tconstructor() {\n\t\textend({ CausticsProjectionMaterial, Group, Scene, Mesh, PlaneGeometry, LineBasicMaterial, OrthographicCamera });\n\n\t\tconst autoEffect = injectAutoEffect();\n\n\t\tconst update = createCausticsUpdate(() => {\n\t\t\tconst { lightSource, ...rest } = this.options();\n\n\t\t\treturn {\n\t\t\t\tparams: Object.assign(rest, {\n\t\t\t\t\tlightSource: Array.isArray(lightSource) ? new Vector3(...lightSource) : resolveRef(lightSource),\n\t\t\t\t}),\n\t\t\t\tnormalTarget: this.normalTarget(),\n\t\t\t\tnormalTargetB: this.normalTargetB(),\n\t\t\t\tcausticsTarget: this.causticsTarget(),\n\t\t\t\tcausticsTargetB: this.causticsTargetB(),\n\t\t\t\tcamera: this.cameraRef().nativeElement,\n\t\t\t\tscene: this.sceneRef().nativeElement,\n\t\t\t\tgroup: this.groupRef().nativeElement,\n\t\t\t\tplane: this.planeRef().nativeElement,\n\t\t\t\thelper: this.cameraHelper(),\n\t\t\t};\n\t\t});\n\n\t\tinjectBeforeRender(({ gl }) => update(gl));\n\n\t\tafterNextRender(() => {\n\t\t\tautoEffect(() => {\n\t\t\t\t// track all changes\n\t\t\t\tthis.options();\n\t\t\t\tconst [group, scene, plane] = [\n\t\t\t\t\tthis.groupRef().nativeElement,\n\t\t\t\t\tthis.sceneRef().nativeElement,\n\t\t\t\t\tthis.planeRef().nativeElement,\n\t\t\t\t];\n\t\t\t\tconst groupLocalState = getLocalState(group);\n\t\t\t\tconst sceneLocalState = getLocalState(scene);\n\t\t\t\tconst planeLocalState = getLocalState(plane);\n\n\t\t\t\tif (!groupLocalState || !sceneLocalState || !planeLocalState) return;\n\n\t\t\t\tgroupLocalState.objects();\n\t\t\t\tsceneLocalState.objects();\n\t\t\t\tplaneLocalState.objects();\n\t\t\t\tplaneLocalState.nonObjects();\n\n\t\t\t\tgroup.updateWorldMatrix(false, true);\n\t\t\t});\n\t\t});\n\t}\n}\n"]}

package/esm2022/staging/lib/center.mjs

@@ -0,0 +1,118 @@
+import { afterNextRender, ChangeDetectionStrategy, Component, CUSTOM_ELEMENTS_SCHEMA, input, output, viewChild, } from '@angular/core';
+import { extend, getLocalState, omit, pick } from 'angular-three';
+import { injectAutoEffect } from 'ngxtension/auto-effect';
+import { mergeInputs } from 'ngxtension/inject-inputs';
+import { Box3, Group, Sphere, Vector3 } from 'three';
+import * as i0 from "@angular/core";
+const defaultOptions = {
+    precise: true,
+    cacheKey: 0,
+};
+export class NgtsCenter {
+    constructor() {
+        this.options = input(defaultOptions, { transform: mergeInputs(defaultOptions) });
+        this.parameters = omit(this.options, [
+            'top',
+            'right',
+            'bottom',
+            'left',
+            'front',
+            'back',
+            'disable',
+            'disableX',
+            'disableY',
+            'disableZ',
+            'precise',
+            'cacheKey',
+        ]);
+        this.centered = output();
+        this.groupRef = viewChild.required('group');
+        this.outerRef = viewChild.required('outer');
+        this.innerRef = viewChild.required('inner');
+        this.centerOptions = pick(this.options, [
+            'top',
+            'right',
+            'bottom',
+            'left',
+            'front',
+            'back',
+            'disable',
+            'disableX',
+            'disableY',
+            'disableZ',
+            'precise',
+            'cacheKey',
+        ]);
+        extend({ Group });
+        const autoEffect = injectAutoEffect();
+        afterNextRender(() => {
+            autoEffect(() => {
+                const [{ precise, top, bottom, right, left, front, back, disable, disableZ, disableY, disableX }, group, outer, inner,] = [
+                    this.centerOptions(),
+                    this.groupRef().nativeElement,
+                    this.outerRef().nativeElement,
+                    this.innerRef().nativeElement,
+                ];
+                const localState = getLocalState(inner);
+                const children = localState?.objects();
+                if (!children?.length)
+                    return;
+                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);
+                this.centered.emit({
+                    parent: group.parent,
+                    container: group,
+                    width,
+                    height,
+                    depth,
+                    boundingBox: box3,
+                    boundingSphere: sphere,
+                    center,
+                    verticalAlignment: vAlign,
+                    horizontalAlignment: hAlign,
+                    depthAlignment: dAlign,
+                });
+            });
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsCenter, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "18.2.0", type: NgtsCenter, isStandalone: true, selector: "ngts-center", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { centered: "centered" }, viewQueries: [{ propertyName: "groupRef", first: true, predicate: ["group"], descendants: true, isSignal: true }, { propertyName: "outerRef", first: true, predicate: ["outer"], descendants: true, isSignal: true }, { propertyName: "innerRef", first: true, predicate: ["inner"], descendants: true, isSignal: true }], ngImport: i0, template: `
+		<ngt-group #group [parameters]="parameters()">
+			<ngt-group #outer>
+				<ngt-group #inner>
+					<ng-content />
+				</ngt-group>
+			</ngt-group>
+		</ngt-group>
+	`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsCenter, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-center',
+                    standalone: true,
+                    template: `
+		<ngt-group #group [parameters]="parameters()">
+			<ngt-group #outer>
+				<ngt-group #inner>
+					<ng-content />
+				</ngt-group>
+			</ngt-group>
+		</ngt-group>
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"center.js","sourceRoot":"","sources":["../../../../../../libs/soba/staging/src/lib/center.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n\tafterNextRender,\n\tChangeDetectionStrategy,\n\tComponent,\n\tCUSTOM_ELEMENTS_SCHEMA,\n\tElementRef,\n\tinput,\n\toutput,\n\tviewChild,\n} from '@angular/core';\nimport { extend, getLocalState, NgtGroup, omit, pick } from 'angular-three';\nimport { injectAutoEffect } from 'ngxtension/auto-effect';\nimport { mergeInputs } from 'ngxtension/inject-inputs';\nimport { Box3, Group, Object3D, Sphere, Vector3 } from 'three';\n\nexport interface NgtsCenterState {\n\t/** The next parent above <Center> */\n\tparent: Object3D;\n\t/** The outmost container group of the <Center> component */\n\tcontainer: Object3D;\n\twidth: number;\n\theight: number;\n\tdepth: number;\n\tboundingBox: Box3;\n\tboundingSphere: Sphere;\n\tcenter: Vector3;\n\tverticalAlignment: number;\n\thorizontalAlignment: number;\n\tdepthAlignment: number;\n}\n\nexport interface NgtsCenterOptions {\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\nconst defaultOptions: Partial<NgtGroup> & NgtsCenterOptions = {\n\tprecise: true,\n\tcacheKey: 0,\n};\n\n@Component({\n\tselector: 'ngts-center',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-group #group [parameters]=\"parameters()\">\n\t\t\t<ngt-group #outer>\n\t\t\t\t<ngt-group #inner>\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\tchangeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class NgtsCenter {\n\toptions = input(defaultOptions, { transform: mergeInputs(defaultOptions) });\n\tparameters = omit(this.options, [\n\t\t'top',\n\t\t'right',\n\t\t'bottom',\n\t\t'left',\n\t\t'front',\n\t\t'back',\n\t\t'disable',\n\t\t'disableX',\n\t\t'disableY',\n\t\t'disableZ',\n\t\t'precise',\n\t\t'cacheKey',\n\t]);\n\n\tcentered = output<NgtsCenterState>();\n\n\tgroupRef = viewChild.required<ElementRef<Group>>('group');\n\tprivate outerRef = viewChild.required<ElementRef<Group>>('outer');\n\tprivate innerRef = viewChild.required<ElementRef<Group>>('inner');\n\n\tcenterOptions = pick(this.options, [\n\t\t'top',\n\t\t'right',\n\t\t'bottom',\n\t\t'left',\n\t\t'front',\n\t\t'back',\n\t\t'disable',\n\t\t'disableX',\n\t\t'disableY',\n\t\t'disableZ',\n\t\t'precise',\n\t\t'cacheKey',\n\t]);\n\n\tconstructor() {\n\t\textend({ Group });\n\n\t\tconst autoEffect = injectAutoEffect();\n\n\t\tafterNextRender(() => {\n\t\t\tautoEffect(() => {\n\t\t\t\tconst [\n\t\t\t\t\t{ precise, top, bottom, right, left, front, back, disable, disableZ, disableY, disableX },\n\t\t\t\t\tgroup,\n\t\t\t\t\touter,\n\t\t\t\t\tinner,\n\t\t\t\t] = [\n\t\t\t\t\tthis.centerOptions(),\n\t\t\t\t\tthis.groupRef().nativeElement,\n\t\t\t\t\tthis.outerRef().nativeElement,\n\t\t\t\t\tthis.innerRef().nativeElement,\n\t\t\t\t];\n\n\t\t\t\tconst localState = getLocalState(inner);\n\t\t\t\tconst children = localState?.objects();\n\t\t\t\tif (!children?.length) return;\n\n\t\t\t\touter.matrixWorld.identity();\n\t\t\t\tconst box3 = new Box3().setFromObject(inner, precise);\n\t\t\t\tconst center = new Vector3();\n\t\t\t\tconst sphere = new Sphere();\n\n\t\t\t\tconst width = box3.max.x - box3.min.x;\n\t\t\t\tconst height = box3.max.y - box3.min.y;\n\t\t\t\tconst depth = box3.max.z - box3.min.z;\n\n\t\t\t\tbox3.getCenter(center);\n\t\t\t\tbox3.getBoundingSphere(sphere);\n\n\t\t\t\tconst vAlign = top ? height / 2 : bottom ? -height / 2 : 0;\n\t\t\t\tconst hAlign = left ? -width / 2 : right ? width / 2 : 0;\n\t\t\t\tconst dAlign = front ? depth / 2 : back ? -depth / 2 : 0;\n\n\t\t\t\touter.position.set(\n\t\t\t\t\tdisable || disableX ? 0 : -center.x + hAlign,\n\t\t\t\t\tdisable || disableY ? 0 : -center.y + vAlign,\n\t\t\t\t\tdisable || disableZ ? 0 : -center.z + dAlign,\n\t\t\t\t);\n\n\t\t\t\tthis.centered.emit({\n\t\t\t\t\tparent: group.parent!,\n\t\t\t\t\tcontainer: group,\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,\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/lib/contact-shadows.mjs

@@ -0,0 +1,214 @@
+import { CUSTOM_ELEMENTS_SCHEMA, ChangeDetectionStrategy, Component, computed, input, viewChild, } from '@angular/core';
+import { NgtArgs, extend, injectBeforeRender, injectStore, omit, pick } from 'angular-three';
+import { mergeInputs } from 'ngxtension/inject-inputs';
+import { Color, Group, Mesh, MeshBasicMaterial, MeshDepthMaterial, OrthographicCamera, PlaneGeometry, ShaderMaterial, WebGLRenderTarget, } from 'three';
+import { HorizontalBlurShader, VerticalBlurShader } from 'three-stdlib';
+import * as i0 from "@angular/core";
+const defaultOptions = {
+    scale: 10,
+    frames: Infinity,
+    opacity: 1,
+    width: 1,
+    height: 1,
+    blur: 1,
+    near: 0,
+    far: 10,
+    resolution: 512,
+    smooth: true,
+    color: '#000000',
+    depthWrite: false,
+};
+export class NgtsContactShadows {
+    constructor() {
+        this.Math = Math;
+        this.options = input(defaultOptions, { transform: mergeInputs(defaultOptions) });
+        this.parameters = omit(this.options, [
+            'scale',
+            'frames',
+            'opacity',
+            'width',
+            'height',
+            'blur',
+            'near',
+            'far',
+            'resolution',
+            'smooth',
+            'color',
+            'depthWrite',
+            'renderOrder',
+        ]);
+        this.contactShadowsRef = viewChild.required('contactShadows');
+        this.shadowsCameraRef = viewChild('shadowsCamera');
+        this.store = injectStore();
+        this.scene = this.store.select('scene');
+        this.gl = this.store.select('gl');
+        this.scaledWidth = computed(() => {
+            const { width, scale } = this.options();
+            return width * (Array.isArray(scale) ? scale[0] : scale);
+        });
+        this.scaledHeight = computed(() => {
+            const { height, scale } = this.options();
+            return height * (Array.isArray(scale) ? scale[1] : scale);
+        });
+        this.resolution = pick(this.options, 'resolution');
+        this.color = pick(this.options, 'color');
+        this.near = pick(this.options, 'near');
+        this.far = pick(this.options, 'far');
+        this.smooth = pick(this.options, 'smooth');
+        this.frames = pick(this.options, 'frames');
+        this.blur = pick(this.options, 'blur');
+        this.renderTarget = computed(() => this.createRenderTarget(this.resolution()));
+        this.renderTargetBlur = computed(() => this.createRenderTarget(this.resolution()));
+        this.planeGeometry = computed(() => new PlaneGeometry(this.scaledWidth(), this.scaledHeight()).rotateX(Math.PI / 2));
+        this.blurPlane = computed(() => new Mesh(this.planeGeometry()));
+        this.depthMaterial = computed(() => {
+            const color = new Color(this.color());
+            const material = new MeshDepthMaterial();
+            material.depthTest = material.depthWrite = false;
+            material.onBeforeCompile = (shader) => {
+                shader.uniforms = { ...shader.uniforms, ucolor: { value: 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 );');
+            };
+            return material;
+        });
+        this.horizontalBlurMaterial = new ShaderMaterial({ ...HorizontalBlurShader, depthTest: false });
+        this.verticalBlurMaterial = new ShaderMaterial({ ...VerticalBlurShader, depthTest: false });
+        this.renderOrder = pick(this.options, 'renderOrder');
+        this.opacity = pick(this.options, 'opacity');
+        this.depthWrite = pick(this.options, 'depthWrite');
+        this.texture = pick(this.renderTarget, 'texture');
+        this.cameraArgs = computed(() => {
+            const [width, height, near, far] = [this.scaledWidth(), this.scaledHeight(), this.near(), this.far()];
+            return [-width / 2, width / 2, height / 2, -height / 2, near, far];
+        });
+        extend({ Group, Mesh, MeshBasicMaterial, OrthographicCamera });
+        let count = 0;
+        injectBeforeRender(() => {
+            const shadowsCamera = this.shadowsCameraRef()?.nativeElement;
+            if (!shadowsCamera)
+                return;
+            const frames = this.frames();
+            if (frames === Infinity || count < frames) {
+                this.renderShadows();
+                count++;
+            }
+        });
+    }
+    renderShadows() {
+        const shadowsCamera = this.shadowsCameraRef()?.nativeElement;
+        if (!shadowsCamera)
+            return;
+        const [blur, smooth, gl, scene, contactShadows, depthMaterial, renderTarget] = [
+            this.blur(),
+            this.smooth(),
+            this.gl(),
+            this.scene(),
+            this.contactShadowsRef().nativeElement,
+            this.depthMaterial(),
+            this.renderTarget(),
+        ];
+        const initialBackground = scene.background;
+        const initialOverrideMaterial = scene.overrideMaterial;
+        const initialClearAlpha = gl.getClearAlpha();
+        contactShadows.visible = false;
+        scene.background = null;
+        scene.overrideMaterial = depthMaterial;
+        gl.setClearAlpha(0);
+        // render to the render target to get the depths
+        gl.setRenderTarget(renderTarget);
+        gl.render(scene, shadowsCamera);
+        this.blurShadows(blur);
+        if (smooth)
+            this.blurShadows(blur * 0.4);
+        // reset
+        gl.setRenderTarget(null);
+        contactShadows.visible = true;
+        scene.overrideMaterial = initialOverrideMaterial;
+        scene.background = initialBackground;
+        gl.setClearAlpha(initialClearAlpha);
+    }
+    blurShadows(blur) {
+        const shadowsCamera = this.shadowsCameraRef()?.nativeElement;
+        if (!shadowsCamera)
+            return;
+        const [blurPlane, horizontalBlurMaterial, verticalBlurMaterial, renderTargetBlur, renderTarget, gl] = [
+            this.blurPlane(),
+            this.horizontalBlurMaterial,
+            this.verticalBlurMaterial,
+            this.renderTargetBlur(),
+            this.renderTarget(),
+            this.gl(),
+        ];
+        blurPlane.visible = true;
+        blurPlane.material = horizontalBlurMaterial;
+        horizontalBlurMaterial.uniforms['tDiffuse'].value = renderTarget.texture;
+        horizontalBlurMaterial.uniforms['h'].value = blur / 256;
+        gl.setRenderTarget(renderTargetBlur);
+        gl.render(blurPlane, shadowsCamera);
+        blurPlane.material = verticalBlurMaterial;
+        verticalBlurMaterial.uniforms['tDiffuse'].value = renderTargetBlur.texture;
+        verticalBlurMaterial.uniforms['v'].value = blur / 256;
+        gl.setRenderTarget(renderTarget);
+        gl.render(blurPlane, shadowsCamera);
+        blurPlane.visible = false;
+    }
+    createRenderTarget(resolution) {
+        const renderTarget = new WebGLRenderTarget(resolution, resolution);
+        renderTarget.texture.generateMipmaps = false;
+        return renderTarget;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsContactShadows, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "18.2.0", type: NgtsContactShadows, isStandalone: true, selector: "ngts-contact-shadows", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, viewQueries: [{ propertyName: "contactShadowsRef", first: true, predicate: ["contactShadows"], descendants: true, isSignal: true }, { propertyName: "shadowsCameraRef", first: true, predicate: ["shadowsCamera"], descendants: true, isSignal: true }], ngImport: i0, template: `
+		<ngt-group #contactShadows [rotation]="[Math.PI / 2, 0, 0]" [parameters]="parameters()">
+			<ngt-mesh
+				[scale]="[1, -1, 1]"
+				[rotation]="[-Math.PI / 2, 0, 0]"
+				[renderOrder]="renderOrder() ?? 0"
+				[geometry]="planeGeometry()"
+			>
+				<ngt-mesh-basic-material
+					[transparent]="true"
+					[opacity]="opacity()"
+					[depthWrite]="depthWrite()"
+					[map]="texture()"
+				/>
+			</ngt-mesh>
+			<ngt-orthographic-camera *args="cameraArgs()" #shadowsCamera />
+		</ngt-group>
+	`, isInline: true, dependencies: [{ kind: "directive", type: NgtArgs, selector: "ng-template[args]", inputs: ["args"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsContactShadows, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-contact-shadows',
+                    standalone: true,
+                    template: `
+		<ngt-group #contactShadows [rotation]="[Math.PI / 2, 0, 0]" [parameters]="parameters()">
+			<ngt-mesh
+				[scale]="[1, -1, 1]"
+				[rotation]="[-Math.PI / 2, 0, 0]"
+				[renderOrder]="renderOrder() ?? 0"
+				[geometry]="planeGeometry()"
+			>
+				<ngt-mesh-basic-material
+					[transparent]="true"
+					[opacity]="opacity()"
+					[depthWrite]="depthWrite()"
+					[map]="texture()"
+				/>
+			</ngt-mesh>
+			<ngt-orthographic-camera *args="cameraArgs()" #shadowsCamera />
+		</ngt-group>
+	`,
+                    imports: [NgtArgs],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"contact-shadows.js","sourceRoot":"","sources":["../../../../../../libs/soba/staging/src/lib/contact-shadows.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n\tCUSTOM_ELEMENTS_SCHEMA,\n\tChangeDetectionStrategy,\n\tComponent,\n\tElementRef,\n\tcomputed,\n\tinput,\n\tviewChild,\n} from '@angular/core';\nimport { NgtArgs, NgtGroup, extend, injectBeforeRender, injectStore, omit, pick } from 'angular-three';\nimport { mergeInputs } from 'ngxtension/inject-inputs';\nimport {\n\tColor,\n\tColorRepresentation,\n\tGroup,\n\tMesh,\n\tMeshBasicMaterial,\n\tMeshDepthMaterial,\n\tOrthographicCamera,\n\tPlaneGeometry,\n\tShaderMaterial,\n\tWebGLRenderTarget,\n} from 'three';\nimport { HorizontalBlurShader, VerticalBlurShader } from 'three-stdlib';\n\nexport interface NgtsContactShadowsOptions extends Partial<Omit<NgtGroup, 'scale'>> {\n\topacity: number;\n\twidth: number;\n\theight: number;\n\tblur: number;\n\tnear: number;\n\tfar: number;\n\tsmooth: boolean;\n\tresolution: number;\n\tframes: number;\n\tscale: number | [x: number, y: number];\n\tcolor: ColorRepresentation;\n\tdepthWrite: boolean;\n}\n\nconst defaultOptions: NgtsContactShadowsOptions = {\n\tscale: 10,\n\tframes: Infinity,\n\topacity: 1,\n\twidth: 1,\n\theight: 1,\n\tblur: 1,\n\tnear: 0,\n\tfar: 10,\n\tresolution: 512,\n\tsmooth: true,\n\tcolor: '#000000',\n\tdepthWrite: false,\n};\n\n@Component({\n\tselector: 'ngts-contact-shadows',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-group #contactShadows [rotation]=\"[Math.PI / 2, 0, 0]\" [parameters]=\"parameters()\">\n\t\t\t<ngt-mesh\n\t\t\t\t[scale]=\"[1, -1, 1]\"\n\t\t\t\t[rotation]=\"[-Math.PI / 2, 0, 0]\"\n\t\t\t\t[renderOrder]=\"renderOrder() ?? 0\"\n\t\t\t\t[geometry]=\"planeGeometry()\"\n\t\t\t>\n\t\t\t\t<ngt-mesh-basic-material\n\t\t\t\t\t[transparent]=\"true\"\n\t\t\t\t\t[opacity]=\"opacity()\"\n\t\t\t\t\t[depthWrite]=\"depthWrite()\"\n\t\t\t\t\t[map]=\"texture()\"\n\t\t\t\t/>\n\t\t\t</ngt-mesh>\n\t\t\t<ngt-orthographic-camera *args=\"cameraArgs()\" #shadowsCamera />\n\t\t</ngt-group>\n\t`,\n\timports: [NgtArgs],\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class NgtsContactShadows {\n\tMath = Math;\n\n\toptions = input(defaultOptions, { transform: mergeInputs(defaultOptions) });\n\tparameters = omit(this.options, [\n\t\t'scale',\n\t\t'frames',\n\t\t'opacity',\n\t\t'width',\n\t\t'height',\n\t\t'blur',\n\t\t'near',\n\t\t'far',\n\t\t'resolution',\n\t\t'smooth',\n\t\t'color',\n\t\t'depthWrite',\n\t\t'renderOrder',\n\t]);\n\n\tcontactShadowsRef = viewChild.required<ElementRef<Group>>('contactShadows');\n\tshadowsCameraRef = viewChild<ElementRef<OrthographicCamera>>('shadowsCamera');\n\n\tprivate store = injectStore();\n\tprivate scene = this.store.select('scene');\n\tprivate gl = this.store.select('gl');\n\n\tprivate scaledWidth = computed(() => {\n\t\tconst { width, scale } = this.options();\n\t\treturn width * (Array.isArray(scale) ? scale[0] : scale);\n\t});\n\tprivate scaledHeight = computed(() => {\n\t\tconst { height, scale } = this.options();\n\t\treturn height * (Array.isArray(scale) ? scale[1] : scale);\n\t});\n\tprivate resolution = pick(this.options, 'resolution');\n\tprivate color = pick(this.options, 'color');\n\tprivate near = pick(this.options, 'near');\n\tprivate far = pick(this.options, 'far');\n\tprivate smooth = pick(this.options, 'smooth');\n\tprivate frames = pick(this.options, 'frames');\n\tprivate blur = pick(this.options, 'blur');\n\n\tprivate renderTarget = computed(() => this.createRenderTarget(this.resolution()));\n\tprivate renderTargetBlur = computed(() => this.createRenderTarget(this.resolution()));\n\tplaneGeometry = computed(() => new PlaneGeometry(this.scaledWidth(), this.scaledHeight()).rotateX(Math.PI / 2));\n\tprivate blurPlane = computed(() => new Mesh(this.planeGeometry()));\n\tprivate depthMaterial = computed(() => {\n\t\tconst color = new Color(this.color());\n\t\tconst material = new MeshDepthMaterial();\n\t\tmaterial.depthTest = material.depthWrite = false;\n\t\tmaterial.onBeforeCompile = (shader) => {\n\t\t\tshader.uniforms = { ...shader.uniforms, ucolor: { value: color } };\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\t\treturn material;\n\t});\n\n\tprivate horizontalBlurMaterial = new ShaderMaterial({ ...HorizontalBlurShader, depthTest: false });\n\tprivate verticalBlurMaterial = new ShaderMaterial({ ...VerticalBlurShader, depthTest: false });\n\n\trenderOrder = pick(this.options, 'renderOrder');\n\topacity = pick(this.options, 'opacity');\n\tdepthWrite = pick(this.options, 'depthWrite');\n\ttexture = pick(this.renderTarget, 'texture');\n\tcameraArgs = computed(() => {\n\t\tconst [width, height, near, far] = [this.scaledWidth(), this.scaledHeight(), this.near(), this.far()];\n\t\treturn [-width / 2, width / 2, height / 2, -height / 2, near, far];\n\t});\n\n\tconstructor() {\n\t\textend({ Group, Mesh, MeshBasicMaterial, OrthographicCamera });\n\n\t\tlet count = 0;\n\t\tinjectBeforeRender(() => {\n\t\t\tconst shadowsCamera = this.shadowsCameraRef()?.nativeElement;\n\t\t\tif (!shadowsCamera) return;\n\n\t\t\tconst frames = this.frames();\n\t\t\tif (frames === Infinity || count < frames) {\n\t\t\t\tthis.renderShadows();\n\t\t\t\tcount++;\n\t\t\t}\n\t\t});\n\t}\n\n\tprivate renderShadows() {\n\t\tconst shadowsCamera = this.shadowsCameraRef()?.nativeElement;\n\t\tif (!shadowsCamera) return;\n\n\t\tconst [blur, smooth, gl, scene, contactShadows, depthMaterial, renderTarget] = [\n\t\t\tthis.blur(),\n\t\t\tthis.smooth(),\n\t\t\tthis.gl(),\n\t\t\tthis.scene(),\n\t\t\tthis.contactShadowsRef().nativeElement,\n\t\t\tthis.depthMaterial(),\n\t\t\tthis.renderTarget(),\n\t\t];\n\n\t\tconst initialBackground = scene.background;\n\t\tconst initialOverrideMaterial = scene.overrideMaterial;\n\t\tconst initialClearAlpha = gl.getClearAlpha();\n\n\t\tcontactShadows.visible = false;\n\t\tscene.background = null;\n\t\tscene.overrideMaterial = depthMaterial;\n\t\tgl.setClearAlpha(0);\n\n\t\t// render to the render target to get the depths\n\t\tgl.setRenderTarget(renderTarget);\n\t\tgl.render(scene, shadowsCamera);\n\n\t\tthis.blurShadows(blur);\n\t\tif (smooth) this.blurShadows(blur * 0.4);\n\n\t\t// reset\n\t\tgl.setRenderTarget(null);\n\n\t\tcontactShadows.visible = true;\n\t\tscene.overrideMaterial = initialOverrideMaterial;\n\t\tscene.background = initialBackground;\n\t\tgl.setClearAlpha(initialClearAlpha);\n\t}\n\n\tprivate blurShadows(blur: number) {\n\t\tconst shadowsCamera = this.shadowsCameraRef()?.nativeElement;\n\t\tif (!shadowsCamera) return;\n\n\t\tconst [blurPlane, horizontalBlurMaterial, verticalBlurMaterial, renderTargetBlur, renderTarget, gl] = [\n\t\t\tthis.blurPlane(),\n\t\t\tthis.horizontalBlurMaterial,\n\t\t\tthis.verticalBlurMaterial,\n\t\t\tthis.renderTargetBlur(),\n\t\t\tthis.renderTarget(),\n\t\t\tthis.gl(),\n\t\t];\n\n\t\tblurPlane.visible = true;\n\t\tblurPlane.material = horizontalBlurMaterial;\n\t\thorizontalBlurMaterial.uniforms['tDiffuse'].value = renderTarget.texture;\n\t\thorizontalBlurMaterial.uniforms['h'].value = blur / 256;\n\t\tgl.setRenderTarget(renderTargetBlur);\n\t\tgl.render(blurPlane, shadowsCamera);\n\n\t\tblurPlane.material = verticalBlurMaterial;\n\t\tverticalBlurMaterial.uniforms['tDiffuse'].value = renderTargetBlur.texture;\n\t\tverticalBlurMaterial.uniforms['v'].value = blur / 256;\n\t\tgl.setRenderTarget(renderTarget);\n\t\tgl.render(blurPlane, shadowsCamera);\n\t\tblurPlane.visible = false;\n\t}\n\n\tprivate createRenderTarget(resolution: number) {\n\t\tconst renderTarget = new WebGLRenderTarget(resolution, resolution);\n\t\trenderTarget.texture.generateMipmaps = false;\n\t\treturn renderTarget;\n\t}\n}\n"]}