three-stdlib 2.15.2 → 2.16.1

package/shaders/SubsurfaceScatteringShader.js

@@ -1,59 +1,45 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const THREE = require("three");
+import { ShaderChunk, UniformsUtils, ShaderLib, Color } from 'three';
+
+/**
+ * ------------------------------------------------------------------------------------------
+ * Subsurface Scattering shader
+ * Based on GDC 2011 – Approximating Translucency for a Fast, Cheap and Convincing Subsurface Scattering Look
+ * https://colinbarrebrisebois.com/2011/03/07/gdc-2011-approximating-translucency-for-a-fast-cheap-and-convincing-subsurface-scattering-look/
+ *------------------------------------------------------------------------------------------
+ */
+
 function replaceAll(string, find, replace) {
   return string.split(find).join(replace);
 }
-const meshphong_frag_head = THREE.ShaderChunk["meshphong_frag"].slice(
-  0,
-  THREE.ShaderChunk["meshphong_frag"].indexOf("void main() {")
-);
-const meshphong_frag_body = THREE.ShaderChunk["meshphong_frag"].slice(THREE.ShaderChunk["meshphong_frag"].indexOf("void main() {"));
+
+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() {'));
 const SubsurfaceScatteringShader = {
-  uniforms: THREE.UniformsUtils.merge([
-    THREE.ShaderLib["phong"].uniforms,
-    {
-      thicknessMap: { value: null },
-      thicknessColor: { value: new THREE.Color(16777215) },
-      thicknessDistortion: { value: 0.1 },
-      thicknessAmbient: { value: 0 },
-      thicknessAttenuation: { value: 0.1 },
-      thicknessPower: { value: 2 },
-      thicknessScale: { value: 10 }
+  uniforms: UniformsUtils.merge([ShaderLib['phong'].uniforms, {
+    thicknessMap: {
+      value: null
+    },
+    thicknessColor: {
+      value: new Color(0xffffff)
+    },
+    thicknessDistortion: {
+      value: 0.1
+    },
+    thicknessAmbient: {
+      value: 0.0
+    },
+    thicknessAttenuation: {
+      value: 0.1
+    },
+    thicknessPower: {
+      value: 2.0
+    },
+    thicknessScale: {
+      value: 10.0
     }
-  ]),
-  vertexShader: ["#define USE_UV", THREE.ShaderChunk["meshphong_vert"]].join("\n"),
-  fragmentShader: [
-    "#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>",
-      replaceAll(
-        THREE.ShaderChunk["lights_fragment_begin"],
-        "RE_Direct( directLight, geometry, material, reflectedLight );",
-        [
-          "RE_Direct( directLight, geometry, material, reflectedLight );",
-          "#if defined( SUBSURFACE ) && defined( USE_UV )",
-          " RE_Direct_Scattering(directLight, vUv, geometry, reflectedLight);",
-          "#endif"
-        ].join("\n")
-      )
-    )
-  ].join("\n")
+  }]),
+  vertexShader: ['#define USE_UV', ShaderChunk['meshphong_vert']].join('\n'),
+  fragmentShader: ['#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>', replaceAll(ShaderChunk['lights_fragment_begin'], 'RE_Direct( directLight, geometry, material, reflectedLight );', ['RE_Direct( directLight, geometry, material, reflectedLight );', '#if defined( SUBSURFACE ) && defined( USE_UV )', ' RE_Direct_Scattering(directLight, vUv, geometry, reflectedLight);', '#endif'].join('\n')))].join('\n')
 };
-exports.SubsurfaceScatteringShader = SubsurfaceScatteringShader;
+
+export { SubsurfaceScatteringShader };

package/shaders/TechnicolorShader.cjs.js

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

package/shaders/TechnicolorShader.js

@@ -1,24 +1,17 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+/**
+ * Technicolor Shader
+ * Simulates the look of the two-strip technicolor process popular in early 20th century films.
+ * More historical info here: http://www.widescreenmuseum.com/oldcolor/technicolor1.htm
+ * Demo here: http://charliehoey.com/technicolor_shader/shader_test.html
+ */
 const TechnicolorShader = {
   uniforms: {
-    tDiffuse: { value: null }
+    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")
+  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;
+
+export { TechnicolorShader };

package/shaders/ToneMapShader.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const e={uniforms:{tDiffuse:{value:null},averageLuminance:{value:1},luminanceMap:{value:null},maxLuminance:{value:16},minLuminance:{value:.01},middleGrey:{value:.6}},vertexShader:["varying vec2 vUv;","void main() {","\tvUv = uv;","\tgl_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","\tuniform sampler2D luminanceMap;","#else","\tuniform float averageLuminance;","#endif","vec3 ToneMap( vec3 vColor ) {","\t#ifdef ADAPTED_LUMINANCE","\t\tfloat fLumAvg = texture2D(luminanceMap, vec2(0.5, 0.5)).r;","\t#else","\t\tfloat fLumAvg = averageLuminance;","\t#endif","\tfloat fLumPixel = linearToRelativeLuminance( vColor );","\tfloat fLumScaled = (fLumPixel * middleGrey) / max( minLuminance, fLumAvg );","\tfloat fLumCompressed = (fLumScaled * (1.0 + (fLumScaled / (maxLuminance * maxLuminance)))) / (1.0 + fLumScaled);","\treturn fLumCompressed * vColor;","}","void main() {","\tvec4 texel = texture2D( tDiffuse, vUv );","\tgl_FragColor = vec4( ToneMap( texel.xyz ), texel.w );","}"].join("\n")};exports.ToneMapShader=e;

package/shaders/ToneMapShader.js

@@ -1,48 +1,32 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+/**
+ * Full-screen tone-mapping shader based on http://www.cis.rit.edu/people/faculty/ferwerda/publications/sig02_paper.pdf
+ */
 const ToneMapShader = {
   uniforms: {
-    tDiffuse: { value: null },
-    averageLuminance: { value: 1 },
-    luminanceMap: { value: null },
-    maxLuminance: { value: 16 },
-    minLuminance: { value: 0.01 },
-    middleGrey: { value: 0.6 }
+    tDiffuse: {
+      value: null
+    },
+    averageLuminance: {
+      value: 1.0
+    },
+    luminanceMap: {
+      value: null
+    },
+    maxLuminance: {
+      value: 16.0
+    },
+    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",
-    "		float fLumAvg = texture2D(luminanceMap, vec2(0.5, 0.5)).r;",
-    "	#else",
-    "		float fLumAvg = averageLuminance;",
-    "	#endif",
-    "	float fLumPixel = linearToRelativeLuminance( vColor );",
-    "	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")
+  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;
+
+export { ToneMapShader };

package/shaders/ToonShader.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var o=require("three");const i={uniforms:{uDirLightPos:{value:new o.Vector3},uDirLightColor:{value:new o.Color(15658734)},uAmbientLightColor:{value:new o.Color(328965)},uBaseColor:{value:new o.Color(16777215)}},vertexShader:["varying vec3 vNormal;","varying vec3 vRefract;","void main() {","\tvec4 worldPosition = modelMatrix * vec4( position, 1.0 );","\tvec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );","\tvec3 worldNormal = normalize ( mat3( modelMatrix[0].xyz, modelMatrix[1].xyz, modelMatrix[2].xyz ) * normal );","\tvNormal = normalize( normalMatrix * normal );","\tvec3 I = worldPosition.xyz - cameraPosition;","\tvRefract = refract( normalize( I ), worldNormal, 1.02 );","\tgl_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() {","\tfloat directionalLightWeighting = max( dot( normalize( vNormal ), uDirLightPos ), 0.0);","\tvec3 lightWeighting = uAmbientLightColor + uDirLightColor * directionalLightWeighting;","\tfloat intensity = smoothstep( - 0.5, 1.0, pow( length(lightWeighting), 20.0 ) );","\tintensity += length(lightWeighting) * 0.2;","\tfloat cameraWeighting = dot( normalize( vNormal ), vRefract );","\tintensity += pow( 1.0 - length( cameraWeighting ), 6.0 );","\tintensity = intensity * 0.2 + 0.3;","\tif ( intensity < 0.50 ) {","\t\tgl_FragColor = vec4( 2.0 * intensity * uBaseColor, 1.0 );","\t} else {","\t\tgl_FragColor = vec4( 1.0 - 2.0 * ( 1.0 - intensity ) * ( 1.0 - uBaseColor ), 1.0 );","}","}"].join("\n")},r={uniforms:{uDirLightPos:{value:new o.Vector3},uDirLightColor:{value:new o.Color(15658734)},uAmbientLightColor:{value:new o.Color(328965)},uBaseColor:{value:new o.Color(15658734)},uLineColor1:{value:new o.Color(8421504)},uLineColor2:{value:new o.Color(0)},uLineColor3:{value:new o.Color(0)},uLineColor4:{value:new o.Color(0)}},vertexShader:["varying vec3 vNormal;","void main() {","\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );","\tvNormal = 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() {","\tfloat camera = max( dot( normalize( vNormal ), vec3( 0.0, 0.0, 1.0 ) ), 0.4);","\tfloat light = max( dot( normalize( vNormal ), uDirLightPos ), 0.0);","\tgl_FragColor = vec4( uBaseColor, 1.0 );","\tif ( length(uAmbientLightColor + uDirLightColor * light) < 1.00 ) {","\t\tgl_FragColor *= vec4( uLineColor1, 1.0 );","\t}","\tif ( length(uAmbientLightColor + uDirLightColor * camera) < 0.50 ) {","\t\tgl_FragColor *= vec4( uLineColor2, 1.0 );","\t}","}"].join("\n")},e={uniforms:{uDirLightPos:{value:new o.Vector3},uDirLightColor:{value:new o.Color(15658734)},uAmbientLightColor:{value:new o.Color(328965)},uBaseColor:{value:new o.Color(16777215)},uLineColor1:{value:new o.Color(0)},uLineColor2:{value:new o.Color(0)},uLineColor3:{value:new o.Color(0)},uLineColor4:{value:new o.Color(0)}},vertexShader:["varying vec3 vNormal;","void main() {","\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );","\tvNormal = 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() {","\tfloat directionalLightWeighting = max( dot( normalize(vNormal), uDirLightPos ), 0.0);","\tvec3 lightWeighting = uAmbientLightColor + uDirLightColor * directionalLightWeighting;","\tgl_FragColor = vec4( uBaseColor, 1.0 );","\tif ( length(lightWeighting) < 1.00 ) {","\t\tif ( mod(gl_FragCoord.x + gl_FragCoord.y, 10.0) == 0.0) {","\t\t\tgl_FragColor = vec4( uLineColor1, 1.0 );","\t\t}","\t}","\tif ( length(lightWeighting) < 0.75 ) {","\t\tif (mod(gl_FragCoord.x - gl_FragCoord.y, 10.0) == 0.0) {","\t\t\tgl_FragColor = vec4( uLineColor2, 1.0 );","\t\t}","\t}","\tif ( length(lightWeighting) < 0.50 ) {","\t\tif (mod(gl_FragCoord.x + gl_FragCoord.y - 5.0, 10.0) == 0.0) {","\t\t\tgl_FragColor = vec4( uLineColor3, 1.0 );","\t\t}","\t}","\tif ( length(lightWeighting) < 0.3465 ) {","\t\tif (mod(gl_FragCoord.x - gl_FragCoord.y - 5.0, 10.0) == 0.0) {","\t\t\tgl_FragColor = vec4( uLineColor4, 1.0 );","\t}","\t}","}"].join("\n")},t={uniforms:{uDirLightPos:{value:new o.Vector3},uDirLightColor:{value:new o.Color(15658734)},uAmbientLightColor:{value:new o.Color(328965)},uBaseColor:{value:new o.Color(16777215)},uLineColor1:{value:new o.Color(0)}},vertexShader:["varying vec3 vNormal;","void main() {","\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );","\tvNormal = 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 ) {","\t\tif ( ( mod(gl_FragCoord.x, 4.001) + mod(gl_FragCoord.y, 4.0) ) > 6.00 ) {","\t\t\tgl_FragColor = vec4( uLineColor1, 1.0 );","\t\t}","\t}","\tif ( length(lightWeighting) < 0.50 ) {","\t\tif ( ( mod(gl_FragCoord.x + 2.0, 4.001) + mod(gl_FragCoord.y + 2.0, 4.0) ) > 6.00 ) {","\t\t\tgl_FragColor = vec4( uLineColor1, 1.0 );","\t\t}","\t}","}"].join("\n")};exports.ToonShader1=i,exports.ToonShader2=r,exports.ToonShaderDotted=t,exports.ToonShaderHatching=e;

package/shaders/ToonShader.js

@@ -1,188 +1,112 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const THREE = require("three");
+import { Vector3, Color } from 'three';
+
+/**
+ * Currently contains:
+ *
+ *	toon1
+ *	toon2
+ *	hatching
+ *	dotted
+ */
+
 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) }
+    uDirLightPos: {
+      value: new Vector3()
+    },
+    uDirLightColor: {
+      value: new Color(0xeeeeee)
+    },
+    uAmbientLightColor: {
+      value: new Color(0x050505)
+    },
+    uBaseColor: {
+      value: new Color(0xffffff)
+    }
   },
-  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")
+  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) }
+    uDirLightPos: {
+      value: new Vector3()
+    },
+    uDirLightColor: {
+      value: new Color(0xeeeeee)
+    },
+    uAmbientLightColor: {
+      value: new Color(0x050505)
+    },
+    uBaseColor: {
+      value: new Color(0xeeeeee)
+    },
+    uLineColor1: {
+      value: new Color(0x808080)
+    },
+    uLineColor2: {
+      value: new Color(0x000000)
+    },
+    uLineColor3: {
+      value: new Color(0x000000)
+    },
+    uLineColor4: {
+      value: new Color(0x000000)
+    }
   },
-  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")
+  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) }
+    uDirLightPos: {
+      value: new Vector3()
+    },
+    uDirLightColor: {
+      value: new Color(0xeeeeee)
+    },
+    uAmbientLightColor: {
+      value: new Color(0x050505)
+    },
+    uBaseColor: {
+      value: new Color(0xffffff)
+    },
+    uLineColor1: {
+      value: new Color(0x000000)
+    },
+    uLineColor2: {
+      value: new Color(0x000000)
+    },
+    uLineColor3: {
+      value: new Color(0x000000)
+    },
+    uLineColor4: {
+      value: new Color(0x000000)
+    }
   },
-  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")
+  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) }
+    uDirLightPos: {
+      value: new Vector3()
+    },
+    uDirLightColor: {
+      value: new Color(0xeeeeee)
+    },
+    uAmbientLightColor: {
+      value: new Color(0x050505)
+    },
+    uBaseColor: {
+      value: new Color(0xffffff)
+    },
+    uLineColor1: {
+      value: new Color(0x000000)
+    }
   },
-  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")
+  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;
+
+export { ToonShader1, ToonShader2, ToonShaderDotted, ToonShaderHatching };

package/shaders/TriangleBlurShader.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const t={uniforms:{texture:{value:null},delta:{value:new(require("three").Vector2)(1,1)}},vertexShader:["varying vec2 vUv;","void main() {","\tvUv = uv;","\tgl_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() {","\tvec4 color = vec4( 0.0 );","\tfloat total = 0.0;","\tfloat offset = rand( vUv );","\tfor ( float t = -ITERATIONS; t <= ITERATIONS; t ++ ) {","\t\tfloat percent = ( t + offset - 0.5 ) / ITERATIONS;","\t\tfloat weight = 1.0 - abs( percent );","\t\tcolor += texture2D( texture, vUv + delta * percent ) * weight;","\t\ttotal += weight;","\t}","\tgl_FragColor = color / total;","}"].join("\n")};exports.TriangleBlurShader=t;

package/shaders/TriangleBlurShader.js

@@ -1,36 +1,27 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const THREE = require("three");
+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.
+ */
+
 const TriangleBlurShader = {
   uniforms: {
-    texture: { value: null },
-    delta: { value: new THREE.Vector2(1, 1) }
+    texture: {
+      value: null
+    },
+    delta: {
+      value: new 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;",
-    "	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")
+  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;
+
+export { TriangleBlurShader };

package/shaders/UnpackDepthRGBAShader.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const e={uniforms:{tDiffuse:{value:null},opacity:{value:1}},vertexShader:["varying vec2 vUv;","void main() {","\tvUv = uv;","\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );","}"].join("\n"),fragmentShader:["uniform float opacity;","uniform sampler2D tDiffuse;","varying vec2 vUv;","#include <packing>","void main() {","\tfloat depth = 1.0 - unpackRGBAToDepth( texture2D( tDiffuse, vUv ) );","\tgl_FragColor = vec4( vec3( depth ), opacity );","}"].join("\n")};exports.UnpackDepthRGBAShader=e;

package/shaders/UnpackDepthRGBAShader.js

@@ -1,26 +1,18 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+/**
+ * Unpack RGBA depth shader
+ * - show RGBA encoded depth as monochrome color
+ */
 const UnpackDepthRGBAShader = {
   uniforms: {
-    tDiffuse: { value: null },
-    opacity: { value: 1 }
+    tDiffuse: {
+      value: null
+    },
+    opacity: {
+      value: 1.0
+    }
   },
-  vertexShader: [
-    "varying vec2 vUv;",
-    "void main() {",
-    "	vUv = uv;",
-    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
-    "}"
-  ].join("\n"),
-  fragmentShader: [
-    "uniform float opacity;",
-    "uniform sampler2D tDiffuse;",
-    "varying vec2 vUv;",
-    "#include <packing>",
-    "void main() {",
-    "	float depth = 1.0 - unpackRGBAToDepth( texture2D( tDiffuse, vUv ) );",
-    "	gl_FragColor = vec4( vec3( depth ), opacity );",
-    "}"
-  ].join("\n")
+  vertexShader: ['varying vec2 vUv;', 'void main() {', '	vUv = uv;', '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );', '}'].join('\n'),
+  fragmentShader: ['uniform float opacity;', 'uniform sampler2D tDiffuse;', 'varying vec2 vUv;', '#include <packing>', 'void main() {', '	float depth = 1.0 - unpackRGBAToDepth( texture2D( tDiffuse, vUv ) );', '	gl_FragColor = vec4( vec3( depth ), opacity );', '}'].join('\n')
 };
-exports.UnpackDepthRGBAShader = UnpackDepthRGBAShader;
+
+export { UnpackDepthRGBAShader };