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

package/esm2022/shaders/caustics-material/caustics-projection-material.mjs

@@ -0,0 +1,33 @@
+import * as THREE from 'three';
+import { shaderMaterial } from '../shader-material/shader-material';
+export const CausticsProjectionMaterial = shaderMaterial({
+    causticsTexture: null,
+    causticsTextureB: null,
+    color: new THREE.Color(),
+    lightProjMatrix: new THREE.Matrix4(),
+    lightViewMatrix: new THREE.Matrix4(),
+}, 
+/* glsl */ `varying vec3 vWorldPosition;
+void main() {
+  gl_Position = projectionMatrix * viewMatrix * modelMatrix * vec4(position, 1.);
+  vec4 worldPosition = modelMatrix * vec4(position, 1.);
+  vWorldPosition = worldPosition.xyz;
+}`, 
+/* glsl */ `varying vec3 vWorldPosition;
+uniform vec3 color;
+uniform sampler2D causticsTexture;
+uniform sampler2D causticsTextureB;
+uniform mat4 lightProjMatrix;
+uniform mat4 lightViewMatrix;
+ void main() {
+  // Apply caustics
+  vec4 lightSpacePos = lightProjMatrix * lightViewMatrix * vec4(vWorldPosition, 1.0);
+  lightSpacePos.xyz /= lightSpacePos.w;
+  lightSpacePos.xyz = lightSpacePos.xyz * 0.5 + 0.5;
+  vec3 front = texture2D(causticsTexture, lightSpacePos.xy).rgb;
+  vec3 back = texture2D(causticsTextureB, lightSpacePos.xy).rgb;
+  gl_FragColor = vec4((front + back) * color, 1.0);
+  #include <tonemapping_fragment>
+  #include <encodings_fragment>
+}`);
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/shaders/convolution-material/convolution-material.mjs

@@ -0,0 +1,94 @@
+import { NoBlending, ShaderMaterial, Uniform, Vector2 } from 'three';
+export class ConvolutionMaterial extends ShaderMaterial {
+    constructor(texelSize = new Vector2()) {
+        super({
+            uniforms: {
+                inputBuffer: new Uniform(null),
+                depthBuffer: new Uniform(null),
+                resolution: new Uniform(new Vector2()),
+                texelSize: new Uniform(new Vector2()),
+                halfTexelSize: new Uniform(new Vector2()),
+                kernel: new Uniform(0.0),
+                scale: new Uniform(1.0),
+                cameraNear: new Uniform(0.0),
+                cameraFar: new Uniform(1.0),
+                minDepthThreshold: new Uniform(0.0),
+                maxDepthThreshold: new Uniform(1.0),
+                depthScale: new Uniform(0.0),
+                depthToBlurRatioBias: new Uniform(0.25),
+            },
+            fragmentShader: `#include <common>
+        #include <dithering_pars_fragment>
+        uniform sampler2D inputBuffer;
+        uniform sampler2D depthBuffer;
+        uniform float cameraNear;
+        uniform float cameraFar;
+        uniform float minDepthThreshold;
+        uniform float maxDepthThreshold;
+        uniform float depthScale;
+        uniform float depthToBlurRatioBias;
+        varying vec2 vUv;
+        varying vec2 vUv0;
+        varying vec2 vUv1;
+        varying vec2 vUv2;
+        varying vec2 vUv3;
+
+        void main() {
+          float depthFactor = 0.0;
+
+          #ifdef USE_DEPTH
+            vec4 depth = texture2D(depthBuffer, vUv);
+            depthFactor = smoothstep(minDepthThreshold, maxDepthThreshold, 1.0-(depth.r * depth.a));
+            depthFactor *= depthScale;
+            depthFactor = max(0.0, min(1.0, depthFactor + 0.25));
+          #endif
+
+          vec4 sum = texture2D(inputBuffer, mix(vUv0, vUv, depthFactor));
+          sum += texture2D(inputBuffer, mix(vUv1, vUv, depthFactor));
+          sum += texture2D(inputBuffer, mix(vUv2, vUv, depthFactor));
+          sum += texture2D(inputBuffer, mix(vUv3, vUv, depthFactor));
+          gl_FragColor = sum * 0.25 ;
+
+          #include <dithering_fragment>
+          #include <tonemapping_fragment>
+          #include <encodings_fragment>
+        }`,
+            vertexShader: `uniform vec2 texelSize;
+        uniform vec2 halfTexelSize;
+        uniform float kernel;
+        uniform float scale;
+        varying vec2 vUv;
+        varying vec2 vUv0;
+        varying vec2 vUv1;
+        varying vec2 vUv2;
+        varying vec2 vUv3;
+
+        void main() {
+          vec2 uv = position.xy * 0.5 + 0.5;
+          vUv = uv;
+
+          vec2 dUv = (texelSize * vec2(kernel) + halfTexelSize) * scale;
+          vUv0 = vec2(uv.x - dUv.x, uv.y + dUv.y);
+          vUv1 = vec2(uv.x + dUv.x, uv.y + dUv.y);
+          vUv2 = vec2(uv.x + dUv.x, uv.y - dUv.y);
+          vUv3 = vec2(uv.x - dUv.x, uv.y - dUv.y);
+
+          gl_Position = vec4(position.xy, 1.0, 1.0);
+        }`,
+            blending: NoBlending,
+            depthWrite: false,
+            depthTest: false,
+        });
+        this.toneMapped = false;
+        this.setTexelSize(texelSize.x, texelSize.y);
+        this.kernel = new Float32Array([0.0, 1.0, 2.0, 2.0, 3.0]);
+    }
+    setTexelSize(x, y) {
+        this.uniforms['texelSize'].value.set(x, y);
+        this.uniforms['halfTexelSize'].value.set(x, y).multiplyScalar(0.5);
+    }
+    setResolution(resolution) {
+        this.uniforms['resolution'].value.copy(resolution);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/shaders/discard-material/discard-material.mjs

@@ -0,0 +1,3 @@
+import { shaderMaterial } from '../shader-material/shader-material';
+export const DiscardMaterial = shaderMaterial({}, 'void main() { }', 'void main() { gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0); discard;  }');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlzY2FyZC1tYXRlcmlhbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvc29iYS9zaGFkZXJzL3NyYy9kaXNjYXJkLW1hdGVyaWFsL2Rpc2NhcmQtbWF0ZXJpYWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLG9DQUFvQyxDQUFDO0FBRXBFLE1BQU0sQ0FBQyxNQUFNLGVBQWUsR0FBRyxjQUFjLENBQ3pDLEVBQUUsRUFDRixpQkFBaUIsRUFDakIsb0VBQW9FLENBQ3ZFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBzaGFkZXJNYXRlcmlhbCB9IGZyb20gJy4uL3NoYWRlci1tYXRlcmlhbC9zaGFkZXItbWF0ZXJpYWwnO1xuXG5leHBvcnQgY29uc3QgRGlzY2FyZE1hdGVyaWFsID0gc2hhZGVyTWF0ZXJpYWwoXG4gICAge30sXG4gICAgJ3ZvaWQgbWFpbigpIHsgfScsXG4gICAgJ3ZvaWQgbWFpbigpIHsgZ2xfRnJhZ0NvbG9yID0gdmVjNCgwLjAsIDAuMCwgMC4wLCAwLjApOyBkaXNjYXJkOyAgfSdcbik7XG4iXX0=

package/esm2022/shaders/index.mjs

@@ -1,15 +1,15 @@
-export * from './lib/blur-pass/blur-pass';
-export * from './lib/caustics-material/caustics-material';
-export * from './lib/caustics-projection-material/caustics-projection-material';
-export * from './lib/convolution-material/convolution-material';
-export * from './lib/discard-material/discard-material';
-export * from './lib/mesh-distort-material/mesh-distort-material';
-export * from './lib/mesh-reflector-material/mesh-reflector-material';
-export * from './lib/mesh-refraction-material/mesh-refraction-material';
-export * from './lib/mesh-transmission-material/mesh-transmission-material';
-export * from './lib/mesh-wobble-material/mesh-wobble-material';
-export * from './lib/shader-material/shader-material';
-export * from './lib/soft-shadow-material/soft-shadow-material';
-export * from './lib/spot-light-material/spot-light-material';
-export * from './lib/star-field-material/star-field-material';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXItdGhyZWUtc29iYS9zaGFkZXJzL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsMkNBQTJDLENBQUM7QUFDMUQsY0FBYyxpRUFBaUUsQ0FBQztBQUNoRixjQUFjLGlEQUFpRCxDQUFDO0FBQ2hFLGNBQWMseUNBQXlDLENBQUM7QUFDeEQsY0FBYyxtREFBbUQsQ0FBQztBQUNsRSxjQUFjLHVEQUF1RCxDQUFDO0FBQ3RFLGNBQWMseURBQXlELENBQUM7QUFDeEUsY0FBYyw2REFBNkQsQ0FBQztBQUM1RSxjQUFjLGlEQUFpRCxDQUFDO0FBQ2hFLGNBQWMsdUNBQXVDLENBQUM7QUFDdEQsY0FBYyxpREFBaUQsQ0FBQztBQUNoRSxjQUFjLCtDQUErQyxDQUFDO0FBQzlELGNBQWMsK0NBQStDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2xpYi9ibHVyLXBhc3MvYmx1ci1wYXNzJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NhdXN0aWNzLW1hdGVyaWFsL2NhdXN0aWNzLW1hdGVyaWFsJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NhdXN0aWNzLXByb2plY3Rpb24tbWF0ZXJpYWwvY2F1c3RpY3MtcHJvamVjdGlvbi1tYXRlcmlhbCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb252b2x1dGlvbi1tYXRlcmlhbC9jb252b2x1dGlvbi1tYXRlcmlhbCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9kaXNjYXJkLW1hdGVyaWFsL2Rpc2NhcmQtbWF0ZXJpYWwnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvbWVzaC1kaXN0b3J0LW1hdGVyaWFsL21lc2gtZGlzdG9ydC1tYXRlcmlhbCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9tZXNoLXJlZmxlY3Rvci1tYXRlcmlhbC9tZXNoLXJlZmxlY3Rvci1tYXRlcmlhbCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9tZXNoLXJlZnJhY3Rpb24tbWF0ZXJpYWwvbWVzaC1yZWZyYWN0aW9uLW1hdGVyaWFsJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL21lc2gtdHJhbnNtaXNzaW9uLW1hdGVyaWFsL21lc2gtdHJhbnNtaXNzaW9uLW1hdGVyaWFsJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL21lc2gtd29iYmxlLW1hdGVyaWFsL21lc2gtd29iYmxlLW1hdGVyaWFsJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3NoYWRlci1tYXRlcmlhbC9zaGFkZXItbWF0ZXJpYWwnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvc29mdC1zaGFkb3ctbWF0ZXJpYWwvc29mdC1zaGFkb3ctbWF0ZXJpYWwnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvc3BvdC1saWdodC1tYXRlcmlhbC9zcG90LWxpZ2h0LW1hdGVyaWFsJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3N0YXItZmllbGQtbWF0ZXJpYWwvc3Rhci1maWVsZC1tYXRlcmlhbCc7XG4iXX0=
+export * from './blur-pass/blur-pass';
+export * from './caustics-material/caustics-material';
+export * from './caustics-material/caustics-projection-material';
+export * from './convolution-material/convolution-material';
+export * from './discard-material/discard-material';
+export * from './mesh-distort-material/mesh-distort-material';
+export * from './mesh-reflector-material/mesh-reflector-material';
+export * from './mesh-refraction-material/mesh-refraction-material';
+export * from './mesh-transmission-material/mesh-transmission-material';
+export * from './mesh-wobble-material/mesh-wobble-material';
+export * from './soft-shadow-material/soft-shadow-material';
+export * from './sparkles-material/sparkles-material';
+export * from './spot-light-material/spot-light-material';
+export * from './star-field-material/star-field-material';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL3NvYmEvc2hhZGVycy9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLHVDQUF1QyxDQUFDO0FBQ3RELGNBQWMsa0RBQWtELENBQUM7QUFDakUsY0FBYyw2Q0FBNkMsQ0FBQztBQUM1RCxjQUFjLHFDQUFxQyxDQUFDO0FBQ3BELGNBQWMsK0NBQStDLENBQUM7QUFDOUQsY0FBYyxtREFBbUQsQ0FBQztBQUNsRSxjQUFjLHFEQUFxRCxDQUFDO0FBQ3BFLGNBQWMseURBQXlELENBQUM7QUFDeEUsY0FBYyw2Q0FBNkMsQ0FBQztBQUM1RCxjQUFjLDZDQUE2QyxDQUFDO0FBQzVELGNBQWMsdUNBQXVDLENBQUM7QUFDdEQsY0FBYywyQ0FBMkMsQ0FBQztBQUMxRCxjQUFjLDJDQUEyQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9ibHVyLXBhc3MvYmx1ci1wYXNzJztcbmV4cG9ydCAqIGZyb20gJy4vY2F1c3RpY3MtbWF0ZXJpYWwvY2F1c3RpY3MtbWF0ZXJpYWwnO1xuZXhwb3J0ICogZnJvbSAnLi9jYXVzdGljcy1tYXRlcmlhbC9jYXVzdGljcy1wcm9qZWN0aW9uLW1hdGVyaWFsJztcbmV4cG9ydCAqIGZyb20gJy4vY29udm9sdXRpb24tbWF0ZXJpYWwvY29udm9sdXRpb24tbWF0ZXJpYWwnO1xuZXhwb3J0ICogZnJvbSAnLi9kaXNjYXJkLW1hdGVyaWFsL2Rpc2NhcmQtbWF0ZXJpYWwnO1xuZXhwb3J0ICogZnJvbSAnLi9tZXNoLWRpc3RvcnQtbWF0ZXJpYWwvbWVzaC1kaXN0b3J0LW1hdGVyaWFsJztcbmV4cG9ydCAqIGZyb20gJy4vbWVzaC1yZWZsZWN0b3ItbWF0ZXJpYWwvbWVzaC1yZWZsZWN0b3ItbWF0ZXJpYWwnO1xuZXhwb3J0ICogZnJvbSAnLi9tZXNoLXJlZnJhY3Rpb24tbWF0ZXJpYWwvbWVzaC1yZWZyYWN0aW9uLW1hdGVyaWFsJztcbmV4cG9ydCAqIGZyb20gJy4vbWVzaC10cmFuc21pc3Npb24tbWF0ZXJpYWwvbWVzaC10cmFuc21pc3Npb24tbWF0ZXJpYWwnO1xuZXhwb3J0ICogZnJvbSAnLi9tZXNoLXdvYmJsZS1tYXRlcmlhbC9tZXNoLXdvYmJsZS1tYXRlcmlhbCc7XG5leHBvcnQgKiBmcm9tICcuL3NvZnQtc2hhZG93LW1hdGVyaWFsL3NvZnQtc2hhZG93LW1hdGVyaWFsJztcbmV4cG9ydCAqIGZyb20gJy4vc3BhcmtsZXMtbWF0ZXJpYWwvc3BhcmtsZXMtbWF0ZXJpYWwnO1xuZXhwb3J0ICogZnJvbSAnLi9zcG90LWxpZ2h0LW1hdGVyaWFsL3Nwb3QtbGlnaHQtbWF0ZXJpYWwnO1xuZXhwb3J0ICogZnJvbSAnLi9zdGFyLWZpZWxkLW1hdGVyaWFsL3N0YXItZmllbGQtbWF0ZXJpYWwnO1xuIl19

package/esm2022/shaders/mesh-distort-material/mesh-distort-material.mjs

@@ -0,0 +1,55 @@
+import { InjectionToken } from '@angular/core';
+import * as THREE from 'three';
+export const NGTS_DISTORT_MATERIAL_SHADER = new InjectionToken('DistortMaterialShader');
+export function provideNgtsMeshDistortMaterialShader(distortShader) {
+    return {
+        provide: NGTS_DISTORT_MATERIAL_SHADER,
+        useFactory: () => {
+            return class extends THREE.MeshPhysicalMaterial {
+                constructor(parameters = {}) {
+                    super(parameters);
+                    this.setValues(parameters);
+                    this._time = { value: 0 };
+                    this._distort = { value: 0.4 };
+                    this._radius = { value: 1 };
+                }
+                onBeforeCompile(shader) {
+                    shader.uniforms['time'] = this._time;
+                    shader.uniforms['radius'] = this._radius;
+                    shader.uniforms['distort'] = this._distort;
+                    shader.vertexShader = `
+									    uniform float time;
+									    uniform float radius;
+									    uniform float distort;
+									    ${distortShader}
+									    ${shader.vertexShader}
+									  `;
+                    shader.vertexShader = shader.vertexShader.replace('#include <begin_vertex>', `
+									      float updateTime = time / 50.0;
+									      float noise = snoise(vec3(position / 2.0 + updateTime * 5.0));
+									      vec3 transformed = vec3(position * (noise * pow(distort, 2.0) + radius));
+									      `);
+                }
+                get time() {
+                    return this._time.value;
+                }
+                set time(v) {
+                    this._time.value = v;
+                }
+                get distort() {
+                    return this._distort.value;
+                }
+                set distort(v) {
+                    this._distort.value = v;
+                }
+                get radius() {
+                    return this._radius.value;
+                }
+                set radius(v) {
+                    this._radius.value = v;
+                }
+            };
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,223 @@
+import { MeshStandardMaterial } from 'three';
+export class MeshReflectorMaterial extends MeshStandardMaterial {
+    constructor(parameters = {}) {
+        super(parameters);
+        this._tDepth = { value: null };
+        this._distortionMap = { value: null };
+        this._tDiffuse = { value: null };
+        this._tDiffuseBlur = { value: null };
+        this._textureMatrix = { value: null };
+        this._hasBlur = { value: false };
+        this._mirror = { value: 0.0 };
+        this._mixBlur = { value: 0.0 };
+        this._blurStrength = { value: 0.5 };
+        this._minDepthThreshold = { value: 0.9 };
+        this._maxDepthThreshold = { value: 1 };
+        this._depthScale = { value: 0 };
+        this._depthToBlurRatioBias = { value: 0.25 };
+        this._distortion = { value: 1 };
+        this._mixContrast = { value: 1.0 };
+        this.setValues(parameters);
+    }
+    onBeforeCompile(shader) {
+        if (!shader.defines?.USE_UV) {
+            shader.defines.USE_UV = '';
+        }
+        shader.uniforms.hasBlur = this._hasBlur;
+        shader.uniforms.tDiffuse = this._tDiffuse;
+        shader.uniforms.tDepth = this._tDepth;
+        shader.uniforms.distortionMap = this._distortionMap;
+        shader.uniforms.tDiffuseBlur = this._tDiffuseBlur;
+        shader.uniforms.textureMatrix = this._textureMatrix;
+        shader.uniforms.mirror = this._mirror;
+        shader.uniforms.mixBlur = this._mixBlur;
+        shader.uniforms.mixStrength = this._blurStrength;
+        shader.uniforms.minDepthThreshold = this._minDepthThreshold;
+        shader.uniforms.maxDepthThreshold = this._maxDepthThreshold;
+        shader.uniforms.depthScale = this._depthScale;
+        shader.uniforms.depthToBlurRatioBias = this._depthToBlurRatioBias;
+        shader.uniforms.distortion = this._distortion;
+        shader.uniforms.mixContrast = this._mixContrast;
+        shader.vertexShader = `
+        uniform mat4 textureMatrix;
+        varying vec4 my_vUv;
+      ${shader.vertexShader}`;
+        shader.vertexShader = shader.vertexShader.replace('#include <project_vertex>', `#include <project_vertex>
+        my_vUv = textureMatrix * vec4( position, 1.0 );
+        gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );`);
+        shader.fragmentShader = `
+        uniform sampler2D tDiffuse;
+        uniform sampler2D tDiffuseBlur;
+        uniform sampler2D tDepth;
+        uniform sampler2D distortionMap;
+        uniform float distortion;
+        uniform float cameraNear;
+			  uniform float cameraFar;
+        uniform bool hasBlur;
+        uniform float mixBlur;
+        uniform float mirror;
+        uniform float mixStrength;
+        uniform float minDepthThreshold;
+        uniform float maxDepthThreshold;
+        uniform float mixContrast;
+        uniform float depthScale;
+        uniform float depthToBlurRatioBias;
+        varying vec4 my_vUv;
+        ${shader.fragmentShader}`;
+        shader.fragmentShader = shader.fragmentShader.replace('#include <emissivemap_fragment>', `#include <emissivemap_fragment>
+
+      float distortionFactor = 0.0;
+      #ifdef USE_DISTORTION
+        distortionFactor = texture2D(distortionMap, vUv).r * distortion;
+      #endif
+
+      vec4 new_vUv = my_vUv;
+      new_vUv.x += distortionFactor;
+      new_vUv.y += distortionFactor;
+
+      vec4 base = texture2DProj(tDiffuse, new_vUv);
+      vec4 blur = texture2DProj(tDiffuseBlur, new_vUv);
+
+      vec4 merge = base;
+
+      #ifdef USE_NORMALMAP
+        vec2 normal_uv = vec2(0.0);
+        vec4 normalColor = texture2D(normalMap, vUv * normalScale);
+        vec3 my_normal = normalize( vec3( normalColor.r * 2.0 - 1.0, normalColor.b,  normalColor.g * 2.0 - 1.0 ) );
+        vec3 coord = new_vUv.xyz / new_vUv.w;
+        normal_uv = coord.xy + coord.z * my_normal.xz * 0.05;
+        vec4 base_normal = texture2D(tDiffuse, normal_uv);
+        vec4 blur_normal = texture2D(tDiffuseBlur, normal_uv);
+        merge = base_normal;
+        blur = blur_normal;
+      #endif
+
+      float depthFactor = 0.0001;
+      float blurFactor = 0.0;
+
+      #ifdef USE_DEPTH
+        vec4 depth = texture2DProj(tDepth, new_vUv);
+        depthFactor = smoothstep(minDepthThreshold, maxDepthThreshold, 1.0-(depth.r * depth.a));
+        depthFactor *= depthScale;
+        depthFactor = max(0.0001, min(1.0, depthFactor));
+
+        #ifdef USE_BLUR
+          blur = blur * min(1.0, depthFactor + depthToBlurRatioBias);
+          merge = merge * min(1.0, depthFactor + 0.5);
+        #else
+          merge = merge * depthFactor;
+        #endif
+
+      #endif
+
+      float reflectorRoughnessFactor = roughness;
+      #ifdef USE_ROUGHNESSMAP
+        vec4 reflectorTexelRoughness = texture2D( roughnessMap, vUv );
+        reflectorRoughnessFactor *= reflectorTexelRoughness.g;
+      #endif
+
+      #ifdef USE_BLUR
+        blurFactor = min(1.0, mixBlur * reflectorRoughnessFactor);
+        merge = mix(merge, blur, blurFactor);
+      #endif
+
+      vec4 newMerge = vec4(0.0, 0.0, 0.0, 1.0);
+      newMerge.r = (merge.r - 0.5) * mixContrast + 0.5;
+      newMerge.g = (merge.g - 0.5) * mixContrast + 0.5;
+      newMerge.b = (merge.b - 0.5) * mixContrast + 0.5;
+
+      diffuseColor.rgb = diffuseColor.rgb * ((1.0 - min(1.0, mirror)) + newMerge.rgb * mixStrength);
+      `);
+    }
+    get tDiffuse() {
+        return this._tDiffuse.value;
+    }
+    set tDiffuse(v) {
+        this._tDiffuse.value = v;
+    }
+    get tDepth() {
+        return this._tDepth.value;
+    }
+    set tDepth(v) {
+        this._tDepth.value = v;
+    }
+    get distortionMap() {
+        return this._distortionMap.value;
+    }
+    set distortionMap(v) {
+        this._distortionMap.value = v;
+    }
+    get tDiffuseBlur() {
+        return this._tDiffuseBlur.value;
+    }
+    set tDiffuseBlur(v) {
+        this._tDiffuseBlur.value = v;
+    }
+    get textureMatrix() {
+        return this._textureMatrix.value;
+    }
+    set textureMatrix(v) {
+        this._textureMatrix.value = v;
+    }
+    get hasBlur() {
+        return this._hasBlur.value;
+    }
+    set hasBlur(v) {
+        this._hasBlur.value = v;
+    }
+    get mirror() {
+        return this._mirror.value;
+    }
+    set mirror(v) {
+        this._mirror.value = v;
+    }
+    get mixBlur() {
+        return this._mixBlur.value;
+    }
+    set mixBlur(v) {
+        this._mixBlur.value = v;
+    }
+    get mixStrength() {
+        return this._blurStrength.value;
+    }
+    set mixStrength(v) {
+        this._blurStrength.value = v;
+    }
+    get minDepthThreshold() {
+        return this._minDepthThreshold.value;
+    }
+    set minDepthThreshold(v) {
+        this._minDepthThreshold.value = v;
+    }
+    get maxDepthThreshold() {
+        return this._maxDepthThreshold.value;
+    }
+    set maxDepthThreshold(v) {
+        this._maxDepthThreshold.value = v;
+    }
+    get depthScale() {
+        return this._depthScale.value;
+    }
+    set depthScale(v) {
+        this._depthScale.value = v;
+    }
+    get depthToBlurRatioBias() {
+        return this._depthToBlurRatioBias.value;
+    }
+    set depthToBlurRatioBias(v) {
+        this._depthToBlurRatioBias.value = v;
+    }
+    get distortion() {
+        return this._distortion.value;
+    }
+    set distortion(v) {
+        this._distortion.value = v;
+    }
+    get mixContrast() {
+        return this._mixContrast.value;
+    }
+    set mixContrast(v) {
+        this._mixContrast.value = v;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mesh-reflector-material.js","sourceRoot":"","sources":["../../../../../../libs/soba/shaders/src/mesh-reflector-material/mesh-reflector-material.ts"],"names":[],"mappings":"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","sourcesContent":["import { Matrix4, MeshStandardMaterial, Texture } from 'three';\n\ntype UninitializedUniform<Value> = { value: Value | null };\n\nexport class MeshReflectorMaterial extends MeshStandardMaterial {\n    private _tDepth: UninitializedUniform<Texture> = { value: null };\n    private _distortionMap: UninitializedUniform<Texture> = { value: null };\n    private _tDiffuse: UninitializedUniform<Texture> = { value: null };\n    private _tDiffuseBlur: UninitializedUniform<Texture> = { value: null };\n    private _textureMatrix: UninitializedUniform<Matrix4> = { value: null };\n    private _hasBlur: { value: boolean } = { value: false };\n    private _mirror: { value: number } = { value: 0.0 };\n    private _mixBlur: { value: number } = { value: 0.0 };\n    private _blurStrength: { value: number } = { value: 0.5 };\n    private _minDepthThreshold: { value: number } = { value: 0.9 };\n    private _maxDepthThreshold: { value: number } = { value: 1 };\n    private _depthScale: { value: number } = { value: 0 };\n    private _depthToBlurRatioBias: { value: number } = { value: 0.25 };\n    private _distortion: { value: number } = { value: 1 };\n    private _mixContrast: { value: number } = { value: 1.0 };\n\n    constructor(parameters = {}) {\n        super(parameters);\n        this.setValues(parameters);\n    }\n    override onBeforeCompile(shader: any) {\n        if (!shader.defines?.USE_UV) {\n            shader.defines.USE_UV = '';\n        }\n        shader.uniforms.hasBlur = this._hasBlur;\n        shader.uniforms.tDiffuse = this._tDiffuse;\n        shader.uniforms.tDepth = this._tDepth;\n        shader.uniforms.distortionMap = this._distortionMap;\n        shader.uniforms.tDiffuseBlur = this._tDiffuseBlur;\n        shader.uniforms.textureMatrix = this._textureMatrix;\n        shader.uniforms.mirror = this._mirror;\n        shader.uniforms.mixBlur = this._mixBlur;\n        shader.uniforms.mixStrength = this._blurStrength;\n        shader.uniforms.minDepthThreshold = this._minDepthThreshold;\n        shader.uniforms.maxDepthThreshold = this._maxDepthThreshold;\n        shader.uniforms.depthScale = this._depthScale;\n        shader.uniforms.depthToBlurRatioBias = this._depthToBlurRatioBias;\n        shader.uniforms.distortion = this._distortion;\n        shader.uniforms.mixContrast = this._mixContrast;\n        shader.vertexShader = `\n        uniform mat4 textureMatrix;\n        varying vec4 my_vUv;\n      ${shader.vertexShader}`;\n        shader.vertexShader = shader.vertexShader.replace(\n            '#include <project_vertex>',\n            `#include <project_vertex>\n        my_vUv = textureMatrix * vec4( position, 1.0 );\n        gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );`\n        );\n        shader.fragmentShader = `\n        uniform sampler2D tDiffuse;\n        uniform sampler2D tDiffuseBlur;\n        uniform sampler2D tDepth;\n        uniform sampler2D distortionMap;\n        uniform float distortion;\n        uniform float cameraNear;\n\t\t\t  uniform float cameraFar;\n        uniform bool hasBlur;\n        uniform float mixBlur;\n        uniform float mirror;\n        uniform float mixStrength;\n        uniform float minDepthThreshold;\n        uniform float maxDepthThreshold;\n        uniform float mixContrast;\n        uniform float depthScale;\n        uniform float depthToBlurRatioBias;\n        varying vec4 my_vUv;\n        ${shader.fragmentShader}`;\n        shader.fragmentShader = shader.fragmentShader.replace(\n            '#include <emissivemap_fragment>',\n            `#include <emissivemap_fragment>\n\n      float distortionFactor = 0.0;\n      #ifdef USE_DISTORTION\n        distortionFactor = texture2D(distortionMap, vUv).r * distortion;\n      #endif\n\n      vec4 new_vUv = my_vUv;\n      new_vUv.x += distortionFactor;\n      new_vUv.y += distortionFactor;\n\n      vec4 base = texture2DProj(tDiffuse, new_vUv);\n      vec4 blur = texture2DProj(tDiffuseBlur, new_vUv);\n\n      vec4 merge = base;\n\n      #ifdef USE_NORMALMAP\n        vec2 normal_uv = vec2(0.0);\n        vec4 normalColor = texture2D(normalMap, vUv * normalScale);\n        vec3 my_normal = normalize( vec3( normalColor.r * 2.0 - 1.0, normalColor.b,  normalColor.g * 2.0 - 1.0 ) );\n        vec3 coord = new_vUv.xyz / new_vUv.w;\n        normal_uv = coord.xy + coord.z * my_normal.xz * 0.05;\n        vec4 base_normal = texture2D(tDiffuse, normal_uv);\n        vec4 blur_normal = texture2D(tDiffuseBlur, normal_uv);\n        merge = base_normal;\n        blur = blur_normal;\n      #endif\n\n      float depthFactor = 0.0001;\n      float blurFactor = 0.0;\n\n      #ifdef USE_DEPTH\n        vec4 depth = texture2DProj(tDepth, new_vUv);\n        depthFactor = smoothstep(minDepthThreshold, maxDepthThreshold, 1.0-(depth.r * depth.a));\n        depthFactor *= depthScale;\n        depthFactor = max(0.0001, min(1.0, depthFactor));\n\n        #ifdef USE_BLUR\n          blur = blur * min(1.0, depthFactor + depthToBlurRatioBias);\n          merge = merge * min(1.0, depthFactor + 0.5);\n        #else\n          merge = merge * depthFactor;\n        #endif\n\n      #endif\n\n      float reflectorRoughnessFactor = roughness;\n      #ifdef USE_ROUGHNESSMAP\n        vec4 reflectorTexelRoughness = texture2D( roughnessMap, vUv );\n        reflectorRoughnessFactor *= reflectorTexelRoughness.g;\n      #endif\n\n      #ifdef USE_BLUR\n        blurFactor = min(1.0, mixBlur * reflectorRoughnessFactor);\n        merge = mix(merge, blur, blurFactor);\n      #endif\n\n      vec4 newMerge = vec4(0.0, 0.0, 0.0, 1.0);\n      newMerge.r = (merge.r - 0.5) * mixContrast + 0.5;\n      newMerge.g = (merge.g - 0.5) * mixContrast + 0.5;\n      newMerge.b = (merge.b - 0.5) * mixContrast + 0.5;\n\n      diffuseColor.rgb = diffuseColor.rgb * ((1.0 - min(1.0, mirror)) + newMerge.rgb * mixStrength);\n      `\n        );\n    }\n    get tDiffuse(): Texture | null {\n        return this._tDiffuse.value;\n    }\n    set tDiffuse(v: Texture | null) {\n        this._tDiffuse.value = v;\n    }\n    get tDepth(): Texture | null {\n        return this._tDepth.value;\n    }\n    set tDepth(v: Texture | null) {\n        this._tDepth.value = v;\n    }\n    get distortionMap(): Texture | null {\n        return this._distortionMap.value;\n    }\n    set distortionMap(v: Texture | null) {\n        this._distortionMap.value = v;\n    }\n    get tDiffuseBlur(): Texture | null {\n        return this._tDiffuseBlur.value;\n    }\n    set tDiffuseBlur(v: Texture | null) {\n        this._tDiffuseBlur.value = v;\n    }\n    get textureMatrix(): Matrix4 | null {\n        return this._textureMatrix.value;\n    }\n    set textureMatrix(v: Matrix4 | null) {\n        this._textureMatrix.value = v;\n    }\n    get hasBlur(): boolean {\n        return this._hasBlur.value;\n    }\n    set hasBlur(v: boolean) {\n        this._hasBlur.value = v;\n    }\n    get mirror(): number {\n        return this._mirror.value;\n    }\n    set mirror(v: number) {\n        this._mirror.value = v;\n    }\n    get mixBlur(): number {\n        return this._mixBlur.value;\n    }\n    set mixBlur(v: number) {\n        this._mixBlur.value = v;\n    }\n    get mixStrength(): number {\n        return this._blurStrength.value;\n    }\n    set mixStrength(v: number) {\n        this._blurStrength.value = v;\n    }\n    get minDepthThreshold(): number {\n        return this._minDepthThreshold.value;\n    }\n    set minDepthThreshold(v: number) {\n        this._minDepthThreshold.value = v;\n    }\n    get maxDepthThreshold(): number {\n        return this._maxDepthThreshold.value;\n    }\n    set maxDepthThreshold(v: number) {\n        this._maxDepthThreshold.value = v;\n    }\n    get depthScale(): number {\n        return this._depthScale.value;\n    }\n    set depthScale(v: number) {\n        this._depthScale.value = v;\n    }\n    get depthToBlurRatioBias(): number {\n        return this._depthToBlurRatioBias.value;\n    }\n    set depthToBlurRatioBias(v: number) {\n        this._depthToBlurRatioBias.value = v;\n    }\n    get distortion(): number {\n        return this._distortion.value;\n    }\n    set distortion(v: number) {\n        this._distortion.value = v;\n    }\n    get mixContrast(): number {\n        return this._mixContrast.value;\n    }\n    set mixContrast(v: number) {\n        this._mixContrast.value = v;\n    }\n}\n"]}