angular-three-soba 1.9.3 → 1.11.0

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

@@ -1,6 +1,7 @@
 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()) {
@@ -154,6 +155,195 @@ class BlurPass {
     }
 }
 
+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 {
@@ -430,6 +620,434 @@ class MeshReflectorMaterial extends MeshStandardMaterial {
     }
 }
 
+// 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);
@@ -466,36 +1084,6 @@ class MeshWobbleMaterial extends THREE.MeshStandardMaterial {
     }
 }
 
-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;
-}
-
 class SpotLightMaterial extends ShaderMaterial {
     constructor() {
         super({
@@ -585,5 +1173,5 @@ class SpotLightMaterial extends ShaderMaterial {
  * Generated bundle index. Do not edit.
  */
 
-export { BlurPass, ConvolutionMaterial, MeshReflectorMaterial, MeshWobbleMaterial, NGTS_DISTORT_MATERIAL_SHADER, SpotLightMaterial, provideNgtsMeshDistortMaterialShader, shaderMaterial };
+export { BlurPass, CausticsMaterial, CausticsProjectionMaterial, ConvolutionMaterial, DiscardMaterial, MeshReflectorMaterial, MeshRefractionMaterial, MeshTransmissionMaterial, MeshWobbleMaterial, NGTS_DISTORT_MATERIAL_SHADER, SpotLightMaterial, provideNgtsMeshDistortMaterialShader, shaderMaterial };
 //# sourceMappingURL=angular-three-soba-shaders.mjs.map