three-stdlib 2.24.2 → 2.25.1

package/shaders/SubsurfaceScatteringShader.js

@@ -1,98 +0,0 @@
-import { ShaderChunk, UniformsUtils, ShaderLib, Color } from "three";
-let _SubsurfaceScatteringShader;
-function get() {
-  if (_SubsurfaceScatteringShader)
-    return _SubsurfaceScatteringShader;
-  const meshphong_frag_head = ShaderChunk["meshphong_frag"].slice(
-    0,
-    ShaderChunk["meshphong_frag"].indexOf("void main() {")
-  );
-  const meshphong_frag_body = ShaderChunk["meshphong_frag"].slice(
-    ShaderChunk["meshphong_frag"].indexOf("void main() {")
-  );
-  _SubsurfaceScatteringShader = {
-    uniforms: /* @__PURE__ */ UniformsUtils.merge([
-      ShaderLib["phong"].uniforms,
-      {
-        thicknessMap: { value: null },
-        thicknessColor: { value: /* @__PURE__ */ new Color(16777215) },
-        thicknessDistortion: { value: 0.1 },
-        thicknessAmbient: { value: 0 },
-        thicknessAttenuation: { value: 0.1 },
-        thicknessPower: { value: 2 },
-        thicknessScale: { value: 10 }
-      }
-    ]),
-    vertexShader: (
-      /* glsl */
-      `
-    #define USE_UV
-    ${ShaderChunk["meshphong_vert"]}
-  `
-    ),
-    fragmentShader: (
-      /* glsl */
-      `
-    #define USE_UV',
-    #define SUBSURFACE',
-
-    ${meshphong_frag_head}
-
-    uniform sampler2D thicknessMap;
-    uniform float thicknessPower;
-    uniform float thicknessScale;
-    uniform float thicknessDistortion;
-    uniform float thicknessAmbient;
-    uniform float thicknessAttenuation;
-    uniform vec3 thicknessColor;
-
-    void RE_Direct_Scattering(const in IncidentLight directLight, const in vec2 uv, const in GeometricContext geometry, inout ReflectedLight reflectedLight) {
-    	vec3 thickness = thicknessColor * texture2D(thicknessMap, uv).r;
-    	vec3 scatteringHalf = normalize(directLight.direction + (geometry.normal * thicknessDistortion));
-    	float scatteringDot = pow(saturate(dot(geometry.viewDir, -scatteringHalf)), thicknessPower) * thicknessScale;
-    	vec3 scatteringIllu = (scatteringDot + thicknessAmbient) * thickness;
-    	reflectedLight.directDiffuse += scatteringIllu * thicknessAttenuation * directLight.color;
-    }
-
-    ${meshphong_frag_body.replace(
-        "#include <lights_fragment_begin>",
-        ShaderChunk["lights_fragment_begin"].replace(
-          /RE_Direct\( directLight, geometry, material, reflectedLight \);/g,
-          /* glsl */
-          `
-        RE_Direct( directLight, geometry, material, reflectedLight );
-
-        #if defined( SUBSURFACE ) && defined( USE_UV )
-          RE_Direct_Scattering(directLight, vUv, geometry, reflectedLight);
-        #endif
-      `
-        )
-      )}
-  `
-    )
-  };
-  return _SubsurfaceScatteringShader;
-}
-const SubsurfaceScatteringShader = {
-  get uniforms() {
-    return get().uniforms;
-  },
-  set uniforms(value) {
-    get().uniforms = value;
-  },
-  get vertexShader() {
-    return get().vertexShader;
-  },
-  set vertexShader(value) {
-    get().vertexShader = value;
-  },
-  get fragmentShader() {
-    return get().vertexShader;
-  },
-  set fragmentShader(value) {
-    get().vertexShader = value;
-  }
-};
-export {
-  SubsurfaceScatteringShader
-};

package/shaders/TechnicolorShader.cjs

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const TechnicolorShader = {
-  uniforms: {
-    tDiffuse: { value: null }
-  },
-  vertexShader: [
-    "varying vec2 vUv;",
-    "void main() {",
-    "	vUv = uv;",
-    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
-    "}"
-  ].join("\n"),
-  fragmentShader: [
-    "uniform sampler2D tDiffuse;",
-    "varying vec2 vUv;",
-    "void main() {",
-    "	vec4 tex = texture2D( tDiffuse, vec2( vUv.x, vUv.y ) );",
-    "	vec4 newTex = vec4(tex.r, (tex.g + tex.b) * .5, (tex.g + tex.b) * .5, 1.0);",
-    "	gl_FragColor = newTex;",
-    "}"
-  ].join("\n")
-};
-exports.TechnicolorShader = TechnicolorShader;

package/shaders/TechnicolorShader.js

@@ -1,24 +0,0 @@
-const TechnicolorShader = {
-  uniforms: {
-    tDiffuse: { value: null }
-  },
-  vertexShader: [
-    "varying vec2 vUv;",
-    "void main() {",
-    "	vUv = uv;",
-    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
-    "}"
-  ].join("\n"),
-  fragmentShader: [
-    "uniform sampler2D tDiffuse;",
-    "varying vec2 vUv;",
-    "void main() {",
-    "	vec4 tex = texture2D( tDiffuse, vec2( vUv.x, vUv.y ) );",
-    "	vec4 newTex = vec4(tex.r, (tex.g + tex.b) * .5, (tex.g + tex.b) * .5, 1.0);",
-    "	gl_FragColor = newTex;",
-    "}"
-  ].join("\n")
-};
-export {
-  TechnicolorShader
-};

package/shaders/ToneMapShader.cjs

@@ -1,51 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const ToneMapShader = {
-  uniforms: {
-    tDiffuse: { value: null },
-    averageLuminance: { value: 1 },
-    luminanceMap: { value: null },
-    maxLuminance: { value: 16 },
-    minLuminance: { value: 0.01 },
-    middleGrey: { value: 0.6 }
-  },
-  vertexShader: [
-    "varying vec2 vUv;",
-    "void main() {",
-    "	vUv = uv;",
-    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
-    "}"
-  ].join("\n"),
-  fragmentShader: [
-    "#include <common>",
-    "uniform sampler2D tDiffuse;",
-    "varying vec2 vUv;",
-    "uniform float middleGrey;",
-    "uniform float minLuminance;",
-    "uniform float maxLuminance;",
-    "#ifdef ADAPTED_LUMINANCE",
-    "	uniform sampler2D luminanceMap;",
-    "#else",
-    "	uniform float averageLuminance;",
-    "#endif",
-    "vec3 ToneMap( vec3 vColor ) {",
-    "	#ifdef ADAPTED_LUMINANCE",
-    // Get the calculated average luminance
-    "		float fLumAvg = texture2D(luminanceMap, vec2(0.5, 0.5)).r;",
-    "	#else",
-    "		float fLumAvg = averageLuminance;",
-    "	#endif",
-    // Calculate the luminance of the current pixel
-    "	float fLumPixel = linearToRelativeLuminance( vColor );",
-    // Apply the modified operator (Eq. 4)
-    "	float fLumScaled = (fLumPixel * middleGrey) / max( minLuminance, fLumAvg );",
-    "	float fLumCompressed = (fLumScaled * (1.0 + (fLumScaled / (maxLuminance * maxLuminance)))) / (1.0 + fLumScaled);",
-    "	return fLumCompressed * vColor;",
-    "}",
-    "void main() {",
-    "	vec4 texel = texture2D( tDiffuse, vUv );",
-    "	gl_FragColor = vec4( ToneMap( texel.xyz ), texel.w );",
-    "}"
-  ].join("\n")
-};
-exports.ToneMapShader = ToneMapShader;

package/shaders/ToneMapShader.js

@@ -1,51 +0,0 @@
-const ToneMapShader = {
-  uniforms: {
-    tDiffuse: { value: null },
-    averageLuminance: { value: 1 },
-    luminanceMap: { value: null },
-    maxLuminance: { value: 16 },
-    minLuminance: { value: 0.01 },
-    middleGrey: { value: 0.6 }
-  },
-  vertexShader: [
-    "varying vec2 vUv;",
-    "void main() {",
-    "	vUv = uv;",
-    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
-    "}"
-  ].join("\n"),
-  fragmentShader: [
-    "#include <common>",
-    "uniform sampler2D tDiffuse;",
-    "varying vec2 vUv;",
-    "uniform float middleGrey;",
-    "uniform float minLuminance;",
-    "uniform float maxLuminance;",
-    "#ifdef ADAPTED_LUMINANCE",
-    "	uniform sampler2D luminanceMap;",
-    "#else",
-    "	uniform float averageLuminance;",
-    "#endif",
-    "vec3 ToneMap( vec3 vColor ) {",
-    "	#ifdef ADAPTED_LUMINANCE",
-    // Get the calculated average luminance
-    "		float fLumAvg = texture2D(luminanceMap, vec2(0.5, 0.5)).r;",
-    "	#else",
-    "		float fLumAvg = averageLuminance;",
-    "	#endif",
-    // Calculate the luminance of the current pixel
-    "	float fLumPixel = linearToRelativeLuminance( vColor );",
-    // Apply the modified operator (Eq. 4)
-    "	float fLumScaled = (fLumPixel * middleGrey) / max( minLuminance, fLumAvg );",
-    "	float fLumCompressed = (fLumScaled * (1.0 + (fLumScaled / (maxLuminance * maxLuminance)))) / (1.0 + fLumScaled);",
-    "	return fLumCompressed * vColor;",
-    "}",
-    "void main() {",
-    "	vec4 texel = texture2D( tDiffuse, vUv );",
-    "	gl_FragColor = vec4( ToneMap( texel.xyz ), texel.w );",
-    "}"
-  ].join("\n")
-};
-export {
-  ToneMapShader
-};

package/shaders/ToonShader.cjs

@@ -1,188 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const THREE = require("three");
-const ToonShader1 = {
-  uniforms: {
-    uDirLightPos: { value: /* @__PURE__ */ new THREE.Vector3() },
-    uDirLightColor: { value: /* @__PURE__ */ new THREE.Color(15658734) },
-    uAmbientLightColor: { value: /* @__PURE__ */ new THREE.Color(328965) },
-    uBaseColor: { value: /* @__PURE__ */ new THREE.Color(16777215) }
-  },
-  vertexShader: [
-    "varying vec3 vNormal;",
-    "varying vec3 vRefract;",
-    "void main() {",
-    "	vec4 worldPosition = modelMatrix * vec4( position, 1.0 );",
-    "	vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );",
-    "	vec3 worldNormal = normalize ( mat3( modelMatrix[0].xyz, modelMatrix[1].xyz, modelMatrix[2].xyz ) * normal );",
-    "	vNormal = normalize( normalMatrix * normal );",
-    "	vec3 I = worldPosition.xyz - cameraPosition;",
-    "	vRefract = refract( normalize( I ), worldNormal, 1.02 );",
-    "	gl_Position = projectionMatrix * mvPosition;",
-    "}"
-  ].join("\n"),
-  fragmentShader: [
-    "uniform vec3 uBaseColor;",
-    "uniform vec3 uDirLightPos;",
-    "uniform vec3 uDirLightColor;",
-    "uniform vec3 uAmbientLightColor;",
-    "varying vec3 vNormal;",
-    "varying vec3 vRefract;",
-    "void main() {",
-    "	float directionalLightWeighting = max( dot( normalize( vNormal ), uDirLightPos ), 0.0);",
-    "	vec3 lightWeighting = uAmbientLightColor + uDirLightColor * directionalLightWeighting;",
-    "	float intensity = smoothstep( - 0.5, 1.0, pow( length(lightWeighting), 20.0 ) );",
-    "	intensity += length(lightWeighting) * 0.2;",
-    "	float cameraWeighting = dot( normalize( vNormal ), vRefract );",
-    "	intensity += pow( 1.0 - length( cameraWeighting ), 6.0 );",
-    "	intensity = intensity * 0.2 + 0.3;",
-    "	if ( intensity < 0.50 ) {",
-    "		gl_FragColor = vec4( 2.0 * intensity * uBaseColor, 1.0 );",
-    "	} else {",
-    "		gl_FragColor = vec4( 1.0 - 2.0 * ( 1.0 - intensity ) * ( 1.0 - uBaseColor ), 1.0 );",
-    "}",
-    "}"
-  ].join("\n")
-};
-const ToonShader2 = {
-  uniforms: {
-    uDirLightPos: { value: /* @__PURE__ */ new THREE.Vector3() },
-    uDirLightColor: { value: /* @__PURE__ */ new THREE.Color(15658734) },
-    uAmbientLightColor: { value: /* @__PURE__ */ new THREE.Color(328965) },
-    uBaseColor: { value: /* @__PURE__ */ new THREE.Color(15658734) },
-    uLineColor1: { value: /* @__PURE__ */ new THREE.Color(8421504) },
-    uLineColor2: { value: /* @__PURE__ */ new THREE.Color(0) },
-    uLineColor3: { value: /* @__PURE__ */ new THREE.Color(0) },
-    uLineColor4: { value: /* @__PURE__ */ new THREE.Color(0) }
-  },
-  vertexShader: [
-    "varying vec3 vNormal;",
-    "void main() {",
-    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
-    "	vNormal = normalize( normalMatrix * normal );",
-    "}"
-  ].join("\n"),
-  fragmentShader: [
-    "uniform vec3 uBaseColor;",
-    "uniform vec3 uLineColor1;",
-    "uniform vec3 uLineColor2;",
-    "uniform vec3 uLineColor3;",
-    "uniform vec3 uLineColor4;",
-    "uniform vec3 uDirLightPos;",
-    "uniform vec3 uDirLightColor;",
-    "uniform vec3 uAmbientLightColor;",
-    "varying vec3 vNormal;",
-    "void main() {",
-    "	float camera = max( dot( normalize( vNormal ), vec3( 0.0, 0.0, 1.0 ) ), 0.4);",
-    "	float light = max( dot( normalize( vNormal ), uDirLightPos ), 0.0);",
-    "	gl_FragColor = vec4( uBaseColor, 1.0 );",
-    "	if ( length(uAmbientLightColor + uDirLightColor * light) < 1.00 ) {",
-    "		gl_FragColor *= vec4( uLineColor1, 1.0 );",
-    "	}",
-    "	if ( length(uAmbientLightColor + uDirLightColor * camera) < 0.50 ) {",
-    "		gl_FragColor *= vec4( uLineColor2, 1.0 );",
-    "	}",
-    "}"
-  ].join("\n")
-};
-const ToonShaderHatching = {
-  uniforms: {
-    uDirLightPos: { value: /* @__PURE__ */ new THREE.Vector3() },
-    uDirLightColor: { value: /* @__PURE__ */ new THREE.Color(15658734) },
-    uAmbientLightColor: { value: /* @__PURE__ */ new THREE.Color(328965) },
-    uBaseColor: { value: /* @__PURE__ */ new THREE.Color(16777215) },
-    uLineColor1: { value: /* @__PURE__ */ new THREE.Color(0) },
-    uLineColor2: { value: /* @__PURE__ */ new THREE.Color(0) },
-    uLineColor3: { value: /* @__PURE__ */ new THREE.Color(0) },
-    uLineColor4: { value: /* @__PURE__ */ new THREE.Color(0) }
-  },
-  vertexShader: [
-    "varying vec3 vNormal;",
-    "void main() {",
-    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
-    "	vNormal = normalize( normalMatrix * normal );",
-    "}"
-  ].join("\n"),
-  fragmentShader: [
-    "uniform vec3 uBaseColor;",
-    "uniform vec3 uLineColor1;",
-    "uniform vec3 uLineColor2;",
-    "uniform vec3 uLineColor3;",
-    "uniform vec3 uLineColor4;",
-    "uniform vec3 uDirLightPos;",
-    "uniform vec3 uDirLightColor;",
-    "uniform vec3 uAmbientLightColor;",
-    "varying vec3 vNormal;",
-    "void main() {",
-    "	float directionalLightWeighting = max( dot( normalize(vNormal), uDirLightPos ), 0.0);",
-    "	vec3 lightWeighting = uAmbientLightColor + uDirLightColor * directionalLightWeighting;",
-    "	gl_FragColor = vec4( uBaseColor, 1.0 );",
-    "	if ( length(lightWeighting) < 1.00 ) {",
-    "		if ( mod(gl_FragCoord.x + gl_FragCoord.y, 10.0) == 0.0) {",
-    "			gl_FragColor = vec4( uLineColor1, 1.0 );",
-    "		}",
-    "	}",
-    "	if ( length(lightWeighting) < 0.75 ) {",
-    "		if (mod(gl_FragCoord.x - gl_FragCoord.y, 10.0) == 0.0) {",
-    "			gl_FragColor = vec4( uLineColor2, 1.0 );",
-    "		}",
-    "	}",
-    "	if ( length(lightWeighting) < 0.50 ) {",
-    "		if (mod(gl_FragCoord.x + gl_FragCoord.y - 5.0, 10.0) == 0.0) {",
-    "			gl_FragColor = vec4( uLineColor3, 1.0 );",
-    "		}",
-    "	}",
-    "	if ( length(lightWeighting) < 0.3465 ) {",
-    "		if (mod(gl_FragCoord.x - gl_FragCoord.y - 5.0, 10.0) == 0.0) {",
-    "			gl_FragColor = vec4( uLineColor4, 1.0 );",
-    "	}",
-    "	}",
-    "}"
-  ].join("\n")
-};
-const ToonShaderDotted = {
-  uniforms: {
-    uDirLightPos: { value: /* @__PURE__ */ new THREE.Vector3() },
-    uDirLightColor: { value: /* @__PURE__ */ new THREE.Color(15658734) },
-    uAmbientLightColor: { value: /* @__PURE__ */ new THREE.Color(328965) },
-    uBaseColor: { value: /* @__PURE__ */ new THREE.Color(16777215) },
-    uLineColor1: { value: /* @__PURE__ */ new THREE.Color(0) }
-  },
-  vertexShader: [
-    "varying vec3 vNormal;",
-    "void main() {",
-    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
-    "	vNormal = normalize( normalMatrix * normal );",
-    "}"
-  ].join("\n"),
-  fragmentShader: [
-    "uniform vec3 uBaseColor;",
-    "uniform vec3 uLineColor1;",
-    "uniform vec3 uLineColor2;",
-    "uniform vec3 uLineColor3;",
-    "uniform vec3 uLineColor4;",
-    "uniform vec3 uDirLightPos;",
-    "uniform vec3 uDirLightColor;",
-    "uniform vec3 uAmbientLightColor;",
-    "varying vec3 vNormal;",
-    "void main() {",
-    "float directionalLightWeighting = max( dot( normalize(vNormal), uDirLightPos ), 0.0);",
-    "vec3 lightWeighting = uAmbientLightColor + uDirLightColor * directionalLightWeighting;",
-    "gl_FragColor = vec4( uBaseColor, 1.0 );",
-    "if ( length(lightWeighting) < 1.00 ) {",
-    "		if ( ( mod(gl_FragCoord.x, 4.001) + mod(gl_FragCoord.y, 4.0) ) > 6.00 ) {",
-    "			gl_FragColor = vec4( uLineColor1, 1.0 );",
-    "		}",
-    "	}",
-    "	if ( length(lightWeighting) < 0.50 ) {",
-    "		if ( ( mod(gl_FragCoord.x + 2.0, 4.001) + mod(gl_FragCoord.y + 2.0, 4.0) ) > 6.00 ) {",
-    "			gl_FragColor = vec4( uLineColor1, 1.0 );",
-    "		}",
-    "	}",
-    "}"
-  ].join("\n")
-};
-exports.ToonShader1 = ToonShader1;
-exports.ToonShader2 = ToonShader2;
-exports.ToonShaderDotted = ToonShaderDotted;
-exports.ToonShaderHatching = ToonShaderHatching;

package/shaders/ToonShader.js

@@ -1,188 +0,0 @@
-import { Vector3, Color } from "three";
-const ToonShader1 = {
-  uniforms: {
-    uDirLightPos: { value: /* @__PURE__ */ new Vector3() },
-    uDirLightColor: { value: /* @__PURE__ */ new Color(15658734) },
-    uAmbientLightColor: { value: /* @__PURE__ */ new Color(328965) },
-    uBaseColor: { value: /* @__PURE__ */ new Color(16777215) }
-  },
-  vertexShader: [
-    "varying vec3 vNormal;",
-    "varying vec3 vRefract;",
-    "void main() {",
-    "	vec4 worldPosition = modelMatrix * vec4( position, 1.0 );",
-    "	vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );",
-    "	vec3 worldNormal = normalize ( mat3( modelMatrix[0].xyz, modelMatrix[1].xyz, modelMatrix[2].xyz ) * normal );",
-    "	vNormal = normalize( normalMatrix * normal );",
-    "	vec3 I = worldPosition.xyz - cameraPosition;",
-    "	vRefract = refract( normalize( I ), worldNormal, 1.02 );",
-    "	gl_Position = projectionMatrix * mvPosition;",
-    "}"
-  ].join("\n"),
-  fragmentShader: [
-    "uniform vec3 uBaseColor;",
-    "uniform vec3 uDirLightPos;",
-    "uniform vec3 uDirLightColor;",
-    "uniform vec3 uAmbientLightColor;",
-    "varying vec3 vNormal;",
-    "varying vec3 vRefract;",
-    "void main() {",
-    "	float directionalLightWeighting = max( dot( normalize( vNormal ), uDirLightPos ), 0.0);",
-    "	vec3 lightWeighting = uAmbientLightColor + uDirLightColor * directionalLightWeighting;",
-    "	float intensity = smoothstep( - 0.5, 1.0, pow( length(lightWeighting), 20.0 ) );",
-    "	intensity += length(lightWeighting) * 0.2;",
-    "	float cameraWeighting = dot( normalize( vNormal ), vRefract );",
-    "	intensity += pow( 1.0 - length( cameraWeighting ), 6.0 );",
-    "	intensity = intensity * 0.2 + 0.3;",
-    "	if ( intensity < 0.50 ) {",
-    "		gl_FragColor = vec4( 2.0 * intensity * uBaseColor, 1.0 );",
-    "	} else {",
-    "		gl_FragColor = vec4( 1.0 - 2.0 * ( 1.0 - intensity ) * ( 1.0 - uBaseColor ), 1.0 );",
-    "}",
-    "}"
-  ].join("\n")
-};
-const ToonShader2 = {
-  uniforms: {
-    uDirLightPos: { value: /* @__PURE__ */ new Vector3() },
-    uDirLightColor: { value: /* @__PURE__ */ new Color(15658734) },
-    uAmbientLightColor: { value: /* @__PURE__ */ new Color(328965) },
-    uBaseColor: { value: /* @__PURE__ */ new Color(15658734) },
-    uLineColor1: { value: /* @__PURE__ */ new Color(8421504) },
-    uLineColor2: { value: /* @__PURE__ */ new Color(0) },
-    uLineColor3: { value: /* @__PURE__ */ new Color(0) },
-    uLineColor4: { value: /* @__PURE__ */ new Color(0) }
-  },
-  vertexShader: [
-    "varying vec3 vNormal;",
-    "void main() {",
-    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
-    "	vNormal = normalize( normalMatrix * normal );",
-    "}"
-  ].join("\n"),
-  fragmentShader: [
-    "uniform vec3 uBaseColor;",
-    "uniform vec3 uLineColor1;",
-    "uniform vec3 uLineColor2;",
-    "uniform vec3 uLineColor3;",
-    "uniform vec3 uLineColor4;",
-    "uniform vec3 uDirLightPos;",
-    "uniform vec3 uDirLightColor;",
-    "uniform vec3 uAmbientLightColor;",
-    "varying vec3 vNormal;",
-    "void main() {",
-    "	float camera = max( dot( normalize( vNormal ), vec3( 0.0, 0.0, 1.0 ) ), 0.4);",
-    "	float light = max( dot( normalize( vNormal ), uDirLightPos ), 0.0);",
-    "	gl_FragColor = vec4( uBaseColor, 1.0 );",
-    "	if ( length(uAmbientLightColor + uDirLightColor * light) < 1.00 ) {",
-    "		gl_FragColor *= vec4( uLineColor1, 1.0 );",
-    "	}",
-    "	if ( length(uAmbientLightColor + uDirLightColor * camera) < 0.50 ) {",
-    "		gl_FragColor *= vec4( uLineColor2, 1.0 );",
-    "	}",
-    "}"
-  ].join("\n")
-};
-const ToonShaderHatching = {
-  uniforms: {
-    uDirLightPos: { value: /* @__PURE__ */ new Vector3() },
-    uDirLightColor: { value: /* @__PURE__ */ new Color(15658734) },
-    uAmbientLightColor: { value: /* @__PURE__ */ new Color(328965) },
-    uBaseColor: { value: /* @__PURE__ */ new Color(16777215) },
-    uLineColor1: { value: /* @__PURE__ */ new Color(0) },
-    uLineColor2: { value: /* @__PURE__ */ new Color(0) },
-    uLineColor3: { value: /* @__PURE__ */ new Color(0) },
-    uLineColor4: { value: /* @__PURE__ */ new Color(0) }
-  },
-  vertexShader: [
-    "varying vec3 vNormal;",
-    "void main() {",
-    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
-    "	vNormal = normalize( normalMatrix * normal );",
-    "}"
-  ].join("\n"),
-  fragmentShader: [
-    "uniform vec3 uBaseColor;",
-    "uniform vec3 uLineColor1;",
-    "uniform vec3 uLineColor2;",
-    "uniform vec3 uLineColor3;",
-    "uniform vec3 uLineColor4;",
-    "uniform vec3 uDirLightPos;",
-    "uniform vec3 uDirLightColor;",
-    "uniform vec3 uAmbientLightColor;",
-    "varying vec3 vNormal;",
-    "void main() {",
-    "	float directionalLightWeighting = max( dot( normalize(vNormal), uDirLightPos ), 0.0);",
-    "	vec3 lightWeighting = uAmbientLightColor + uDirLightColor * directionalLightWeighting;",
-    "	gl_FragColor = vec4( uBaseColor, 1.0 );",
-    "	if ( length(lightWeighting) < 1.00 ) {",
-    "		if ( mod(gl_FragCoord.x + gl_FragCoord.y, 10.0) == 0.0) {",
-    "			gl_FragColor = vec4( uLineColor1, 1.0 );",
-    "		}",
-    "	}",
-    "	if ( length(lightWeighting) < 0.75 ) {",
-    "		if (mod(gl_FragCoord.x - gl_FragCoord.y, 10.0) == 0.0) {",
-    "			gl_FragColor = vec4( uLineColor2, 1.0 );",
-    "		}",
-    "	}",
-    "	if ( length(lightWeighting) < 0.50 ) {",
-    "		if (mod(gl_FragCoord.x + gl_FragCoord.y - 5.0, 10.0) == 0.0) {",
-    "			gl_FragColor = vec4( uLineColor3, 1.0 );",
-    "		}",
-    "	}",
-    "	if ( length(lightWeighting) < 0.3465 ) {",
-    "		if (mod(gl_FragCoord.x - gl_FragCoord.y - 5.0, 10.0) == 0.0) {",
-    "			gl_FragColor = vec4( uLineColor4, 1.0 );",
-    "	}",
-    "	}",
-    "}"
-  ].join("\n")
-};
-const ToonShaderDotted = {
-  uniforms: {
-    uDirLightPos: { value: /* @__PURE__ */ new Vector3() },
-    uDirLightColor: { value: /* @__PURE__ */ new Color(15658734) },
-    uAmbientLightColor: { value: /* @__PURE__ */ new Color(328965) },
-    uBaseColor: { value: /* @__PURE__ */ new Color(16777215) },
-    uLineColor1: { value: /* @__PURE__ */ new Color(0) }
-  },
-  vertexShader: [
-    "varying vec3 vNormal;",
-    "void main() {",
-    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
-    "	vNormal = normalize( normalMatrix * normal );",
-    "}"
-  ].join("\n"),
-  fragmentShader: [
-    "uniform vec3 uBaseColor;",
-    "uniform vec3 uLineColor1;",
-    "uniform vec3 uLineColor2;",
-    "uniform vec3 uLineColor3;",
-    "uniform vec3 uLineColor4;",
-    "uniform vec3 uDirLightPos;",
-    "uniform vec3 uDirLightColor;",
-    "uniform vec3 uAmbientLightColor;",
-    "varying vec3 vNormal;",
-    "void main() {",
-    "float directionalLightWeighting = max( dot( normalize(vNormal), uDirLightPos ), 0.0);",
-    "vec3 lightWeighting = uAmbientLightColor + uDirLightColor * directionalLightWeighting;",
-    "gl_FragColor = vec4( uBaseColor, 1.0 );",
-    "if ( length(lightWeighting) < 1.00 ) {",
-    "		if ( ( mod(gl_FragCoord.x, 4.001) + mod(gl_FragCoord.y, 4.0) ) > 6.00 ) {",
-    "			gl_FragColor = vec4( uLineColor1, 1.0 );",
-    "		}",
-    "	}",
-    "	if ( length(lightWeighting) < 0.50 ) {",
-    "		if ( ( mod(gl_FragCoord.x + 2.0, 4.001) + mod(gl_FragCoord.y + 2.0, 4.0) ) > 6.00 ) {",
-    "			gl_FragColor = vec4( uLineColor1, 1.0 );",
-    "		}",
-    "	}",
-    "}"
-  ].join("\n")
-};
-export {
-  ToonShader1,
-  ToonShader2,
-  ToonShaderDotted,
-  ToonShaderHatching
-};

package/shaders/TriangleBlurShader.cjs

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const THREE = require("three");
-const TriangleBlurShader = {
-  uniforms: {
-    texture: { value: null },
-    delta: { value: /* @__PURE__ */ new THREE.Vector2(1, 1) }
-  },
-  vertexShader: [
-    "varying vec2 vUv;",
-    "void main() {",
-    "	vUv = uv;",
-    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
-    "}"
-  ].join("\n"),
-  fragmentShader: [
-    "#include <common>",
-    "#define ITERATIONS 10.0",
-    "uniform sampler2D texture;",
-    "uniform vec2 delta;",
-    "varying vec2 vUv;",
-    "void main() {",
-    "	vec4 color = vec4( 0.0 );",
-    "	float total = 0.0;",
-    // randomize the lookup values to hide the fixed number of samples
-    "	float offset = rand( vUv );",
-    "	for ( float t = -ITERATIONS; t <= ITERATIONS; t ++ ) {",
-    "		float percent = ( t + offset - 0.5 ) / ITERATIONS;",
-    "		float weight = 1.0 - abs( percent );",
-    "		color += texture2D( texture, vUv + delta * percent ) * weight;",
-    "		total += weight;",
-    "	}",
-    "	gl_FragColor = color / total;",
-    "}"
-  ].join("\n")
-};
-exports.TriangleBlurShader = TriangleBlurShader;