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

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

@@ -0,0 +1,268 @@
+import * as THREE from 'three';
+export 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 = {
+                ...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),
+        }));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mesh-transmission-material.js","sourceRoot":"","sources":["../../../../../../libs/soba/shaders/src/mesh-transmission-material/mesh-transmission-material.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAM/B,MAAM,OAAO,wBAAyB,SAAQ,KAAK,CAAC,oBAAoB;IAmBpE,YAAY,OAAO,GAAG,CAAC,EAAE,mBAAmB,GAAG,KAAK;QAChD,KAAK,EAAE,CAAC;QAER,IAAI,CAAC,QAAQ,GAAG;YACZ,mBAAmB,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE;YACpC,0EAA0E;YAC1E,YAAY,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE;YAC1B,0DAA0D;YAC1D,aAAa,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE;YAC3B,eAAe,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE;YAChC,oGAAoG;YACpG,SAAS,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE;YACvB,SAAS,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE;YACvB,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE;YAC7B,mBAAmB,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE;YACxC,gBAAgB,EAAE,EAAE,KAAK,EAAE,IAAI,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE;YACrD,UAAU,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE;YAC1B,IAAI,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE;YAClB,UAAU,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE;YAC1B,eAAe,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE;YAC/B,kBAAkB,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE;YAClC,MAAM,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE;SAC1B,CAAC;QAEF,IAAI,CAAC,eAAe,GAAG,CAAC,MAA6D,EAAE,EAAE;YACrF,MAAM,CAAC,QAAQ,GAAG;gBACd,GAAG,MAAM,CAAC,QAAQ;gBAClB,GAAG,IAAI,CAAC,QAAQ;aACnB,CAAC;YAEF,sDAAsD;YACtD,IAAI,mBAAmB;gBAAE,MAAM,CAAC,OAAO,CAAC,aAAa,CAAC,GAAG,EAAE,CAAC;YAC5D,kFAAkF;YAClF,yCAAyC;;gBACpC,MAAM,CAAC,OAAO,CAAC,kBAAkB,CAAC,GAAG,EAAE,CAAC;YAE7C,OAAO;YACP,MAAM,CAAC,cAAc;gBACjB,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA2Ff,GAAG,MAAM,CAAC,cAAc,CAAC;YAEvB,sBAAsB;YACtB,MAAM,CAAC,cAAc,GAAG,MAAM,CAAC,cAAc,CAAC,OAAO,CACjD,uCAAuC;YACvC,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4ER,CACJ,CAAC;YAEF,iBAAiB;YACjB,MAAM,CAAC,cAAc,GAAG,MAAM,CAAC,cAAc,CAAC,OAAO,CACjD,kCAAkC;YAClC,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;kCA0BS,OAAO;;;;+IAIsG,OAAO;;;;;sIAKhB,OAAO,0EAA0E,OAAO;;;;;2IAKnF,OAAO,yEAAyE,OAAO;;;;;;;0BAOxM,OAAO;uFACsD,CAC1E,CAAC;QACN,CAAC,CAAC;QAEF,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE,CACxC,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,IAAI,EAAE;YAC9B,GAAG,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAkC,CAAC,CAAC,KAAK;YAClE,GAAG,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAkC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC;SAC5E,CAAC,CACL,CAAC;IACN,CAAC;CACJ","sourcesContent":["import * as THREE from 'three';\n\ninterface Uniform<T> {\n    value: T;\n}\n\nexport class MeshTransmissionMaterial extends THREE.MeshPhysicalMaterial {\n    uniforms: {\n        chromaticAberration: Uniform<number>;\n        transmission: Uniform<number>;\n        transmissionMap: Uniform<THREE.Texture | null>;\n        _transmission: Uniform<number>;\n        thickness: Uniform<number>;\n        roughness: Uniform<number>;\n        thicknessMap: Uniform<THREE.Texture | null>;\n        attenuationDistance: Uniform<number>;\n        attenuationColor: Uniform<THREE.Color>;\n        anisotropy: Uniform<number>;\n        time: Uniform<number>;\n        distortion: Uniform<number>;\n        distortionScale: Uniform<number>;\n        temporalDistortion: Uniform<number>;\n        buffer: Uniform<THREE.Texture | null>;\n    };\n\n    constructor(samples = 6, transmissionSampler = false) {\n        super();\n\n        this.uniforms = {\n            chromaticAberration: { value: 0.05 },\n            // Transmission must always be 0, unless transmissionSampler is being used\n            transmission: { value: 0 },\n            // Instead a workaround is used, see below for reasons why\n            _transmission: { value: 1 },\n            transmissionMap: { value: null },\n            // Roughness is 1 in THREE.MeshPhysicalMaterial but it makes little sense in a transmission material\n            roughness: { value: 0 },\n            thickness: { value: 0 },\n            thicknessMap: { value: null },\n            attenuationDistance: { value: Infinity },\n            attenuationColor: { value: new THREE.Color('white') },\n            anisotropy: { value: 0.1 },\n            time: { value: 0 },\n            distortion: { value: 0.0 },\n            distortionScale: { value: 0.5 },\n            temporalDistortion: { value: 0.0 },\n            buffer: { value: null },\n        };\n\n        this.onBeforeCompile = (shader: THREE.Shader & { defines: { [key: string]: string } }) => {\n            shader.uniforms = {\n                ...shader.uniforms,\n                ...this.uniforms,\n            };\n\n            // If the transmission sampler is active inject a flag\n            if (transmissionSampler) shader.defines['USE_SAMPLER'] = '';\n            // Otherwise we do use use .transmission and must therefore force USE_TRANSMISSION\n            // because threejs won't inject it for us\n            else shader.defines['USE_TRANSMISSION'] = '';\n\n            // Head\n            shader.fragmentShader =\n                /*glsl*/ `\n      uniform float chromaticAberration;\n      uniform float anisotropy;\n      uniform float time;\n      uniform float distortion;\n      uniform float distortionScale;\n      uniform float temporalDistortion;\n      uniform sampler2D buffer;\n\n      vec3 random3(vec3 c) {\n        float j = 4096.0*sin(dot(c,vec3(17.0, 59.4, 15.0)));\n        vec3 r;\n        r.z = fract(512.0*j);\n        j *= .125;\n        r.x = fract(512.0*j);\n        j *= .125;\n        r.y = fract(512.0*j);\n        return r-0.5;\n      }\n\n      float seed = 0.0;\n      uint hash( uint x ) {\n        x += ( x << 10u );\n        x ^= ( x >>  6u );\n        x += ( x <<  3u );\n        x ^= ( x >> 11u );\n        x += ( x << 15u );\n        return x;\n      }\n\n      // Compound versions of the hashing algorithm I whipped together.\n      uint hash( uvec2 v ) { return hash( v.x ^ hash(v.y)                         ); }\n      uint hash( uvec3 v ) { return hash( v.x ^ hash(v.y) ^ hash(v.z)             ); }\n      uint hash( uvec4 v ) { return hash( v.x ^ hash(v.y) ^ hash(v.z) ^ hash(v.w) ); }\n\n      // Construct a float with half-open range [0:1] using low 23 bits.\n      // All zeroes yields 0.0, all ones yields the next smallest representable value below 1.0.\n      float floatConstruct( uint m ) {\n        const uint ieeeMantissa = 0x007FFFFFu; // binary32 mantissa bitmask\n        const uint ieeeOne      = 0x3F800000u; // 1.0 in IEEE binary32\n        m &= ieeeMantissa;                     // Keep only mantissa bits (fractional part)\n        m |= ieeeOne;                          // Add fractional part to 1.0\n        float  f = uintBitsToFloat( m );       // Range [1:2]\n        return f - 1.0;                        // Range [0:1]\n      }\n\n      // Pseudo-random value in half-open range [0:1].\n      float random( float x ) { return floatConstruct(hash(floatBitsToUint(x))); }\n      float random( vec2  v ) { return floatConstruct(hash(floatBitsToUint(v))); }\n      float random( vec3  v ) { return floatConstruct(hash(floatBitsToUint(v))); }\n      float random( vec4  v ) { return floatConstruct(hash(floatBitsToUint(v))); }\n\n      float rand() {\n        float result = random(vec3(gl_FragCoord.xy, seed));\n        seed += 1.0;\n        return result;\n      }\n\n      const float F3 =  0.3333333;\n      const float G3 =  0.1666667;\n\n      float snoise(vec3 p) {\n        vec3 s = floor(p + dot(p, vec3(F3)));\n        vec3 x = p - s + dot(s, vec3(G3));\n        vec3 e = step(vec3(0.0), x - x.yzx);\n        vec3 i1 = e*(1.0 - e.zxy);\n        vec3 i2 = 1.0 - e.zxy*(1.0 - e);\n        vec3 x1 = x - i1 + G3;\n        vec3 x2 = x - i2 + 2.0*G3;\n        vec3 x3 = x - 1.0 + 3.0*G3;\n        vec4 w, d;\n        w.x = dot(x, x);\n        w.y = dot(x1, x1);\n        w.z = dot(x2, x2);\n        w.w = dot(x3, x3);\n        w = max(0.6 - w, 0.0);\n        d.x = dot(random3(s), x);\n        d.y = dot(random3(s + i1), x1);\n        d.z = dot(random3(s + i2), x2);\n        d.w = dot(random3(s + 1.0), x3);\n        w *= w;\n        w *= w;\n        d *= w;\n        return dot(d, vec4(52.0));\n      }\n\n      float snoiseFractal(vec3 m) {\n        return 0.5333333* snoise(m)\n              +0.2666667* snoise(2.0*m)\n              +0.1333333* snoise(4.0*m)\n              +0.0666667* snoise(8.0*m);\n      }\\n` + shader.fragmentShader;\n\n            // Remove transmission\n            shader.fragmentShader = shader.fragmentShader.replace(\n                '#include <transmission_pars_fragment>',\n                /*glsl*/ `\n        #ifdef USE_TRANSMISSION\n          // Transmission code is based on glTF-Sampler-Viewer\n          // https://github.com/KhronosGroup/glTF-Sample-Viewer\n          uniform float _transmission;\n          uniform float thickness;\n          uniform float attenuationDistance;\n          uniform vec3 attenuationColor;\n          #ifdef USE_TRANSMISSIONMAP\n            uniform sampler2D transmissionMap;\n          #endif\n          #ifdef USE_THICKNESSMAP\n            uniform sampler2D thicknessMap;\n          #endif\n          uniform vec2 transmissionSamplerSize;\n          uniform sampler2D transmissionSamplerMap;\n          uniform mat4 modelMatrix;\n          uniform mat4 projectionMatrix;\n          varying vec3 vWorldPosition;\n          vec3 getVolumeTransmissionRay( const in vec3 n, const in vec3 v, const in float thickness, const in float ior, const in mat4 modelMatrix ) {\n            // Direction of refracted light.\n            vec3 refractionVector = refract( - v, normalize( n ), 1.0 / ior );\n            // Compute rotation-independant scaling of the model matrix.\n            vec3 modelScale;\n            modelScale.x = length( vec3( modelMatrix[ 0 ].xyz ) );\n            modelScale.y = length( vec3( modelMatrix[ 1 ].xyz ) );\n            modelScale.z = length( vec3( modelMatrix[ 2 ].xyz ) );\n            // The thickness is specified in local space.\n            return normalize( refractionVector ) * thickness * modelScale;\n          }\n          float applyIorToRoughness( const in float roughness, const in float ior ) {\n            // Scale roughness with IOR so that an IOR of 1.0 results in no microfacet refraction and\n            // an IOR of 1.5 results in the default amount of microfacet refraction.\n            return roughness * clamp( ior * 2.0 - 2.0, 0.0, 1.0 );\n          }\n          vec4 getTransmissionSample( const in vec2 fragCoord, const in float roughness, const in float ior ) {\n            float framebufferLod = log2( transmissionSamplerSize.x ) * applyIorToRoughness( roughness, ior );\n            #ifdef USE_SAMPLER\n              #ifdef texture2DLodEXT\n                return texture2DLodEXT(transmissionSamplerMap, fragCoord.xy, framebufferLod);\n              #else\n                return texture2D(transmissionSamplerMap, fragCoord.xy, framebufferLod);\n              #endif\n            #else\n              return texture2D(buffer, fragCoord.xy);\n            #endif\n          }\n          vec3 applyVolumeAttenuation( const in vec3 radiance, const in float transmissionDistance, const in vec3 attenuationColor, const in float attenuationDistance ) {\n            if ( isinf( attenuationDistance ) ) {\n              // Attenuation distance is +∞, i.e. the transmitted color is not attenuated at all.\n              return radiance;\n            } else {\n              // Compute light attenuation using Beer's law.\n              vec3 attenuationCoefficient = -log( attenuationColor ) / attenuationDistance;\n              vec3 transmittance = exp( - attenuationCoefficient * transmissionDistance ); // Beer's law\n              return transmittance * radiance;\n            }\n          }\n          vec4 getIBLVolumeRefraction( const in vec3 n, const in vec3 v, const in float roughness, const in vec3 diffuseColor,\n            const in vec3 specularColor, const in float specularF90, const in vec3 position, const in mat4 modelMatrix,\n            const in mat4 viewMatrix, const in mat4 projMatrix, const in float ior, const in float thickness,\n            const in vec3 attenuationColor, const in float attenuationDistance ) {\n            vec3 transmissionRay = getVolumeTransmissionRay( n, v, thickness, ior, modelMatrix );\n            vec3 refractedRayExit = position + transmissionRay;\n            // Project refracted vector on the framebuffer, while mapping to normalized device coordinates.\n            vec4 ndcPos = projMatrix * viewMatrix * vec4( refractedRayExit, 1.0 );\n            vec2 refractionCoords = ndcPos.xy / ndcPos.w;\n            refractionCoords += 1.0;\n            refractionCoords /= 2.0;\n            // Sample framebuffer to get pixel the refracted ray hits.\n            vec4 transmittedLight = getTransmissionSample( refractionCoords, roughness, ior );\n            vec3 attenuatedColor = applyVolumeAttenuation( transmittedLight.rgb, length( transmissionRay ), attenuationColor, attenuationDistance );\n            // Get the specular component.\n            vec3 F = EnvironmentBRDF( n, v, specularColor, specularF90, roughness );\n            return vec4( ( 1.0 - F ) * attenuatedColor * diffuseColor, transmittedLight.a );\n          }\n        #endif\\n`\n            );\n\n            // Add refraction\n            shader.fragmentShader = shader.fragmentShader.replace(\n                '#include <transmission_fragment>',\n                /*glsl*/ `\n        // Improve the refraction to use the world pos\n        material.transmission = _transmission;\n        material.transmissionAlpha = 1.0;\n        material.thickness = thickness;\n        material.attenuationDistance = attenuationDistance;\n        material.attenuationColor = attenuationColor;\n        #ifdef USE_TRANSMISSIONMAP\n          material.transmission *= texture2D( transmissionMap, vUv ).r;\n        #endif\n        #ifdef USE_THICKNESSMAP\n          material.thickness *= texture2D( thicknessMap, vUv ).g;\n        #endif\n\n        vec3 pos = vWorldPosition;\n        vec3 v = normalize( cameraPosition - pos );\n        vec3 n = inverseTransformDirection( normal, viewMatrix );\n        vec3 transmission = vec3(0.0);\n        float transmissionR, transmissionB, transmissionG;\n        float randomCoords = rand();\n        float thickness_smear = thickness * max(pow(roughnessFactor, 0.33), anisotropy);\n        vec3 distortionNormal = vec3(0.0);\n        vec3 temporalOffset = vec3(time, -time, -time) * temporalDistortion;\n        if (distortion > 0.0) {\n          distortionNormal = distortion * vec3(snoiseFractal(vec3((pos * distortionScale + temporalOffset))), snoiseFractal(vec3(pos.zxy * distortionScale - temporalOffset)), snoiseFractal(vec3(pos.yxz * distortionScale + temporalOffset)));\n        }\n        for (float i = 0.0; i < ${samples}.0; i ++) {\n          vec3 sampleNorm = normalize(n + roughnessFactor * roughnessFactor * 2.0 * normalize(vec3(rand() - 0.5, rand() - 0.5, rand() - 0.5)) * pow(rand(), 0.33) + distortionNormal);\n          transmissionR = getIBLVolumeRefraction(\n            sampleNorm, v, material.roughness, material.diffuseColor, material.specularColor, material.specularF90,\n            pos, modelMatrix, viewMatrix, projectionMatrix, material.ior, material.thickness  + thickness_smear * (i + randomCoords) / float(${samples}),\n            material.attenuationColor, material.attenuationDistance\n          ).r;\n          transmissionG = getIBLVolumeRefraction(\n            sampleNorm, v, material.roughness, material.diffuseColor, material.specularColor, material.specularF90,\n            pos, modelMatrix, viewMatrix, projectionMatrix, material.ior  * (1.0 + chromaticAberration * (i + randomCoords) / float(${samples})) , material.thickness + thickness_smear * (i + randomCoords) / float(${samples}),\n            material.attenuationColor, material.attenuationDistance\n          ).g;\n          transmissionB = getIBLVolumeRefraction(\n            sampleNorm, v, material.roughness, material.diffuseColor, material.specularColor, material.specularF90,\n            pos, modelMatrix, viewMatrix, projectionMatrix, material.ior * (1.0 + 2.0 * chromaticAberration * (i + randomCoords) / float(${samples})), material.thickness + thickness_smear * (i + randomCoords) / float(${samples}),\n            material.attenuationColor, material.attenuationDistance\n          ).b;\n          transmission.r += transmissionR;\n          transmission.g += transmissionG;\n          transmission.b += transmissionB;\n        }\n        transmission /= ${samples}.0;\n        totalDiffuse = mix( totalDiffuse, transmission.rgb, material.transmission );\\n`\n            );\n        };\n\n        Object.keys(this.uniforms).forEach((name) =>\n            Object.defineProperty(this, name, {\n                get: () => this.uniforms[name as keyof typeof this.uniforms].value,\n                set: (v) => (this.uniforms[name as keyof typeof this.uniforms].value = v),\n            })\n        );\n    }\n}\n"]}

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

@@ -0,0 +1,37 @@
+import * as THREE from 'three';
+export 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;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,34 @@
+import * as THREE from 'three';
+export 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;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/shaders/soft-shadow-material/soft-shadow-material.mjs

@@ -0,0 +1,33 @@
+import * as THREE from 'three';
+import { shaderMaterial } from '../shader-material/shader-material';
+export const SoftShadowMaterial = shaderMaterial({
+    color: new THREE.Color(),
+    blend: 2.0,
+    alphaTest: 0.75,
+    opacity: 0,
+    map: null,
+}, 
+// language=glsl
+`
+varying vec2 vUv;
+void main() {
+  gl_Position = projectionMatrix * viewMatrix * modelMatrix * vec4(position, 1.);
+  vUv = uv;
+}
+    `, 
+// language=glsl
+`
+varying vec2 vUv;
+uniform sampler2D map;
+uniform vec3 color;
+uniform float 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 <encodings_fragment>
+}
+    `);
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,47 @@
+import { shaderMaterial } from '../shader-material/shader-material';
+export const SparklesMaterial = shaderMaterial({ time: 0, pixelRatio: 1 }, 
+// language=GLSL
+`
+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;
+}
+  `, 
+// language=GLSL
+`
+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);
+}
+  `);
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/shaders/spot-light-material/spot-light-material.mjs

@@ -0,0 +1,86 @@
+import { Color, ShaderMaterial, Vector2, Vector3 } from 'three';
+export class SpotLightMaterial extends ShaderMaterial {
+    constructor() {
+        super({
+            uniforms: {
+                depth: { value: null },
+                opacity: { value: 1 },
+                attenuation: { value: 2.5 },
+                anglePower: { value: 12 },
+                spotPosition: { value: new Vector3(0, 0, 0) },
+                lightColor: { value: new Color('white') },
+                cameraNear: { value: 0 },
+                cameraFar: { value: 1 },
+                resolution: { value: new Vector2(0, 0) },
+            },
+            transparent: true,
+            depthWrite: false,
+            vertexShader: /* glsl */ `
+      varying vec3 vNormal;
+      varying vec3 vWorldPosition;
+      varying float vViewZ;
+      varying float vIntensity;
+      uniform vec3 spotPosition;
+      uniform float attenuation;
+
+      void main() {
+        // compute intensity
+        vNormal = normalize( normalMatrix * normal );
+        vec4 worldPosition	= modelMatrix * vec4( position, 1.0 );
+        vWorldPosition = worldPosition.xyz;
+        vec4 viewPosition = viewMatrix * worldPosition;
+        vViewZ = viewPosition.z;
+        float intensity	= distance(worldPosition.xyz, spotPosition) / attenuation;
+        intensity	= 1.0 - clamp(intensity, 0.0, 1.0);
+        vIntensity = intensity;
+        // set gl_Position
+        gl_Position	= projectionMatrix * viewPosition;
+
+      }`,
+            fragmentShader: /* glsl */ `
+      #include <packing>
+
+      varying vec3 vNormal;
+      varying vec3 vWorldPosition;
+      uniform vec3 lightColor;
+      uniform vec3 spotPosition;
+      uniform float attenuation;
+      uniform float anglePower;
+      uniform sampler2D depth;
+      uniform vec2 resolution;
+      uniform float cameraNear;
+      uniform float cameraFar;
+      varying float vViewZ;
+      varying float vIntensity;
+      uniform float opacity;
+
+      float readDepth( sampler2D depthSampler, vec2 coord ) {
+        float fragCoordZ = texture2D( depthSampler, coord ).x;
+        float viewZ = perspectiveDepthToViewZ(fragCoordZ, cameraNear, cameraFar);
+        return viewZ;
+      }
+
+      void main() {
+        float d = 1.0;
+        bool isSoft = resolution[0] > 0.0 && resolution[1] > 0.0;
+        if (isSoft) {
+          vec2 sUv = gl_FragCoord.xy / resolution;
+          d = readDepth(depth, sUv);
+        }
+        float intensity = vIntensity;
+        vec3 normal	= vec3(vNormal.x, vNormal.y, abs(vNormal.z));
+        float angleIntensity	= pow( dot(normal, vec3(0.0, 0.0, 1.0)), anglePower );
+        intensity	*= angleIntensity;
+        // fades when z is close to sampled depth, meaning the cone is intersecting existing geometry
+        if (isSoft) {
+          intensity	*= smoothstep(0., 1., vViewZ - d);
+        }
+        gl_FragColor = vec4(lightColor, intensity * opacity);
+
+        #include <tonemapping_fragment>
+	      #include <encodings_fragment>
+      }`,
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/shaders/star-field-material/star-field-material.mjs

@@ -0,0 +1,32 @@
+import { shaderMaterial } from '../shader-material/shader-material';
+export const StarFieldMaterial = shaderMaterial({ time: 0.0, fade: 0.0 }, 
+// language=GLSL
+`
+uniform float time;
+attribute float size;
+varying vec3 vColor;
+void main() {
+  vColor = color;
+  vec4 mvPosition = modelViewMatrix * vec4(position, 0.5);
+  gl_PointSize = size * (30.0 / -mvPosition.z) * (3.0 + sin(time + 100.0));
+  gl_Position = projectionMatrix * mvPosition;
+}
+  `, 
+// language=GLSL
+`
+uniform sampler2D pointTexture;
+uniform float fade;
+varying vec3 vColor;
+void main() {
+  float opacity = 1.0;
+  if (fade == 1.0) {
+    float d = distance(gl_PointCoord, vec2(0.5, 0.5));
+    opacity = 1.0 / (1.0 + exp(16.0 * (d - 0.25)));
+  }
+  gl_FragColor = vec4(vColor, opacity);
+
+  #include <tonemapping_fragment>
+  #include <encodings_fragment>
+}
+  `);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3Rhci1maWVsZC1tYXRlcmlhbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvc29iYS9zaGFkZXJzL3NyYy9zdGFyLWZpZWxkLW1hdGVyaWFsL3N0YXItZmllbGQtbWF0ZXJpYWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLG9DQUFvQyxDQUFDO0FBRXBFLE1BQU0sQ0FBQyxNQUFNLGlCQUFpQixHQUFHLGNBQWMsQ0FDM0MsRUFBRSxJQUFJLEVBQUUsR0FBRyxFQUFFLElBQUksRUFBRSxHQUFHLEVBQUU7QUFDeEIsZ0JBQWdCO0FBQ2hCOzs7Ozs7Ozs7O0dBVUQ7QUFDQyxnQkFBZ0I7QUFDaEI7Ozs7Ozs7Ozs7Ozs7OztHQWVELENBQ0YsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IHNoYWRlck1hdGVyaWFsIH0gZnJvbSAnLi4vc2hhZGVyLW1hdGVyaWFsL3NoYWRlci1tYXRlcmlhbCc7XG5cbmV4cG9ydCBjb25zdCBTdGFyRmllbGRNYXRlcmlhbCA9IHNoYWRlck1hdGVyaWFsKFxuICAgIHsgdGltZTogMC4wLCBmYWRlOiAwLjAgfSxcbiAgICAvLyBsYW5ndWFnZT1HTFNMXG4gICAgYFxudW5pZm9ybSBmbG9hdCB0aW1lO1xuYXR0cmlidXRlIGZsb2F0IHNpemU7XG52YXJ5aW5nIHZlYzMgdkNvbG9yO1xudm9pZCBtYWluKCkge1xuICB2Q29sb3IgPSBjb2xvcjtcbiAgdmVjNCBtdlBvc2l0aW9uID0gbW9kZWxWaWV3TWF0cml4ICogdmVjNChwb3NpdGlvbiwgMC41KTtcbiAgZ2xfUG9pbnRTaXplID0gc2l6ZSAqICgzMC4wIC8gLW12UG9zaXRpb24ueikgKiAoMy4wICsgc2luKHRpbWUgKyAxMDAuMCkpO1xuICBnbF9Qb3NpdGlvbiA9IHByb2plY3Rpb25NYXRyaXggKiBtdlBvc2l0aW9uO1xufVxuICBgLFxuICAgIC8vIGxhbmd1YWdlPUdMU0xcbiAgICBgXG51bmlmb3JtIHNhbXBsZXIyRCBwb2ludFRleHR1cmU7XG51bmlmb3JtIGZsb2F0IGZhZGU7XG52YXJ5aW5nIHZlYzMgdkNvbG9yO1xudm9pZCBtYWluKCkge1xuICBmbG9hdCBvcGFjaXR5ID0gMS4wO1xuICBpZiAoZmFkZSA9PSAxLjApIHtcbiAgICBmbG9hdCBkID0gZGlzdGFuY2UoZ2xfUG9pbnRDb29yZCwgdmVjMigwLjUsIDAuNSkpO1xuICAgIG9wYWNpdHkgPSAxLjAgLyAoMS4wICsgZXhwKDE2LjAgKiAoZCAtIDAuMjUpKSk7XG4gIH1cbiAgZ2xfRnJhZ0NvbG9yID0gdmVjNCh2Q29sb3IsIG9wYWNpdHkpO1xuXG4gICNpbmNsdWRlIDx0b25lbWFwcGluZ19mcmFnbWVudD5cbiAgI2luY2x1ZGUgPGVuY29kaW5nc19mcmFnbWVudD5cbn1cbiAgYFxuKTtcbiJdfQ==