three-stdlib 2.22.7 → 2.22.8

package/dist/shaders/TechnicolorShader.js

@@ -0,0 +1,24 @@
+"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/dist/shaders/TechnicolorShader.mjs

@@ -0,0 +1,24 @@
+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/dist/shaders/ToneMapShader.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Full-screen tone-mapping shader based on http://www.cis.rit.edu/people/faculty/ferwerda/publications/sig02_paper.pdf
+ */
+export declare const ToneMapShader: {
+    uniforms: {
+        tDiffuse: {
+            value: null;
+        };
+        averageLuminance: {
+            value: number;
+        };
+        luminanceMap: {
+            value: null;
+        };
+        maxLuminance: {
+            value: number;
+        };
+        minLuminance: {
+            value: number;
+        };
+        middleGrey: {
+            value: number;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/dist/shaders/ToneMapShader.js

@@ -0,0 +1,51 @@
+"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/dist/shaders/ToneMapShader.mjs

@@ -0,0 +1,51 @@
+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/dist/shaders/ToonShader.d.ts

@@ -0,0 +1,108 @@
+import { Color, Vector3 } from 'three';
+/**
+ * Currently contains:
+ *
+ *	toon1
+ *	toon2
+ *	hatching
+ *	dotted
+ */
+export declare const ToonShader1: {
+    uniforms: {
+        uDirLightPos: {
+            value: Vector3;
+        };
+        uDirLightColor: {
+            value: Color;
+        };
+        uAmbientLightColor: {
+            value: Color;
+        };
+        uBaseColor: {
+            value: Color;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};
+export declare const ToonShader2: {
+    uniforms: {
+        uDirLightPos: {
+            value: Vector3;
+        };
+        uDirLightColor: {
+            value: Color;
+        };
+        uAmbientLightColor: {
+            value: Color;
+        };
+        uBaseColor: {
+            value: Color;
+        };
+        uLineColor1: {
+            value: Color;
+        };
+        uLineColor2: {
+            value: Color;
+        };
+        uLineColor3: {
+            value: Color;
+        };
+        uLineColor4: {
+            value: Color;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};
+export declare const ToonShaderHatching: {
+    uniforms: {
+        uDirLightPos: {
+            value: Vector3;
+        };
+        uDirLightColor: {
+            value: Color;
+        };
+        uAmbientLightColor: {
+            value: Color;
+        };
+        uBaseColor: {
+            value: Color;
+        };
+        uLineColor1: {
+            value: Color;
+        };
+        uLineColor2: {
+            value: Color;
+        };
+        uLineColor3: {
+            value: Color;
+        };
+        uLineColor4: {
+            value: Color;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};
+export declare const ToonShaderDotted: {
+    uniforms: {
+        uDirLightPos: {
+            value: Vector3;
+        };
+        uDirLightColor: {
+            value: Color;
+        };
+        uAmbientLightColor: {
+            value: Color;
+        };
+        uBaseColor: {
+            value: Color;
+        };
+        uLineColor1: {
+            value: Color;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/dist/shaders/ToonShader.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+const ToonShader1 = {
+  uniforms: {
+    uDirLightPos: { value: new THREE.Vector3() },
+    uDirLightColor: { value: new THREE.Color(15658734) },
+    uAmbientLightColor: { value: new THREE.Color(328965) },
+    uBaseColor: { value: 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: new THREE.Vector3() },
+    uDirLightColor: { value: new THREE.Color(15658734) },
+    uAmbientLightColor: { value: new THREE.Color(328965) },
+    uBaseColor: { value: new THREE.Color(15658734) },
+    uLineColor1: { value: new THREE.Color(8421504) },
+    uLineColor2: { value: new THREE.Color(0) },
+    uLineColor3: { value: new THREE.Color(0) },
+    uLineColor4: { value: 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: new THREE.Vector3() },
+    uDirLightColor: { value: new THREE.Color(15658734) },
+    uAmbientLightColor: { value: new THREE.Color(328965) },
+    uBaseColor: { value: new THREE.Color(16777215) },
+    uLineColor1: { value: new THREE.Color(0) },
+    uLineColor2: { value: new THREE.Color(0) },
+    uLineColor3: { value: new THREE.Color(0) },
+    uLineColor4: { value: 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: new THREE.Vector3() },
+    uDirLightColor: { value: new THREE.Color(15658734) },
+    uAmbientLightColor: { value: new THREE.Color(328965) },
+    uBaseColor: { value: new THREE.Color(16777215) },
+    uLineColor1: { value: 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/dist/shaders/ToonShader.mjs

@@ -0,0 +1,188 @@
+import { Vector3, Color } from "three";
+const ToonShader1 = {
+  uniforms: {
+    uDirLightPos: { value: new Vector3() },
+    uDirLightColor: { value: new Color(15658734) },
+    uAmbientLightColor: { value: new Color(328965) },
+    uBaseColor: { value: 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: new Vector3() },
+    uDirLightColor: { value: new Color(15658734) },
+    uAmbientLightColor: { value: new Color(328965) },
+    uBaseColor: { value: new Color(15658734) },
+    uLineColor1: { value: new Color(8421504) },
+    uLineColor2: { value: new Color(0) },
+    uLineColor3: { value: new Color(0) },
+    uLineColor4: { value: 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: new Vector3() },
+    uDirLightColor: { value: new Color(15658734) },
+    uAmbientLightColor: { value: new Color(328965) },
+    uBaseColor: { value: new Color(16777215) },
+    uLineColor1: { value: new Color(0) },
+    uLineColor2: { value: new Color(0) },
+    uLineColor3: { value: new Color(0) },
+    uLineColor4: { value: 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: new Vector3() },
+    uDirLightColor: { value: new Color(15658734) },
+    uAmbientLightColor: { value: new Color(328965) },
+    uBaseColor: { value: new Color(16777215) },
+    uLineColor1: { value: 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/dist/shaders/TriangleBlurShader.d.ts

@@ -0,0 +1,22 @@
+import { Vector2 } from 'three';
+/**
+ * Triangle blur shader
+ * based on glfx.js triangle blur shader
+ * https://github.com/evanw/glfx.js
+ *
+ * A basic blur filter, which convolves the image with a
+ * pyramid filter. The pyramid filter is separable and is applied as two
+ * perpendicular triangle filters.
+ */
+export declare const TriangleBlurShader: {
+    uniforms: {
+        texture: {
+            value: null;
+        };
+        delta: {
+            value: Vector2;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};