angular-three-soba 1.12.4 → 1.14.0

package/esm2022/materials/lib/mesh-reflector-material/mesh-reflector-material.mjs

@@ -0,0 +1,328 @@
+import { NgIf } from '@angular/common';
+import { Component, CUSTOM_ELEMENTS_SCHEMA, inject, Input } from '@angular/core';
+import { extend, getLocalState, injectBeforeRender, injectNgtRef, NgtArgs, NgtPush, NgtRxStore, NgtStore, startWithUndefined, } from 'angular-three';
+import { BlurPass, MeshReflectorMaterial } from 'angular-three-soba/shaders';
+import { combineLatest, debounceTime, map } from 'rxjs';
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+extend({ MeshReflectorMaterial });
+class NgtsMeshReflectorMaterial extends NgtRxStore {
+    set resolution(resolution) {
+        this.set({ resolution });
+    }
+    set mixBlur(mixBlur) {
+        this.set({ mixBlur });
+    }
+    set mixStrength(mixStrength) {
+        this.set({ mixStrength });
+    }
+    set blur(blur) {
+        this.set({ blur });
+    }
+    set mirror(mirror) {
+        this.set({ mirror });
+    }
+    set minDepthThreshold(minDepthThreshold) {
+        this.set({ minDepthThreshold });
+    }
+    set maxDepthThreshold(maxDepthThreshold) {
+        this.set({ maxDepthThreshold });
+    }
+    set depthScale(depthScale) {
+        this.set({ depthScale });
+    }
+    set depthToBlurRatioBias(depthToBlurRatioBias) {
+        this.set({ depthToBlurRatioBias });
+    }
+    set distortionMap(distortionMap) {
+        this.set({ distortionMap });
+    }
+    set distortion(distortion) {
+        this.set({ distortion });
+    }
+    set mixContrast(mixContrast) {
+        this.set({ mixContrast });
+    }
+    set reflectorOffset(reflectorOffset) {
+        this.set({ reflectorOffset });
+    }
+    get reflectorProps() {
+        return this.get('reflectorEntities', 'reflectorProps');
+    }
+    initialize() {
+        super.initialize();
+        this.set({
+            mixBlur: 0,
+            mixStrength: 1,
+            resolution: 256,
+            blur: [0, 0],
+            minDepthThreshold: 0.9,
+            maxDepthThreshold: 1,
+            depthScale: 0,
+            depthToBlurRatioBias: 0.25,
+            mirror: 0,
+            distortion: 1,
+            mixContrast: 1,
+            reflectorOffset: 0,
+        });
+    }
+    constructor() {
+        super();
+        this.materialRef = injectNgtRef();
+        this.defines$ = this.select('reflectorEntities', 'reflectorProps', 'defines').pipe(debounceTime(0));
+        this.store = inject(NgtStore);
+        this.reflectorPlane = new THREE.Plane();
+        this.normal = new THREE.Vector3();
+        this.reflectorWorldPosition = new THREE.Vector3();
+        this.cameraWorldPosition = new THREE.Vector3();
+        this.rotationMatrix = new THREE.Matrix4();
+        this.lookAtPosition = new THREE.Vector3(0, 0, -1);
+        this.clipPlane = new THREE.Vector4();
+        this.view = new THREE.Vector3();
+        this.target = new THREE.Vector3();
+        this.q = new THREE.Vector4();
+        this.textureMatrix = new THREE.Matrix4();
+        this.virtualCamera = new THREE.PerspectiveCamera();
+        this.connect('normalizedBlur', this.select('blur').pipe(map((blur) => (Array.isArray(blur) ? blur : [blur, blur]))));
+        this.connect('hasBlur', this.select('normalizedBlur').pipe(map(([x, y]) => x + y > 0)));
+        this.connect('reflectorEntities', combineLatest([
+            this.store.select('gl'),
+            this.select('normalizedBlur'),
+            this.select('resolution'),
+            this.select('mirror'),
+            this.select('hasBlur'),
+            this.select('mixBlur'),
+            this.select('mixStrength'),
+            this.select('minDepthThreshold'),
+            this.select('maxDepthThreshold'),
+            this.select('depthScale'),
+            this.select('depthToBlurRatioBias'),
+            this.select('distortion'),
+            this.select('distortionMap').pipe(startWithUndefined()),
+            this.select('mixContrast'),
+        ]).pipe(map(([gl, blur, resolution, mirror, hasBlur, mixBlur, mixStrength, minDepthThreshold, maxDepthThreshold, depthScale, depthToBlurRatioBias, distortion, distortionMap, mixContrast,]) => {
+            const parameters = {
+                minFilter: THREE.LinearFilter,
+                magFilter: THREE.LinearFilter,
+                encoding: gl.outputEncoding,
+                type: THREE.HalfFloatType,
+            };
+            const fbo1 = new THREE.WebGLRenderTarget(resolution, resolution, parameters);
+            fbo1.depthBuffer = true;
+            fbo1.depthTexture = new THREE.DepthTexture(resolution, resolution);
+            fbo1.depthTexture.format = THREE.DepthFormat;
+            fbo1.depthTexture.type = THREE.UnsignedShortType;
+            const fbo2 = new THREE.WebGLRenderTarget(resolution, resolution, parameters);
+            const blurPass = new BlurPass({
+                gl,
+                resolution,
+                width: blur[0],
+                height: blur[1],
+                minDepthThreshold,
+                maxDepthThreshold,
+                depthScale,
+                depthToBlurRatioBias,
+            });
+            const reflectorProps = {
+                mirror,
+                textureMatrix: this.textureMatrix,
+                mixBlur,
+                tDiffuse: fbo1.texture,
+                tDepth: fbo1.depthTexture,
+                tDiffuseBlur: fbo2.texture,
+                hasBlur,
+                mixStrength,
+                minDepthThreshold,
+                maxDepthThreshold,
+                depthScale,
+                depthToBlurRatioBias,
+                distortion,
+                distortionMap,
+                mixContrast,
+                defines: {
+                    USE_BLUR: hasBlur ? '' : undefined,
+                    USE_DEPTH: depthScale > 0 ? '' : undefined,
+                    USE_DISTORTION: distortionMap ? '' : undefined,
+                },
+            };
+            return { fbo1, fbo2, blurPass, reflectorProps };
+        })));
+        injectBeforeRender(this.onBeforeRender.bind(this));
+    }
+    beforeRender(state) {
+        const parent = getLocalState(this.materialRef.nativeElement).parent;
+        if (!parent)
+            return;
+        const { camera } = state;
+        this.reflectorWorldPosition.setFromMatrixPosition(parent.matrixWorld);
+        this.cameraWorldPosition.setFromMatrixPosition(camera.matrixWorld);
+        this.rotationMatrix.extractRotation(parent.matrixWorld);
+        this.normal.set(0, 0, 1);
+        this.normal.applyMatrix4(this.rotationMatrix);
+        this.reflectorWorldPosition.addScaledVector(this.normal, this.get('reflectorOffset'));
+        this.view.subVectors(this.reflectorWorldPosition, this.cameraWorldPosition);
+        // Avoid rendering when reflector is facing away
+        if (this.view.dot(this.normal) > 0)
+            return;
+        this.view.reflect(this.normal).negate();
+        this.view.add(this.reflectorWorldPosition);
+        this.rotationMatrix.extractRotation(camera.matrixWorld);
+        this.lookAtPosition.set(0, 0, -1);
+        this.lookAtPosition.applyMatrix4(this.rotationMatrix);
+        this.lookAtPosition.add(this.cameraWorldPosition);
+        this.target.subVectors(this.reflectorWorldPosition, this.lookAtPosition);
+        this.target.reflect(this.normal).negate();
+        this.target.add(this.reflectorWorldPosition);
+        this.virtualCamera.position.copy(this.view);
+        this.virtualCamera.up.set(0, 1, 0);
+        this.virtualCamera.up.applyMatrix4(this.rotationMatrix);
+        this.virtualCamera.up.reflect(this.normal);
+        this.virtualCamera.lookAt(this.target);
+        this.virtualCamera.far = camera.far; // Used in WebGLBackground
+        this.virtualCamera.updateMatrixWorld();
+        this.virtualCamera.projectionMatrix.copy(camera.projectionMatrix);
+        // Update the texture matrix
+        this.textureMatrix.set(0.5, 0.0, 0.0, 0.5, 0.0, 0.5, 0.0, 0.5, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 1.0);
+        this.textureMatrix.multiply(this.virtualCamera.projectionMatrix);
+        this.textureMatrix.multiply(this.virtualCamera.matrixWorldInverse);
+        this.textureMatrix.multiply(parent.matrixWorld);
+        // Now update projection matrix with new clip plane, implementing code from: http://www.terathon.com/code/oblique.html
+        // Paper explaining this technique: http://www.terathon.com/lengyel/Lengyel-Oblique.pdf
+        this.reflectorPlane.setFromNormalAndCoplanarPoint(this.normal, this.reflectorWorldPosition);
+        this.reflectorPlane.applyMatrix4(this.virtualCamera.matrixWorldInverse);
+        this.clipPlane.set(this.reflectorPlane.normal.x, this.reflectorPlane.normal.y, this.reflectorPlane.normal.z, this.reflectorPlane.constant);
+        const projectionMatrix = this.virtualCamera.projectionMatrix;
+        this.q.x = (Math.sign(this.clipPlane.x) + projectionMatrix.elements[8]) / projectionMatrix.elements[0];
+        this.q.y = (Math.sign(this.clipPlane.y) + projectionMatrix.elements[9]) / projectionMatrix.elements[5];
+        this.q.z = -1.0;
+        this.q.w = (1.0 + projectionMatrix.elements[10]) / projectionMatrix.elements[14];
+        // Calculate the scaled plane vector
+        this.clipPlane.multiplyScalar(2.0 / this.clipPlane.dot(this.q));
+        // Replacing the third row of the projection matrix
+        projectionMatrix.elements[2] = this.clipPlane.x;
+        projectionMatrix.elements[6] = this.clipPlane.y;
+        projectionMatrix.elements[10] = this.clipPlane.z + 1.0;
+        projectionMatrix.elements[14] = this.clipPlane.w;
+    }
+    onBeforeRender(state) {
+        if (!this.materialRef.nativeElement)
+            return;
+        const parent = getLocalState(this.materialRef.nativeElement).parent;
+        if (!parent)
+            return;
+        const { gl, scene } = state;
+        const { hasBlur } = this.get();
+        const { fbo1, fbo2, blurPass } = this.get('reflectorEntities');
+        if (fbo1 && fbo2 && blurPass) {
+            parent.visible = false;
+            const currentXrEnabled = gl.xr.enabled;
+            const currentShadowAutoUpdate = gl.shadowMap.autoUpdate;
+            this.beforeRender(state);
+            gl.xr.enabled = false;
+            gl.shadowMap.autoUpdate = false;
+            gl.setRenderTarget(fbo1);
+            gl.state.buffers.depth.setMask(true);
+            if (!gl.autoClear)
+                gl.clear();
+            gl.render(scene, this.virtualCamera);
+            if (hasBlur)
+                blurPass.render(gl, fbo1, fbo2);
+            gl.xr.enabled = currentXrEnabled;
+            gl.shadowMap.autoUpdate = currentShadowAutoUpdate;
+            parent.visible = true;
+            gl.setRenderTarget(null);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsMeshReflectorMaterial, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: NgtsMeshReflectorMaterial, isStandalone: true, selector: "ngts-mesh-reflector-material", inputs: { materialRef: "materialRef", resolution: "resolution", mixBlur: "mixBlur", mixStrength: "mixStrength", blur: "blur", mirror: "mirror", minDepthThreshold: "minDepthThreshold", maxDepthThreshold: "maxDepthThreshold", depthScale: "depthScale", depthToBlurRatioBias: "depthToBlurRatioBias", distortionMap: "distortionMap", distortion: "distortion", mixContrast: "mixContrast", reflectorOffset: "reflectorOffset" }, usesInheritance: true, ngImport: i0, template: `
+        <ngt-mesh-reflector-material
+            ngtCompound
+            attach="material"
+            *ngIf="defines$ | ngtPush as defines"
+            [ref]="materialRef"
+            [defines]="defines"
+            [mirror]="reflectorProps.mirror"
+            [textureMatrix]="reflectorProps.textureMatrix"
+            [mixBlur]="reflectorProps.mixBlur"
+            [tDiffuse]="reflectorProps.tDiffuse"
+            [tDepth]="reflectorProps.tDepth"
+            [tDiffuseBlur]="reflectorProps.tDiffuseBlur"
+            [hasBlur]="reflectorProps.hasBlur"
+            [mixStrength]="reflectorProps.mixStrength"
+            [minDepthThreshold]="reflectorProps.minDepthThreshold"
+            [maxDepthThreshold]="reflectorProps.maxDepthThreshold"
+            [depthScale]="reflectorProps.depthScale"
+            [depthToBlurRatioBias]="reflectorProps.depthToBlurRatioBias"
+            [distortion]="reflectorProps.distortion"
+            [distortionMap]="reflectorProps.distortionMap"
+            [mixContrast]="reflectorProps.mixContrast"
+        >
+            <ng-content />
+        </ngt-mesh-reflector-material>
+    `, isInline: true, dependencies: [{ kind: "pipe", type: NgtPush, name: "ngtPush" }, { kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] }); }
+}
+export { NgtsMeshReflectorMaterial };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsMeshReflectorMaterial, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-mesh-reflector-material',
+                    standalone: true,
+                    template: `
+        <ngt-mesh-reflector-material
+            ngtCompound
+            attach="material"
+            *ngIf="defines$ | ngtPush as defines"
+            [ref]="materialRef"
+            [defines]="defines"
+            [mirror]="reflectorProps.mirror"
+            [textureMatrix]="reflectorProps.textureMatrix"
+            [mixBlur]="reflectorProps.mixBlur"
+            [tDiffuse]="reflectorProps.tDiffuse"
+            [tDepth]="reflectorProps.tDepth"
+            [tDiffuseBlur]="reflectorProps.tDiffuseBlur"
+            [hasBlur]="reflectorProps.hasBlur"
+            [mixStrength]="reflectorProps.mixStrength"
+            [minDepthThreshold]="reflectorProps.minDepthThreshold"
+            [maxDepthThreshold]="reflectorProps.maxDepthThreshold"
+            [depthScale]="reflectorProps.depthScale"
+            [depthToBlurRatioBias]="reflectorProps.depthToBlurRatioBias"
+            [distortion]="reflectorProps.distortion"
+            [distortionMap]="reflectorProps.distortionMap"
+            [mixContrast]="reflectorProps.mixContrast"
+        >
+            <ng-content />
+        </ngt-mesh-reflector-material>
+    `,
+                    imports: [NgtArgs, NgtPush, NgIf],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { materialRef: [{
+                type: Input
+            }], resolution: [{
+                type: Input
+            }], mixBlur: [{
+                type: Input
+            }], mixStrength: [{
+                type: Input
+            }], blur: [{
+                type: Input
+            }], mirror: [{
+                type: Input
+            }], minDepthThreshold: [{
+                type: Input
+            }], maxDepthThreshold: [{
+                type: Input
+            }], depthScale: [{
+                type: Input
+            }], depthToBlurRatioBias: [{
+                type: Input
+            }], distortionMap: [{
+                type: Input
+            }], distortion: [{
+                type: Input
+            }], mixContrast: [{
+                type: Input
+            }], reflectorOffset: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mesh-reflector-material.js","sourceRoot":"","sources":["../../../../../../../libs/angular-three-soba/materials/src/lib/mesh-reflector-material/mesh-reflector-material.ts"],"names":[],"mappings":"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","sourcesContent":["import { NgIf } from '@angular/common';\nimport { Component, CUSTOM_ELEMENTS_SCHEMA, inject, Input } from '@angular/core';\nimport {\n    extend,\n    getLocalState,\n    injectBeforeRender,\n    injectNgtRef,\n    NgtArgs,\n    NgtPush,\n    NgtRenderState,\n    NgtRxStore,\n    NgtStore,\n    startWithUndefined,\n} from 'angular-three';\nimport { BlurPass, MeshReflectorMaterial } from 'angular-three-soba/shaders';\nimport { combineLatest, debounceTime, map } from 'rxjs';\nimport * as THREE from 'three';\n\nextend({ MeshReflectorMaterial });\n\n@Component({\n    selector: 'ngts-mesh-reflector-material',\n    standalone: true,\n    template: `\n        <ngt-mesh-reflector-material\n            ngtCompound\n            attach=\"material\"\n            *ngIf=\"defines$ | ngtPush as defines\"\n            [ref]=\"materialRef\"\n            [defines]=\"defines\"\n            [mirror]=\"reflectorProps.mirror\"\n            [textureMatrix]=\"reflectorProps.textureMatrix\"\n            [mixBlur]=\"reflectorProps.mixBlur\"\n            [tDiffuse]=\"reflectorProps.tDiffuse\"\n            [tDepth]=\"reflectorProps.tDepth\"\n            [tDiffuseBlur]=\"reflectorProps.tDiffuseBlur\"\n            [hasBlur]=\"reflectorProps.hasBlur\"\n            [mixStrength]=\"reflectorProps.mixStrength\"\n            [minDepthThreshold]=\"reflectorProps.minDepthThreshold\"\n            [maxDepthThreshold]=\"reflectorProps.maxDepthThreshold\"\n            [depthScale]=\"reflectorProps.depthScale\"\n            [depthToBlurRatioBias]=\"reflectorProps.depthToBlurRatioBias\"\n            [distortion]=\"reflectorProps.distortion\"\n            [distortionMap]=\"reflectorProps.distortionMap\"\n            [mixContrast]=\"reflectorProps.mixContrast\"\n        >\n            <ng-content />\n        </ngt-mesh-reflector-material>\n    `,\n    imports: [NgtArgs, NgtPush, NgIf],\n    schemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsMeshReflectorMaterial extends NgtRxStore {\n    @Input() materialRef = injectNgtRef<MeshReflectorMaterial>();\n\n    @Input() set resolution(resolution: number) {\n        this.set({ resolution });\n    }\n\n    @Input() set mixBlur(mixBlur: number) {\n        this.set({ mixBlur });\n    }\n\n    @Input() set mixStrength(mixStrength: number) {\n        this.set({ mixStrength });\n    }\n\n    @Input() set blur(blur: [number, number] | number) {\n        this.set({ blur });\n    }\n\n    @Input() set mirror(mirror: number) {\n        this.set({ mirror });\n    }\n\n    @Input() set minDepthThreshold(minDepthThreshold: number) {\n        this.set({ minDepthThreshold });\n    }\n\n    @Input() set maxDepthThreshold(maxDepthThreshold: number) {\n        this.set({ maxDepthThreshold });\n    }\n\n    @Input() set depthScale(depthScale: number) {\n        this.set({ depthScale });\n    }\n\n    @Input() set depthToBlurRatioBias(depthToBlurRatioBias: number) {\n        this.set({ depthToBlurRatioBias });\n    }\n\n    @Input() set distortionMap(distortionMap: THREE.Texture) {\n        this.set({ distortionMap });\n    }\n\n    @Input() set distortion(distortion: number) {\n        this.set({ distortion });\n    }\n\n    @Input() set mixContrast(mixContrast: number) {\n        this.set({ mixContrast });\n    }\n\n    @Input() set reflectorOffset(reflectorOffset: number) {\n        this.set({ reflectorOffset });\n    }\n\n    readonly defines$ = this.select('reflectorEntities', 'reflectorProps', 'defines').pipe(debounceTime(0));\n\n    get reflectorProps() {\n        return this.get('reflectorEntities', 'reflectorProps');\n    }\n\n    private readonly store = inject(NgtStore);\n\n    private readonly reflectorPlane = new THREE.Plane();\n    private readonly normal = new THREE.Vector3();\n    private readonly reflectorWorldPosition = new THREE.Vector3();\n    private readonly cameraWorldPosition = new THREE.Vector3();\n    private readonly rotationMatrix = new THREE.Matrix4();\n    private readonly lookAtPosition = new THREE.Vector3(0, 0, -1);\n    private readonly clipPlane = new THREE.Vector4();\n    private readonly view = new THREE.Vector3();\n    private readonly target = new THREE.Vector3();\n    private readonly q = new THREE.Vector4();\n    private readonly textureMatrix = new THREE.Matrix4();\n    private readonly virtualCamera = new THREE.PerspectiveCamera();\n\n    override initialize(): void {\n        super.initialize();\n        this.set({\n            mixBlur: 0,\n            mixStrength: 1,\n            resolution: 256,\n            blur: [0, 0],\n            minDepthThreshold: 0.9,\n            maxDepthThreshold: 1,\n            depthScale: 0,\n            depthToBlurRatioBias: 0.25,\n            mirror: 0,\n            distortion: 1,\n            mixContrast: 1,\n            reflectorOffset: 0,\n        });\n    }\n\n    constructor() {\n        super();\n\n        this.connect(\n            'normalizedBlur',\n            this.select('blur').pipe(map((blur) => (Array.isArray(blur) ? blur : [blur, blur])))\n        );\n        this.connect('hasBlur', this.select('normalizedBlur').pipe(map(([x, y]) => x + y > 0)));\n        this.connect(\n            'reflectorEntities',\n            combineLatest([\n                this.store.select('gl'),\n                this.select('normalizedBlur'),\n                this.select('resolution'),\n                this.select('mirror'),\n                this.select('hasBlur'),\n                this.select('mixBlur'),\n                this.select('mixStrength'),\n                this.select('minDepthThreshold'),\n                this.select('maxDepthThreshold'),\n                this.select('depthScale'),\n                this.select('depthToBlurRatioBias'),\n                this.select('distortion'),\n                this.select('distortionMap').pipe(startWithUndefined()),\n                this.select('mixContrast'),\n            ]).pipe(\n                map(\n                    ([\n                        gl,\n                        blur,\n                        resolution,\n                        mirror,\n                        hasBlur,\n                        mixBlur,\n                        mixStrength,\n                        minDepthThreshold,\n                        maxDepthThreshold,\n                        depthScale,\n                        depthToBlurRatioBias,\n                        distortion,\n                        distortionMap,\n                        mixContrast,\n                    ]) => {\n                        const parameters = {\n                            minFilter: THREE.LinearFilter,\n                            magFilter: THREE.LinearFilter,\n                            encoding: gl.outputEncoding,\n                            type: THREE.HalfFloatType,\n                        };\n                        const fbo1 = new THREE.WebGLRenderTarget(resolution, resolution, parameters);\n                        fbo1.depthBuffer = true;\n                        fbo1.depthTexture = new THREE.DepthTexture(resolution, resolution);\n                        fbo1.depthTexture.format = THREE.DepthFormat;\n                        fbo1.depthTexture.type = THREE.UnsignedShortType;\n\n                        const fbo2 = new THREE.WebGLRenderTarget(resolution, resolution, parameters);\n                        const blurPass = new BlurPass({\n                            gl,\n                            resolution,\n                            width: blur[0],\n                            height: blur[1],\n                            minDepthThreshold,\n                            maxDepthThreshold,\n                            depthScale,\n                            depthToBlurRatioBias,\n                        });\n                        const reflectorProps = {\n                            mirror,\n                            textureMatrix: this.textureMatrix,\n                            mixBlur,\n                            tDiffuse: fbo1.texture,\n                            tDepth: fbo1.depthTexture,\n                            tDiffuseBlur: fbo2.texture,\n                            hasBlur,\n                            mixStrength,\n                            minDepthThreshold,\n                            maxDepthThreshold,\n                            depthScale,\n                            depthToBlurRatioBias,\n                            distortion,\n                            distortionMap,\n                            mixContrast,\n                            defines: {\n                                USE_BLUR: hasBlur ? '' : undefined,\n                                USE_DEPTH: depthScale > 0 ? '' : undefined,\n                                USE_DISTORTION: distortionMap ? '' : undefined,\n                            },\n                        };\n\n                        return { fbo1, fbo2, blurPass, reflectorProps };\n                    }\n                )\n            )\n        );\n\n        injectBeforeRender(this.onBeforeRender.bind(this));\n    }\n\n    private beforeRender(state: NgtRenderState) {\n        const parent = getLocalState(this.materialRef.nativeElement).parent;\n        if (!parent) return;\n\n        const { camera } = state;\n\n        this.reflectorWorldPosition.setFromMatrixPosition(parent.matrixWorld);\n        this.cameraWorldPosition.setFromMatrixPosition(camera.matrixWorld);\n        this.rotationMatrix.extractRotation(parent.matrixWorld);\n        this.normal.set(0, 0, 1);\n        this.normal.applyMatrix4(this.rotationMatrix);\n        this.reflectorWorldPosition.addScaledVector(this.normal, this.get('reflectorOffset'));\n        this.view.subVectors(this.reflectorWorldPosition, this.cameraWorldPosition);\n        // Avoid rendering when reflector is facing away\n        if (this.view.dot(this.normal) > 0) return;\n        this.view.reflect(this.normal).negate();\n        this.view.add(this.reflectorWorldPosition);\n        this.rotationMatrix.extractRotation(camera.matrixWorld);\n        this.lookAtPosition.set(0, 0, -1);\n        this.lookAtPosition.applyMatrix4(this.rotationMatrix);\n        this.lookAtPosition.add(this.cameraWorldPosition);\n        this.target.subVectors(this.reflectorWorldPosition, this.lookAtPosition);\n        this.target.reflect(this.normal).negate();\n        this.target.add(this.reflectorWorldPosition);\n        this.virtualCamera.position.copy(this.view);\n        this.virtualCamera.up.set(0, 1, 0);\n        this.virtualCamera.up.applyMatrix4(this.rotationMatrix);\n        this.virtualCamera.up.reflect(this.normal);\n        this.virtualCamera.lookAt(this.target);\n        this.virtualCamera.far = camera.far; // Used in WebGLBackground\n        this.virtualCamera.updateMatrixWorld();\n        this.virtualCamera.projectionMatrix.copy(camera.projectionMatrix);\n        // Update the texture matrix\n        this.textureMatrix.set(0.5, 0.0, 0.0, 0.5, 0.0, 0.5, 0.0, 0.5, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 1.0);\n        this.textureMatrix.multiply(this.virtualCamera.projectionMatrix);\n        this.textureMatrix.multiply(this.virtualCamera.matrixWorldInverse);\n        this.textureMatrix.multiply(parent.matrixWorld);\n        // Now update projection matrix with new clip plane, implementing code from: http://www.terathon.com/code/oblique.html\n        // Paper explaining this technique: http://www.terathon.com/lengyel/Lengyel-Oblique.pdf\n        this.reflectorPlane.setFromNormalAndCoplanarPoint(this.normal, this.reflectorWorldPosition);\n        this.reflectorPlane.applyMatrix4(this.virtualCamera.matrixWorldInverse);\n        this.clipPlane.set(\n            this.reflectorPlane.normal.x,\n            this.reflectorPlane.normal.y,\n            this.reflectorPlane.normal.z,\n            this.reflectorPlane.constant\n        );\n        const projectionMatrix = this.virtualCamera.projectionMatrix;\n        this.q.x = (Math.sign(this.clipPlane.x) + projectionMatrix.elements[8]) / projectionMatrix.elements[0];\n        this.q.y = (Math.sign(this.clipPlane.y) + projectionMatrix.elements[9]) / projectionMatrix.elements[5];\n        this.q.z = -1.0;\n        this.q.w = (1.0 + projectionMatrix.elements[10]) / projectionMatrix.elements[14];\n        // Calculate the scaled plane vector\n        this.clipPlane.multiplyScalar(2.0 / this.clipPlane.dot(this.q));\n        // Replacing the third row of the projection matrix\n        projectionMatrix.elements[2] = this.clipPlane.x;\n        projectionMatrix.elements[6] = this.clipPlane.y;\n        projectionMatrix.elements[10] = this.clipPlane.z + 1.0;\n        projectionMatrix.elements[14] = this.clipPlane.w;\n    }\n\n    private onBeforeRender(state: NgtRenderState) {\n        if (!this.materialRef.nativeElement) return;\n        const parent = getLocalState(this.materialRef.nativeElement).parent;\n        if (!parent) return;\n\n        const { gl, scene } = state;\n        const { hasBlur } = this.get();\n        const { fbo1, fbo2, blurPass } = this.get('reflectorEntities');\n\n        if (fbo1 && fbo2 && blurPass) {\n            parent.visible = false;\n            const currentXrEnabled = gl.xr.enabled;\n            const currentShadowAutoUpdate = gl.shadowMap.autoUpdate;\n            this.beforeRender(state);\n            gl.xr.enabled = false;\n            gl.shadowMap.autoUpdate = false;\n            gl.setRenderTarget(fbo1);\n            gl.state.buffers.depth.setMask(true);\n            if (!gl.autoClear) gl.clear();\n            gl.render(scene, this.virtualCamera);\n            if (hasBlur) blurPass.render(gl, fbo1, fbo2);\n            gl.xr.enabled = currentXrEnabled;\n            gl.shadowMap.autoUpdate = currentShadowAutoUpdate;\n            parent.visible = true;\n            gl.setRenderTarget(null);\n        }\n    }\n}\n"]}

package/esm2022/materials/lib/mesh-refraction-material/mesh-refraction-material.mjs

@@ -0,0 +1,158 @@
+import { NgIf } from '@angular/common';
+import { Component, CUSTOM_ELEMENTS_SCHEMA, inject, Input } from '@angular/core';
+import { extend, getLocalState, injectBeforeRender, injectNgtRef, NgtPush, NgtRxStore, NgtStore } from 'angular-three';
+import { MeshRefractionMaterial } from 'angular-three-soba/shaders';
+import { combineLatest, map } from 'rxjs';
+import { MeshBVH, SAH } from 'three-mesh-bvh';
+import * as i0 from "@angular/core";
+extend({ MeshRefractionMaterial });
+const isCubeTexture = (def) => def && def.isCubeTexture;
+class NgtsMeshRefractionMaterial extends NgtRxStore {
+    /** Environment map */
+    set envMap(envMap) {
+        this.set({ envMap });
+    }
+    /** Number of ray-cast bounces, it can be expensive to have too many, 2 */
+    set bounces(bounces) {
+        this.set({ bounces });
+    }
+    /** Refraction index, 2.4 */
+    set ior(ior) {
+        this.set({ ior });
+    }
+    /** Fresnel (strip light), 0 */
+    set fresnel(fresnel) {
+        this.set({ fresnel });
+    }
+    /** RGB shift intensity, can be expensive, 0 */
+    set aberrationStrength(aberrationStrength) {
+        this.set({ aberrationStrength });
+    }
+    /** Color, white */
+    set color(color) {
+        this.set({ color });
+    }
+    /** If this is on it uses fewer ray casts for the RGB shift sacrificing physical accuracy, true */
+    set fastChroma(fastChroma) {
+        this.set({ fastChroma });
+    }
+    initialize() {
+        super.initialize();
+        this.set({
+            aberrationStrength: 0,
+            fastChroma: true,
+        });
+    }
+    constructor() {
+        super();
+        this.materialRef = injectNgtRef();
+        this.defines$ = this.select('defines');
+        this.store = inject(NgtStore);
+        this.connect('defines', combineLatest([this.select('aberrationStrength'), this.select('fastChroma'), this.select('envMap')]).pipe(map(([aberrationStrength, fastChroma, envMap]) => {
+            const temp = {};
+            // Sampler2D and SamplerCube need different defines
+            const isCubeMap = isCubeTexture(envMap);
+            const w = (isCubeMap ? envMap.image[0]?.width : envMap.image.width) ?? 1024;
+            const cubeSize = w / 4;
+            const _lodMax = Math.floor(Math.log2(cubeSize));
+            const _cubeSize = Math.pow(2, _lodMax);
+            const width = 3 * Math.max(_cubeSize, 16 * 7);
+            const height = 4 * _cubeSize;
+            if (isCubeMap)
+                temp['ENVMAP_TYPE_CUBEM'] = '';
+            temp['CUBEUV_TEXEL_WIDTH'] = `${1.0 / width}`;
+            temp['CUBEUV_TEXEL_HEIGHT'] = `${1.0 / height}`;
+            temp['CUBEUV_MAX_MIP'] = `${_lodMax}.0`;
+            // Add defines from chromatic aberration
+            if (aberrationStrength > 0)
+                temp['CHROMATIC_ABERRATIONS'] = '';
+            if (fastChroma)
+                temp['FAST_CHROMA'] = '';
+            return temp;
+        })));
+        this.connect('resolution', this.store.select('size').pipe(map((size) => [size.width, size.height])));
+        injectBeforeRender(({ camera }) => {
+            if (this.materialRef.nativeElement) {
+                this.materialRef.nativeElement.viewMatrixInverse = camera.matrixWorld;
+                this.materialRef.nativeElement.projectionMatrixInverse = camera.projectionMatrixInverse;
+            }
+        });
+    }
+    ngOnInit() {
+        this.setupGeometry();
+    }
+    setupGeometry() {
+        this.hold(this.materialRef.$, (material) => {
+            const geometry = getLocalState(material).parent?.geometry;
+            if (geometry) {
+                material.bvh.updateFrom(new MeshBVH(geometry.toNonIndexed(), { lazyGeneration: false, strategy: SAH }));
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsMeshRefractionMaterial, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: NgtsMeshRefractionMaterial, isStandalone: true, selector: "ngts-mesh-refraction-material", inputs: { materialRef: "materialRef", envMap: "envMap", bounces: "bounces", ior: "ior", fresnel: "fresnel", aberrationStrength: "aberrationStrength", color: "color", fastChroma: "fastChroma" }, usesInheritance: true, ngImport: i0, template: `
+        <ngt-mesh-refraction-material
+            *ngIf="defines$ | ngtPush as defines"
+            [ref]="materialRef"
+            [defines]="defines"
+            [resolution]="get('resolution')"
+            [aberrationStrength]="get('aberrationStrength')"
+            [envMap]="get('envMap')"
+            [bounces]="get('bounces')"
+            [ior]="get('ior')"
+            [fresnel]="get('fresnel')"
+            [color]="get('color')"
+            [fastChroma]="get('fastChroma')"
+            ngtCompound
+            attach="material"
+        >
+            <ng-content />
+        </ngt-mesh-refraction-material>
+    `, isInline: true, dependencies: [{ kind: "pipe", type: NgtPush, name: "ngtPush" }, { kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] }); }
+}
+export { NgtsMeshRefractionMaterial };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsMeshRefractionMaterial, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-mesh-refraction-material',
+                    standalone: true,
+                    template: `
+        <ngt-mesh-refraction-material
+            *ngIf="defines$ | ngtPush as defines"
+            [ref]="materialRef"
+            [defines]="defines"
+            [resolution]="get('resolution')"
+            [aberrationStrength]="get('aberrationStrength')"
+            [envMap]="get('envMap')"
+            [bounces]="get('bounces')"
+            [ior]="get('ior')"
+            [fresnel]="get('fresnel')"
+            [color]="get('color')"
+            [fastChroma]="get('fastChroma')"
+            ngtCompound
+            attach="material"
+        >
+            <ng-content />
+        </ngt-mesh-refraction-material>
+    `,
+                    imports: [NgtPush, NgIf],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { materialRef: [{
+                type: Input
+            }], envMap: [{
+                type: Input
+            }], bounces: [{
+                type: Input
+            }], ior: [{
+                type: Input
+            }], fresnel: [{
+                type: Input
+            }], aberrationStrength: [{
+                type: Input
+            }], color: [{
+                type: Input
+            }], fastChroma: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mesh-refraction-material.js","sourceRoot":"","sources":["../../../../../../../libs/angular-three-soba/materials/src/lib/mesh-refraction-material/mesh-refraction-material.ts"],"names":[],"mappings":"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","sourcesContent":["import { NgIf } from '@angular/common';\nimport { Component, CUSTOM_ELEMENTS_SCHEMA, inject, Input, OnInit } from '@angular/core';\nimport { extend, getLocalState, injectBeforeRender, injectNgtRef, NgtPush, NgtRxStore, NgtStore } from 'angular-three';\nimport { MeshRefractionMaterial } from 'angular-three-soba/shaders';\nimport { combineLatest, map } from 'rxjs';\nimport { MeshBVH, SAH } from 'three-mesh-bvh';\n\nextend({ MeshRefractionMaterial });\n\nconst isCubeTexture = (def: THREE.CubeTexture | THREE.Texture): def is THREE.CubeTexture =>\n    def && (def as THREE.CubeTexture).isCubeTexture;\n\n@Component({\n    selector: 'ngts-mesh-refraction-material',\n    standalone: true,\n    template: `\n        <ngt-mesh-refraction-material\n            *ngIf=\"defines$ | ngtPush as defines\"\n            [ref]=\"materialRef\"\n            [defines]=\"defines\"\n            [resolution]=\"get('resolution')\"\n            [aberrationStrength]=\"get('aberrationStrength')\"\n            [envMap]=\"get('envMap')\"\n            [bounces]=\"get('bounces')\"\n            [ior]=\"get('ior')\"\n            [fresnel]=\"get('fresnel')\"\n            [color]=\"get('color')\"\n            [fastChroma]=\"get('fastChroma')\"\n            ngtCompound\n            attach=\"material\"\n        >\n            <ng-content />\n        </ngt-mesh-refraction-material>\n    `,\n    imports: [NgtPush, NgIf],\n    schemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsMeshRefractionMaterial extends NgtRxStore implements OnInit {\n    @Input() materialRef = injectNgtRef<InstanceType<typeof MeshRefractionMaterial>>();\n    /** Environment map */\n    @Input() set envMap(envMap: THREE.CubeTexture | THREE.Texture) {\n        this.set({ envMap });\n    }\n    /** Number of ray-cast bounces, it can be expensive to have too many, 2 */\n    @Input() set bounces(bounces: number) {\n        this.set({ bounces });\n    }\n    /** Refraction index, 2.4 */\n    @Input() set ior(ior: number) {\n        this.set({ ior });\n    }\n    /** Fresnel (strip light), 0 */\n    @Input() set fresnel(fresnel: number) {\n        this.set({ fresnel });\n    }\n    /** RGB shift intensity, can be expensive, 0 */\n    @Input() set aberrationStrength(aberrationStrength: number) {\n        this.set({ aberrationStrength });\n    }\n    /** Color, white */\n    @Input() set color(color: THREE.ColorRepresentation) {\n        this.set({ color });\n    }\n    /** If this is on it uses fewer ray casts for the RGB shift sacrificing physical accuracy, true */\n    @Input() set fastChroma(fastChroma: boolean) {\n        this.set({ fastChroma });\n    }\n\n    readonly defines$ = this.select('defines');\n\n    private readonly store = inject(NgtStore);\n\n    override initialize(): void {\n        super.initialize();\n        this.set({\n            aberrationStrength: 0,\n            fastChroma: true,\n        });\n    }\n\n    constructor() {\n        super();\n        this.connect(\n            'defines',\n            combineLatest([this.select('aberrationStrength'), this.select('fastChroma'), this.select('envMap')]).pipe(\n                map(([aberrationStrength, fastChroma, envMap]) => {\n                    const temp = {} as { [key: string]: string };\n                    // Sampler2D and SamplerCube need different defines\n                    const isCubeMap = isCubeTexture(envMap);\n                    const w = (isCubeMap ? envMap.image[0]?.width : envMap.image.width) ?? 1024;\n                    const cubeSize = w / 4;\n                    const _lodMax = Math.floor(Math.log2(cubeSize));\n                    const _cubeSize = Math.pow(2, _lodMax);\n                    const width = 3 * Math.max(_cubeSize, 16 * 7);\n                    const height = 4 * _cubeSize;\n                    if (isCubeMap) temp['ENVMAP_TYPE_CUBEM'] = '';\n                    temp['CUBEUV_TEXEL_WIDTH'] = `${1.0 / width}`;\n                    temp['CUBEUV_TEXEL_HEIGHT'] = `${1.0 / height}`;\n                    temp['CUBEUV_MAX_MIP'] = `${_lodMax}.0`;\n                    // Add defines from chromatic aberration\n                    if (aberrationStrength > 0) temp['CHROMATIC_ABERRATIONS'] = '';\n                    if (fastChroma) temp['FAST_CHROMA'] = '';\n                    return temp;\n                })\n            )\n        );\n        this.connect('resolution', this.store.select('size').pipe(map((size) => [size.width, size.height])));\n\n        injectBeforeRender(({ camera }) => {\n            if (this.materialRef.nativeElement) {\n                (this.materialRef.nativeElement as any)!.viewMatrixInverse = camera.matrixWorld;\n                (this.materialRef.nativeElement as any)!.projectionMatrixInverse = camera.projectionMatrixInverse;\n            }\n        });\n    }\n\n    ngOnInit() {\n        this.setupGeometry();\n    }\n\n    private setupGeometry() {\n        this.hold(this.materialRef.$, (material) => {\n            const geometry = getLocalState(material).parent?.geometry;\n            if (geometry) {\n                (material as any).bvh.updateFrom(\n                    new MeshBVH(geometry.toNonIndexed(), { lazyGeneration: false, strategy: SAH } as any)\n                );\n            }\n        });\n    }\n}\n"]}