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

package/esm2022/staging/camera-shake/camera-shake.mjs

@@ -0,0 +1,117 @@
+import { computed, Directive, effect, inject, Input } from '@angular/core';
+import { injectBeforeRender, NgtSignalStore, NgtStore } from 'angular-three';
+import { SimplexNoise } from 'three-stdlib';
+import * as i0 from "@angular/core";
+class NgtsCameraShake extends NgtSignalStore {
+    #store = inject(NgtStore);
+    #initialRotation = this.#store.get('camera').rotation.clone();
+    #yawNoise = new SimplexNoise();
+    #rollNoise = new SimplexNoise();
+    #pitchNoise = new SimplexNoise();
+    set intensity(intensity) {
+        this.set({ intensity });
+    }
+    set decay(decay) {
+        this.set({ decay });
+    }
+    set decayRate(decayRate) {
+        this.set({ decayRate });
+    }
+    set maxYaw(maxYaw) {
+        this.set({ maxYaw });
+    }
+    set maxPitch(maxPitch) {
+        this.set({ maxPitch });
+    }
+    set maxRoll(maxRoll) {
+        this.set({ maxRoll });
+    }
+    set yawFrequency(yawFrequency) {
+        this.set({ yawFrequency });
+    }
+    set pitchFrequency(pitchFrequency) {
+        this.set({ pitchFrequency });
+    }
+    set rollFrequency(rollFrequency) {
+        this.set({ rollFrequency });
+    }
+    constructor() {
+        super({
+            intensity: 1,
+            decayRate: 0.65,
+            maxYaw: 0.1,
+            maxPitch: 0.1,
+            maxRoll: 0.1,
+            yawFrequency: 0.1,
+            pitchFrequency: 0.1,
+            rollFrequency: 0.1,
+        });
+        injectBeforeRender(({ clock, delta, camera }) => {
+            const { intensity, maxYaw, maxPitch, maxRoll, yawFrequency, pitchFrequency, rollFrequency, decay, decayRate, } = this.get();
+            const shake = Math.pow(intensity, 2);
+            const yaw = maxYaw * shake * this.#yawNoise.noise(clock.elapsedTime * yawFrequency, 1);
+            const pitch = maxPitch * shake * this.#pitchNoise.noise(clock.elapsedTime * pitchFrequency, 1);
+            const roll = maxRoll * shake * this.#rollNoise.noise(clock.elapsedTime * rollFrequency, 1);
+            camera.rotation.set(this.#initialRotation.x + pitch, this.#initialRotation.y + yaw, this.#initialRotation.z + roll);
+            if (decay && intensity > 0) {
+                this.set({ intensity: intensity - decayRate * delta });
+                this.#constraintIntensity();
+            }
+        });
+        this.#setChangeEvent();
+    }
+    ngOnInit() { }
+    #setChangeEvent() {
+        const camera = this.#store.select('camera');
+        const controls = this.#store.select('controls');
+        const trigger = computed(() => ({ camera: camera(), controls: controls() }));
+        effect((onCleanup) => {
+            const { camera, controls } = trigger();
+            if (controls) {
+                const callback = () => void (this.#initialRotation = camera.rotation.clone());
+                controls.addEventListener('change', callback);
+                callback();
+                onCleanup(() => void controls.removeEventListener('change', callback));
+            }
+        });
+    }
+    getIntensity() {
+        return this.get('intensity');
+    }
+    setIntensity(intensity) {
+        this.set({ intensity });
+        this.#constraintIntensity();
+    }
+    #constraintIntensity() {
+        const intensity = this.get('intensity');
+        if (intensity < 0 || intensity > 1) {
+            this.set({ intensity: intensity < 0 ? 0 : 1 });
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsCameraShake, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: NgtsCameraShake, isStandalone: true, selector: "ngts-camera-shake", inputs: { intensity: "intensity", decay: "decay", decayRate: "decayRate", maxYaw: "maxYaw", maxPitch: "maxPitch", maxRoll: "maxRoll", yawFrequency: "yawFrequency", pitchFrequency: "pitchFrequency", rollFrequency: "rollFrequency" }, usesInheritance: true, ngImport: i0 }); }
+}
+export { NgtsCameraShake };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsCameraShake, decorators: [{
+            type: Directive,
+            args: [{ selector: 'ngts-camera-shake', standalone: true }]
+        }], ctorParameters: function () { return []; }, propDecorators: { intensity: [{
+                type: Input
+            }], decay: [{
+                type: Input
+            }], decayRate: [{
+                type: Input
+            }], maxYaw: [{
+                type: Input
+            }], maxPitch: [{
+                type: Input
+            }], maxRoll: [{
+                type: Input
+            }], yawFrequency: [{
+                type: Input
+            }], pitchFrequency: [{
+                type: Input
+            }], rollFrequency: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"camera-shake.js","sourceRoot":"","sources":["../../../../../../libs/soba/staging/src/camera-shake/camera-shake.ts"],"names":[],"mappings":"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","sourcesContent":["import { computed, Directive, effect, inject, Input, OnInit } from '@angular/core';\nimport { injectBeforeRender, NgtSignalStore, NgtStore } from 'angular-three';\nimport { SimplexNoise } from 'three-stdlib';\n\nexport interface NgtsCameraShakeState {\n    intensity: number;\n    decay: boolean;\n    decayRate: number;\n    maxYaw: number;\n    maxPitch: number;\n    maxRoll: number;\n    yawFrequency: number;\n    pitchFrequency: number;\n    rollFrequency: number;\n}\n\n@Directive({ selector: 'ngts-camera-shake', standalone: true })\nexport class NgtsCameraShake extends NgtSignalStore<NgtsCameraShakeState> implements OnInit {\n    readonly #store = inject(NgtStore);\n\n    #initialRotation = this.#store.get('camera').rotation.clone();\n\n    readonly #yawNoise = new SimplexNoise();\n    readonly #rollNoise = new SimplexNoise();\n    readonly #pitchNoise = new SimplexNoise();\n\n    @Input() set intensity(intensity: number) {\n        this.set({ intensity });\n    }\n\n    @Input() set decay(decay: boolean) {\n        this.set({ decay });\n    }\n\n    @Input() set decayRate(decayRate: number) {\n        this.set({ decayRate });\n    }\n\n    @Input() set maxYaw(maxYaw: number) {\n        this.set({ maxYaw });\n    }\n\n    @Input() set maxPitch(maxPitch: number) {\n        this.set({ maxPitch });\n    }\n\n    @Input() set maxRoll(maxRoll: number) {\n        this.set({ maxRoll });\n    }\n\n    @Input() set yawFrequency(yawFrequency: number) {\n        this.set({ yawFrequency });\n    }\n\n    @Input() set pitchFrequency(pitchFrequency: number) {\n        this.set({ pitchFrequency });\n    }\n\n    @Input() set rollFrequency(rollFrequency: number) {\n        this.set({ rollFrequency });\n    }\n\n    constructor() {\n        super({\n            intensity: 1,\n            decayRate: 0.65,\n            maxYaw: 0.1,\n            maxPitch: 0.1,\n            maxRoll: 0.1,\n            yawFrequency: 0.1,\n            pitchFrequency: 0.1,\n            rollFrequency: 0.1,\n        });\n\n        injectBeforeRender(({ clock, delta, camera }) => {\n            const {\n                intensity,\n                maxYaw,\n                maxPitch,\n                maxRoll,\n                yawFrequency,\n                pitchFrequency,\n                rollFrequency,\n                decay,\n                decayRate,\n            } = this.get();\n\n            const shake = Math.pow(intensity, 2);\n            const yaw = maxYaw * shake * this.#yawNoise.noise(clock.elapsedTime * yawFrequency, 1);\n            const pitch = maxPitch * shake * this.#pitchNoise.noise(clock.elapsedTime * pitchFrequency, 1);\n            const roll = maxRoll * shake * this.#rollNoise.noise(clock.elapsedTime * rollFrequency, 1);\n\n            camera.rotation.set(\n                this.#initialRotation.x + pitch,\n                this.#initialRotation.y + yaw,\n                this.#initialRotation.z + roll\n            );\n\n            if (decay && intensity > 0) {\n                this.set({ intensity: intensity - decayRate * delta });\n                this.#constraintIntensity();\n            }\n        });\n\n        this.#setChangeEvent();\n    }\n\n    ngOnInit(): void {}\n\n    #setChangeEvent() {\n        const camera = this.#store.select('camera');\n        const controls = this.#store.select('controls');\n        const trigger = computed(() => ({ camera: camera(), controls: controls() }));\n        effect((onCleanup) => {\n            const { camera, controls } = trigger();\n            if (controls) {\n                const callback = () => void (this.#initialRotation = camera.rotation.clone());\n                controls.addEventListener('change', callback);\n                callback();\n                onCleanup(() => void controls.removeEventListener('change', callback));\n            }\n        });\n    }\n\n    getIntensity() {\n        return this.get('intensity');\n    }\n\n    setIntensity(intensity: number) {\n        this.set({ intensity });\n        this.#constraintIntensity();\n    }\n\n    #constraintIntensity() {\n        const intensity = this.get('intensity');\n        if (intensity < 0 || intensity > 1) {\n            this.set({ intensity: intensity < 0 ? 0 : 1 });\n        }\n    }\n}\n"]}

package/esm2022/staging/caustics/caustisc.mjs

@@ -0,0 +1,384 @@
+import { NgIf } from '@angular/common';
+import { Component, computed, CUSTOM_ELEMENTS_SCHEMA, effect, inject, Input } from '@angular/core';
+import { extend, injectNgtRef, NgtSignalStore, NgtStore, requestAnimationInInjectionContext } from 'angular-three';
+import { NgtsEdges } from 'angular-three-soba/abstractions';
+import { injectNgtsFBO } from 'angular-three-soba/misc';
+import { CausticsMaterial, CausticsProjectionMaterial } from 'angular-three-soba/shaders';
+import * as THREE from 'three';
+import { Group, LineBasicMaterial, Mesh, OrthographicCamera, PlaneGeometry, Scene } from 'three';
+import { FullScreenQuad } from 'three-stdlib';
+import * as i0 from "@angular/core";
+extend({ Group, Scene, Mesh, PlaneGeometry, OrthographicCamera, CausticsProjectionMaterial, LineBasicMaterial });
+const NORMALPROPS = {
+    depth: true,
+    minFilter: THREE.LinearFilter,
+    magFilter: THREE.LinearFilter,
+    encoding: THREE.LinearEncoding,
+    type: THREE.UnsignedByteType,
+};
+const CAUSTICPROPS = {
+    minFilter: THREE.LinearMipmapLinearFilter,
+    magFilter: THREE.LinearFilter,
+    encoding: THREE.LinearEncoding,
+    format: THREE.RGBAFormat,
+    type: THREE.FloatType,
+    generateMipmaps: true,
+};
+function createNormalMaterial(side = THREE.FrontSide) {
+    const viewMatrix = { value: new THREE.Matrix4() };
+    return Object.assign(new THREE.MeshNormalMaterial({ side }), {
+        viewMatrix,
+        onBeforeCompile: (shader) => {
+            shader.uniforms.viewMatrix = viewMatrix;
+            shader.fragmentShader =
+                `vec3 inverseTransformDirection( in vec3 dir, in mat4 matrix ) {
+           return normalize( ( vec4( dir, 0.0 ) * matrix ).xyz );
+         }\n` +
+                    shader.fragmentShader.replace('#include <normal_fragment_maps>', `#include <normal_fragment_maps>
+           normal = inverseTransformDirection( normal, viewMatrix );\n`);
+        },
+    });
+}
+class NgtsCaustics extends NgtSignalStore {
+    /** How many frames it will render, set it to Infinity for runtime, default: 1 */
+    set frames(frames) {
+        this.set({ frames });
+    }
+    /** Enables visual cues to help you stage your scene, default: false */
+    set debug(debug) {
+        this.set({ debug });
+    }
+    /** Will display caustics only and skip the models, default: false */
+    set causticsOnly(causticsOnly) {
+        this.set({ causticsOnly });
+    }
+    /** Will include back faces and enable the backsideIOR prop, default: false */
+    set backside(backside) {
+        this.set({ backside });
+    }
+    /** The IOR refraction index, default: 1.1 */
+    set ior(ior) {
+        this.set({ ior });
+    }
+    /** The IOR refraction index for back faces (only available when backside is enabled), default: 1.1 */
+    set backsideIOR(backsideIOR) {
+        this.set({ backsideIOR });
+    }
+    /** The texel size, default: 0.3125 */
+    set worldRadius(worldRadius) {
+        this.set({ worldRadius });
+    }
+    /** Intensity of the prjected caustics, default: 0.05 */
+    set intensity(intensity) {
+        this.set({ intensity });
+    }
+    /** Caustics color, default: white */
+    set color(color) {
+        this.set({ color });
+    }
+    /** Buffer resolution, default: 2048 */
+    set resolution(resolution) {
+        this.set({ resolution });
+    }
+    /** Camera position, it will point towards the contents bounds center, default: [5, 5, 5] */
+    set lightSource(lightSource) {
+        this.set({ lightSource });
+    }
+    #resolution;
+    #normalTargetSettings;
+    #causticsTargetSettings;
+    #store;
+    constructor() {
+        super({
+            frames: 1,
+            ior: 1.1,
+            color: 'white',
+            causticsOnly: false,
+            backside: false,
+            backsideIOR: 1.1,
+            worldRadius: 0.3125,
+            intensity: 0.05,
+            resolution: 2024,
+            lightSource: [5, 5, 5],
+        });
+        this.CustomBlending = THREE.CustomBlending;
+        this.OneFactor = THREE.OneFactor;
+        this.SrcAlphaFactor = THREE.SrcAlphaFactor;
+        this.Math = Math;
+        this.planeRef = injectNgtRef();
+        this.sceneRef = injectNgtRef();
+        this.cameraRef = injectNgtRef();
+        this.causticsRef = injectNgtRef();
+        this.causticsColor = this.select('color');
+        this.causticsDebug = this.select('debug');
+        this.#resolution = this.select('resolution');
+        this.#normalTargetSettings = computed(() => ({
+            width: this.#resolution(),
+            height: this.#resolution(),
+            settings: NORMALPROPS,
+        }));
+        this.#causticsTargetSettings = computed(() => ({
+            width: this.#resolution(),
+            height: this.#resolution(),
+            settings: CAUSTICPROPS,
+        }));
+        this.normalTargetFbo = injectNgtsFBO(this.#normalTargetSettings);
+        this.normalTargetBFbo = injectNgtsFBO(this.#normalTargetSettings);
+        this.causticsTargetFbo = injectNgtsFBO(this.#causticsTargetSettings);
+        this.causticsTargetBFbo = injectNgtsFBO(this.#causticsTargetSettings);
+        this.#store = inject(NgtStore);
+        requestAnimationInInjectionContext(() => {
+            this.#updateWorldMatrix();
+            this.#setBeforeRender();
+        });
+    }
+    #updateWorldMatrix() {
+        const trigger = computed(() => ({
+            sceneChildren: this.sceneRef.children()(),
+            caustics: this.causticsRef.nativeElement,
+            causticsChildren: this.causticsRef.children()(),
+            state: this.select()(),
+        }));
+        effect(() => {
+            const { caustics } = trigger();
+            if (!caustics)
+                return;
+            caustics.updateWorldMatrix(false, true);
+        });
+    }
+    #setBeforeRender() {
+        const causticsMaterial = new CausticsMaterial();
+        const causticsQuad = new FullScreenQuad(causticsMaterial);
+        const normalMaterial = createNormalMaterial();
+        const normalMaterialB = createNormalMaterial(THREE.BackSide);
+        const trigger = computed(() => ({
+            scene: this.sceneRef.nativeElement,
+            sceneChildren: this.sceneRef.children()(),
+            caustics: this.causticsRef.nativeElement,
+            camera: this.cameraRef.nativeElement,
+            normalTarget: this.normalTargetFbo(),
+            normalTargetB: this.normalTargetBFbo(),
+            causticsTarget: this.causticsTargetFbo(),
+            causticsTargetB: this.causticsTargetBFbo(),
+            plane: this.planeRef.nativeElement,
+            planeChildren: this.planeRef.children('both')(),
+        }));
+        effect((onCleanup) => {
+            const { caustics, sceneChildren, scene, camera, plane, normalTarget, normalTargetB, causticsTarget, causticsTargetB, } = trigger();
+            if (!caustics)
+                return;
+            caustics.updateWorldMatrix(false, true);
+            if (sceneChildren.length > 1) {
+                const v = new THREE.Vector3();
+                const lpF = new THREE.Frustum();
+                const lpM = new THREE.Matrix4();
+                const lpP = new THREE.Plane();
+                const lightDir = new THREE.Vector3();
+                const lightDirInv = new THREE.Vector3();
+                const bounds = new THREE.Box3();
+                const focusPos = new THREE.Vector3();
+                let count = 0;
+                const sub = this.#store.get('internal').subscribe(({ gl }) => {
+                    const { frames, lightSource, resolution, worldRadius, intensity, backside, backsideIOR, ior, causticsOnly, } = this.get();
+                    if (frames === Infinity || count++ < frames) {
+                        if (Array.isArray(lightSource))
+                            lightDir.fromArray(lightSource).normalize();
+                        else
+                            lightDir.copy(caustics.worldToLocal(lightSource.nativeElement.getWorldPosition(v)).normalize());
+                        lightDirInv.copy(lightDir).multiplyScalar(-1);
+                        let boundsVertices = [];
+                        scene.parent?.matrixWorld.identity();
+                        bounds.setFromObject(scene, true);
+                        boundsVertices.push(new THREE.Vector3(bounds.min.x, bounds.min.y, bounds.min.z));
+                        boundsVertices.push(new THREE.Vector3(bounds.min.x, bounds.min.y, bounds.max.z));
+                        boundsVertices.push(new THREE.Vector3(bounds.min.x, bounds.max.y, bounds.min.z));
+                        boundsVertices.push(new THREE.Vector3(bounds.min.x, bounds.max.y, bounds.max.z));
+                        boundsVertices.push(new THREE.Vector3(bounds.max.x, bounds.min.y, bounds.min.z));
+                        boundsVertices.push(new THREE.Vector3(bounds.max.x, bounds.min.y, bounds.max.z));
+                        boundsVertices.push(new THREE.Vector3(bounds.max.x, bounds.max.y, bounds.min.z));
+                        boundsVertices.push(new THREE.Vector3(bounds.max.x, bounds.max.y, bounds.max.z));
+                        const worldVerts = boundsVertices.map((v) => v.clone());
+                        bounds.getCenter(focusPos);
+                        boundsVertices = boundsVertices.map((v) => v.clone().sub(focusPos));
+                        const lightPlane = lpP.set(lightDirInv, 0);
+                        const projectedVerts = boundsVertices.map((v) => lightPlane.projectPoint(v, new THREE.Vector3()));
+                        const centralVert = projectedVerts
+                            .reduce((a, b) => a.add(b), v.set(0, 0, 0))
+                            .divideScalar(projectedVerts.length);
+                        const radius = projectedVerts
+                            .map((v) => v.distanceTo(centralVert))
+                            .reduce((a, b) => Math.max(a, b));
+                        const dirLength = boundsVertices.map((x) => x.dot(lightDir)).reduce((a, b) => Math.max(a, b));
+                        // Shadows
+                        camera.position.copy(lightDir.clone().multiplyScalar(dirLength).add(focusPos));
+                        camera.lookAt(scene.localToWorld(focusPos.clone()));
+                        const dirMatrix = lpM.lookAt(camera.position, focusPos, v.set(0, 1, 0));
+                        camera.left = -radius;
+                        camera.right = radius;
+                        camera.top = radius;
+                        camera.bottom = -radius;
+                        const yOffset = v.set(0, radius, 0).applyMatrix4(dirMatrix);
+                        const yTime = (camera.position.y + yOffset.y) / lightDir.y;
+                        camera.near = 0.1;
+                        camera.far = yTime;
+                        camera.updateProjectionMatrix();
+                        camera.updateMatrixWorld();
+                        // Now find size of ground plane
+                        const groundProjectedCoords = worldVerts.map((v) => v.add(lightDir.clone().multiplyScalar(-v.y / lightDir.y)));
+                        const centerPos = groundProjectedCoords
+                            .reduce((a, b) => a.add(b), v.set(0, 0, 0))
+                            .divideScalar(groundProjectedCoords.length);
+                        const maxSize = 2 *
+                            groundProjectedCoords
+                                .map((v) => Math.hypot(v.x - centerPos.x, v.z - centerPos.z))
+                                .reduce((a, b) => Math.max(a, b));
+                        plane.scale.setScalar(maxSize);
+                        plane.position.copy(centerPos);
+                        // if (debug) helper.current?.update();
+                        // Inject uniforms
+                        normalMaterialB.viewMatrix.value = normalMaterial.viewMatrix.value = camera.matrixWorldInverse;
+                        const dirLightNearPlane = lpF.setFromProjectionMatrix(lpM.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse)).planes[4];
+                        causticsMaterial.cameraMatrixWorld = camera.matrixWorld;
+                        causticsMaterial.cameraProjectionMatrixInv = camera.projectionMatrixInverse;
+                        causticsMaterial.lightDir = lightDirInv;
+                        causticsMaterial.lightPlaneNormal = dirLightNearPlane.normal;
+                        causticsMaterial.lightPlaneConstant = dirLightNearPlane.constant;
+                        causticsMaterial.near = camera.near;
+                        causticsMaterial.far = camera.far;
+                        causticsMaterial.resolution = resolution;
+                        causticsMaterial.size = radius;
+                        causticsMaterial.intensity = intensity;
+                        causticsMaterial.worldRadius = worldRadius;
+                        // Switch the scene on
+                        scene.visible = true;
+                        // Render front face normals
+                        gl.setRenderTarget(normalTarget);
+                        gl.clear();
+                        scene.overrideMaterial = normalMaterial;
+                        gl.render(scene, camera);
+                        // Render back face normals, if enabled
+                        gl.setRenderTarget(normalTargetB);
+                        gl.clear();
+                        if (backside) {
+                            scene.overrideMaterial = normalMaterialB;
+                            gl.render(scene, camera);
+                        }
+                        // Remove the override material
+                        scene.overrideMaterial = null;
+                        // Render front face caustics
+                        causticsMaterial.ior = ior;
+                        plane.material.lightProjMatrix = camera.projectionMatrix;
+                        plane.material.lightViewMatrix = camera.matrixWorldInverse;
+                        causticsMaterial.normalTexture = normalTarget.texture;
+                        causticsMaterial.depthTexture = normalTarget.depthTexture;
+                        gl.setRenderTarget(causticsTarget);
+                        gl.clear();
+                        causticsQuad.render(gl);
+                        // Render back face caustics, if enabled
+                        causticsMaterial.ior = backsideIOR;
+                        causticsMaterial.normalTexture = normalTargetB.texture;
+                        causticsMaterial.depthTexture = normalTargetB.depthTexture;
+                        gl.setRenderTarget(causticsTargetB);
+                        gl.clear();
+                        if (backside)
+                            causticsQuad.render(gl);
+                        // Reset render target
+                        gl.setRenderTarget(null);
+                        // Switch the scene off if caustics is all that's wanted
+                        if (causticsOnly)
+                            scene.visible = false;
+                    }
+                });
+                onCleanup(() => sub());
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsCaustics, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: NgtsCaustics, isStandalone: true, selector: "ngts-caustics", inputs: { causticsRef: "causticsRef", frames: "frames", debug: "debug", causticsOnly: "causticsOnly", backside: "backside", ior: "ior", backsideIOR: "backsideIOR", worldRadius: "worldRadius", intensity: "intensity", color: "color", resolution: "resolution", lightSource: "lightSource" }, usesInheritance: true, ngImport: i0, template: `
+        <ngt-group [ref]="causticsRef" ngtCompound>
+            <ngt-scene [ref]="sceneRef">
+                <ngt-orthographic-camera [ref]="cameraRef" [up]="[0, 1, 0]" />
+                <ng-content />
+            </ngt-scene>
+            <ngt-mesh [renderOrder]="2" [ref]="planeRef" [rotation]="[-Math.PI / 2, 0, 0]">
+                <ngt-plane-geometry />
+                <ngt-caustics-projection-material
+                    *ngIf="causticsTargetFbo() && causticsTargetBFbo()"
+                    [transparent]="true"
+                    [color]="causticsColor()"
+                    [causticsTexture]="causticsTargetFbo().texture"
+                    [causticsTextureB]="causticsTargetBFbo().texture"
+                    [blending]="CustomBlending"
+                    [blendSrc]="OneFactor"
+                    [blendDst]="SrcAlphaFactor"
+                    [depthWrite]="false"
+                />
+
+                <ngts-edges *ngIf="causticsDebug()" [withChildren]="true">
+                    <ngt-line-basic-material color="#ffff00" [toneMapped]="false" />
+                </ngts-edges>
+            </ngt-mesh>
+        </ngt-group>
+    `, isInline: true, dependencies: [{ kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: NgtsEdges, selector: "ngts-edges", inputs: ["edgesRef", "threshold", "color", "geometry", "userData", "withChildren"] }] }); }
+}
+export { NgtsCaustics };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsCaustics, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-caustics',
+                    standalone: true,
+                    template: `
+        <ngt-group [ref]="causticsRef" ngtCompound>
+            <ngt-scene [ref]="sceneRef">
+                <ngt-orthographic-camera [ref]="cameraRef" [up]="[0, 1, 0]" />
+                <ng-content />
+            </ngt-scene>
+            <ngt-mesh [renderOrder]="2" [ref]="planeRef" [rotation]="[-Math.PI / 2, 0, 0]">
+                <ngt-plane-geometry />
+                <ngt-caustics-projection-material
+                    *ngIf="causticsTargetFbo() && causticsTargetBFbo()"
+                    [transparent]="true"
+                    [color]="causticsColor()"
+                    [causticsTexture]="causticsTargetFbo().texture"
+                    [causticsTextureB]="causticsTargetBFbo().texture"
+                    [blending]="CustomBlending"
+                    [blendSrc]="OneFactor"
+                    [blendDst]="SrcAlphaFactor"
+                    [depthWrite]="false"
+                />
+
+                <ngts-edges *ngIf="causticsDebug()" [withChildren]="true">
+                    <ngt-line-basic-material color="#ffff00" [toneMapped]="false" />
+                </ngts-edges>
+            </ngt-mesh>
+        </ngt-group>
+    `,
+                    imports: [NgIf, NgtsEdges],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { causticsRef: [{
+                type: Input
+            }], frames: [{
+                type: Input
+            }], debug: [{
+                type: Input
+            }], causticsOnly: [{
+                type: Input
+            }], backside: [{
+                type: Input
+            }], ior: [{
+                type: Input
+            }], backsideIOR: [{
+                type: Input
+            }], worldRadius: [{
+                type: Input
+            }], intensity: [{
+                type: Input
+            }], color: [{
+                type: Input
+            }], resolution: [{
+                type: Input
+            }], lightSource: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"caustisc.js","sourceRoot":"","sources":["../../../../../../libs/soba/staging/src/caustics/caustisc.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACvC,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,sBAAsB,EAAE,MAAM,EAAc,MAAM,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAC/G,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,cAAc,EAAE,QAAQ,EAAE,kCAAkC,EAAE,MAAM,eAAe,CAAC;AACnH,OAAO,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAC5D,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,EAAE,gBAAgB,EAAE,0BAA0B,EAAE,MAAM,4BAA4B,CAAC;AAC1F,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAAE,KAAK,EAAE,iBAAiB,EAAE,IAAI,EAAE,kBAAkB,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AACjG,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;;AAE9C,MAAM,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,aAAa,EAAE,kBAAkB,EAAE,0BAA0B,EAAE,iBAAiB,EAAE,CAAC,CAAC;AAEjH,MAAM,WAAW,GAAG;IAChB,KAAK,EAAE,IAAI;IACX,SAAS,EAAE,KAAK,CAAC,YAAY;IAC7B,SAAS,EAAE,KAAK,CAAC,YAAY;IAC7B,QAAQ,EAAE,KAAK,CAAC,cAAc;IAC9B,IAAI,EAAE,KAAK,CAAC,gBAAgB;CAC/B,CAAC;AAEF,MAAM,YAAY,GAAG;IACjB,SAAS,EAAE,KAAK,CAAC,wBAAwB;IACzC,SAAS,EAAE,KAAK,CAAC,YAAY;IAC7B,QAAQ,EAAE,KAAK,CAAC,cAAc;IAC9B,MAAM,EAAE,KAAK,CAAC,UAAU;IACxB,IAAI,EAAE,KAAK,CAAC,SAAS;IACrB,eAAe,EAAE,IAAI;CACxB,CAAC;AA8BF,SAAS,oBAAoB,CAAC,OAAmB,KAAK,CAAC,SAAS;IAC5D,MAAM,UAAU,GAAG,EAAE,KAAK,EAAE,IAAI,KAAK,CAAC,OAAO,EAAE,EAAE,CAAC;IAClD,OAAO,MAAM,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,kBAAkB,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE;QACzD,UAAU;QACV,eAAe,EAAE,CAAC,MAAW,EAAE,EAAE;YAC7B,MAAM,CAAC,QAAQ,CAAC,UAAU,GAAG,UAAU,CAAC;YACxC,MAAM,CAAC,cAAc;gBACjB;;aAEH;oBACG,MAAM,CAAC,cAAc,CAAC,OAAO,CACzB,iCAAiC,EACjC;uEACmD,CACtD,CAAC;QACV,CAAC;KACJ,CAAC,CAAC;AACP,CAAC;AA2BD,MAgCa,YAAa,SAAQ,cAAiC;IAY/D,iFAAiF;IACjF,IAAa,MAAM,CAAC,MAAc;QAC9B,IAAI,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC;IACzB,CAAC;IACD,uEAAuE;IACvE,IAAa,KAAK,CAAC,KAAc;QAC7B,IAAI,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;IACxB,CAAC;IACD,qEAAqE;IACrE,IAAa,YAAY,CAAC,YAAqB;QAC3C,IAAI,CAAC,GAAG,CAAC,EAAE,YAAY,EAAE,CAAC,CAAC;IAC/B,CAAC;IACD,8EAA8E;IAC9E,IAAa,QAAQ,CAAC,QAAiB;QACnC,IAAI,CAAC,GAAG,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC;IAC3B,CAAC;IACD,6CAA6C;IAC7C,IAAa,GAAG,CAAC,GAAW;QACxB,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC;IACtB,CAAC;IACD,sGAAsG;IACtG,IAAa,WAAW,CAAC,WAAmB;QACxC,IAAI,CAAC,GAAG,CAAC,EAAE,WAAW,EAAE,CAAC,CAAC;IAC9B,CAAC;IACD,sCAAsC;IACtC,IAAa,WAAW,CAAC,WAAmB;QACxC,IAAI,CAAC,GAAG,CAAC,EAAE,WAAW,EAAE,CAAC,CAAC;IAC9B,CAAC;IACD,wDAAwD;IACxD,IAAa,SAAS,CAAC,SAAiB;QACpC,IAAI,CAAC,GAAG,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC;IAC5B,CAAC;IACD,qCAAqC;IACrC,IAAa,KAAK,CAAC,KAAgC;QAC/C,IAAI,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;IACxB,CAAC;IACD,uCAAuC;IACvC,IAAa,UAAU,CAAC,UAAkB;QACtC,IAAI,CAAC,GAAG,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC;IAC7B,CAAC;IACD,4FAA4F;IAC5F,IAAa,WAAW,CAAC,WAA2E;QAChG,IAAI,CAAC,GAAG,CAAC,EAAE,WAAW,EAAE,CAAC,CAAC;IAC9B,CAAC;IAKQ,WAAW,CAA6B;IAExC,qBAAqB,CAI1B;IAEK,uBAAuB,CAI5B;IAOK,MAAM,CAAoB;IAEnC;QACI,KAAK,CAAC;YACF,MAAM,EAAE,CAAC;YACT,GAAG,EAAE,GAAG;YACR,KAAK,EAAE,OAAO;YACd,YAAY,EAAE,KAAK;YACnB,QAAQ,EAAE,KAAK;YACf,WAAW,EAAE,GAAG;YAChB,WAAW,EAAE,MAAM;YACnB,SAAS,EAAE,IAAI;YACf,UAAU,EAAE,IAAI;YAChB,WAAW,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;SACzB,CAAC,CAAC;QA5FE,mBAAc,GAAG,KAAK,CAAC,cAAc,CAAC;QACtC,cAAS,GAAG,KAAK,CAAC,SAAS,CAAC;QAC5B,mBAAc,GAAG,KAAK,CAAC,cAAc,CAAC;QACtC,SAAI,GAAG,IAAI,CAAC;QAEZ,aAAQ,GAAG,YAAY,EAAc,CAAC;QACtC,aAAQ,GAAG,YAAY,EAAe,CAAC;QACvC,cAAS,GAAG,YAAY,EAA4B,CAAC;QAErD,gBAAW,GAAG,YAAY,EAAe,CAAC;QA+C1C,kBAAa,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QACrC,kBAAa,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QAErC,gBAAW,GAAG,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;QAExC,0BAAqB,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAC;YAC7C,KAAK,EAAE,IAAI,CAAC,WAAW,EAAE;YACzB,MAAM,EAAE,IAAI,CAAC,WAAW,EAAE;YAC1B,QAAQ,EAAE,WAAW;SACxB,CAAC,CAAC,CAAC;QAEK,4BAAuB,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAC;YAC/C,KAAK,EAAE,IAAI,CAAC,WAAW,EAAE;YACzB,MAAM,EAAE,IAAI,CAAC,WAAW,EAAE;YAC1B,QAAQ,EAAE,YAAY;SACzB,CAAC,CAAC,CAAC;QAEK,oBAAe,GAAG,aAAa,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC;QAC5D,qBAAgB,GAAG,aAAa,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC;QAC7D,sBAAiB,GAAG,aAAa,CAAC,IAAI,CAAC,uBAAuB,CAAC,CAAC;QAChE,uBAAkB,GAAG,aAAa,CAAC,IAAI,CAAC,uBAAuB,CAAC,CAAC;QAEjE,WAAM,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;QAe/B,kCAAkC,CAAC,GAAG,EAAE;YACpC,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAC1B,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAC5B,CAAC,CAAC,CAAC;IACP,CAAC;IAED,kBAAkB;QACd,MAAM,OAAO,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAC;YAC5B,aAAa,EAAE,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,EAAE;YACzC,QAAQ,EAAE,IAAI,CAAC,WAAW,CAAC,aAAa;YACxC,gBAAgB,EAAE,IAAI,CAAC,WAAW,CAAC,QAAQ,EAAE,EAAE;YAC/C,KAAK,EAAE,IAAI,CAAC,MAAM,EAAE,EAAE;SACzB,CAAC,CAAC,CAAC;QAEJ,MAAM,CAAC,GAAG,EAAE;YACR,MAAM,EAAE,QAAQ,EAAE,GAAG,OAAO,EAAE,CAAC;YAC/B,IAAI,CAAC,QAAQ;gBAAE,OAAO;YACtB,QAAQ,CAAC,iBAAiB,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QAC5C,CAAC,CAAC,CAAC;IACP,CAAC;IAED,gBAAgB;QACZ,MAAM,gBAAgB,GAAG,IAAI,gBAAgB,EAA0B,CAAC;QACxE,MAAM,YAAY,GAAG,IAAI,cAAc,CAAC,gBAAgB,CAAC,CAAC;QAE1D,MAAM,cAAc,GAAG,oBAAoB,EAAE,CAAC;QAC9C,MAAM,eAAe,GAAG,oBAAoB,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;QAE7D,MAAM,OAAO,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAC;YAC5B,KAAK,EAAE,IAAI,CAAC,QAAQ,CAAC,aAAa;YAClC,aAAa,EAAE,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,EAAE;YACzC,QAAQ,EAAE,IAAI,CAAC,WAAW,CAAC,aAAa;YACxC,MAAM,EAAE,IAAI,CAAC,SAAS,CAAC,aAAa;YACpC,YAAY,EAAE,IAAI,CAAC,eAAe,EAAE;YACpC,aAAa,EAAE,IAAI,CAAC,gBAAgB,EAAE;YACtC,cAAc,EAAE,IAAI,CAAC,iBAAiB,EAAE;YACxC,eAAe,EAAE,IAAI,CAAC,kBAAkB,EAAE;YAC1C,KAAK,EAAE,IAAI,CAAC,QAAQ,CAAC,aAAa;YAClC,aAAa,EAAE,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE;SAClD,CAAC,CAAC,CAAC;QAEJ,MAAM,CAAC,CAAC,SAAS,EAAE,EAAE;YACjB,MAAM,EACF,QAAQ,EACR,aAAa,EACb,KAAK,EACL,MAAM,EACN,KAAK,EACL,YAAY,EACZ,aAAa,EACb,cAAc,EACd,eAAe,GAClB,GAAG,OAAO,EAAE,CAAC;YACd,IAAI,CAAC,QAAQ;gBAAE,OAAO;YACtB,QAAQ,CAAC,iBAAiB,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;YAExC,IAAI,aAAa,CAAC,MAAM,GAAG,CAAC,EAAE;gBAC1B,MAAM,CAAC,GAAG,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC;gBAC9B,MAAM,GAAG,GAAG,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC;gBAChC,MAAM,GAAG,GAAG,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC;gBAChC,MAAM,GAAG,GAAG,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC;gBAE9B,MAAM,QAAQ,GAAG,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC;gBACrC,MAAM,WAAW,GAAG,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC;gBACxC,MAAM,MAAM,GAAG,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC;gBAChC,MAAM,QAAQ,GAAG,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC;gBAErC,IAAI,KAAK,GAAG,CAAC,CAAC;gBACd,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE;oBACzD,MAAM,EACF,MAAM,EACN,WAAW,EACX,UAAU,EACV,WAAW,EACX,SAAS,EACT,QAAQ,EACR,WAAW,EACX,GAAG,EACH,YAAY,GACf,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;oBAEf,IAAI,MAAM,KAAK,QAAQ,IAAI,KAAK,EAAE,GAAG,MAAM,EAAE;wBACzC,IAAI,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC;4BAAE,QAAQ,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC,SAAS,EAAE,CAAC;;4BAExE,QAAQ,CAAC,IAAI,CACT,QAAQ,CAAC,YAAY,CAAC,WAAW,CAAC,aAAa,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,EAAE,CACnF,CAAC;wBAEN,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC;wBAE9C,IAAI,cAAc,GAAoB,EAAE,CAAC;wBACzC,KAAK,CAAC,MAAM,EAAE,WAAW,CAAC,QAAQ,EAAE,CAAC;wBACrC,MAAM,CAAC,aAAa,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;wBAClC,cAAc,CAAC,IAAI,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;wBACjF,cAAc,CAAC,IAAI,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;wBACjF,cAAc,CAAC,IAAI,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;wBACjF,cAAc,CAAC,IAAI,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;wBACjF,cAAc,CAAC,IAAI,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;wBACjF,cAAc,CAAC,IAAI,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;wBACjF,cAAc,CAAC,IAAI,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;wBACjF,cAAc,CAAC,IAAI,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;wBAEjF,MAAM,UAAU,GAAG,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC;wBAExD,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;wBAC3B,cAAc,GAAG,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC;wBACpE,MAAM,UAAU,GAAG,GAAG,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC;wBAC3C,MAAM,cAAc,GAAG,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAC5C,UAAU,CAAC,YAAY,CAAC,CAAC,EAAE,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC,CAClD,CAAC;wBAEF,MAAM,WAAW,GAAG,cAAc;6BAC7B,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;6BAC1C,YAAY,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;wBACzC,MAAM,MAAM,GAAG,cAAc;6BACxB,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC;6BACrC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;wBACtC,MAAM,SAAS,GAAG,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;wBAE9F,UAAU;wBACV,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC;wBAC/E,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,YAAY,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;wBACpD,MAAM,SAAS,GAAG,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,QAAQ,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;wBACxE,MAAM,CAAC,IAAI,GAAG,CAAC,MAAM,CAAC;wBACtB,MAAM,CAAC,KAAK,GAAG,MAAM,CAAC;wBACtB,MAAM,CAAC,GAAG,GAAG,MAAM,CAAC;wBACpB,MAAM,CAAC,MAAM,GAAG,CAAC,MAAM,CAAC;wBACxB,MAAM,OAAO,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;wBAC5D,MAAM,KAAK,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC;wBAC3D,MAAM,CAAC,IAAI,GAAG,GAAG,CAAC;wBAClB,MAAM,CAAC,GAAG,GAAG,KAAK,CAAC;wBACnB,MAAM,CAAC,sBAAsB,EAAE,CAAC;wBAChC,MAAM,CAAC,iBAAiB,EAAE,CAAC;wBAE3B,gCAAgC;wBAChC,MAAM,qBAAqB,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAC/C,CAAC,CAAC,GAAG,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC,CAC5D,CAAC;wBACF,MAAM,SAAS,GAAG,qBAAqB;6BAClC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;6BAC1C,YAAY,CAAC,qBAAqB,CAAC,MAAM,CAAC,CAAC;wBAChD,MAAM,OAAO,GACT,CAAC;4BACD,qBAAqB;iCAChB,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;iCAC5D,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;wBAC1C,KAAK,CAAC,KAAK,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;wBAC/B,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;wBAE/B,uCAAuC;wBAEvC,kBAAkB;wBAClB,eAAe,CAAC,UAAU,CAAC,KAAK,GAAG,cAAc,CAAC,UAAU,CAAC,KAAK,GAAG,MAAM,CAAC,kBAAkB,CAAC;wBAE/F,MAAM,iBAAiB,GAAG,GAAG,CAAC,uBAAuB,CACjD,GAAG,CAAC,gBAAgB,CAAC,MAAM,CAAC,gBAAgB,EAAE,MAAM,CAAC,kBAAkB,CAAC,CAC3E,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;wBAEZ,gBAAgB,CAAC,iBAAiB,GAAG,MAAM,CAAC,WAAW,CAAC;wBACxD,gBAAgB,CAAC,yBAAyB,GAAG,MAAM,CAAC,uBAAuB,CAAC;wBAC5E,gBAAgB,CAAC,QAAQ,GAAG,WAAW,CAAC;wBAExC,gBAAgB,CAAC,gBAAgB,GAAG,iBAAiB,CAAC,MAAM,CAAC;wBAC7D,gBAAgB,CAAC,kBAAkB,GAAG,iBAAiB,CAAC,QAAQ,CAAC;wBAEjE,gBAAgB,CAAC,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC;wBACpC,gBAAgB,CAAC,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC;wBAClC,gBAAgB,CAAC,UAAU,GAAG,UAAU,CAAC;wBACzC,gBAAgB,CAAC,IAAI,GAAG,MAAM,CAAC;wBAC/B,gBAAgB,CAAC,SAAS,GAAG,SAAS,CAAC;wBACvC,gBAAgB,CAAC,WAAW,GAAG,WAAW,CAAC;wBAE3C,sBAAsB;wBACtB,KAAK,CAAC,OAAO,GAAG,IAAI,CAAC;wBAErB,4BAA4B;wBAC5B,EAAE,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC;wBACjC,EAAE,CAAC,KAAK,EAAE,CAAC;wBACX,KAAK,CAAC,gBAAgB,GAAG,cAAc,CAAC;wBACxC,EAAE,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;wBAEzB,uCAAuC;wBACvC,EAAE,CAAC,eAAe,CAAC,aAAa,CAAC,CAAC;wBAClC,EAAE,CAAC,KAAK,EAAE,CAAC;wBACX,IAAI,QAAQ,EAAE;4BACV,KAAK,CAAC,gBAAgB,GAAG,eAAe,CAAC;4BACzC,EAAE,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;yBAC5B;wBAED,+BAA+B;wBAC/B,KAAK,CAAC,gBAAgB,GAAG,IAAI,CAAC;wBAE9B,6BAA6B;wBAC7B,gBAAgB,CAAC,GAAG,GAAG,GAAG,CAAC;wBAC1B,KAAK,CAAC,QAA2C,CAAC,eAAe,GAAG,MAAM,CAAC,gBAAgB,CAAC;wBAC5F,KAAK,CAAC,QAA2C,CAAC,eAAe,GAAG,MAAM,CAAC,kBAAkB,CAAC;wBAC/F,gBAAgB,CAAC,aAAa,GAAG,YAAY,CAAC,OAAO,CAAC;wBACtD,gBAAgB,CAAC,YAAY,GAAG,YAAY,CAAC,YAAY,CAAC;wBAC1D,EAAE,CAAC,eAAe,CAAC,cAAc,CAAC,CAAC;wBACnC,EAAE,CAAC,KAAK,EAAE,CAAC;wBACX,YAAY,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;wBAExB,wCAAwC;wBACxC,gBAAgB,CAAC,GAAG,GAAG,WAAW,CAAC;wBACnC,gBAAgB,CAAC,aAAa,GAAG,aAAa,CAAC,OAAO,CAAC;wBACvD,gBAAgB,CAAC,YAAY,GAAG,aAAa,CAAC,YAAY,CAAC;wBAC3D,EAAE,CAAC,eAAe,CAAC,eAAe,CAAC,CAAC;wBACpC,EAAE,CAAC,KAAK,EAAE,CAAC;wBACX,IAAI,QAAQ;4BAAE,YAAY,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;wBAEtC,sBAAsB;wBACtB,EAAE,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;wBAEzB,wDAAwD;wBACxD,IAAI,YAAY;4BAAE,KAAK,CAAC,OAAO,GAAG,KAAK,CAAC;qBAC3C;gBACL,CAAC,CAAC,CAAC;gBAEH,SAAS,CAAC,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;aAC1B;QACL,CAAC,CAAC,CAAC;IACP,CAAC;8GA3TQ,YAAY;kGAAZ,YAAY,gYA7BX;;;;;;;;;;;;;;;;;;;;;;;;;KAyBT,4DACS,IAAI,6FAAE,SAAS;;SAGhB,YAAY;2FAAZ,YAAY;kBAhCxB,SAAS;mBAAC;oBACP,QAAQ,EAAE,eAAe;oBACzB,UAAU,EAAE,IAAI;oBAChB,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;KAyBT;oBACD,OAAO,EAAE,CAAC,IAAI,EAAE,SAAS,CAAC;oBAC1B,OAAO,EAAE,CAAC,sBAAsB,CAAC;iBACpC;0EAWY,WAAW;sBAAnB,KAAK;gBAGO,MAAM;sBAAlB,KAAK;gBAIO,KAAK;sBAAjB,KAAK;gBAIO,YAAY;sBAAxB,KAAK;gBAIO,QAAQ;sBAApB,KAAK;gBAIO,GAAG;sBAAf,KAAK;gBAIO,WAAW;sBAAvB,KAAK;gBAIO,WAAW;sBAAvB,KAAK;gBAIO,SAAS;sBAArB,KAAK;gBAIO,KAAK;sBAAjB,KAAK;gBAIO,UAAU;sBAAtB,KAAK;gBAIO,WAAW;sBAAvB,KAAK","sourcesContent":["import { NgIf } from '@angular/common';\nimport { Component, computed, CUSTOM_ELEMENTS_SCHEMA, effect, ElementRef, inject, Input } from '@angular/core';\nimport { extend, injectNgtRef, NgtSignalStore, NgtStore, requestAnimationInInjectionContext } from 'angular-three';\nimport { NgtsEdges } from 'angular-three-soba/abstractions';\nimport { injectNgtsFBO } from 'angular-three-soba/misc';\nimport { CausticsMaterial, CausticsProjectionMaterial } from 'angular-three-soba/shaders';\nimport * as THREE from 'three';\nimport { Group, LineBasicMaterial, Mesh, OrthographicCamera, PlaneGeometry, Scene } from 'three';\nimport { FullScreenQuad } from 'three-stdlib';\n\nextend({ Group, Scene, Mesh, PlaneGeometry, OrthographicCamera, CausticsProjectionMaterial, LineBasicMaterial });\n\nconst NORMALPROPS = {\n    depth: true,\n    minFilter: THREE.LinearFilter,\n    magFilter: THREE.LinearFilter,\n    encoding: THREE.LinearEncoding,\n    type: THREE.UnsignedByteType,\n};\n\nconst CAUSTICPROPS = {\n    minFilter: THREE.LinearMipmapLinearFilter,\n    magFilter: THREE.LinearFilter,\n    encoding: THREE.LinearEncoding,\n    format: THREE.RGBAFormat,\n    type: THREE.FloatType,\n    generateMipmaps: true,\n};\n\ntype CausticsMaterialType = THREE.ShaderMaterial & {\n    cameraMatrixWorld?: THREE.Matrix4;\n    cameraProjectionMatrixInv?: THREE.Matrix4;\n    lightPlaneNormal?: THREE.Vector3;\n    lightPlaneConstant?: number;\n    normalTexture?: THREE.Texture | null;\n    depthTexture?: THREE.Texture | null;\n    lightDir?: THREE.Vector3;\n    near?: number;\n    far?: number;\n    modelMatrix?: THREE.Matrix4;\n    worldRadius?: number;\n    ior?: number;\n    bounces?: number;\n    resolution?: number;\n    size?: number;\n    intensity?: number;\n};\n\ntype CausticsProjectionMaterialType = THREE.MeshNormalMaterial & {\n    viewMatrix: { value?: THREE.Matrix4 };\n    color?: THREE.Color;\n    causticsTexture?: THREE.Texture;\n    causticsTextureB?: THREE.Texture;\n    lightProjMatrix?: THREE.Matrix4;\n    lightViewMatrix?: THREE.Matrix4;\n};\n\nfunction createNormalMaterial(side: THREE.Side = THREE.FrontSide) {\n    const viewMatrix = { value: new THREE.Matrix4() };\n    return Object.assign(new THREE.MeshNormalMaterial({ side }), {\n        viewMatrix,\n        onBeforeCompile: (shader: any) => {\n            shader.uniforms.viewMatrix = viewMatrix;\n            shader.fragmentShader =\n                `vec3 inverseTransformDirection( in vec3 dir, in mat4 matrix ) {\n           return normalize( ( vec4( dir, 0.0 ) * matrix ).xyz );\n         }\\n` +\n                shader.fragmentShader.replace(\n                    '#include <normal_fragment_maps>',\n                    `#include <normal_fragment_maps>\n           normal = inverseTransformDirection( normal, viewMatrix );\\n`\n                );\n        },\n    });\n}\n\nexport interface NgtsCausticsState {\n    /** How many frames it will render, set it to Infinity for runtime, default: 1 */\n    frames: number;\n    /** Enables visual cues to help you stage your scene, default: false */\n    debug: boolean;\n    /** Will display caustics only and skip the models, default: false */\n    causticsOnly: boolean;\n    /** Will include back faces and enable the backsideIOR prop, default: false */\n    backside: boolean;\n    /** The IOR refraction index, default: 1.1 */\n    ior: number;\n    /** The IOR refraction index for back faces (only available when backside is enabled), default: 1.1 */\n    backsideIOR: number;\n    /** The texel size, default: 0.3125 */\n    worldRadius: number;\n    /** Intensity of the prjected caustics, default: 0.05 */\n    intensity: number;\n    /** Caustics color, default: white */\n    color: THREE.ColorRepresentation;\n    /** Buffer resolution, default: 2048 */\n    resolution: number;\n    /** Camera position, it will point towards the contents bounds center, default: [5, 5, 5] */\n    lightSource: [x: number, y: number, z: number] | ElementRef<THREE.Object3D>;\n}\n\n@Component({\n    selector: 'ngts-caustics',\n    standalone: true,\n    template: `\n        <ngt-group [ref]=\"causticsRef\" ngtCompound>\n            <ngt-scene [ref]=\"sceneRef\">\n                <ngt-orthographic-camera [ref]=\"cameraRef\" [up]=\"[0, 1, 0]\" />\n                <ng-content />\n            </ngt-scene>\n            <ngt-mesh [renderOrder]=\"2\" [ref]=\"planeRef\" [rotation]=\"[-Math.PI / 2, 0, 0]\">\n                <ngt-plane-geometry />\n                <ngt-caustics-projection-material\n                    *ngIf=\"causticsTargetFbo() && causticsTargetBFbo()\"\n                    [transparent]=\"true\"\n                    [color]=\"causticsColor()\"\n                    [causticsTexture]=\"causticsTargetFbo().texture\"\n                    [causticsTextureB]=\"causticsTargetBFbo().texture\"\n                    [blending]=\"CustomBlending\"\n                    [blendSrc]=\"OneFactor\"\n                    [blendDst]=\"SrcAlphaFactor\"\n                    [depthWrite]=\"false\"\n                />\n\n                <ngts-edges *ngIf=\"causticsDebug()\" [withChildren]=\"true\">\n                    <ngt-line-basic-material color=\"#ffff00\" [toneMapped]=\"false\" />\n                </ngts-edges>\n            </ngt-mesh>\n        </ngt-group>\n    `,\n    imports: [NgIf, NgtsEdges],\n    schemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsCaustics extends NgtSignalStore<NgtsCausticsState> {\n    readonly CustomBlending = THREE.CustomBlending;\n    readonly OneFactor = THREE.OneFactor;\n    readonly SrcAlphaFactor = THREE.SrcAlphaFactor;\n    readonly Math = Math;\n\n    readonly planeRef = injectNgtRef<THREE.Mesh>();\n    readonly sceneRef = injectNgtRef<THREE.Scene>();\n    readonly cameraRef = injectNgtRef<THREE.OrthographicCamera>();\n\n    @Input() causticsRef = injectNgtRef<THREE.Group>();\n\n    /** How many frames it will render, set it to Infinity for runtime, default: 1 */\n    @Input() set frames(frames: number) {\n        this.set({ frames });\n    }\n    /** Enables visual cues to help you stage your scene, default: false */\n    @Input() set debug(debug: boolean) {\n        this.set({ debug });\n    }\n    /** Will display caustics only and skip the models, default: false */\n    @Input() set causticsOnly(causticsOnly: boolean) {\n        this.set({ causticsOnly });\n    }\n    /** Will include back faces and enable the backsideIOR prop, default: false */\n    @Input() set backside(backside: boolean) {\n        this.set({ backside });\n    }\n    /** The IOR refraction index, default: 1.1 */\n    @Input() set ior(ior: number) {\n        this.set({ ior });\n    }\n    /** The IOR refraction index for back faces (only available when backside is enabled), default: 1.1 */\n    @Input() set backsideIOR(backsideIOR: number) {\n        this.set({ backsideIOR });\n    }\n    /** The texel size, default: 0.3125 */\n    @Input() set worldRadius(worldRadius: number) {\n        this.set({ worldRadius });\n    }\n    /** Intensity of the prjected caustics, default: 0.05 */\n    @Input() set intensity(intensity: number) {\n        this.set({ intensity });\n    }\n    /** Caustics color, default: white */\n    @Input() set color(color: THREE.ColorRepresentation) {\n        this.set({ color });\n    }\n    /** Buffer resolution, default: 2048 */\n    @Input() set resolution(resolution: number) {\n        this.set({ resolution });\n    }\n    /** Camera position, it will point towards the contents bounds center, default: [5, 5, 5] */\n    @Input() set lightSource(lightSource: [x: number, y: number, z: number] | ElementRef<THREE.Object3D>) {\n        this.set({ lightSource });\n    }\n\n    readonly causticsColor = this.select('color');\n    readonly causticsDebug = this.select('debug');\n\n    readonly #resolution = this.select('resolution');\n\n    readonly #normalTargetSettings = computed(() => ({\n        width: this.#resolution(),\n        height: this.#resolution(),\n        settings: NORMALPROPS,\n    }));\n\n    readonly #causticsTargetSettings = computed(() => ({\n        width: this.#resolution(),\n        height: this.#resolution(),\n        settings: CAUSTICPROPS,\n    }));\n\n    readonly normalTargetFbo = injectNgtsFBO(this.#normalTargetSettings);\n    readonly normalTargetBFbo = injectNgtsFBO(this.#normalTargetSettings);\n    readonly causticsTargetFbo = injectNgtsFBO(this.#causticsTargetSettings);\n    readonly causticsTargetBFbo = injectNgtsFBO(this.#causticsTargetSettings);\n\n    readonly #store = inject(NgtStore);\n\n    constructor() {\n        super({\n            frames: 1,\n            ior: 1.1,\n            color: 'white',\n            causticsOnly: false,\n            backside: false,\n            backsideIOR: 1.1,\n            worldRadius: 0.3125,\n            intensity: 0.05,\n            resolution: 2024,\n            lightSource: [5, 5, 5],\n        });\n        requestAnimationInInjectionContext(() => {\n            this.#updateWorldMatrix();\n            this.#setBeforeRender();\n        });\n    }\n\n    #updateWorldMatrix() {\n        const trigger = computed(() => ({\n            sceneChildren: this.sceneRef.children()(),\n            caustics: this.causticsRef.nativeElement,\n            causticsChildren: this.causticsRef.children()(),\n            state: this.select()(),\n        }));\n\n        effect(() => {\n            const { caustics } = trigger();\n            if (!caustics) return;\n            caustics.updateWorldMatrix(false, true);\n        });\n    }\n\n    #setBeforeRender() {\n        const causticsMaterial = new CausticsMaterial() as CausticsMaterialType;\n        const causticsQuad = new FullScreenQuad(causticsMaterial);\n\n        const normalMaterial = createNormalMaterial();\n        const normalMaterialB = createNormalMaterial(THREE.BackSide);\n\n        const trigger = computed(() => ({\n            scene: this.sceneRef.nativeElement,\n            sceneChildren: this.sceneRef.children()(),\n            caustics: this.causticsRef.nativeElement,\n            camera: this.cameraRef.nativeElement,\n            normalTarget: this.normalTargetFbo(),\n            normalTargetB: this.normalTargetBFbo(),\n            causticsTarget: this.causticsTargetFbo(),\n            causticsTargetB: this.causticsTargetBFbo(),\n            plane: this.planeRef.nativeElement,\n            planeChildren: this.planeRef.children('both')(),\n        }));\n\n        effect((onCleanup) => {\n            const {\n                caustics,\n                sceneChildren,\n                scene,\n                camera,\n                plane,\n                normalTarget,\n                normalTargetB,\n                causticsTarget,\n                causticsTargetB,\n            } = trigger();\n            if (!caustics) return;\n            caustics.updateWorldMatrix(false, true);\n\n            if (sceneChildren.length > 1) {\n                const v = new THREE.Vector3();\n                const lpF = new THREE.Frustum();\n                const lpM = new THREE.Matrix4();\n                const lpP = new THREE.Plane();\n\n                const lightDir = new THREE.Vector3();\n                const lightDirInv = new THREE.Vector3();\n                const bounds = new THREE.Box3();\n                const focusPos = new THREE.Vector3();\n\n                let count = 0;\n                const sub = this.#store.get('internal').subscribe(({ gl }) => {\n                    const {\n                        frames,\n                        lightSource,\n                        resolution,\n                        worldRadius,\n                        intensity,\n                        backside,\n                        backsideIOR,\n                        ior,\n                        causticsOnly,\n                    } = this.get();\n\n                    if (frames === Infinity || count++ < frames) {\n                        if (Array.isArray(lightSource)) lightDir.fromArray(lightSource).normalize();\n                        else\n                            lightDir.copy(\n                                caustics.worldToLocal(lightSource.nativeElement.getWorldPosition(v)).normalize()\n                            );\n\n                        lightDirInv.copy(lightDir).multiplyScalar(-1);\n\n                        let boundsVertices: THREE.Vector3[] = [];\n                        scene.parent?.matrixWorld.identity();\n                        bounds.setFromObject(scene, true);\n                        boundsVertices.push(new THREE.Vector3(bounds.min.x, bounds.min.y, bounds.min.z));\n                        boundsVertices.push(new THREE.Vector3(bounds.min.x, bounds.min.y, bounds.max.z));\n                        boundsVertices.push(new THREE.Vector3(bounds.min.x, bounds.max.y, bounds.min.z));\n                        boundsVertices.push(new THREE.Vector3(bounds.min.x, bounds.max.y, bounds.max.z));\n                        boundsVertices.push(new THREE.Vector3(bounds.max.x, bounds.min.y, bounds.min.z));\n                        boundsVertices.push(new THREE.Vector3(bounds.max.x, bounds.min.y, bounds.max.z));\n                        boundsVertices.push(new THREE.Vector3(bounds.max.x, bounds.max.y, bounds.min.z));\n                        boundsVertices.push(new THREE.Vector3(bounds.max.x, bounds.max.y, bounds.max.z));\n\n                        const worldVerts = boundsVertices.map((v) => v.clone());\n\n                        bounds.getCenter(focusPos);\n                        boundsVertices = boundsVertices.map((v) => v.clone().sub(focusPos));\n                        const lightPlane = lpP.set(lightDirInv, 0);\n                        const projectedVerts = boundsVertices.map((v) =>\n                            lightPlane.projectPoint(v, new THREE.Vector3())\n                        );\n\n                        const centralVert = projectedVerts\n                            .reduce((a, b) => a.add(b), v.set(0, 0, 0))\n                            .divideScalar(projectedVerts.length);\n                        const radius = projectedVerts\n                            .map((v) => v.distanceTo(centralVert))\n                            .reduce((a, b) => Math.max(a, b));\n                        const dirLength = boundsVertices.map((x) => x.dot(lightDir)).reduce((a, b) => Math.max(a, b));\n\n                        // Shadows\n                        camera.position.copy(lightDir.clone().multiplyScalar(dirLength).add(focusPos));\n                        camera.lookAt(scene.localToWorld(focusPos.clone()));\n                        const dirMatrix = lpM.lookAt(camera.position, focusPos, v.set(0, 1, 0));\n                        camera.left = -radius;\n                        camera.right = radius;\n                        camera.top = radius;\n                        camera.bottom = -radius;\n                        const yOffset = v.set(0, radius, 0).applyMatrix4(dirMatrix);\n                        const yTime = (camera.position.y + yOffset.y) / lightDir.y;\n                        camera.near = 0.1;\n                        camera.far = yTime;\n                        camera.updateProjectionMatrix();\n                        camera.updateMatrixWorld();\n\n                        // Now find size of ground plane\n                        const groundProjectedCoords = worldVerts.map((v) =>\n                            v.add(lightDir.clone().multiplyScalar(-v.y / lightDir.y))\n                        );\n                        const centerPos = groundProjectedCoords\n                            .reduce((a, b) => a.add(b), v.set(0, 0, 0))\n                            .divideScalar(groundProjectedCoords.length);\n                        const maxSize =\n                            2 *\n                            groundProjectedCoords\n                                .map((v) => Math.hypot(v.x - centerPos.x, v.z - centerPos.z))\n                                .reduce((a, b) => Math.max(a, b));\n                        plane.scale.setScalar(maxSize);\n                        plane.position.copy(centerPos);\n\n                        // if (debug) helper.current?.update();\n\n                        // Inject uniforms\n                        normalMaterialB.viewMatrix.value = normalMaterial.viewMatrix.value = camera.matrixWorldInverse;\n\n                        const dirLightNearPlane = lpF.setFromProjectionMatrix(\n                            lpM.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse)\n                        ).planes[4];\n\n                        causticsMaterial.cameraMatrixWorld = camera.matrixWorld;\n                        causticsMaterial.cameraProjectionMatrixInv = camera.projectionMatrixInverse;\n                        causticsMaterial.lightDir = lightDirInv;\n\n                        causticsMaterial.lightPlaneNormal = dirLightNearPlane.normal;\n                        causticsMaterial.lightPlaneConstant = dirLightNearPlane.constant;\n\n                        causticsMaterial.near = camera.near;\n                        causticsMaterial.far = camera.far;\n                        causticsMaterial.resolution = resolution;\n                        causticsMaterial.size = radius;\n                        causticsMaterial.intensity = intensity;\n                        causticsMaterial.worldRadius = worldRadius;\n\n                        // Switch the scene on\n                        scene.visible = true;\n\n                        // Render front face normals\n                        gl.setRenderTarget(normalTarget);\n                        gl.clear();\n                        scene.overrideMaterial = normalMaterial;\n                        gl.render(scene, camera);\n\n                        // Render back face normals, if enabled\n                        gl.setRenderTarget(normalTargetB);\n                        gl.clear();\n                        if (backside) {\n                            scene.overrideMaterial = normalMaterialB;\n                            gl.render(scene, camera);\n                        }\n\n                        // Remove the override material\n                        scene.overrideMaterial = null;\n\n                        // Render front face caustics\n                        causticsMaterial.ior = ior;\n                        (plane.material as CausticsProjectionMaterialType).lightProjMatrix = camera.projectionMatrix;\n                        (plane.material as CausticsProjectionMaterialType).lightViewMatrix = camera.matrixWorldInverse;\n                        causticsMaterial.normalTexture = normalTarget.texture;\n                        causticsMaterial.depthTexture = normalTarget.depthTexture;\n                        gl.setRenderTarget(causticsTarget);\n                        gl.clear();\n                        causticsQuad.render(gl);\n\n                        // Render back face caustics, if enabled\n                        causticsMaterial.ior = backsideIOR;\n                        causticsMaterial.normalTexture = normalTargetB.texture;\n                        causticsMaterial.depthTexture = normalTargetB.depthTexture;\n                        gl.setRenderTarget(causticsTargetB);\n                        gl.clear();\n                        if (backside) causticsQuad.render(gl);\n\n                        // Reset render target\n                        gl.setRenderTarget(null);\n\n                        // Switch the scene off if caustics is all that's wanted\n                        if (causticsOnly) scene.visible = false;\n                    }\n                });\n\n                onCleanup(() => sub());\n            }\n        });\n    }\n}\n"]}