angular-three-soba 2.0.0-beta.26 → 2.0.0-beta.261

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

@@ -1,368 +1,25 @@
+import { getVersion } from 'angular-three-soba/misc';
+import { shaderMaterial } from 'angular-three-soba/vanilla-exports';
 import * as THREE from 'three';
-import { ShaderMaterial, Uniform, Vector2, NoBlending, WebGLRenderTarget, LinearFilter, HalfFloatType, Scene, PerspectiveCamera, BufferGeometry, BufferAttribute, Mesh, MeshStandardMaterial } from 'three';
-import { InjectionToken, inject, runInInjectionContext, computed, effect } from '@angular/core';
+import { Color, Vector3 } from 'three';
 import { MeshBVHUniformStruct, shaderStructs, shaderIntersectFunction } from 'three-mesh-bvh';
-import { assertInjectionContext } from 'angular-three';
-
-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,
-            type: HalfFloatType,
-        });
-        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 PerspectiveCamera();
-        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;
-        let material = this.convolutionMaterial;
-        let 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 {
-                        ...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(),
-}, `varying vec3 vWorldPosition;
-   void main() {
-     gl_Position = projectionMatrix * viewMatrix * modelMatrix * vec4(position, 1.);
-     vec4 worldPosition = modelMatrix * vec4(position, 1.);
-     vWorldPosition = worldPosition.xyz;
-   }`, `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 <${parseInt(THREE.REVISION.replace(/\D+/g, '')) >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
-   }`);
-
-const DiscardMaterial = shaderMaterial({}, 'void main() { }', 'void main() { gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0); discard;  }');
 
 const GridMaterial = shaderMaterial({
     cellSize: 0.5,
     sectionSize: 1,
     fadeDistance: 100,
     fadeStrength: 1,
+    fadeFrom: 1,
     cellThickness: 0.5,
     sectionThickness: 1,
-    cellColor: new THREE.Color(),
-    sectionColor: new THREE.Color(),
+    cellColor: new Color(),
+    sectionColor: new Color(),
     infiniteGrid: false,
     followCamera: false,
-    worldCamProjPosition: new THREE.Vector3(),
-    worldPlanePosition: new THREE.Vector3(),
+    worldCamProjPosition: new Vector3(),
+    worldPlanePosition: new Vector3(),
 }, 
-/* glsl */ `
+/* language=glsl glsl */ `
     varying vec3 localPosition;
     varying vec4 worldPosition;
 
@@ -385,7 +42,7 @@ const GridMaterial = shaderMaterial({
       gl_Position = projectionMatrix * viewMatrix * worldPosition;
     }
   `, 
-/* glsl */ `
+/* language=glsl glsl */ `
     varying vec3 localPosition;
     varying vec4 worldPosition;
 
@@ -396,6 +53,7 @@ const GridMaterial = shaderMaterial({
     uniform vec3 sectionColor;
     uniform float fadeDistance;
     uniform float fadeStrength;
+    uniform float fadeFrom;
     uniform float cellThickness;
     uniform float sectionThickness;
 
@@ -410,7 +68,8 @@ const GridMaterial = shaderMaterial({
       float g1 = getGrid(cellSize, cellThickness);
       float g2 = getGrid(sectionSize, sectionThickness);
 
-      float dist = distance(worldCamProjPosition, worldPosition.xyz);
+      vec3 from = worldCamProjPosition*vec3(fadeFrom);
+      float dist = distance(from, worldPosition.xyz);
       float d = 1.0 - min(dist / fadeDistance, 1.0);
       vec3 color = mix(cellColor, sectionColor, min(1.0, sectionThickness * g2));
 
@@ -419,288 +78,10 @@ const GridMaterial = shaderMaterial({
       if (gl_FragColor.a <= 0.0) discard;
 
       #include <tonemapping_fragment>
-      #include <${parseInt(THREE.REVISION.replace(/\D+/g, '')) >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
+      #include <${getVersion() >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
     }
   `);
 
-const NGTS_DISTORT_MATERIAL_SHADER = new InjectionToken('DistortMaterialShader');
-function injectNgtsMeshDistortMaterial() {
-    return inject(NGTS_DISTORT_MATERIAL_SHADER);
-}
-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;
-        }
-    };
-}
-function provideNgtsMeshDistortMaterialShader(distortShader) {
-    return { provide: NGTS_DISTORT_MATERIAL_SHADER, useFactory: () => createMeshDistortMaterial(distortShader) };
-}
-
-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;
-    }
-}
-
-// Author: N8Programs
-// https://github.com/N8python/diamonds
 const MeshRefractionMaterial = shaderMaterial({
     envMap: null,
     bounces: 3,
@@ -708,25 +89,26 @@ const MeshRefractionMaterial = shaderMaterial({
     correctMips: true,
     aberrationStrength: 0.01,
     fresnel: 0,
-    // @ts-expect-error: typing is not matched
+    // @ts-expect-error - UniformValue from pmndrs/vanilla does not include MeshBVHUniformStruct
     bvh: new MeshBVHUniformStruct(),
     color: new THREE.Color('white'),
+    opacity: 1,
     resolution: new THREE.Vector2(),
     viewMatrixInverse: new THREE.Matrix4(),
     projectionMatrixInverse: new THREE.Matrix4(),
 }, 
-/*glsl*/ `
+/* language=glsl glsl */ `
   uniform mat4 viewMatrixInverse;
 
   varying vec3 vWorldPosition;
   varying vec3 vNormal;
   varying mat4 vModelMatrixInverse;
 
-  #ifdef USE_INSTANCING_COLOR
-    varying vec3 vInstanceColor;
-  #endif
+  #include <color_pars_vertex>
 
   void main() {
+    #include <color_vertex>
+
     vec4 transformedNormal = vec4(normal, 0.0);
     vec4 transformedPosition = vec4(position, 1.0);
     #ifdef USE_INSTANCING
@@ -740,15 +122,11 @@ const MeshRefractionMaterial = shaderMaterial({
       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*/ `
+/* language=glsl glsl */ `
   #define ENVMAP_TYPE_CUBE_UV
   precision highp isampler2D;
   precision highp usampler2D;
@@ -756,9 +134,7 @@ const MeshRefractionMaterial = shaderMaterial({
   varying vec3 vNormal;
   varying mat4 vModelMatrixInverse;
 
-  #ifdef USE_INSTANCING_COLOR
-    varying vec3 vInstanceColor;
-  #endif
+  #include <color_pars_fragment>
 
   #ifdef ENVMAP_TYPE_CUBEM
     uniform samplerCube envMap;
@@ -779,6 +155,7 @@ const MeshRefractionMaterial = shaderMaterial({
   uniform mat4 viewMatrixInverse;
   uniform float aberrationStrength;
   uniform vec3 color;
+  uniform float opacity;
 
   float fresnelFunc(vec3 viewDirection, vec3 worldNormal) {
     return pow( 1.0 + dot( viewDirection, worldNormal), 10.0 );
@@ -834,7 +211,10 @@ const MeshRefractionMaterial = shaderMaterial({
     vec3 normal = vNormal;
     vec3 rayOrigin = cameraPosition;
     vec3 rayDirection = normalize(vWorldPosition - cameraPosition);
-    vec3 finalColor;
+
+    vec4 diffuseColor = vec4(color, opacity);
+    #include <color_fragment>
+
     #ifdef CHROMATIC_ABERRATIONS
       vec3 rayDirectionG = totalInternalReflection(rayOrigin, rayDirection, normal, max(ior, 1.0), vModelMatrixInverse);
       #ifdef FAST_CHROMA
@@ -847,743 +227,23 @@ const MeshRefractionMaterial = shaderMaterial({
       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);
+      diffuseColor.rgb *= 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;
+      diffuseColor.rgb *= textureGradient(envMap, rayDirection, directionCamPerfect).rgb;
     #endif
 
     vec3 viewDirection = normalize(vWorldPosition - cameraPosition);
     float nFresnel = fresnelFunc(viewDirection, normal) * fresnel;
-    gl_FragColor = vec4(mix(finalColor, vec3(1.0), nFresnel), 1.0);
+    gl_FragColor = vec4(mix(diffuseColor.rgb, vec3(1.0), nFresnel), diffuseColor.a);
+
     #include <tonemapping_fragment>
-    #include <${parseInt(THREE.REVISION.replace(/\D+/g, '')) >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
+    #include <${getVersion() >= 154 ? 'colorspace_fragment' : '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') },
-            anisotropicBlur: { 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 = {
-                ...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 anisotropicBlur;
-      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), anisotropicBlur);
-        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,
-}, `varying vec2 vUv;
-   void main() {
-     gl_Position = projectionMatrix * viewMatrix * modelMatrix * vec4(position, 1.);
-     vUv = uv;
-   }`, `varying vec2 vUv;
-   uniform sampler2D map;
-   uniform vec3 color;
-   uniform float opacity;
-   uniform float alphaTest;
-   uniform float blend;
-   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 <${parseInt(THREE.REVISION.replace(/\D+/g, '')) >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
-   }`);
-
-const SparklesMaterial = shaderMaterial({ time: 0, pixelRatio: 1 }, ` uniform float pixelRatio;
-    uniform float time;
-    attribute float size;
-    attribute float speed;
-    attribute float opacity;
-    attribute vec3 noise;
-    attribute vec3 color;
-    varying vec3 vColor;
-    varying float vOpacity;
-    void main() {
-      vec4 modelPosition = modelMatrix * vec4(position, 1.0);
-      modelPosition.y += sin(time * speed + modelPosition.x * noise.x * 100.0) * 0.2;
-      modelPosition.z += cos(time * speed + modelPosition.x * noise.y * 100.0) * 0.2;
-      modelPosition.x += cos(time * speed + modelPosition.x * noise.z * 100.0) * 0.2;
-      vec4 viewPosition = viewMatrix * modelPosition;
-      vec4 projectionPostion = projectionMatrix * viewPosition;
-      gl_Position = projectionPostion;
-      gl_PointSize = size * 25. * pixelRatio;
-      gl_PointSize *= (1.0 / - viewPosition.z);
-      vColor = color;
-      vOpacity = opacity;
-    }`, ` varying vec3 vColor;
-    varying float vOpacity;
-    void main() {
-      float distanceToCenter = distance(gl_PointCoord, vec2(0.5));
-      float strength = 0.05 / distanceToCenter - 0.1;
-      gl_FragColor = vec4(vColor, strength * vOpacity);
-      #include <tonemapping_fragment>
-      #include <${parseInt(THREE.REVISION.replace(/\D+/g, '')) >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
-    }`);
-
-class SpotLightMaterial extends THREE.ShaderMaterial {
-    constructor() {
-        super({
-            uniforms: {
-                depth: { value: null },
-                opacity: { value: 1 },
-                attenuation: { value: 2.5 },
-                anglePower: { value: 12 },
-                spotPosition: { value: new THREE.Vector3(0, 0, 0) },
-                lightColor: { value: new THREE.Color('white') },
-                cameraNear: { value: 0 },
-                cameraFar: { value: 1 },
-                resolution: { value: new THREE.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 <${parseInt(THREE.REVISION.replace(/\D+/g, '')) >= 154 ? 'colorspace_fragment' : '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 <${parseInt(THREE.REVISION.replace(/\D+/g, '')) >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
-}
-  `);
-
-const WireframeMaterialShaders = {
-    uniforms: {
-        strokeOpacity: 1,
-        fillOpacity: 0.25,
-        fillMix: 0,
-        thickness: 0.05,
-        colorBackfaces: false,
-        dashInvert: true,
-        dash: false,
-        dashRepeats: 4,
-        dashLength: 0.5,
-        squeeze: false,
-        squeezeMin: 0.2,
-        squeezeMax: 1,
-        stroke: new THREE.Color('#ff0000'),
-        backfaceStroke: new THREE.Color('#0000ff'),
-        fill: new THREE.Color('#00ff00'),
-    },
-    vertex: /* glsl */ `
-	  attribute vec3 barycentric;
-
-		varying vec3 v_edges_Barycentric;
-		varying vec3 v_edges_Position;
-
-		void initWireframe() {
-			v_edges_Barycentric = barycentric;
-			v_edges_Position = position.xyz;
-		}
-	  `,
-    fragment: /* glsl */ `
-		#ifndef PI
-	  	#define PI 3.1415926535897932384626433832795
-		#endif
-
-	  varying vec3 v_edges_Barycentric;
-	  varying vec3 v_edges_Position;
-
-	  uniform float strokeOpacity;
-	  uniform float fillOpacity;
-	  uniform float fillMix;
-	  uniform float thickness;
-	  uniform bool colorBackfaces;
-
-	  // Dash
-	  uniform bool dashInvert;
-	  uniform bool dash;
-	  uniform bool dashOnly;
-	  uniform float dashRepeats;
-	  uniform float dashLength;
-
-	  // Squeeze
-	  uniform bool squeeze;
-	  uniform float squeezeMin;
-	  uniform float squeezeMax;
-
-	  // Colors
-	  uniform vec3 stroke;
-	  uniform vec3 backfaceStroke;
-	  uniform vec3 fill;
-
-	  // This is like
-	  float wireframe_aastep(float threshold, float dist) {
-		  float afwidth = fwidth(dist) * 0.5;
-		  return smoothstep(threshold - afwidth, threshold + afwidth, dist);
-	  }
-
-	  float wireframe_map(float value, float min1, float max1, float min2, float max2) {
-		  return min2 + (value - min1) * (max2 - min2) / (max1 - min1);
-	  }
-
-	  float getWireframe() {
-			vec3 barycentric = v_edges_Barycentric;
-
-			// Distance from center of each triangle to its edges.
-			float d = min(min(barycentric.x, barycentric.y), barycentric.z);
-
-			// for dashed rendering, we can use this to get the 0 .. 1 value of the line length
-			float positionAlong = max(barycentric.x, barycentric.y);
-			if (barycentric.y < barycentric.x && barycentric.y < barycentric.z) {
-				positionAlong = 1.0 - positionAlong;
-			}
-
-			// the thickness of the stroke
-			float computedThickness = wireframe_map(thickness, 0.0, 1.0, 0.0, 0.34);
-
-			// if we want to shrink the thickness toward the center of the line segment
-			if (squeeze) {
-				computedThickness *= mix(squeezeMin, squeezeMax, (1.0 - sin(positionAlong * PI)));
-			}
-
-			// Create dash pattern
-			if (dash) {
-				// here we offset the stroke position depending on whether it
-				// should overlap or not
-				float offset = 1.0 / dashRepeats * dashLength / 2.0;
-				if (!dashInvert) {
-					offset += 1.0 / dashRepeats / 2.0;
-				}
-
-				// if we should animate the dash or not
-				// if (dashAnimate) {
-				// 	offset += time * 0.22;
-				// }
-
-				// create the repeating dash pattern
-				float pattern = fract((positionAlong + offset) * dashRepeats);
-				computedThickness *= 1.0 - wireframe_aastep(dashLength, pattern);
-			}
-
-			// compute the anti-aliased stroke edge
-			float edge = 1.0 - wireframe_aastep(computedThickness, d);
-
-			return edge;
-	  }
-	  `,
-};
-const WireframeMaterial = shaderMaterial(WireframeMaterialShaders.uniforms, WireframeMaterialShaders.vertex +
-    /* glsl */ `
-  	void main() {
-		initWireframe();
-		gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
-	}
-  `, WireframeMaterialShaders.fragment +
-    /* glsl */ `
-  void main () {
-		// Compute color
-
-		float edge = getWireframe();
-		vec4 colorStroke = vec4(stroke, edge);
-
-		#ifdef FLIP_SIDED
-			colorStroke.rgb = backfaceStroke;
-		#endif
-
-		vec4 colorFill = vec4(fill, fillOpacity);
-		vec4 outColor = mix(colorFill, colorStroke, edge * strokeOpacity);
-
-		gl_FragColor = outColor;
-	}
-  `);
-function setWireframeOverride(material, uniforms) {
-    material.onBeforeCompile = (shader) => {
-        shader.uniforms = {
-            ...shader.uniforms,
-            ...uniforms,
-        };
-        shader.vertexShader = shader.vertexShader.replace('void main() {', `
-		  ${WireframeMaterialShaders.vertex}
-		  void main() {
-			initWireframe();
-		`);
-        shader.fragmentShader = shader.fragmentShader.replace('void main() {', `
-		  ${WireframeMaterialShaders.fragment}
-		  void main() {
-		`);
-        shader.fragmentShader = shader.fragmentShader.replace('#include <color_fragment>', 
-        /* glsl */ `
-		  #include <color_fragment>
-			  float edge = getWireframe();
-		  vec4 colorStroke = vec4(stroke, edge);
-		  #ifdef FLIP_SIDED
-			  colorStroke.rgb = backfaceStroke;
-		  #endif
-		  vec4 colorFill = vec4(mix(diffuseColor.rgb, fill, fillMix), mix(diffuseColor.a, fillOpacity, fillMix));
-		  vec4 outColor = mix(colorFill, colorStroke, edge * strokeOpacity);
-
-		  diffuseColor.rgb = outColor.rgb;
-		  diffuseColor.a *= outColor.a;
-		`);
-    };
-    material.side = THREE.DoubleSide;
-    material.transparent = true;
-}
-function injectNgtsWireframeUniforms(uniformsFactory, stateFactory, { injector } = {}) {
-    injector = assertInjectionContext(injectNgtsWireframeUniforms, injector);
-    return runInInjectionContext(injector, () => {
-        const uniforms = uniformsFactory();
-        const state = computed(() => stateFactory());
-        const fillOpacity = computed(() => state().fillOpacity);
-        const fillMix = computed(() => state().fillMix);
-        const strokeOpacity = computed(() => state().strokeOpacity);
-        const thickness = computed(() => state().thickness);
-        const colorBackfaces = computed(() => state().colorBackfaces);
-        const dash = computed(() => state().dash);
-        const dashInvert = computed(() => state().dashInvert);
-        const dashRepeats = computed(() => state().dashRepeats);
-        const dashLength = computed(() => state().dashLength);
-        const squeeze = computed(() => state().squeeze);
-        const squeezeMin = computed(() => state().squeezeMin);
-        const squeezeMax = computed(() => state().squeezeMax);
-        const stroke = computed(() => state().stroke);
-        const fill = computed(() => state().fill);
-        const backfaceStroke = computed(() => state().backfaceStroke);
-        effect(() => {
-            uniforms['fillOpacity'].value = fillOpacity() ?? uniforms['fillOpacity'].value;
-        });
-        effect(() => {
-            uniforms['fillMix'].value = fillMix() ?? uniforms['fillMix'].value;
-        });
-        effect(() => {
-            uniforms['strokeOpacity'].value = strokeOpacity() ?? uniforms['strokeOpacity'].value;
-        });
-        effect(() => {
-            uniforms['thickness'].value = thickness() ?? uniforms['thickness'].value;
-        });
-        effect(() => {
-            uniforms['colorBackfaces'].value = colorBackfaces() ?? uniforms['colorBackfaces'].value;
-        });
-        effect(() => {
-            uniforms['dash'].value = dash() ?? uniforms['dash'].value;
-        });
-        effect(() => {
-            uniforms['dashInvert'].value = dashInvert() ?? uniforms['dashInvert'].value;
-        });
-        effect(() => {
-            uniforms['dashRepeats'].value = dashRepeats() ?? uniforms['dashRepeats'].value;
-        });
-        effect(() => {
-            uniforms['dashLength'].value = dashLength() ?? uniforms['dashLength'].value;
-        });
-        effect(() => {
-            uniforms['squeeze'].value = squeeze() ?? uniforms['squeeze'].value;
-        });
-        effect(() => {
-            uniforms['squeezeMin'].value = squeezeMin() ?? uniforms['squeezeMin'].value;
-        });
-        effect(() => {
-            uniforms['squeezeMax'].value = squeezeMax() ?? uniforms['squeezeMax'].value;
-        });
-        effect(() => {
-            uniforms['stroke'].value = stroke() ? new THREE.Color(stroke()) : uniforms['stroke'].value;
-        });
-        effect(() => {
-            uniforms['fill'].value = fill() ? new THREE.Color(fill()) : uniforms['fill'].value;
-        });
-        effect(() => {
-            uniforms['backfaceStroke'].value = backfaceStroke()
-                ? new THREE.Color(backfaceStroke())
-                : uniforms['backfaceStroke'].value;
-        });
-    });
-}
-
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { BlurPass, CausticsMaterial, CausticsProjectionMaterial, ConvolutionMaterial, DiscardMaterial, GridMaterial, MeshReflectorMaterial, MeshRefractionMaterial, MeshTransmissionMaterial, MeshWobbleMaterial, NGTS_DISTORT_MATERIAL_SHADER, SoftShadowMaterial, SparklesMaterial, SpotLightMaterial, StarFieldMaterial, WireframeMaterial, WireframeMaterialShaders, createMeshDistortMaterial, injectNgtsMeshDistortMaterial, injectNgtsWireframeUniforms, provideNgtsMeshDistortMaterialShader, setWireframeOverride, shaderMaterial };
+export { GridMaterial, MeshRefractionMaterial };
 //# sourceMappingURL=angular-three-soba-shaders.mjs.map