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

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

@@ -0,0 +1,33 @@
+import * as THREE from 'three';
+import { shaderMaterial } from '../shader-material/shader-material';
+export 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'}>
+    }`);
+//# sourceMappingURL=data:application/json;base64,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

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

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

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

@@ -0,0 +1,33 @@
+import * as THREE from 'three';
+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 <${parseInt(THREE.REVISION.replace(/\D+/g, '')) >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
+}
+  `);
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,247 @@
+import { computed, effect, runInInjectionContext } from '@angular/core';
+import { assertInjectionContext } from 'angular-three';
+import * as THREE from 'three';
+import { shaderMaterial } from '../shader-material/shader-material';
+export 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;
+	  }
+	  `,
+};
+export 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;
+	}
+  `);
+export 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;
+}
+export 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;
+        });
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wireframe-material.js","sourceRoot":"","sources":["../../../../../../libs/soba/shaders/src/wireframe-material/wireframe-material.ts"],"names":[],"mappings":"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","sourcesContent":["import { computed, effect, runInInjectionContext, type Injector } from '@angular/core';\nimport { assertInjectionContext, type NgtShaderMaterial } from 'angular-three';\nimport * as THREE from 'three';\nimport { shaderMaterial } from '../shader-material/shader-material';\n\nexport type WireframeMaterialState = {\n\tfillOpacity?: number;\n\tfillMix?: number;\n\tstrokeOpacity?: number;\n\tthickness?: number;\n\tcolorBackfaces?: boolean;\n\tdashInvert?: boolean;\n\tdash?: boolean;\n\tdashRepeats?: number;\n\tdashLength?: number;\n\tsqueeze?: boolean;\n\tsqueezeMin?: number;\n\tsqueezeMax?: number;\n\tstroke?: THREE.ColorRepresentation;\n\tbackfaceStroke?: THREE.ColorRepresentation;\n\tfill?: THREE.ColorRepresentation;\n};\n\nexport const WireframeMaterialShaders = {\n\tuniforms: {\n\t\tstrokeOpacity: 1,\n\t\tfillOpacity: 0.25,\n\t\tfillMix: 0,\n\t\tthickness: 0.05,\n\t\tcolorBackfaces: false,\n\t\tdashInvert: true,\n\t\tdash: false,\n\t\tdashRepeats: 4,\n\t\tdashLength: 0.5,\n\t\tsqueeze: false,\n\t\tsqueezeMin: 0.2,\n\t\tsqueezeMax: 1,\n\t\tstroke: new THREE.Color('#ff0000'),\n\t\tbackfaceStroke: new THREE.Color('#0000ff'),\n\t\tfill: new THREE.Color('#00ff00'),\n\t},\n\tvertex: /* glsl */ `\n\t  attribute vec3 barycentric;\n\n\t\tvarying vec3 v_edges_Barycentric;\n\t\tvarying vec3 v_edges_Position;\n\n\t\tvoid initWireframe() {\n\t\t\tv_edges_Barycentric = barycentric;\n\t\t\tv_edges_Position = position.xyz;\n\t\t}\n\t  `,\n\tfragment: /* glsl */ `\n\t\t#ifndef PI\n\t  \t#define PI 3.1415926535897932384626433832795\n\t\t#endif\n\n\t  varying vec3 v_edges_Barycentric;\n\t  varying vec3 v_edges_Position;\n\n\t  uniform float strokeOpacity;\n\t  uniform float fillOpacity;\n\t  uniform float fillMix;\n\t  uniform float thickness;\n\t  uniform bool colorBackfaces;\n\n\t  // Dash\n\t  uniform bool dashInvert;\n\t  uniform bool dash;\n\t  uniform bool dashOnly;\n\t  uniform float dashRepeats;\n\t  uniform float dashLength;\n\n\t  // Squeeze\n\t  uniform bool squeeze;\n\t  uniform float squeezeMin;\n\t  uniform float squeezeMax;\n\n\t  // Colors\n\t  uniform vec3 stroke;\n\t  uniform vec3 backfaceStroke;\n\t  uniform vec3 fill;\n\n\t  // This is like\n\t  float wireframe_aastep(float threshold, float dist) {\n\t\t  float afwidth = fwidth(dist) * 0.5;\n\t\t  return smoothstep(threshold - afwidth, threshold + afwidth, dist);\n\t  }\n\n\t  float wireframe_map(float value, float min1, float max1, float min2, float max2) {\n\t\t  return min2 + (value - min1) * (max2 - min2) / (max1 - min1);\n\t  }\n\n\t  float getWireframe() {\n\t\t\tvec3 barycentric = v_edges_Barycentric;\n\n\t\t\t// Distance from center of each triangle to its edges.\n\t\t\tfloat d = min(min(barycentric.x, barycentric.y), barycentric.z);\n\n\t\t\t// for dashed rendering, we can use this to get the 0 .. 1 value of the line length\n\t\t\tfloat positionAlong = max(barycentric.x, barycentric.y);\n\t\t\tif (barycentric.y < barycentric.x && barycentric.y < barycentric.z) {\n\t\t\t\tpositionAlong = 1.0 - positionAlong;\n\t\t\t}\n\n\t\t\t// the thickness of the stroke\n\t\t\tfloat computedThickness = wireframe_map(thickness, 0.0, 1.0, 0.0, 0.34);\n\n\t\t\t// if we want to shrink the thickness toward the center of the line segment\n\t\t\tif (squeeze) {\n\t\t\t\tcomputedThickness *= mix(squeezeMin, squeezeMax, (1.0 - sin(positionAlong * PI)));\n\t\t\t}\n\n\t\t\t// Create dash pattern\n\t\t\tif (dash) {\n\t\t\t\t// here we offset the stroke position depending on whether it\n\t\t\t\t// should overlap or not\n\t\t\t\tfloat offset = 1.0 / dashRepeats * dashLength / 2.0;\n\t\t\t\tif (!dashInvert) {\n\t\t\t\t\toffset += 1.0 / dashRepeats / 2.0;\n\t\t\t\t}\n\n\t\t\t\t// if we should animate the dash or not\n\t\t\t\t// if (dashAnimate) {\n\t\t\t\t// \toffset += time * 0.22;\n\t\t\t\t// }\n\n\t\t\t\t// create the repeating dash pattern\n\t\t\t\tfloat pattern = fract((positionAlong + offset) * dashRepeats);\n\t\t\t\tcomputedThickness *= 1.0 - wireframe_aastep(dashLength, pattern);\n\t\t\t}\n\n\t\t\t// compute the anti-aliased stroke edge\n\t\t\tfloat edge = 1.0 - wireframe_aastep(computedThickness, d);\n\n\t\t\treturn edge;\n\t  }\n\t  `,\n};\n\nexport const WireframeMaterial = shaderMaterial(\n\tWireframeMaterialShaders.uniforms,\n\tWireframeMaterialShaders.vertex +\n\t\t/* glsl */ `\n  \tvoid main() {\n\t\tinitWireframe();\n\t\tgl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);\n\t}\n  `,\n\tWireframeMaterialShaders.fragment +\n\t\t/* glsl */ `\n  void main () {\n\t\t// Compute color\n\n\t\tfloat edge = getWireframe();\n\t\tvec4 colorStroke = vec4(stroke, edge);\n\n\t\t#ifdef FLIP_SIDED\n\t\t\tcolorStroke.rgb = backfaceStroke;\n\t\t#endif\n\n\t\tvec4 colorFill = vec4(fill, fillOpacity);\n\t\tvec4 outColor = mix(colorFill, colorStroke, edge * strokeOpacity);\n\n\t\tgl_FragColor = outColor;\n\t}\n  `,\n);\n\ndeclare global {\n\tinterface HTMLElementTagNameMap {\n\t\t/**\n\t\t * @extends ngt-shader-material\n\t\t */\n\t\t'ngt-wireframe-material': WireframeMaterialState & NgtShaderMaterial;\n\t}\n}\n\nexport function setWireframeOverride(\n\tmaterial: THREE.Material,\n\tuniforms: {\n\t\t[key: string]: THREE.IUniform<any>;\n\t},\n) {\n\tmaterial.onBeforeCompile = (shader) => {\n\t\tshader.uniforms = {\n\t\t\t...shader.uniforms,\n\t\t\t...uniforms,\n\t\t};\n\n\t\tshader.vertexShader = shader.vertexShader.replace(\n\t\t\t'void main() {',\n\t\t\t`\n\t\t  ${WireframeMaterialShaders.vertex}\n\t\t  void main() {\n\t\t\tinitWireframe();\n\t\t`,\n\t\t);\n\n\t\tshader.fragmentShader = shader.fragmentShader.replace(\n\t\t\t'void main() {',\n\t\t\t`\n\t\t  ${WireframeMaterialShaders.fragment}\n\t\t  void main() {\n\t\t`,\n\t\t);\n\n\t\tshader.fragmentShader = shader.fragmentShader.replace(\n\t\t\t'#include <color_fragment>',\n\t\t\t/* glsl */ `\n\t\t  #include <color_fragment>\n\t\t\t  float edge = getWireframe();\n\t\t  vec4 colorStroke = vec4(stroke, edge);\n\t\t  #ifdef FLIP_SIDED\n\t\t\t  colorStroke.rgb = backfaceStroke;\n\t\t  #endif\n\t\t  vec4 colorFill = vec4(mix(diffuseColor.rgb, fill, fillMix), mix(diffuseColor.a, fillOpacity, fillMix));\n\t\t  vec4 outColor = mix(colorFill, colorStroke, edge * strokeOpacity);\n\n\t\t  diffuseColor.rgb = outColor.rgb;\n\t\t  diffuseColor.a *= outColor.a;\n\t\t`,\n\t\t);\n\t};\n\n\tmaterial.side = THREE.DoubleSide;\n\tmaterial.transparent = true;\n}\n\nexport function injectNgtsWireframeUniforms(\n\tuniformsFactory: () => Record<string, THREE.IUniform<any>>,\n\tstateFactory: () => Partial<WireframeMaterialState>,\n\t{ injector }: { injector?: Injector } = {},\n) {\n\tinjector = assertInjectionContext(injectNgtsWireframeUniforms, injector);\n\treturn runInInjectionContext(injector, () => {\n\t\tconst uniforms = uniformsFactory();\n\t\tconst state = computed(() => stateFactory());\n\t\tconst fillOpacity = computed(() => state().fillOpacity);\n\t\tconst fillMix = computed(() => state().fillMix);\n\t\tconst strokeOpacity = computed(() => state().strokeOpacity);\n\t\tconst thickness = computed(() => state().thickness);\n\t\tconst colorBackfaces = computed(() => state().colorBackfaces);\n\t\tconst dash = computed(() => state().dash);\n\t\tconst dashInvert = computed(() => state().dashInvert);\n\t\tconst dashRepeats = computed(() => state().dashRepeats);\n\t\tconst dashLength = computed(() => state().dashLength);\n\t\tconst squeeze = computed(() => state().squeeze);\n\t\tconst squeezeMin = computed(() => state().squeezeMin);\n\t\tconst squeezeMax = computed(() => state().squeezeMax);\n\t\tconst stroke = computed(() => state().stroke);\n\t\tconst fill = computed(() => state().fill);\n\t\tconst backfaceStroke = computed(() => state().backfaceStroke);\n\n\t\teffect(() => {\n\t\t\tuniforms['fillOpacity'].value = fillOpacity() ?? uniforms['fillOpacity'].value;\n\t\t});\n\n\t\teffect(() => {\n\t\t\tuniforms['fillMix'].value = fillMix() ?? uniforms['fillMix'].value;\n\t\t});\n\n\t\teffect(() => {\n\t\t\tuniforms['strokeOpacity'].value = strokeOpacity() ?? uniforms['strokeOpacity'].value;\n\t\t});\n\n\t\teffect(() => {\n\t\t\tuniforms['thickness'].value = thickness() ?? uniforms['thickness'].value;\n\t\t});\n\n\t\teffect(() => {\n\t\t\tuniforms['colorBackfaces'].value = colorBackfaces() ?? uniforms['colorBackfaces'].value;\n\t\t});\n\n\t\teffect(() => {\n\t\t\tuniforms['dash'].value = dash() ?? uniforms['dash'].value;\n\t\t});\n\n\t\teffect(() => {\n\t\t\tuniforms['dashInvert'].value = dashInvert() ?? uniforms['dashInvert'].value;\n\t\t});\n\n\t\teffect(() => {\n\t\t\tuniforms['dashRepeats'].value = dashRepeats() ?? uniforms['dashRepeats'].value;\n\t\t});\n\n\t\teffect(() => {\n\t\t\tuniforms['dashLength'].value = dashLength() ?? uniforms['dashLength'].value;\n\t\t});\n\n\t\teffect(() => {\n\t\t\tuniforms['squeeze'].value = squeeze() ?? uniforms['squeeze'].value;\n\t\t});\n\n\t\teffect(() => {\n\t\t\tuniforms['squeezeMin'].value = squeezeMin() ?? uniforms['squeezeMin'].value;\n\t\t});\n\n\t\teffect(() => {\n\t\t\tuniforms['squeezeMax'].value = squeezeMax() ?? uniforms['squeezeMax'].value;\n\t\t});\n\n\t\teffect(() => {\n\t\t\tuniforms['stroke'].value = stroke() ? new THREE.Color(stroke()) : uniforms['stroke'].value;\n\t\t});\n\n\t\teffect(() => {\n\t\t\tuniforms['fill'].value = fill() ? new THREE.Color(fill()) : uniforms['fill'].value;\n\t\t});\n\n\t\teffect(() => {\n\t\t\tuniforms['backfaceStroke'].value = backfaceStroke()\n\t\t\t\t? new THREE.Color(backfaceStroke())\n\t\t\t\t: uniforms['backfaceStroke'].value;\n\t\t});\n\t});\n}\n"]}