angular-three-soba 1.14.1 → 2.0.0-beta.11

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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlzY2FyZC1tYXRlcmlhbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvc29iYS9zaGFkZXJzL3NyYy9kaXNjYXJkLW1hdGVyaWFsL2Rpc2NhcmQtbWF0ZXJpYWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLG9DQUFvQyxDQUFDO0FBRXBFLE1BQU0sQ0FBQyxNQUFNLGVBQWUsR0FBRyxjQUFjLENBQzVDLEVBQUUsRUFDRixpQkFBaUIsRUFDakIsb0VBQW9FLENBQ3BFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBzaGFkZXJNYXRlcmlhbCB9IGZyb20gJy4uL3NoYWRlci1tYXRlcmlhbC9zaGFkZXItbWF0ZXJpYWwnO1xuXG5leHBvcnQgY29uc3QgRGlzY2FyZE1hdGVyaWFsID0gc2hhZGVyTWF0ZXJpYWwoXG5cdHt9LFxuXHQndm9pZCBtYWluKCkgeyB9Jyxcblx0J3ZvaWQgbWFpbigpIHsgZ2xfRnJhZ0NvbG9yID0gdmVjNCgwLjAsIDAuMCwgMC4wLCAwLjApOyBkaXNjYXJkOyAgfScsXG4pO1xuIl19

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

@@ -0,0 +1,77 @@
+import * as THREE from 'three';
+import { shaderMaterial } from '../shader-material/shader-material';
+export const GridMaterial = shaderMaterial({
+    cellSize: 0.5,
+    sectionSize: 1,
+    fadeDistance: 100,
+    fadeStrength: 1,
+    cellThickness: 0.5,
+    sectionThickness: 1,
+    cellColor: new THREE.Color(),
+    sectionColor: new THREE.Color(),
+    infiniteGrid: false,
+    followCamera: false,
+    worldCamProjPosition: new THREE.Vector3(),
+    worldPlanePosition: new THREE.Vector3(),
+}, 
+/* glsl */ `
+    varying vec3 localPosition;
+    varying vec4 worldPosition;
+
+    uniform vec3 worldCamProjPosition;
+    uniform vec3 worldPlanePosition;
+    uniform float fadeDistance;
+    uniform bool infiniteGrid;
+    uniform bool followCamera;
+
+    void main() {
+      localPosition = position.xzy;
+      if (infiniteGrid) localPosition *= 1.0 + fadeDistance;
+
+      worldPosition = modelMatrix * vec4(localPosition, 1.0);
+      if (followCamera) {
+        worldPosition.xyz += (worldCamProjPosition - worldPlanePosition);
+        localPosition = (inverse(modelMatrix) * worldPosition).xyz;
+      }
+
+      gl_Position = projectionMatrix * viewMatrix * worldPosition;
+    }
+  `, 
+/* glsl */ `
+    varying vec3 localPosition;
+    varying vec4 worldPosition;
+
+    uniform vec3 worldCamProjPosition;
+    uniform float cellSize;
+    uniform float sectionSize;
+    uniform vec3 cellColor;
+    uniform vec3 sectionColor;
+    uniform float fadeDistance;
+    uniform float fadeStrength;
+    uniform float cellThickness;
+    uniform float sectionThickness;
+
+    float getGrid(float size, float thickness) {
+      vec2 r = localPosition.xz / size;
+      vec2 grid = abs(fract(r - 0.5) - 0.5) / fwidth(r);
+      float line = min(grid.x, grid.y) + 1.0 - thickness;
+      return 1.0 - min(line, 1.0);
+    }
+
+    void main() {
+      float g1 = getGrid(cellSize, cellThickness);
+      float g2 = getGrid(sectionSize, sectionThickness);
+
+      float dist = distance(worldCamProjPosition, worldPosition.xyz);
+      float d = 1.0 - min(dist / fadeDistance, 1.0);
+      vec3 color = mix(cellColor, sectionColor, min(1.0, sectionThickness * g2));
+
+      gl_FragColor = vec4(color, (g1 + g2) * pow(d, fadeStrength));
+      gl_FragColor.a = mix(0.75 * gl_FragColor.a, gl_FragColor.a, g2);
+      if (gl_FragColor.a <= 0.0) discard;
+
+      #include <tonemapping_fragment>
+      #include <${parseInt(THREE.REVISION.replace(/\D+/g, '')) >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
+    }
+  `);
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/shaders/index.mjs

@@ -1,15 +1,18 @@
-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/caustics-material';
+export * from './caustics/caustics-projection-material';
+export * from './convolution-material/convolution-material';
+export * from './discard-material/discard-material';
+export * from './grid-material/grid-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 './shader-material/shader-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';
+export * from './wireframe-material/wireframe-material';
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,56 @@
+import { InjectionToken, inject } from '@angular/core';
+import * as THREE from 'three';
+export const NGTS_DISTORT_MATERIAL_SHADER = new InjectionToken('DistortMaterialShader');
+export function injectNgtsMeshDistortMaterial() {
+    return inject(NGTS_DISTORT_MATERIAL_SHADER);
+}
+export function createMeshDistortMaterial(distortShader) {
+    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;
+        }
+    };
+}
+export function provideNgtsMeshDistortMaterialShader(distortShader) {
+    return { provide: NGTS_DISTORT_MATERIAL_SHADER, useFactory: () => createMeshDistortMaterial(distortShader) };
+}
+//# 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\tprivate _tDepth: UninitializedUniform<Texture> = { value: null };\n\tprivate _distortionMap: UninitializedUniform<Texture> = { value: null };\n\tprivate _tDiffuse: UninitializedUniform<Texture> = { value: null };\n\tprivate _tDiffuseBlur: UninitializedUniform<Texture> = { value: null };\n\tprivate _textureMatrix: UninitializedUniform<Matrix4> = { value: null };\n\tprivate _hasBlur: { value: boolean } = { value: false };\n\tprivate _mirror: { value: number } = { value: 0.0 };\n\tprivate _mixBlur: { value: number } = { value: 0.0 };\n\tprivate _blurStrength: { value: number } = { value: 0.5 };\n\tprivate _minDepthThreshold: { value: number } = { value: 0.9 };\n\tprivate _maxDepthThreshold: { value: number } = { value: 1 };\n\tprivate _depthScale: { value: number } = { value: 0 };\n\tprivate _depthToBlurRatioBias: { value: number } = { value: 0.25 };\n\tprivate _distortion: { value: number } = { value: 1 };\n\tprivate _mixContrast: { value: number } = { value: 1.0 };\n\n\tconstructor(parameters = {}) {\n\t\tsuper(parameters);\n\t\tthis.setValues(parameters);\n\t}\n\toverride onBeforeCompile(shader: any) {\n\t\tif (!shader.defines?.USE_UV) {\n\t\t\tshader.defines.USE_UV = '';\n\t\t}\n\t\tshader.uniforms.hasBlur = this._hasBlur;\n\t\tshader.uniforms.tDiffuse = this._tDiffuse;\n\t\tshader.uniforms.tDepth = this._tDepth;\n\t\tshader.uniforms.distortionMap = this._distortionMap;\n\t\tshader.uniforms.tDiffuseBlur = this._tDiffuseBlur;\n\t\tshader.uniforms.textureMatrix = this._textureMatrix;\n\t\tshader.uniforms.mirror = this._mirror;\n\t\tshader.uniforms.mixBlur = this._mixBlur;\n\t\tshader.uniforms.mixStrength = this._blurStrength;\n\t\tshader.uniforms.minDepthThreshold = this._minDepthThreshold;\n\t\tshader.uniforms.maxDepthThreshold = this._maxDepthThreshold;\n\t\tshader.uniforms.depthScale = this._depthScale;\n\t\tshader.uniforms.depthToBlurRatioBias = this._depthToBlurRatioBias;\n\t\tshader.uniforms.distortion = this._distortion;\n\t\tshader.uniforms.mixContrast = this._mixContrast;\n\t\tshader.vertexShader = `\n        uniform mat4 textureMatrix;\n        varying vec4 my_vUv;\n      ${shader.vertexShader}`;\n\t\tshader.vertexShader = shader.vertexShader.replace(\n\t\t\t'#include <project_vertex>',\n\t\t\t`#include <project_vertex>\n        my_vUv = textureMatrix * vec4( position, 1.0 );\n        gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );`,\n\t\t);\n\t\tshader.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\t\tshader.fragmentShader = shader.fragmentShader.replace(\n\t\t\t'#include <emissivemap_fragment>',\n\t\t\t`#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\t\t);\n\t}\n\tget tDiffuse(): Texture | null {\n\t\treturn this._tDiffuse.value;\n\t}\n\tset tDiffuse(v: Texture | null) {\n\t\tthis._tDiffuse.value = v;\n\t}\n\tget tDepth(): Texture | null {\n\t\treturn this._tDepth.value;\n\t}\n\tset tDepth(v: Texture | null) {\n\t\tthis._tDepth.value = v;\n\t}\n\tget distortionMap(): Texture | null {\n\t\treturn this._distortionMap.value;\n\t}\n\tset distortionMap(v: Texture | null) {\n\t\tthis._distortionMap.value = v;\n\t}\n\tget tDiffuseBlur(): Texture | null {\n\t\treturn this._tDiffuseBlur.value;\n\t}\n\tset tDiffuseBlur(v: Texture | null) {\n\t\tthis._tDiffuseBlur.value = v;\n\t}\n\tget textureMatrix(): Matrix4 | null {\n\t\treturn this._textureMatrix.value;\n\t}\n\tset textureMatrix(v: Matrix4 | null) {\n\t\tthis._textureMatrix.value = v;\n\t}\n\tget hasBlur(): boolean {\n\t\treturn this._hasBlur.value;\n\t}\n\tset hasBlur(v: boolean) {\n\t\tthis._hasBlur.value = v;\n\t}\n\tget mirror(): number {\n\t\treturn this._mirror.value;\n\t}\n\tset mirror(v: number) {\n\t\tthis._mirror.value = v;\n\t}\n\tget mixBlur(): number {\n\t\treturn this._mixBlur.value;\n\t}\n\tset mixBlur(v: number) {\n\t\tthis._mixBlur.value = v;\n\t}\n\tget mixStrength(): number {\n\t\treturn this._blurStrength.value;\n\t}\n\tset mixStrength(v: number) {\n\t\tthis._blurStrength.value = v;\n\t}\n\tget minDepthThreshold(): number {\n\t\treturn this._minDepthThreshold.value;\n\t}\n\tset minDepthThreshold(v: number) {\n\t\tthis._minDepthThreshold.value = v;\n\t}\n\tget maxDepthThreshold(): number {\n\t\treturn this._maxDepthThreshold.value;\n\t}\n\tset maxDepthThreshold(v: number) {\n\t\tthis._maxDepthThreshold.value = v;\n\t}\n\tget depthScale(): number {\n\t\treturn this._depthScale.value;\n\t}\n\tset depthScale(v: number) {\n\t\tthis._depthScale.value = v;\n\t}\n\tget depthToBlurRatioBias(): number {\n\t\treturn this._depthToBlurRatioBias.value;\n\t}\n\tset depthToBlurRatioBias(v: number) {\n\t\tthis._depthToBlurRatioBias.value = v;\n\t}\n\tget distortion(): number {\n\t\treturn this._distortion.value;\n\t}\n\tset distortion(v: number) {\n\t\tthis._distortion.value = v;\n\t}\n\tget mixContrast(): number {\n\t\treturn this._mixContrast.value;\n\t}\n\tset mixContrast(v: number) {\n\t\tthis._mixContrast.value = v;\n\t}\n}\n"]}