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

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

@@ -1,7 +1,8 @@
 import * as THREE from 'three';
-import { ShaderMaterial, Uniform, Vector2, NoBlending, WebGLRenderTarget, LinearFilter, Scene, PerspectiveCamera, BufferGeometry, BufferAttribute, Mesh, MeshStandardMaterial, Vector3, Color } from 'three';
-import { InjectionToken } from '@angular/core';
+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 { MeshBVHUniformStruct, shaderStructs, shaderIntersectFunction } from 'three-mesh-bvh';
+import { assertInjectionContext } from 'angular-three';
 
 class ConvolutionMaterial extends ShaderMaterial {
     constructor(texelSize = new Vector2()) {
@@ -104,7 +105,7 @@ class BlurPass {
             magFilter: LinearFilter,
             stencilBuffer: false,
             depthBuffer: false,
-            encoding: gl.outputEncoding,
+            type: HalfFloatType,
         });
         this.renderTargetB = this.renderTargetA.clone();
         this.convolutionMaterial = new ConvolutionMaterial();
@@ -131,8 +132,8 @@ class BlurPass {
         const camera = this.camera;
         const renderTargetA = this.renderTargetA;
         const renderTargetB = this.renderTargetB;
-        const material = this.convolutionMaterial;
-        const uniforms = material.uniforms;
+        let material = this.convolutionMaterial;
+        let uniforms = material.uniforms;
         uniforms['depthBuffer'].value = inputBuffer.depthTexture;
         const kernel = material.kernel;
         let lastRT = inputBuffer;
@@ -206,113 +207,115 @@ const CausticsMaterial = shaderMaterial({
     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;
+/* 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;
   }
-  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;
+  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;
   }
-  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);
-}`);
+  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,
@@ -320,85 +323,159 @@ const CausticsProjectionMaterial = shaderMaterial({
     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>
-}`);
+}, `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,
+    cellThickness: 0.5,
+    sectionThickness: 1,
+    cellColor: new THREE.Color(),
+    sectionColor: new THREE.Color(),
+    infiniteGrid: false,
+    followCamera: false,
+    worldCamProjPosition: new THREE.Vector3(),
+    worldPlanePosition: new THREE.Vector3(),
+}, 
+/* glsl */ `
+    varying vec3 localPosition;
+    varying vec4 worldPosition;
+
+    uniform vec3 worldCamProjPosition;
+    uniform vec3 worldPlanePosition;
+    uniform float fadeDistance;
+    uniform bool infiniteGrid;
+    uniform bool followCamera;
+
+    void main() {
+      localPosition = position.xzy;
+      if (infiniteGrid) localPosition *= 1.0 + fadeDistance;
+
+      worldPosition = modelMatrix * vec4(localPosition, 1.0);
+      if (followCamera) {
+        worldPosition.xyz += (worldCamProjPosition - worldPlanePosition);
+        localPosition = (inverse(modelMatrix) * worldPosition).xyz;
+      }
+
+      gl_Position = projectionMatrix * viewMatrix * worldPosition;
+    }
+  `, 
+/* glsl */ `
+    varying vec3 localPosition;
+    varying vec4 worldPosition;
+
+    uniform vec3 worldCamProjPosition;
+    uniform float cellSize;
+    uniform float sectionSize;
+    uniform vec3 cellColor;
+    uniform vec3 sectionColor;
+    uniform float fadeDistance;
+    uniform float fadeStrength;
+    uniform float cellThickness;
+    uniform float sectionThickness;
+
+    float getGrid(float size, float thickness) {
+      vec2 r = localPosition.xz / size;
+      vec2 grid = abs(fract(r - 0.5) - 0.5) / fwidth(r);
+      float line = min(grid.x, grid.y) + 1.0 - thickness;
+      return 1.0 - min(line, 1.0);
+    }
+
+    void main() {
+      float g1 = getGrid(cellSize, cellThickness);
+      float g2 = getGrid(sectionSize, sectionThickness);
+
+      float dist = distance(worldCamProjPosition, worldPosition.xyz);
+      float d = 1.0 - min(dist / fadeDistance, 1.0);
+      vec3 color = mix(cellColor, sectionColor, min(1.0, sectionThickness * g2));
+
+      gl_FragColor = vec4(color, (g1 + g2) * pow(d, fadeStrength));
+      gl_FragColor.a = mix(0.75 * gl_FragColor.a, gl_FragColor.a, g2);
+      if (gl_FragColor.a <= 0.0) discard;
+
+      #include <tonemapping_fragment>
+      #include <${parseInt(THREE.REVISION.replace(/\D+/g, '')) >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
+    }
+  `);
+
 const NGTS_DISTORT_MATERIAL_SHADER = new InjectionToken('DistortMaterialShader');
-function provideNgtsMeshDistortMaterialShader(distortShader) {
-    return {
-        provide: NGTS_DISTORT_MATERIAL_SHADER,
-        useFactory: () => {
-            return class extends THREE.MeshPhysicalMaterial {
-                constructor(parameters = {}) {
-                    super(parameters);
-                    this.setValues(parameters);
-                    this._time = { value: 0 };
-                    this._distort = { value: 0.4 };
-                    this._radius = { value: 1 };
-                }
-                onBeforeCompile(shader) {
-                    shader.uniforms['time'] = this._time;
-                    shader.uniforms['radius'] = this._radius;
-                    shader.uniforms['distort'] = this._distort;
-                    shader.vertexShader = `
+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>', `
+            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;
-                }
-            };
-        },
+        }
+        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 = {}) {
@@ -623,6 +700,7 @@ class MeshReflectorMaterial extends MeshStandardMaterial {
 }
 
 // Author: N8Programs
+// https://github.com/N8python/diamonds
 const MeshRefractionMaterial = shaderMaterial({
     envMap: null,
     bounces: 3,
@@ -630,6 +708,7 @@ const MeshRefractionMaterial = shaderMaterial({
     correctMips: true,
     aberrationStrength: 0.01,
     fresnel: 0,
+    // @ts-expect-error: typing is not matched
     bvh: new MeshBVHUniformStruct(),
     color: new THREE.Color('white'),
     resolution: new THREE.Vector2(),
@@ -783,7 +862,7 @@ const MeshRefractionMaterial = shaderMaterial({
     float nFresnel = fresnelFunc(viewDirection, normal) * fresnel;
     gl_FragColor = vec4(mix(finalColor, vec3(1.0), nFresnel), 1.0);
     #include <tonemapping_fragment>
-    #include <encodings_fragment>
+    #include <${parseInt(THREE.REVISION.replace(/\D+/g, '')) >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
   }`);
 
 class MeshTransmissionMaterial extends THREE.MeshPhysicalMaterial {
@@ -802,7 +881,7 @@ class MeshTransmissionMaterial extends THREE.MeshPhysicalMaterial {
             thicknessMap: { value: null },
             attenuationDistance: { value: Infinity },
             attenuationColor: { value: new THREE.Color('white') },
-            anisotropy: { value: 0.1 },
+            anisotropicBlur: { value: 0.1 },
             time: { value: 0 },
             distortion: { value: 0.0 },
             distortionScale: { value: 0.5 },
@@ -825,7 +904,7 @@ class MeshTransmissionMaterial extends THREE.MeshPhysicalMaterial {
             shader.fragmentShader =
                 /*glsl*/ `
       uniform float chromaticAberration;
-      uniform float anisotropy;
+      uniform float anisotropicBlur;
       uniform float time;
       uniform float distortion;
       uniform float distortionScale;
@@ -1016,7 +1095,7 @@ class MeshTransmissionMaterial extends THREE.MeshPhysicalMaterial {
         vec3 transmission = vec3(0.0);
         float transmissionR, transmissionB, transmissionG;
         float randomCoords = rand();
-        float thickness_smear = thickness * max(pow(roughnessFactor, 0.33), anisotropy);
+        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) {
@@ -1095,32 +1174,55 @@ const SoftShadowMaterial = shaderMaterial({
     alphaTest: 0.75,
     opacity: 0,
     map: null,
-}, 
-// language=GLSL
-`
-varying vec2 vUv;
-void main() {
-  gl_Position = projectionMatrix * viewMatrix * modelMatrix * vec4(position, 1.);
-  vUv = uv;
-}
-  `, 
-// language=GLSL
-`
-varying vec2 vUv;
-uniform sampler2D map;
-uniform vec3 color;
-uniform float blend;
-uniform float opacity;
-uniform float alphaTest;
-void main() {
-  vec4 sampledDiffuseColor = texture2D(map, vUv);
-  gl_FragColor = vec4(color * sampledDiffuseColor.r * blend, max(0.0, (1.0 - (sampledDiffuseColor.r + sampledDiffuseColor.g + sampledDiffuseColor.b) / alphaTest)) * opacity);
-  #include <tonemapping_fragment>
-  #include <encodings_fragment>
-}
-  `);
-
-class SpotLightMaterial extends ShaderMaterial {
+}, `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: {
@@ -1128,11 +1230,11 @@ class SpotLightMaterial extends ShaderMaterial {
                 opacity: { value: 1 },
                 attenuation: { value: 2.5 },
                 anglePower: { value: 12 },
-                spotPosition: { value: new Vector3(0, 0, 0) },
-                lightColor: { value: new Color('white') },
+                spotPosition: { value: new THREE.Vector3(0, 0, 0) },
+                lightColor: { value: new THREE.Color('white') },
                 cameraNear: { value: 0 },
                 cameraFar: { value: 1 },
-                resolution: { value: new Vector2(0, 0) },
+                resolution: { value: new THREE.Vector2(0, 0) },
             },
             transparent: true,
             depthWrite: false,
@@ -1199,7 +1301,7 @@ class SpotLightMaterial extends ShaderMaterial {
         gl_FragColor = vec4(lightColor, intensity * opacity);
 
         #include <tonemapping_fragment>
-	      #include <encodings_fragment>
+	      #include <${parseInt(THREE.REVISION.replace(/\D+/g, '')) >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
       }`,
         });
     }
@@ -1232,13 +1334,256 @@ void main() {
   gl_FragColor = vec4(vColor, opacity);
 
   #include <tonemapping_fragment>
-  #include <encodings_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, MeshReflectorMaterial, MeshRefractionMaterial, MeshTransmissionMaterial, MeshWobbleMaterial, NGTS_DISTORT_MATERIAL_SHADER, SoftShadowMaterial, SpotLightMaterial, StarFieldMaterial, provideNgtsMeshDistortMaterialShader, shaderMaterial };
+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 };
 //# sourceMappingURL=angular-three-soba-shaders.mjs.map