angular-three-soba 1.13.0 → 1.14.1

package/fesm2015/angular-three-soba-shaders.mjs

@@ -1,1239 +0,0 @@
-import * as THREE from 'three';
-import { ShaderMaterial, Uniform, Vector2, NoBlending, WebGLRenderTarget, LinearFilter, Scene, Camera, BufferGeometry, BufferAttribute, Mesh, MeshStandardMaterial, Vector3, Color } from 'three';
-import { InjectionToken } from '@angular/core';
-import { MeshBVHUniformStruct, shaderStructs, shaderIntersectFunction } from 'three-mesh-bvh';
-
-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);
-    }
-}
-
-class BlurPass {
-    constructor({ gl, resolution, width = 500, height = 500, minDepthThreshold = 0, maxDepthThreshold = 1, depthScale = 0, depthToBlurRatioBias = 0.25, }) {
-        this.renderToScreen = false;
-        this.renderTargetA = new WebGLRenderTarget(resolution, resolution, {
-            minFilter: LinearFilter,
-            magFilter: LinearFilter,
-            stencilBuffer: false,
-            depthBuffer: false,
-            encoding: gl.outputEncoding,
-        });
-        this.renderTargetB = this.renderTargetA.clone();
-        this.convolutionMaterial = new ConvolutionMaterial();
-        this.convolutionMaterial.setTexelSize(1.0 / width, 1.0 / height);
-        this.convolutionMaterial.setResolution(new Vector2(width, height));
-        this.scene = new Scene();
-        this.camera = new Camera();
-        this.convolutionMaterial.uniforms['minDepthThreshold'].value = minDepthThreshold;
-        this.convolutionMaterial.uniforms['maxDepthThreshold'].value = maxDepthThreshold;
-        this.convolutionMaterial.uniforms['depthScale'].value = depthScale;
-        this.convolutionMaterial.uniforms['depthToBlurRatioBias'].value = depthToBlurRatioBias;
-        this.convolutionMaterial.defines['USE_DEPTH'] = depthScale > 0;
-        const vertices = new Float32Array([-1, -1, 0, 3, -1, 0, -1, 3, 0]);
-        const uvs = new Float32Array([0, 0, 2, 0, 0, 2]);
-        const geometry = new BufferGeometry();
-        geometry.setAttribute('position', new BufferAttribute(vertices, 3));
-        geometry.setAttribute('uv', new BufferAttribute(uvs, 2));
-        this.screen = new Mesh(geometry, this.convolutionMaterial);
-        this.screen.frustumCulled = false;
-        this.scene.add(this.screen);
-    }
-    render(renderer, inputBuffer, outputBuffer) {
-        const scene = this.scene;
-        const camera = this.camera;
-        const renderTargetA = this.renderTargetA;
-        const renderTargetB = this.renderTargetB;
-        const material = this.convolutionMaterial;
-        const uniforms = material.uniforms;
-        uniforms['depthBuffer'].value = inputBuffer.depthTexture;
-        const kernel = material.kernel;
-        let lastRT = inputBuffer;
-        let destRT;
-        let i, l;
-        // Apply the multi-pass blur.
-        for (i = 0, l = kernel.length - 1; i < l; ++i) {
-            // Alternate between targets.
-            destRT = (i & 1) === 0 ? renderTargetA : renderTargetB;
-            uniforms['kernel'].value = kernel[i];
-            uniforms['inputBuffer'].value = lastRT.texture;
-            renderer.setRenderTarget(destRT);
-            renderer.render(scene, camera);
-            lastRT = destRT;
-        }
-        uniforms['kernel'].value = kernel[i];
-        uniforms['inputBuffer'].value = lastRT.texture;
-        renderer.setRenderTarget(this.renderToScreen ? null : outputBuffer);
-        renderer.render(scene, camera);
-    }
-}
-
-function shaderMaterial(uniforms, vertexShader, fragmentShader, onInit) {
-    const material = class extends THREE.ShaderMaterial {
-        constructor(parameters = {}) {
-            const entries = Object.entries(uniforms);
-            // Create unforms and shaders
-            super({
-                uniforms: entries.reduce((acc, [name, value]) => {
-                    const uniform = THREE.UniformsUtils.clone({ [name]: { value } });
-                    return Object.assign(Object.assign({}, acc), uniform);
-                }, {}),
-                vertexShader,
-                fragmentShader,
-            });
-            this.key = '';
-            // Create getter/setters
-            entries.forEach(([name]) => Object.defineProperty(this, name, {
-                get: () => this.uniforms[name].value,
-                set: (v) => (this.uniforms[name].value = v),
-            }));
-            // Assign parameters, this might include uniforms
-            Object.assign(this, parameters);
-            // Call onInit
-            if (onInit)
-                onInit(this);
-        }
-    };
-    material.key = THREE.MathUtils.generateUUID();
-    return material;
-}
-
-const CausticsMaterial = shaderMaterial({
-    cameraMatrixWorld: new THREE.Matrix4(),
-    cameraProjectionMatrixInv: new THREE.Matrix4(),
-    normalTexture: null,
-    depthTexture: null,
-    lightDir: new THREE.Vector3(0, 1, 0),
-    lightPlaneNormal: new THREE.Vector3(0, 1, 0),
-    lightPlaneConstant: 0,
-    near: 0.1,
-    far: 100,
-    modelMatrix: new THREE.Matrix4(),
-    worldRadius: 1 / 40,
-    ior: 1.1,
-    bounces: 0,
-    resolution: 1024,
-    size: 10,
-    intensity: 0.5,
-}, 
-/* glsl */ `varying vec2 vUv;
-void main() {
-    vUv = uv;
-    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
-}`, 
-/* glsl */ `uniform mat4 cameraMatrixWorld;
-uniform mat4 cameraProjectionMatrixInv;
-uniform vec3 lightDir;
-uniform vec3 lightPlaneNormal;
-uniform float lightPlaneConstant;
-uniform float near;
-uniform float far;
-uniform float time;
-uniform float worldRadius;
-uniform float resolution;
-uniform float size;
-uniform float intensity;
-uniform float ior;
-precision highp isampler2D;
-precision highp usampler2D;
-uniform sampler2D normalTexture;
-uniform sampler2D depthTexture;
-uniform float bounces;
-varying vec2 vUv;
-vec3 WorldPosFromDepth(float depth, vec2 coord) {
-  float z = depth * 2.0 - 1.0;
-  vec4 clipSpacePosition = vec4(coord * 2.0 - 1.0, z, 1.0);
-  vec4 viewSpacePosition = cameraProjectionMatrixInv * clipSpacePosition;
-  // Perspective division
-  viewSpacePosition /= viewSpacePosition.w;
-  vec4 worldSpacePosition = cameraMatrixWorld * viewSpacePosition;
-  return worldSpacePosition.xyz;
-}
-float sdPlane( vec3 p, vec3 n, float h ) {
-  // n must be normalized
-  return dot(p,n) + h;
-}
-float planeIntersect( vec3 ro, vec3 rd, vec4 p ) {
-  return -(dot(ro,p.xyz)+p.w)/dot(rd,p.xyz);
-}
-vec3 totalInternalReflection(vec3 ro, vec3 rd, vec3 pos, vec3 normal, float ior, out vec3 rayOrigin, out vec3 rayDirection) {
-  rayOrigin = ro;
-  rayDirection = rd;
-  rayDirection = refract(rayDirection, normal, 1.0 / ior);
-  rayOrigin = pos + rayDirection * 0.1;
-  return rayDirection;
-}
-void main() {
-  // Each sample consists of random offset in the x and y direction
-  float caustic = 0.0;
-  float causticTexelSize = (1.0 / resolution) * size * 2.0;
-  float texelsNeeded = worldRadius / causticTexelSize;
-  float sampleRadius = texelsNeeded / resolution;
-  float sum = 0.0;
-  if (texture2D(depthTexture, vUv).x == 1.0) {
-    gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);
-    return;
-  }
-  vec2 offset1 = vec2(-0.5, -0.5);//vec2(rand() - 0.5, rand() - 0.5);
-  vec2 offset2 = vec2(-0.5, 0.5);//vec2(rand() - 0.5, rand() - 0.5);
-  vec2 offset3 = vec2(0.5, 0.5);//vec2(rand() - 0.5, rand() - 0.5);
-  vec2 offset4 = vec2(0.5, -0.5);//vec2(rand() - 0.5, rand() - 0.5);
-  vec2 uv1 = vUv + offset1 * sampleRadius;
-  vec2 uv2 = vUv + offset2 * sampleRadius;
-  vec2 uv3 = vUv + offset3 * sampleRadius;
-  vec2 uv4 = vUv + offset4 * sampleRadius;
-  vec3 normal1 = texture2D(normalTexture, uv1, -10.0).rgb * 2.0 - 1.0;
-  vec3 normal2 = texture2D(normalTexture, uv2, -10.0).rgb * 2.0 - 1.0;
-  vec3 normal3 = texture2D(normalTexture, uv3, -10.0).rgb * 2.0 - 1.0;
-  vec3 normal4 = texture2D(normalTexture, uv4, -10.0).rgb * 2.0 - 1.0;
-  float depth1 = texture2D(depthTexture, uv1, -10.0).x;
-  float depth2 = texture2D(depthTexture, uv2, -10.0).x;
-  float depth3 = texture2D(depthTexture, uv3, -10.0).x;
-  float depth4 = texture2D(depthTexture, uv4, -10.0).x;
-  // Sanity check the depths
-  if (depth1 == 1.0 || depth2 == 1.0 || depth3 == 1.0 || depth4 == 1.0) {
-    gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);
-    return;
-  }
-  vec3 pos1 = WorldPosFromDepth(depth1, uv1);
-  vec3 pos2 = WorldPosFromDepth(depth2, uv2);
-  vec3 pos3 = WorldPosFromDepth(depth3, uv3);
-  vec3 pos4 = WorldPosFromDepth(depth4, uv4);
-  vec3 originPos1 = WorldPosFromDepth(0.0, uv1);
-  vec3 originPos2 = WorldPosFromDepth(0.0, uv2);
-  vec3 originPos3 = WorldPosFromDepth(0.0, uv3);
-  vec3 originPos4 = WorldPosFromDepth(0.0, uv4);
-  vec3 endPos1, endPos2, endPos3, endPos4;
-  vec3 endDir1, endDir2, endDir3, endDir4;
-  totalInternalReflection(originPos1, lightDir, pos1, normal1, ior, endPos1, endDir1);
-  totalInternalReflection(originPos2, lightDir, pos2, normal2, ior, endPos2, endDir2);
-  totalInternalReflection(originPos3, lightDir, pos3, normal3, ior, endPos3, endDir3);
-  totalInternalReflection(originPos4, lightDir, pos4, normal4, ior, endPos4, endDir4);
-  float lightPosArea = length(cross(originPos2 - originPos1, originPos3 - originPos1)) + length(cross(originPos3 - originPos1, originPos4 - originPos1));
-  float t1 = planeIntersect(endPos1, endDir1, vec4(lightPlaneNormal, lightPlaneConstant));
-  float t2 = planeIntersect(endPos2, endDir2, vec4(lightPlaneNormal, lightPlaneConstant));
-  float t3 = planeIntersect(endPos3, endDir3, vec4(lightPlaneNormal, lightPlaneConstant));
-  float t4 = planeIntersect(endPos4, endDir4, vec4(lightPlaneNormal, lightPlaneConstant));
-  vec3 finalPos1 = endPos1 + endDir1 * t1;
-  vec3 finalPos2 = endPos2 + endDir2 * t2;
-  vec3 finalPos3 = endPos3 + endDir3 * t3;
-  vec3 finalPos4 = endPos4 + endDir4 * t4;
-  float finalArea = length(cross(finalPos2 - finalPos1, finalPos3 - finalPos1)) + length(cross(finalPos3 - finalPos1, finalPos4 - finalPos1));
-  caustic += intensity * (lightPosArea / finalArea);
-  // Calculate the area of the triangle in light spaces
-  gl_FragColor = vec4(vec3(max(caustic, 0.0)), 1.0);
-}`);
-
-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>
-}`);
-
-const DiscardMaterial = shaderMaterial({}, 'void main() { }', 'void main() { gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0); discard;  }');
-
-const NGTS_DISTORT_MATERIAL_SHADER = new InjectionToken('DistortMaterialShader');
-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;
-                }
-            };
-        },
-    };
-}
-
-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) {
-        var _a;
-        if (!((_a = shader.defines) === null || _a === void 0 ? void 0 : _a.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;
-    }
-}
-
-// Author: N8Programs
-const MeshRefractionMaterial = shaderMaterial({
-    envMap: null,
-    bounces: 3,
-    ior: 2.4,
-    correctMips: true,
-    aberrationStrength: 0.01,
-    fresnel: 0,
-    bvh: new MeshBVHUniformStruct(),
-    color: new THREE.Color('white'),
-    resolution: new THREE.Vector2(),
-    viewMatrixInverse: new THREE.Matrix4(),
-    projectionMatrixInverse: new THREE.Matrix4(),
-}, 
-/*glsl*/ `
-  uniform mat4 viewMatrixInverse;
-
-  varying vec3 vWorldPosition;
-  varying vec3 vNormal;
-  varying mat4 vModelMatrixInverse;
-
-  #ifdef USE_INSTANCING_COLOR
-    varying vec3 vInstanceColor;
-  #endif
-
-  void main() {
-    vec4 transformedNormal = vec4(normal, 0.0);
-    vec4 transformedPosition = vec4(position, 1.0);
-    #ifdef USE_INSTANCING
-      transformedNormal = instanceMatrix * transformedNormal;
-      transformedPosition = instanceMatrix * transformedPosition;
-    #endif
-
-    #ifdef USE_INSTANCING
-      vModelMatrixInverse = inverse(modelMatrix * instanceMatrix);
-    #else
-      vModelMatrixInverse = inverse(modelMatrix);
-    #endif
-
-    #ifdef USE_INSTANCING_COLOR
-      vInstanceColor = instanceColor.rgb;
-    #endif
-
-    vWorldPosition = (modelMatrix * transformedPosition).xyz;
-    vNormal = normalize((viewMatrixInverse * vec4(normalMatrix * transformedNormal.xyz, 0.0)).xyz);
-    gl_Position = projectionMatrix * viewMatrix * modelMatrix * transformedPosition;
-  }`, 
-/*glsl*/ `
-  #define ENVMAP_TYPE_CUBE_UV
-  precision highp isampler2D;
-  precision highp usampler2D;
-  varying vec3 vWorldPosition;
-  varying vec3 vNormal;
-  varying mat4 vModelMatrixInverse;
-
-  #ifdef USE_INSTANCING_COLOR
-    varying vec3 vInstanceColor;
-  #endif
-
-  #ifdef ENVMAP_TYPE_CUBEM
-    uniform samplerCube envMap;
-  #else
-    uniform sampler2D envMap;
-  #endif
-
-  uniform float bounces;
-  ${shaderStructs}
-  ${shaderIntersectFunction}
-  uniform BVH bvh;
-  uniform float ior;
-  uniform bool correctMips;
-  uniform vec2 resolution;
-  uniform float fresnel;
-  uniform mat4 modelMatrix;
-  uniform mat4 projectionMatrixInverse;
-  uniform mat4 viewMatrixInverse;
-  uniform float aberrationStrength;
-  uniform vec3 color;
-
-  float fresnelFunc(vec3 viewDirection, vec3 worldNormal) {
-    return pow( 1.0 + dot( viewDirection, worldNormal), 10.0 );
-  }
-
-  vec3 totalInternalReflection(vec3 ro, vec3 rd, vec3 normal, float ior, mat4 modelMatrixInverse) {
-    vec3 rayOrigin = ro;
-    vec3 rayDirection = rd;
-    rayDirection = refract(rayDirection, normal, 1.0 / ior);
-    rayOrigin = vWorldPosition + rayDirection * 0.001;
-    rayOrigin = (modelMatrixInverse * vec4(rayOrigin, 1.0)).xyz;
-    rayDirection = normalize((modelMatrixInverse * vec4(rayDirection, 0.0)).xyz);
-    for(float i = 0.0; i < bounces; i++) {
-      uvec4 faceIndices = uvec4( 0u );
-      vec3 faceNormal = vec3( 0.0, 0.0, 1.0 );
-      vec3 barycoord = vec3( 0.0 );
-      float side = 1.0;
-      float dist = 0.0;
-      bvhIntersectFirstHit( bvh, rayOrigin, rayDirection, faceIndices, faceNormal, barycoord, side, dist );
-      vec3 hitPos = rayOrigin + rayDirection * max(dist - 0.001, 0.0);
-      vec3 tempDir = refract(rayDirection, faceNormal, ior);
-      if (length(tempDir) != 0.0) {
-        rayDirection = tempDir;
-        break;
-      }
-      rayDirection = reflect(rayDirection, faceNormal);
-      rayOrigin = hitPos + rayDirection * 0.01;
-    }
-    rayDirection = normalize((modelMatrix * vec4(rayDirection, 0.0)).xyz);
-    return rayDirection;
-  }
-
-  #include <common>
-  #include <cube_uv_reflection_fragment>
-
-  #ifdef ENVMAP_TYPE_CUBEM
-    vec4 textureGradient(samplerCube envMap, vec3 rayDirection, vec3 directionCamPerfect) {
-      return textureGrad(envMap, rayDirection, dFdx(correctMips ? directionCamPerfect: rayDirection), dFdy(correctMips ? directionCamPerfect: rayDirection));
-    }
-  #else
-    vec4 textureGradient(sampler2D envMap, vec3 rayDirection, vec3 directionCamPerfect) {
-      vec2 uvv = equirectUv( rayDirection );
-      vec2 smoothUv = equirectUv( directionCamPerfect );
-      return textureGrad(envMap, uvv, dFdx(correctMips ? smoothUv : uvv), dFdy(correctMips ? smoothUv : uvv));
-    }
-  #endif
-
-  void main() {
-    vec2 uv = gl_FragCoord.xy / resolution;
-    vec3 directionCamPerfect = (projectionMatrixInverse * vec4(uv * 2.0 - 1.0, 0.0, 1.0)).xyz;
-    directionCamPerfect = (viewMatrixInverse * vec4(directionCamPerfect, 0.0)).xyz;
-    directionCamPerfect = normalize(directionCamPerfect);
-    vec3 normal = vNormal;
-    vec3 rayOrigin = cameraPosition;
-    vec3 rayDirection = normalize(vWorldPosition - cameraPosition);
-    vec3 finalColor;
-    #ifdef CHROMATIC_ABERRATIONS
-      vec3 rayDirectionG = totalInternalReflection(rayOrigin, rayDirection, normal, max(ior, 1.0), vModelMatrixInverse);
-      #ifdef FAST_CHROMA
-        vec3 rayDirectionR = normalize(rayDirectionG + 1.0 * vec3(aberrationStrength / 2.0));
-        vec3 rayDirectionB = normalize(rayDirectionG - 1.0 * vec3(aberrationStrength / 2.0));
-      #else
-        vec3 rayDirectionR = totalInternalReflection(rayOrigin, rayDirection, normal, max(ior * (1.0 - aberrationStrength), 1.0), vModelMatrixInverse);
-        vec3 rayDirectionB = totalInternalReflection(rayOrigin, rayDirection, normal, max(ior * (1.0 + aberrationStrength), 1.0), vModelMatrixInverse);
-      #endif
-      float finalColorR = textureGradient(envMap, rayDirectionR, directionCamPerfect).r;
-      float finalColorG = textureGradient(envMap, rayDirectionG, directionCamPerfect).g;
-      float finalColorB = textureGradient(envMap, rayDirectionB, directionCamPerfect).b;
-      finalColor = vec3(finalColorR, finalColorG, finalColorB);
-    #else
-      rayDirection = totalInternalReflection(rayOrigin, rayDirection, normal, max(ior, 1.0), vModelMatrixInverse);
-      finalColor = textureGradient(envMap, rayDirection, directionCamPerfect).rgb;
-    #endif
-
-    finalColor *= color;
-    #ifdef USE_INSTANCING_COLOR
-      finalColor *= vInstanceColor;
-    #endif
-
-    vec3 viewDirection = normalize(vWorldPosition - cameraPosition);
-    float nFresnel = fresnelFunc(viewDirection, normal) * fresnel;
-    gl_FragColor = vec4(mix(finalColor, vec3(1.0), nFresnel), 1.0);
-    #include <tonemapping_fragment>
-    #include <encodings_fragment>
-  }`);
-
-class MeshTransmissionMaterial extends THREE.MeshPhysicalMaterial {
-    constructor(samples = 6, transmissionSampler = false) {
-        super();
-        this.uniforms = {
-            chromaticAberration: { value: 0.05 },
-            // Transmission must always be 0, unless transmissionSampler is being used
-            transmission: { value: 0 },
-            // Instead a workaround is used, see below for reasons why
-            _transmission: { value: 1 },
-            transmissionMap: { value: null },
-            // Roughness is 1 in THREE.MeshPhysicalMaterial but it makes little sense in a transmission material
-            roughness: { value: 0 },
-            thickness: { value: 0 },
-            thicknessMap: { value: null },
-            attenuationDistance: { value: Infinity },
-            attenuationColor: { value: new THREE.Color('white') },
-            anisotropy: { value: 0.1 },
-            time: { value: 0 },
-            distortion: { value: 0.0 },
-            distortionScale: { value: 0.5 },
-            temporalDistortion: { value: 0.0 },
-            buffer: { value: null },
-        };
-        this.onBeforeCompile = (shader) => {
-            shader.uniforms = Object.assign(Object.assign({}, shader.uniforms), this.uniforms);
-            // If the transmission sampler is active inject a flag
-            if (transmissionSampler)
-                shader.defines['USE_SAMPLER'] = '';
-            // Otherwise we do use use .transmission and must therefore force USE_TRANSMISSION
-            // because threejs won't inject it for us
-            else
-                shader.defines['USE_TRANSMISSION'] = '';
-            // Head
-            shader.fragmentShader =
-                /*glsl*/ `
-      uniform float chromaticAberration;
-      uniform float anisotropy;
-      uniform float time;
-      uniform float distortion;
-      uniform float distortionScale;
-      uniform float temporalDistortion;
-      uniform sampler2D buffer;
-
-      vec3 random3(vec3 c) {
-        float j = 4096.0*sin(dot(c,vec3(17.0, 59.4, 15.0)));
-        vec3 r;
-        r.z = fract(512.0*j);
-        j *= .125;
-        r.x = fract(512.0*j);
-        j *= .125;
-        r.y = fract(512.0*j);
-        return r-0.5;
-      }
-
-      float seed = 0.0;
-      uint hash( uint x ) {
-        x += ( x << 10u );
-        x ^= ( x >>  6u );
-        x += ( x <<  3u );
-        x ^= ( x >> 11u );
-        x += ( x << 15u );
-        return x;
-      }
-
-      // Compound versions of the hashing algorithm I whipped together.
-      uint hash( uvec2 v ) { return hash( v.x ^ hash(v.y)                         ); }
-      uint hash( uvec3 v ) { return hash( v.x ^ hash(v.y) ^ hash(v.z)             ); }
-      uint hash( uvec4 v ) { return hash( v.x ^ hash(v.y) ^ hash(v.z) ^ hash(v.w) ); }
-
-      // Construct a float with half-open range [0:1] using low 23 bits.
-      // All zeroes yields 0.0, all ones yields the next smallest representable value below 1.0.
-      float floatConstruct( uint m ) {
-        const uint ieeeMantissa = 0x007FFFFFu; // binary32 mantissa bitmask
-        const uint ieeeOne      = 0x3F800000u; // 1.0 in IEEE binary32
-        m &= ieeeMantissa;                     // Keep only mantissa bits (fractional part)
-        m |= ieeeOne;                          // Add fractional part to 1.0
-        float  f = uintBitsToFloat( m );       // Range [1:2]
-        return f - 1.0;                        // Range [0:1]
-      }
-
-      // Pseudo-random value in half-open range [0:1].
-      float random( float x ) { return floatConstruct(hash(floatBitsToUint(x))); }
-      float random( vec2  v ) { return floatConstruct(hash(floatBitsToUint(v))); }
-      float random( vec3  v ) { return floatConstruct(hash(floatBitsToUint(v))); }
-      float random( vec4  v ) { return floatConstruct(hash(floatBitsToUint(v))); }
-
-      float rand() {
-        float result = random(vec3(gl_FragCoord.xy, seed));
-        seed += 1.0;
-        return result;
-      }
-
-      const float F3 =  0.3333333;
-      const float G3 =  0.1666667;
-
-      float snoise(vec3 p) {
-        vec3 s = floor(p + dot(p, vec3(F3)));
-        vec3 x = p - s + dot(s, vec3(G3));
-        vec3 e = step(vec3(0.0), x - x.yzx);
-        vec3 i1 = e*(1.0 - e.zxy);
-        vec3 i2 = 1.0 - e.zxy*(1.0 - e);
-        vec3 x1 = x - i1 + G3;
-        vec3 x2 = x - i2 + 2.0*G3;
-        vec3 x3 = x - 1.0 + 3.0*G3;
-        vec4 w, d;
-        w.x = dot(x, x);
-        w.y = dot(x1, x1);
-        w.z = dot(x2, x2);
-        w.w = dot(x3, x3);
-        w = max(0.6 - w, 0.0);
-        d.x = dot(random3(s), x);
-        d.y = dot(random3(s + i1), x1);
-        d.z = dot(random3(s + i2), x2);
-        d.w = dot(random3(s + 1.0), x3);
-        w *= w;
-        w *= w;
-        d *= w;
-        return dot(d, vec4(52.0));
-      }
-
-      float snoiseFractal(vec3 m) {
-        return 0.5333333* snoise(m)
-              +0.2666667* snoise(2.0*m)
-              +0.1333333* snoise(4.0*m)
-              +0.0666667* snoise(8.0*m);
-      }\n` + shader.fragmentShader;
-            // Remove transmission
-            shader.fragmentShader = shader.fragmentShader.replace('#include <transmission_pars_fragment>', 
-            /*glsl*/ `
-        #ifdef USE_TRANSMISSION
-          // Transmission code is based on glTF-Sampler-Viewer
-          // https://github.com/KhronosGroup/glTF-Sample-Viewer
-          uniform float _transmission;
-          uniform float thickness;
-          uniform float attenuationDistance;
-          uniform vec3 attenuationColor;
-          #ifdef USE_TRANSMISSIONMAP
-            uniform sampler2D transmissionMap;
-          #endif
-          #ifdef USE_THICKNESSMAP
-            uniform sampler2D thicknessMap;
-          #endif
-          uniform vec2 transmissionSamplerSize;
-          uniform sampler2D transmissionSamplerMap;
-          uniform mat4 modelMatrix;
-          uniform mat4 projectionMatrix;
-          varying vec3 vWorldPosition;
-          vec3 getVolumeTransmissionRay( const in vec3 n, const in vec3 v, const in float thickness, const in float ior, const in mat4 modelMatrix ) {
-            // Direction of refracted light.
-            vec3 refractionVector = refract( - v, normalize( n ), 1.0 / ior );
-            // Compute rotation-independant scaling of the model matrix.
-            vec3 modelScale;
-            modelScale.x = length( vec3( modelMatrix[ 0 ].xyz ) );
-            modelScale.y = length( vec3( modelMatrix[ 1 ].xyz ) );
-            modelScale.z = length( vec3( modelMatrix[ 2 ].xyz ) );
-            // The thickness is specified in local space.
-            return normalize( refractionVector ) * thickness * modelScale;
-          }
-          float applyIorToRoughness( const in float roughness, const in float ior ) {
-            // Scale roughness with IOR so that an IOR of 1.0 results in no microfacet refraction and
-            // an IOR of 1.5 results in the default amount of microfacet refraction.
-            return roughness * clamp( ior * 2.0 - 2.0, 0.0, 1.0 );
-          }
-          vec4 getTransmissionSample( const in vec2 fragCoord, const in float roughness, const in float ior ) {
-            float framebufferLod = log2( transmissionSamplerSize.x ) * applyIorToRoughness( roughness, ior );
-            #ifdef USE_SAMPLER
-              #ifdef texture2DLodEXT
-                return texture2DLodEXT(transmissionSamplerMap, fragCoord.xy, framebufferLod);
-              #else
-                return texture2D(transmissionSamplerMap, fragCoord.xy, framebufferLod);
-              #endif
-            #else
-              return texture2D(buffer, fragCoord.xy);
-            #endif
-          }
-          vec3 applyVolumeAttenuation( const in vec3 radiance, const in float transmissionDistance, const in vec3 attenuationColor, const in float attenuationDistance ) {
-            if ( isinf( attenuationDistance ) ) {
-              // Attenuation distance is +∞, i.e. the transmitted color is not attenuated at all.
-              return radiance;
-            } else {
-              // Compute light attenuation using Beer's law.
-              vec3 attenuationCoefficient = -log( attenuationColor ) / attenuationDistance;
-              vec3 transmittance = exp( - attenuationCoefficient * transmissionDistance ); // Beer's law
-              return transmittance * radiance;
-            }
-          }
-          vec4 getIBLVolumeRefraction( const in vec3 n, const in vec3 v, const in float roughness, const in vec3 diffuseColor,
-            const in vec3 specularColor, const in float specularF90, const in vec3 position, const in mat4 modelMatrix,
-            const in mat4 viewMatrix, const in mat4 projMatrix, const in float ior, const in float thickness,
-            const in vec3 attenuationColor, const in float attenuationDistance ) {
-            vec3 transmissionRay = getVolumeTransmissionRay( n, v, thickness, ior, modelMatrix );
-            vec3 refractedRayExit = position + transmissionRay;
-            // Project refracted vector on the framebuffer, while mapping to normalized device coordinates.
-            vec4 ndcPos = projMatrix * viewMatrix * vec4( refractedRayExit, 1.0 );
-            vec2 refractionCoords = ndcPos.xy / ndcPos.w;
-            refractionCoords += 1.0;
-            refractionCoords /= 2.0;
-            // Sample framebuffer to get pixel the refracted ray hits.
-            vec4 transmittedLight = getTransmissionSample( refractionCoords, roughness, ior );
-            vec3 attenuatedColor = applyVolumeAttenuation( transmittedLight.rgb, length( transmissionRay ), attenuationColor, attenuationDistance );
-            // Get the specular component.
-            vec3 F = EnvironmentBRDF( n, v, specularColor, specularF90, roughness );
-            return vec4( ( 1.0 - F ) * attenuatedColor * diffuseColor, transmittedLight.a );
-          }
-        #endif\n`);
-            // Add refraction
-            shader.fragmentShader = shader.fragmentShader.replace('#include <transmission_fragment>', 
-            /*glsl*/ `
-        // Improve the refraction to use the world pos
-        material.transmission = _transmission;
-        material.transmissionAlpha = 1.0;
-        material.thickness = thickness;
-        material.attenuationDistance = attenuationDistance;
-        material.attenuationColor = attenuationColor;
-        #ifdef USE_TRANSMISSIONMAP
-          material.transmission *= texture2D( transmissionMap, vUv ).r;
-        #endif
-        #ifdef USE_THICKNESSMAP
-          material.thickness *= texture2D( thicknessMap, vUv ).g;
-        #endif
-
-        vec3 pos = vWorldPosition;
-        vec3 v = normalize( cameraPosition - pos );
-        vec3 n = inverseTransformDirection( normal, viewMatrix );
-        vec3 transmission = vec3(0.0);
-        float transmissionR, transmissionB, transmissionG;
-        float randomCoords = rand();
-        float thickness_smear = thickness * max(pow(roughnessFactor, 0.33), anisotropy);
-        vec3 distortionNormal = vec3(0.0);
-        vec3 temporalOffset = vec3(time, -time, -time) * temporalDistortion;
-        if (distortion > 0.0) {
-          distortionNormal = distortion * vec3(snoiseFractal(vec3((pos * distortionScale + temporalOffset))), snoiseFractal(vec3(pos.zxy * distortionScale - temporalOffset)), snoiseFractal(vec3(pos.yxz * distortionScale + temporalOffset)));
-        }
-        for (float i = 0.0; i < ${samples}.0; i ++) {
-          vec3 sampleNorm = normalize(n + roughnessFactor * roughnessFactor * 2.0 * normalize(vec3(rand() - 0.5, rand() - 0.5, rand() - 0.5)) * pow(rand(), 0.33) + distortionNormal);
-          transmissionR = getIBLVolumeRefraction(
-            sampleNorm, v, material.roughness, material.diffuseColor, material.specularColor, material.specularF90,
-            pos, modelMatrix, viewMatrix, projectionMatrix, material.ior, material.thickness  + thickness_smear * (i + randomCoords) / float(${samples}),
-            material.attenuationColor, material.attenuationDistance
-          ).r;
-          transmissionG = getIBLVolumeRefraction(
-            sampleNorm, v, material.roughness, material.diffuseColor, material.specularColor, material.specularF90,
-            pos, modelMatrix, viewMatrix, projectionMatrix, material.ior  * (1.0 + chromaticAberration * (i + randomCoords) / float(${samples})) , material.thickness + thickness_smear * (i + randomCoords) / float(${samples}),
-            material.attenuationColor, material.attenuationDistance
-          ).g;
-          transmissionB = getIBLVolumeRefraction(
-            sampleNorm, v, material.roughness, material.diffuseColor, material.specularColor, material.specularF90,
-            pos, modelMatrix, viewMatrix, projectionMatrix, material.ior * (1.0 + 2.0 * chromaticAberration * (i + randomCoords) / float(${samples})), material.thickness + thickness_smear * (i + randomCoords) / float(${samples}),
-            material.attenuationColor, material.attenuationDistance
-          ).b;
-          transmission.r += transmissionR;
-          transmission.g += transmissionG;
-          transmission.b += transmissionB;
-        }
-        transmission /= ${samples}.0;
-        totalDiffuse = mix( totalDiffuse, transmission.rgb, material.transmission );\n`);
-        };
-        Object.keys(this.uniforms).forEach((name) => Object.defineProperty(this, name, {
-            get: () => this.uniforms[name].value,
-            set: (v) => (this.uniforms[name].value = v),
-        }));
-    }
-}
-
-class MeshWobbleMaterial extends THREE.MeshStandardMaterial {
-    constructor(parameters = {}) {
-        super(parameters);
-        this.setValues(parameters);
-        this._time = { value: 0 };
-        this._factor = { value: 1 };
-    }
-    onBeforeCompile(shader) {
-        shader.uniforms['time'] = this._time;
-        shader.uniforms['factor'] = this._factor;
-        shader.vertexShader = `
-      uniform float time;
-      uniform float factor;
-      ${shader.vertexShader}
-    `;
-        shader.vertexShader = shader.vertexShader.replace('#include <begin_vertex>', `float theta = sin( time + position.y ) / 2.0 * factor;
-        float c = cos( theta );
-        float s = sin( theta );
-        mat3 m = mat3( c, 0, s, 0, 1, 0, -s, 0, c );
-        vec3 transformed = vec3( position ) * m;
-        vNormal = vNormal * m;`);
-    }
-    get time() {
-        return this._time.value;
-    }
-    set time(v) {
-        this._time.value = v;
-    }
-    get factor() {
-        return this._factor.value;
-    }
-    set factor(v) {
-        this._factor.value = v;
-    }
-}
-
-const SoftShadowMaterial = shaderMaterial({
-    color: new THREE.Color(),
-    blend: 2.0,
-    alphaTest: 0.75,
-    opacity: 0,
-    map: null,
-}, 
-// language=GLSL
-`
-varying vec2 vUv;
-void main() {
-  gl_Position = projectionMatrix * viewMatrix * modelMatrix * vec4(position, 1.);
-  vUv = uv;
-}
-  `, 
-// language=GLSL
-`
-varying vec2 vUv;
-uniform sampler2D map;
-uniform vec3 color;
-uniform float blend;
-uniform float opacity;
-uniform float alphaTest;
-void main() {
-  vec4 sampledDiffuseColor = texture2D(map, vUv);
-  gl_FragColor = vec4(color * sampledDiffuseColor.r * blend, max(0.0, (1.0 - (sampledDiffuseColor.r + sampledDiffuseColor.g + sampledDiffuseColor.b) / alphaTest)) * opacity);
-  #include <tonemapping_fragment>
-  #include <encodings_fragment>
-}
-  `);
-
-class SpotLightMaterial extends ShaderMaterial {
-    constructor() {
-        super({
-            uniforms: {
-                depth: { value: null },
-                opacity: { value: 1 },
-                attenuation: { value: 2.5 },
-                anglePower: { value: 12 },
-                spotPosition: { value: new Vector3(0, 0, 0) },
-                lightColor: { value: new Color('white') },
-                cameraNear: { value: 0 },
-                cameraFar: { value: 1 },
-                resolution: { value: new Vector2(0, 0) },
-            },
-            transparent: true,
-            depthWrite: false,
-            vertexShader: /* glsl */ `
-      varying vec3 vNormal;
-      varying vec3 vWorldPosition;
-      varying float vViewZ;
-      varying float vIntensity;
-      uniform vec3 spotPosition;
-      uniform float attenuation;
-
-      void main() {
-        // compute intensity
-        vNormal = normalize( normalMatrix * normal );
-        vec4 worldPosition	= modelMatrix * vec4( position, 1.0 );
-        vWorldPosition = worldPosition.xyz;
-        vec4 viewPosition = viewMatrix * worldPosition;
-        vViewZ = viewPosition.z;
-        float intensity	= distance(worldPosition.xyz, spotPosition) / attenuation;
-        intensity	= 1.0 - clamp(intensity, 0.0, 1.0);
-        vIntensity = intensity;
-        // set gl_Position
-        gl_Position	= projectionMatrix * viewPosition;
-
-      }`,
-            fragmentShader: /* glsl */ `
-      #include <packing>
-
-      varying vec3 vNormal;
-      varying vec3 vWorldPosition;
-      uniform vec3 lightColor;
-      uniform vec3 spotPosition;
-      uniform float attenuation;
-      uniform float anglePower;
-      uniform sampler2D depth;
-      uniform vec2 resolution;
-      uniform float cameraNear;
-      uniform float cameraFar;
-      varying float vViewZ;
-      varying float vIntensity;
-      uniform float opacity;
-
-      float readDepth( sampler2D depthSampler, vec2 coord ) {
-        float fragCoordZ = texture2D( depthSampler, coord ).x;
-        float viewZ = perspectiveDepthToViewZ(fragCoordZ, cameraNear, cameraFar);
-        return viewZ;
-      }
-
-      void main() {
-        float d = 1.0;
-        bool isSoft = resolution[0] > 0.0 && resolution[1] > 0.0;
-        if (isSoft) {
-          vec2 sUv = gl_FragCoord.xy / resolution;
-          d = readDepth(depth, sUv);
-        }
-        float intensity = vIntensity;
-        vec3 normal	= vec3(vNormal.x, vNormal.y, abs(vNormal.z));
-        float angleIntensity	= pow( dot(normal, vec3(0.0, 0.0, 1.0)), anglePower );
-        intensity	*= angleIntensity;
-        // fades when z is close to sampled depth, meaning the cone is intersecting existing geometry
-        if (isSoft) {
-          intensity	*= smoothstep(0., 1., vViewZ - d);
-        }
-        gl_FragColor = vec4(lightColor, intensity * opacity);
-
-        #include <tonemapping_fragment>
-	      #include <encodings_fragment>
-      }`,
-        });
-    }
-}
-
-const StarFieldMaterial = shaderMaterial({ time: 0.0, fade: 0.0 }, 
-// language=GLSL
-`
-uniform float time;
-attribute float size;
-varying vec3 vColor;
-void main() {
-  vColor = color;
-  vec4 mvPosition = modelViewMatrix * vec4(position, 0.5);
-  gl_PointSize = size * (30.0 / -mvPosition.z) * (3.0 + sin(time + 100.0));
-  gl_Position = projectionMatrix * mvPosition;
-}
-  `, 
-// language=GLSL
-`
-uniform sampler2D pointTexture;
-uniform float fade;
-varying vec3 vColor;
-void main() {
-  float opacity = 1.0;
-  if (fade == 1.0) {
-    float d = distance(gl_PointCoord, vec2(0.5, 0.5));
-    opacity = 1.0 / (1.0 + exp(16.0 * (d - 0.25)));
-  }
-  gl_FragColor = vec4(vColor, opacity);
-
-  #include <tonemapping_fragment>
-  #include <encodings_fragment>
-}
-  `);
-
-/**
- * Generated bundle index. Do not edit.
- */
-
-export { BlurPass, CausticsMaterial, CausticsProjectionMaterial, ConvolutionMaterial, DiscardMaterial, MeshReflectorMaterial, MeshRefractionMaterial, MeshTransmissionMaterial, MeshWobbleMaterial, NGTS_DISTORT_MATERIAL_SHADER, SoftShadowMaterial, SpotLightMaterial, StarFieldMaterial, provideNgtsMeshDistortMaterialShader, shaderMaterial };
-//# sourceMappingURL=angular-three-soba-shaders.mjs.map