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

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

@@ -0,0 +1,383 @@
+import { NgIf } from '@angular/common';
+import { Component, computed, CUSTOM_ELEMENTS_SCHEMA, inject, Input } from '@angular/core';
+import { extend, getLocalState, injectBeforeRender, injectNgtRef, NgtArgs, NgtSignalStore, NgtStore, } from 'angular-three';
+import { BlurPass, MeshReflectorMaterial } from 'angular-three-soba/shaders';
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+extend({ MeshReflectorMaterial });
+class NgtsMeshReflectorMaterial extends NgtSignalStore {
+    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 });
+    }
+    #store;
+    #gl;
+    #reflectorPlane;
+    #normal;
+    #reflectorWorldPosition;
+    #cameraWorldPosition;
+    #rotationMatrix;
+    #lookAtPosition;
+    #clipPlane;
+    #view;
+    #target;
+    #q;
+    #textureMatrix;
+    #virtualCamera;
+    #blur;
+    #resolution;
+    #mirror;
+    #mixBlur;
+    #mixStrength;
+    #minDepthThreshold;
+    #maxDepthThreshold;
+    #depthScale;
+    #depthToBlurRatioBias;
+    #distortion;
+    #distortionMap;
+    #mixContrast;
+    #normalizedBlur;
+    #hasBlur;
+    #reflectorEntities;
+    constructor() {
+        super({
+            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,
+        });
+        this.materialRef = injectNgtRef();
+        this.reflectorProps = computed(() => this.#reflectorEntities().reflectorProps);
+        this.defines = computed(() => this.reflectorProps().defines);
+        this.reflectorMirror = computed(() => this.reflectorProps().mirror);
+        this.reflectorTextureMatrix = computed(() => this.reflectorProps().textureMatrix);
+        this.reflectorMixBlur = computed(() => this.reflectorProps().mixBlur);
+        this.reflectorTDiffuse = computed(() => this.reflectorProps().tDiffuse);
+        this.reflectorTDepth = computed(() => this.reflectorProps().tDepth);
+        this.reflectorTDiffuseBlur = computed(() => this.reflectorProps().tDiffuseBlur);
+        this.reflectorHasBlur = computed(() => this.reflectorProps().hasBlur);
+        this.reflectorMixStrength = computed(() => this.reflectorProps().mixStrength);
+        this.reflectorMinDepthThreshold = computed(() => this.reflectorProps().minDepthThreshold);
+        this.reflectorMaxDepthThreshold = computed(() => this.reflectorProps().maxDepthThreshold);
+        this.reflectorDepthScale = computed(() => this.reflectorProps().depthScale);
+        this.reflectorDepthToBlurRatioBias = computed(() => this.reflectorProps().depthToBlurRatioBias);
+        this.reflectorDistortion = computed(() => this.reflectorProps().distortion);
+        this.reflectorDistortionMap = computed(() => this.reflectorProps().distortionMap);
+        this.reflectorMixContrast = computed(() => this.reflectorProps().mixContrast);
+        this.#store = inject(NgtStore);
+        this.#gl = this.#store.select('gl');
+        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.#blur = this.select('blur');
+        this.#resolution = this.select('resolution');
+        this.#mirror = this.select('mirror');
+        this.#mixBlur = this.select('mixBlur');
+        this.#mixStrength = this.select('mixStrength');
+        this.#minDepthThreshold = this.select('minDepthThreshold');
+        this.#maxDepthThreshold = this.select('maxDepthThreshold');
+        this.#depthScale = this.select('depthScale');
+        this.#depthToBlurRatioBias = this.select('depthToBlurRatioBias');
+        this.#distortion = this.select('distortion');
+        this.#distortionMap = this.select('distortionMap');
+        this.#mixContrast = this.select('mixContrast');
+        this.#normalizedBlur = computed(() => {
+            const blur = this.#blur();
+            return Array.isArray(blur) ? blur : [blur, blur];
+        });
+        this.#hasBlur = computed(() => {
+            const [x, y] = this.#normalizedBlur();
+            return x + y > 0;
+        });
+        this.#reflectorEntities = computed(() => {
+            const gl = this.#gl();
+            const resolution = this.#resolution();
+            const blur = this.#normalizedBlur();
+            const minDepthThreshold = this.#minDepthThreshold();
+            const maxDepthThreshold = this.#maxDepthThreshold();
+            const depthScale = this.#depthScale();
+            const depthToBlurRatioBias = this.#depthToBlurRatioBias();
+            const mirror = this.#mirror();
+            const mixBlur = this.#mixBlur();
+            const mixStrength = this.#mixStrength();
+            const mixContrast = this.#mixContrast();
+            const distortion = this.#distortion();
+            const distortionMap = this.#distortionMap();
+            const hasBlur = this.#hasBlur();
+            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));
+    }
+    #onBeforeRender(state) {
+        if (!this.materialRef.nativeElement)
+            return;
+        const parent = getLocalState(this.materialRef.nativeElement).parent();
+        if (!parent)
+            return;
+        const { gl, scene } = state;
+        const hasBlur = this.#hasBlur();
+        const { fbo1, fbo2, blurPass } = this.#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);
+        }
+    }
+    #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;
+    }
+    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()"
+            [ref]="materialRef"
+            [defines]="defines()"
+            [mirror]="reflectorMirror()"
+            [textureMatrix]="reflectorTextureMatrix()"
+            [mixBlur]="reflectorMixBlur()"
+            [tDiffuse]="reflectorTDiffuse()"
+            [tDepth]="reflectorTDepth()"
+            [tDiffuseBlur]="reflectorTDiffuseBlur()"
+            [hasBlur]="reflectorHasBlur()"
+            [mixStrength]="reflectorMixStrength()"
+            [minDepthThreshold]="reflectorMinDepthThreshold()"
+            [maxDepthThreshold]="reflectorMaxDepthThreshold()"
+            [depthScale]="reflectorDepthScale()"
+            [depthToBlurRatioBias]="reflectorDepthToBlurRatioBias()"
+            [distortion]="reflectorDistortion()"
+            [distortionMap]="reflectorDistortionMap()"
+            [mixContrast]="reflectorMixContrast()"
+        >
+            <ng-content />
+        </ngt-mesh-reflector-material>
+    `, isInline: true, dependencies: [{ 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()"
+            [ref]="materialRef"
+            [defines]="defines()"
+            [mirror]="reflectorMirror()"
+            [textureMatrix]="reflectorTextureMatrix()"
+            [mixBlur]="reflectorMixBlur()"
+            [tDiffuse]="reflectorTDiffuse()"
+            [tDepth]="reflectorTDepth()"
+            [tDiffuseBlur]="reflectorTDiffuseBlur()"
+            [hasBlur]="reflectorHasBlur()"
+            [mixStrength]="reflectorMixStrength()"
+            [minDepthThreshold]="reflectorMinDepthThreshold()"
+            [maxDepthThreshold]="reflectorMaxDepthThreshold()"
+            [depthScale]="reflectorDepthScale()"
+            [depthToBlurRatioBias]="reflectorDepthToBlurRatioBias()"
+            [distortion]="reflectorDistortion()"
+            [distortionMap]="reflectorDistortionMap()"
+            [mixContrast]="reflectorMixContrast()"
+        >
+            <ng-content />
+        </ngt-mesh-reflector-material>
+    `,
+                    imports: [NgtArgs, 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/soba/materials/src/mesh-reflector-material/mesh-reflector-material.ts"],"names":[],"mappings":"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","sourcesContent":["import { NgIf } from '@angular/common';\nimport { Component, computed, CUSTOM_ELEMENTS_SCHEMA, inject, Input } from '@angular/core';\nimport {\n    extend,\n    getLocalState,\n    injectBeforeRender,\n    injectNgtRef,\n    NgtArgs,\n    NgtRenderState,\n    NgtSignalStore,\n    NgtStore,\n} from 'angular-three';\nimport { BlurPass, MeshReflectorMaterial } from 'angular-three-soba/shaders';\nimport * as THREE from 'three';\n\nextend({ MeshReflectorMaterial });\n\nexport interface NgtsMeshReflectorMaterialState {\n    resolution: number;\n    mixBlur: number;\n    mixStrength: number;\n    blur: [number, number] | number;\n    mirror: number;\n    minDepthThreshold: number;\n    maxDepthThreshold: number;\n    depthScale: number;\n    depthToBlurRatioBias: number;\n    distortionMap?: THREE.Texture;\n    distortion: number;\n    mixContrast: number;\n    reflectorOffset: number;\n}\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()\"\n            [ref]=\"materialRef\"\n            [defines]=\"defines()\"\n            [mirror]=\"reflectorMirror()\"\n            [textureMatrix]=\"reflectorTextureMatrix()\"\n            [mixBlur]=\"reflectorMixBlur()\"\n            [tDiffuse]=\"reflectorTDiffuse()\"\n            [tDepth]=\"reflectorTDepth()\"\n            [tDiffuseBlur]=\"reflectorTDiffuseBlur()\"\n            [hasBlur]=\"reflectorHasBlur()\"\n            [mixStrength]=\"reflectorMixStrength()\"\n            [minDepthThreshold]=\"reflectorMinDepthThreshold()\"\n            [maxDepthThreshold]=\"reflectorMaxDepthThreshold()\"\n            [depthScale]=\"reflectorDepthScale()\"\n            [depthToBlurRatioBias]=\"reflectorDepthToBlurRatioBias()\"\n            [distortion]=\"reflectorDistortion()\"\n            [distortionMap]=\"reflectorDistortionMap()\"\n            [mixContrast]=\"reflectorMixContrast()\"\n        >\n            <ng-content />\n        </ngt-mesh-reflector-material>\n    `,\n    imports: [NgtArgs, NgIf],\n    schemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsMeshReflectorMaterial extends NgtSignalStore<NgtsMeshReflectorMaterialState> {\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 reflectorProps = computed(() => this.#reflectorEntities().reflectorProps);\n    readonly defines = computed(() => this.reflectorProps().defines);\n    readonly reflectorMirror = computed(() => this.reflectorProps().mirror);\n    readonly reflectorTextureMatrix = computed(() => this.reflectorProps().textureMatrix);\n    readonly reflectorMixBlur = computed(() => this.reflectorProps().mixBlur);\n    readonly reflectorTDiffuse = computed(() => this.reflectorProps().tDiffuse);\n    readonly reflectorTDepth = computed(() => this.reflectorProps().tDepth);\n    readonly reflectorTDiffuseBlur = computed(() => this.reflectorProps().tDiffuseBlur);\n    readonly reflectorHasBlur = computed(() => this.reflectorProps().hasBlur);\n    readonly reflectorMixStrength = computed(() => this.reflectorProps().mixStrength);\n    readonly reflectorMinDepthThreshold = computed(() => this.reflectorProps().minDepthThreshold);\n    readonly reflectorMaxDepthThreshold = computed(() => this.reflectorProps().maxDepthThreshold);\n    readonly reflectorDepthScale = computed(() => this.reflectorProps().depthScale);\n    readonly reflectorDepthToBlurRatioBias = computed(() => this.reflectorProps().depthToBlurRatioBias);\n    readonly reflectorDistortion = computed(() => this.reflectorProps().distortion);\n    readonly reflectorDistortionMap = computed(() => this.reflectorProps().distortionMap);\n    readonly reflectorMixContrast = computed(() => this.reflectorProps().mixContrast);\n\n    readonly #store = inject(NgtStore);\n    readonly #gl = this.#store.select('gl');\n\n    readonly #reflectorPlane = new THREE.Plane();\n    readonly #normal = new THREE.Vector3();\n    readonly #reflectorWorldPosition = new THREE.Vector3();\n    readonly #cameraWorldPosition = new THREE.Vector3();\n    readonly #rotationMatrix = new THREE.Matrix4();\n    readonly #lookAtPosition = new THREE.Vector3(0, 0, -1);\n    readonly #clipPlane = new THREE.Vector4();\n    readonly #view = new THREE.Vector3();\n    readonly #target = new THREE.Vector3();\n    readonly #q = new THREE.Vector4();\n    readonly #textureMatrix = new THREE.Matrix4();\n    readonly #virtualCamera = new THREE.PerspectiveCamera();\n\n    readonly #blur = this.select('blur');\n    readonly #resolution = this.select('resolution');\n    readonly #mirror = this.select('mirror');\n    readonly #mixBlur = this.select('mixBlur');\n    readonly #mixStrength = this.select('mixStrength');\n    readonly #minDepthThreshold = this.select('minDepthThreshold');\n    readonly #maxDepthThreshold = this.select('maxDepthThreshold');\n    readonly #depthScale = this.select('depthScale');\n    readonly #depthToBlurRatioBias = this.select('depthToBlurRatioBias');\n    readonly #distortion = this.select('distortion');\n    readonly #distortionMap = this.select('distortionMap');\n    readonly #mixContrast = this.select('mixContrast');\n\n    readonly #normalizedBlur = computed(() => {\n        const blur = this.#blur();\n        return Array.isArray(blur) ? blur : [blur, blur];\n    });\n\n    readonly #hasBlur = computed(() => {\n        const [x, y] = this.#normalizedBlur();\n        return x + y > 0;\n    });\n\n    readonly #reflectorEntities = computed(() => {\n        const gl = this.#gl();\n        const resolution = this.#resolution();\n        const blur = this.#normalizedBlur();\n        const minDepthThreshold = this.#minDepthThreshold();\n        const maxDepthThreshold = this.#maxDepthThreshold();\n        const depthScale = this.#depthScale();\n        const depthToBlurRatioBias = this.#depthToBlurRatioBias();\n        const mirror = this.#mirror();\n        const mixBlur = this.#mixBlur();\n        const mixStrength = this.#mixStrength();\n        const mixContrast = this.#mixContrast();\n        const distortion = this.#distortion();\n        const distortionMap = this.#distortionMap();\n        const hasBlur = this.#hasBlur();\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    constructor() {\n        super({\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        injectBeforeRender(this.#onBeforeRender.bind(this));\n    }\n\n    #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.#hasBlur();\n        const { fbo1, fbo2, blurPass } = this.#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    #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"]}

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

@@ -0,0 +1,168 @@
+import { NgIf } from '@angular/common';
+import { Component, computed, CUSTOM_ELEMENTS_SCHEMA, effect, inject, Input } from '@angular/core';
+import { extend, getLocalState, injectBeforeRender, injectNgtRef, NgtSignalStore, NgtStore } from 'angular-three';
+import { MeshRefractionMaterial } from 'angular-three-soba/shaders';
+import { MeshBVH, SAH } from 'three-mesh-bvh';
+import * as i0 from "@angular/core";
+extend({ MeshRefractionMaterial });
+const isCubeTexture = (def) => def && def.isCubeTexture;
+class NgtsMeshRefractionMaterial extends NgtSignalStore {
+    /** 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 });
+    }
+    #store;
+    #size;
+    #envMap;
+    constructor() {
+        super({ aberrationStrength: 0, fastChroma: true });
+        this.materialRef = injectNgtRef();
+        this.refractionEnvMap = this.select('envMap');
+        this.refractionBounces = this.select('bounces');
+        this.refractionIor = this.select('ior');
+        this.refractionFresnel = this.select('fresnel');
+        this.refractionAberrationStrength = this.select('aberrationStrength');
+        this.refractionColor = this.select('color');
+        this.refractionFastChroma = this.select('fastChroma');
+        this.#store = inject(NgtStore);
+        this.#size = this.#store.select('size');
+        this.#envMap = this.select('envMap');
+        this.defines = computed(() => {
+            const envMap = this.#envMap();
+            if (!envMap)
+                return null;
+            const aberrationStrength = this.refractionAberrationStrength();
+            const fastChroma = this.refractionFastChroma();
+            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.resolution = computed(() => [this.#size().width, this.#size().height]);
+        injectBeforeRender(({ camera }) => {
+            if (this.materialRef.nativeElement) {
+                this.materialRef.nativeElement.viewMatrixInverse = camera.matrixWorld;
+                this.materialRef.nativeElement.projectionMatrixInverse = camera.projectionMatrixInverse;
+            }
+        });
+        this.#setupGeometry();
+    }
+    #setupGeometry() {
+        effect(() => {
+            const material = this.materialRef.nativeElement;
+            if (!material)
+                return;
+            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() as defines"
+            [ref]="materialRef"
+            [defines]="defines"
+            [resolution]="resolution()"
+            [aberrationStrength]="refractionAberrationStrength()"
+            [envMap]="refractionEnvMap()"
+            [bounces]="refractionBounces()"
+            [ior]="refractionIor()"
+            [fresnel]="refractionFresnel()"
+            [color]="refractionColor()"
+            [fastChroma]="refractionFastChroma()"
+            ngtCompound
+            attach="material"
+        >
+            <ng-content />
+        </ngt-mesh-refraction-material>
+    `, isInline: true, dependencies: [{ 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() as defines"
+            [ref]="materialRef"
+            [defines]="defines"
+            [resolution]="resolution()"
+            [aberrationStrength]="refractionAberrationStrength()"
+            [envMap]="refractionEnvMap()"
+            [bounces]="refractionBounces()"
+            [ior]="refractionIor()"
+            [fresnel]="refractionFresnel()"
+            [color]="refractionColor()"
+            [fastChroma]="refractionFastChroma()"
+            ngtCompound
+            attach="material"
+        >
+            <ng-content />
+        </ngt-mesh-refraction-material>
+    `,
+                    imports: [NgIf],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { materialRef: [{
+                type: Input
+            }], envMap: [{
+                type: Input,
+                args: [{ required: true }]
+            }], 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/soba/materials/src/mesh-refraction-material/mesh-refraction-material.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACvC,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,sBAAsB,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AACnG,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,kBAAkB,EAAE,YAAY,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAClH,OAAO,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AACpE,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;;AAE9C,MAAM,CAAC,EAAE,sBAAsB,EAAE,CAAC,CAAC;AAmBnC,MAAM,aAAa,GAAG,CAAC,GAAsC,EAA4B,EAAE,CACvF,GAAG,IAAK,GAAyB,CAAC,aAAa,CAAC;AAEpD,MAyBa,0BAA2B,SAAQ,cAA+C;IAE3F,sBAAsB;IACtB,IAA+B,MAAM,CAAC,MAAyC;QAC3E,IAAI,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC;IACzB,CAAC;IACD,0EAA0E;IAC1E,IAAa,OAAO,CAAC,OAAe;QAChC,IAAI,CAAC,GAAG,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC;IAC1B,CAAC;IACD,4BAA4B;IAC5B,IAAa,GAAG,CAAC,GAAW;QACxB,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC;IACtB,CAAC;IACD,+BAA+B;IAC/B,IAAa,OAAO,CAAC,OAAe;QAChC,IAAI,CAAC,GAAG,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC;IAC1B,CAAC;IACD,+CAA+C;IAC/C,IAAa,kBAAkB,CAAC,kBAA0B;QACtD,IAAI,CAAC,GAAG,CAAC,EAAE,kBAAkB,EAAE,CAAC,CAAC;IACrC,CAAC;IACD,mBAAmB;IACnB,IAAa,KAAK,CAAC,KAAgC;QAC/C,IAAI,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;IACxB,CAAC;IACD,kGAAkG;IAClG,IAAa,UAAU,CAAC,UAAmB;QACvC,IAAI,CAAC,GAAG,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC;IAC7B,CAAC;IAUQ,MAAM,CAAoB;IAC1B,KAAK,CAA8B;IAEnC,OAAO,CAAyB;IA6BzC;QACI,KAAK,CAAC,EAAE,kBAAkB,EAAE,CAAC,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC;QAvE9C,gBAAW,GAAG,YAAY,EAA+C,CAAC;QA8B1E,qBAAgB,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QACzC,sBAAiB,GAAG,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;QAC3C,kBAAa,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QACnC,sBAAiB,GAAG,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;QAC3C,iCAA4B,GAAG,IAAI,CAAC,MAAM,CAAC,oBAAoB,CAAC,CAAC;QACjE,oBAAe,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QACvC,yBAAoB,GAAG,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;QAEjD,WAAM,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;QAC1B,UAAK,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAEnC,YAAO,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAEhC,YAAO,GAAG,QAAQ,CAAC,GAAG,EAAE;YAC7B,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;YAC9B,IAAI,CAAC,MAAM;gBAAE,OAAO,IAAI,CAAC;YAEzB,MAAM,kBAAkB,GAAG,IAAI,CAAC,4BAA4B,EAAE,CAAC;YAC/D,MAAM,UAAU,GAAG,IAAI,CAAC,oBAAoB,EAAE,CAAC;YAE/C,MAAM,IAAI,GAAG,EAA+B,CAAC;YAC7C,mDAAmD;YACnD,MAAM,SAAS,GAAG,aAAa,CAAC,MAAM,CAAC,CAAC;YACxC,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC;YAC5E,MAAM,QAAQ,GAAG,CAAC,GAAG,CAAC,CAAC;YACvB,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;YAChD,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;YACvC,MAAM,KAAK,GAAG,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,EAAE,GAAG,CAAC,CAAC,CAAC;YAC9C,MAAM,MAAM,GAAG,CAAC,GAAG,SAAS,CAAC;YAC7B,IAAI,SAAS;gBAAE,IAAI,CAAC,mBAAmB,CAAC,GAAG,EAAE,CAAC;YAC9C,IAAI,CAAC,oBAAoB,CAAC,GAAG,GAAG,GAAG,GAAG,KAAK,EAAE,CAAC;YAC9C,IAAI,CAAC,qBAAqB,CAAC,GAAG,GAAG,GAAG,GAAG,MAAM,EAAE,CAAC;YAChD,IAAI,CAAC,gBAAgB,CAAC,GAAG,GAAG,OAAO,IAAI,CAAC;YACxC,wCAAwC;YACxC,IAAI,kBAAkB,GAAG,CAAC;gBAAE,IAAI,CAAC,uBAAuB,CAAC,GAAG,EAAE,CAAC;YAC/D,IAAI,UAAU;gBAAE,IAAI,CAAC,aAAa,CAAC,GAAG,EAAE,CAAC;YACzC,OAAO,IAAI,CAAC;QAChB,CAAC,CAAC,CAAC;QACM,eAAU,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC;QAI5E,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE;YAC9B,IAAI,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE;gBAC/B,IAAI,CAAC,WAAW,CAAC,aAAsB,CAAC,iBAAiB,GAAG,MAAM,CAAC,WAAW,CAAC;gBAC/E,IAAI,CAAC,WAAW,CAAC,aAAsB,CAAC,uBAAuB,GAAG,MAAM,CAAC,uBAAuB,CAAC;aACrG;QACL,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,cAAc,EAAE,CAAC;IAC1B,CAAC;IAED,cAAc;QACV,MAAM,CAAC,GAAG,EAAE;YACR,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC;YAChD,IAAI,CAAC,QAAQ;gBAAE,OAAO;YACtB,MAAM,QAAQ,GAAG,aAAa,CAAC,QAAQ,CAAC,CAAC,MAAM,EAAE,EAAE,QAAQ,CAAC;YAC5D,IAAI,QAAQ,EAAE;gBACT,QAAgB,CAAC,GAAG,CAAC,UAAU,CAC5B,IAAI,OAAO,CAAC,QAAQ,CAAC,YAAY,EAAE,EAAE,EAAE,cAAc,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,EAAS,CAAC,CACxF,CAAC;aACL;QACL,CAAC,CAAC,CAAC;IACP,CAAC;8GA7FQ,0BAA0B;kGAA1B,0BAA0B,kTAtBzB;;;;;;;;;;;;;;;;;;KAkBT,4DACS,IAAI;;SAGL,0BAA0B;2FAA1B,0BAA0B;kBAzBtC,SAAS;mBAAC;oBACP,QAAQ,EAAE,+BAA+B;oBACzC,UAAU,EAAE,IAAI;oBAChB,QAAQ,EAAE;;;;;;;;;;;;;;;;;;KAkBT;oBACD,OAAO,EAAE,CAAC,IAAI,CAAC;oBACf,OAAO,EAAE,CAAC,sBAAsB,CAAC;iBACpC;0EAEY,WAAW;sBAAnB,KAAK;gBAEyB,MAAM;sBAApC,KAAK;uBAAC,EAAE,QAAQ,EAAE,IAAI,EAAE;gBAIZ,OAAO;sBAAnB,KAAK;gBAIO,GAAG;sBAAf,KAAK;gBAIO,OAAO;sBAAnB,KAAK;gBAIO,kBAAkB;sBAA9B,KAAK;gBAIO,KAAK;sBAAjB,KAAK;gBAIO,UAAU;sBAAtB,KAAK","sourcesContent":["import { NgIf } from '@angular/common';\nimport { Component, computed, CUSTOM_ELEMENTS_SCHEMA, effect, inject, Input } from '@angular/core';\nimport { extend, getLocalState, injectBeforeRender, injectNgtRef, NgtSignalStore, NgtStore } from 'angular-three';\nimport { MeshRefractionMaterial } from 'angular-three-soba/shaders';\nimport { MeshBVH, SAH } from 'three-mesh-bvh';\n\nextend({ MeshRefractionMaterial });\n\nexport interface NgtsMeshRefractionMaterialState {\n    /** Environment map */\n    envMap: THREE.CubeTexture | THREE.Texture;\n    /** Number of ray-cast bounces, it can be expensive to have too many, 2 */\n    bounces: number;\n    /** Refraction index, 2.4 */\n    ior: number;\n    /** Fresnel (strip light), 0 */\n    fresnel: number;\n    /** RGB shift intensity, can be expensive, 0 */\n    aberrationStrength: number;\n    /** Color, white */\n    color: THREE.ColorRepresentation;\n    /** If this is on it uses fewer ray casts for the RGB shift sacrificing physical accuracy, true */\n    fastChroma: boolean;\n}\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() as defines\"\n            [ref]=\"materialRef\"\n            [defines]=\"defines\"\n            [resolution]=\"resolution()\"\n            [aberrationStrength]=\"refractionAberrationStrength()\"\n            [envMap]=\"refractionEnvMap()\"\n            [bounces]=\"refractionBounces()\"\n            [ior]=\"refractionIor()\"\n            [fresnel]=\"refractionFresnel()\"\n            [color]=\"refractionColor()\"\n            [fastChroma]=\"refractionFastChroma()\"\n            ngtCompound\n            attach=\"material\"\n        >\n            <ng-content />\n        </ngt-mesh-refraction-material>\n    `,\n    imports: [NgIf],\n    schemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsMeshRefractionMaterial extends NgtSignalStore<NgtsMeshRefractionMaterialState> {\n    @Input() materialRef = injectNgtRef<InstanceType<typeof MeshRefractionMaterial>>();\n    /** Environment map */\n    @Input({ required: true }) 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 refractionEnvMap = this.select('envMap');\n    readonly refractionBounces = this.select('bounces');\n    readonly refractionIor = this.select('ior');\n    readonly refractionFresnel = this.select('fresnel');\n    readonly refractionAberrationStrength = this.select('aberrationStrength');\n    readonly refractionColor = this.select('color');\n    readonly refractionFastChroma = this.select('fastChroma');\n\n    readonly #store = inject(NgtStore);\n    readonly #size = this.#store.select('size');\n\n    readonly #envMap = this.select('envMap');\n\n    readonly defines = computed(() => {\n        const envMap = this.#envMap();\n        if (!envMap) return null;\n\n        const aberrationStrength = this.refractionAberrationStrength();\n        const fastChroma = this.refractionFastChroma();\n\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    readonly resolution = computed(() => [this.#size().width, this.#size().height]);\n\n    constructor() {\n        super({ aberrationStrength: 0, fastChroma: true });\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        this.#setupGeometry();\n    }\n\n    #setupGeometry() {\n        effect(() => {\n            const material = this.materialRef.nativeElement;\n            if (!material) return;\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"]}