three-stdlib 2.15.0 → 2.15.2

package/shaders/ParallaxShader.js

@@ -1,54 +1,113 @@
-// Parallax Occlusion shaders from
-//    http://sunandblackcat.com/tipFullView.php?topicid=28
-// No tangent-space transforms logic based on
-//   http://mmikkelsen3d.blogspot.sk/2012/02/parallaxpoc-mapping-and-no-tangent.html
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
 const ParallaxShader = {
-  // Ordered from fastest to best quality.
   modes: {
-    none: 'NO_PARALLAX',
-    basic: 'USE_BASIC_PARALLAX',
-    steep: 'USE_STEEP_PARALLAX',
-    occlusion: 'USE_OCLUSION_PARALLAX',
-    // a.k.a. POM
-    relief: 'USE_RELIEF_PARALLAX'
+    none: "NO_PARALLAX",
+    basic: "USE_BASIC_PARALLAX",
+    steep: "USE_STEEP_PARALLAX",
+    occlusion: "USE_OCLUSION_PARALLAX",
+    relief: "USE_RELIEF_PARALLAX"
   },
   uniforms: {
-    bumpMap: {
-      value: null
-    },
-    map: {
-      value: null
-    },
-    parallaxScale: {
-      value: null
-    },
-    parallaxMinLayers: {
-      value: null
-    },
-    parallaxMaxLayers: {
-      value: null
-    }
+    bumpMap: { value: null },
+    map: { value: null },
+    parallaxScale: { value: null },
+    parallaxMinLayers: { value: null },
+    parallaxMaxLayers: { value: null }
   },
-  vertexShader: ['varying vec2 vUv;', 'varying vec3 vViewPosition;', 'varying vec3 vNormal;', 'void main() {', '	vUv = uv;', '	vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );', '	vViewPosition = -mvPosition.xyz;', '	vNormal = normalize( normalMatrix * normal );', '	gl_Position = projectionMatrix * mvPosition;', '}'].join('\n'),
-  fragmentShader: ['uniform sampler2D bumpMap;', 'uniform sampler2D map;', 'uniform float parallaxScale;', 'uniform float parallaxMinLayers;', 'uniform float parallaxMaxLayers;', 'varying vec2 vUv;', 'varying vec3 vViewPosition;', 'varying vec3 vNormal;', '#ifdef USE_BASIC_PARALLAX', '	vec2 parallaxMap( in vec3 V ) {', '		float initialHeight = texture2D( bumpMap, vUv ).r;', // No Offset Limitting: messy, floating output at grazing angles.
-  //"vec2 texCoordOffset = parallaxScale * V.xy / V.z * initialHeight;",
-  // Offset Limiting
-  '		vec2 texCoordOffset = parallaxScale * V.xy * initialHeight;', '		return vUv - texCoordOffset;', '	}', '#else', '	vec2 parallaxMap( in vec3 V ) {', // Determine number of layers from angle between V and N
-  '		float numLayers = mix( parallaxMaxLayers, parallaxMinLayers, abs( dot( vec3( 0.0, 0.0, 1.0 ), V ) ) );', '		float layerHeight = 1.0 / numLayers;', '		float currentLayerHeight = 0.0;', // Shift of texture coordinates for each iteration
-  '		vec2 dtex = parallaxScale * V.xy / V.z / numLayers;', '		vec2 currentTextureCoords = vUv;', '		float heightFromTexture = texture2D( bumpMap, currentTextureCoords ).r;', // while ( heightFromTexture > currentLayerHeight )
-  // Infinite loops are not well supported. Do a "large" finite
-  // loop, but not too large, as it slows down some compilers.
-  '		for ( int i = 0; i < 30; i += 1 ) {', '			if ( heightFromTexture <= currentLayerHeight ) {', '				break;', '			}', '			currentLayerHeight += layerHeight;', // Shift texture coordinates along vector V
-  '			currentTextureCoords -= dtex;', '			heightFromTexture = texture2D( bumpMap, currentTextureCoords ).r;', '		}', '		#ifdef USE_STEEP_PARALLAX', '			return currentTextureCoords;', '		#elif defined( USE_RELIEF_PARALLAX )', '			vec2 deltaTexCoord = dtex / 2.0;', '			float deltaHeight = layerHeight / 2.0;', // Return to the mid point of previous layer
-  '			currentTextureCoords += deltaTexCoord;', '			currentLayerHeight -= deltaHeight;', // Binary search to increase precision of Steep Parallax Mapping
-  '			const int numSearches = 5;', '			for ( int i = 0; i < numSearches; i += 1 ) {', '				deltaTexCoord /= 2.0;', '				deltaHeight /= 2.0;', '				heightFromTexture = texture2D( bumpMap, currentTextureCoords ).r;', // Shift along or against vector V
-  '				if( heightFromTexture > currentLayerHeight ) {', // Below the surface
-  '					currentTextureCoords -= deltaTexCoord;', '					currentLayerHeight += deltaHeight;', '				} else {', // above the surface
-  '					currentTextureCoords += deltaTexCoord;', '					currentLayerHeight -= deltaHeight;', '				}', '			}', '			return currentTextureCoords;', '		#elif defined( USE_OCLUSION_PARALLAX )', '			vec2 prevTCoords = currentTextureCoords + dtex;', // Heights for linear interpolation
-  '			float nextH = heightFromTexture - currentLayerHeight;', '			float prevH = texture2D( bumpMap, prevTCoords ).r - currentLayerHeight + layerHeight;', // Proportions for linear interpolation
-  '			float weight = nextH / ( nextH - prevH );', // Interpolation of texture coordinates
-  '			return prevTCoords * weight + currentTextureCoords * ( 1.0 - weight );', '		#else', // NO_PARALLAX
-  '			return vUv;', '		#endif', '	}', '#endif', 'vec2 perturbUv( vec3 surfPosition, vec3 surfNormal, vec3 viewPosition ) {', '	vec2 texDx = dFdx( vUv );', '	vec2 texDy = dFdy( vUv );', '	vec3 vSigmaX = dFdx( surfPosition );', '	vec3 vSigmaY = dFdy( surfPosition );', '	vec3 vR1 = cross( vSigmaY, surfNormal );', '	vec3 vR2 = cross( surfNormal, vSigmaX );', '	float fDet = dot( vSigmaX, vR1 );', '	vec2 vProjVscr = ( 1.0 / fDet ) * vec2( dot( vR1, viewPosition ), dot( vR2, viewPosition ) );', '	vec3 vProjVtex;', '	vProjVtex.xy = texDx * vProjVscr.x + texDy * vProjVscr.y;', '	vProjVtex.z = dot( surfNormal, viewPosition );', '	return parallaxMap( vProjVtex );', '}', 'void main() {', '	vec2 mapUv = perturbUv( -vViewPosition, normalize( vNormal ), normalize( vViewPosition ) );', '	gl_FragColor = texture2D( map, mapUv );', '}'].join('\n')
+  vertexShader: [
+    "varying vec2 vUv;",
+    "varying vec3 vViewPosition;",
+    "varying vec3 vNormal;",
+    "void main() {",
+    "	vUv = uv;",
+    "	vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );",
+    "	vViewPosition = -mvPosition.xyz;",
+    "	vNormal = normalize( normalMatrix * normal );",
+    "	gl_Position = projectionMatrix * mvPosition;",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "uniform sampler2D bumpMap;",
+    "uniform sampler2D map;",
+    "uniform float parallaxScale;",
+    "uniform float parallaxMinLayers;",
+    "uniform float parallaxMaxLayers;",
+    "varying vec2 vUv;",
+    "varying vec3 vViewPosition;",
+    "varying vec3 vNormal;",
+    "#ifdef USE_BASIC_PARALLAX",
+    "	vec2 parallaxMap( in vec3 V ) {",
+    "		float initialHeight = texture2D( bumpMap, vUv ).r;",
+    "		vec2 texCoordOffset = parallaxScale * V.xy * initialHeight;",
+    "		return vUv - texCoordOffset;",
+    "	}",
+    "#else",
+    "	vec2 parallaxMap( in vec3 V ) {",
+    "		float numLayers = mix( parallaxMaxLayers, parallaxMinLayers, abs( dot( vec3( 0.0, 0.0, 1.0 ), V ) ) );",
+    "		float layerHeight = 1.0 / numLayers;",
+    "		float currentLayerHeight = 0.0;",
+    "		vec2 dtex = parallaxScale * V.xy / V.z / numLayers;",
+    "		vec2 currentTextureCoords = vUv;",
+    "		float heightFromTexture = texture2D( bumpMap, currentTextureCoords ).r;",
+    "		for ( int i = 0; i < 30; i += 1 ) {",
+    "			if ( heightFromTexture <= currentLayerHeight ) {",
+    "				break;",
+    "			}",
+    "			currentLayerHeight += layerHeight;",
+    "			currentTextureCoords -= dtex;",
+    "			heightFromTexture = texture2D( bumpMap, currentTextureCoords ).r;",
+    "		}",
+    "		#ifdef USE_STEEP_PARALLAX",
+    "			return currentTextureCoords;",
+    "		#elif defined( USE_RELIEF_PARALLAX )",
+    "			vec2 deltaTexCoord = dtex / 2.0;",
+    "			float deltaHeight = layerHeight / 2.0;",
+    "			currentTextureCoords += deltaTexCoord;",
+    "			currentLayerHeight -= deltaHeight;",
+    "			const int numSearches = 5;",
+    "			for ( int i = 0; i < numSearches; i += 1 ) {",
+    "				deltaTexCoord /= 2.0;",
+    "				deltaHeight /= 2.0;",
+    "				heightFromTexture = texture2D( bumpMap, currentTextureCoords ).r;",
+    "				if( heightFromTexture > currentLayerHeight ) {",
+    "					currentTextureCoords -= deltaTexCoord;",
+    "					currentLayerHeight += deltaHeight;",
+    "				} else {",
+    "					currentTextureCoords += deltaTexCoord;",
+    "					currentLayerHeight -= deltaHeight;",
+    "				}",
+    "			}",
+    "			return currentTextureCoords;",
+    "		#elif defined( USE_OCLUSION_PARALLAX )",
+    "			vec2 prevTCoords = currentTextureCoords + dtex;",
+    "			float nextH = heightFromTexture - currentLayerHeight;",
+    "			float prevH = texture2D( bumpMap, prevTCoords ).r - currentLayerHeight + layerHeight;",
+    "			float weight = nextH / ( nextH - prevH );",
+    "			return prevTCoords * weight + currentTextureCoords * ( 1.0 - weight );",
+    "		#else",
+    "			return vUv;",
+    "		#endif",
+    "	}",
+    "#endif",
+    "vec2 perturbUv( vec3 surfPosition, vec3 surfNormal, vec3 viewPosition ) {",
+    "	vec2 texDx = dFdx( vUv );",
+    "	vec2 texDy = dFdy( vUv );",
+    "	vec3 vSigmaX = dFdx( surfPosition );",
+    "	vec3 vSigmaY = dFdy( surfPosition );",
+    "	vec3 vR1 = cross( vSigmaY, surfNormal );",
+    "	vec3 vR2 = cross( surfNormal, vSigmaX );",
+    "	float fDet = dot( vSigmaX, vR1 );",
+    "	vec2 vProjVscr = ( 1.0 / fDet ) * vec2( dot( vR1, viewPosition ), dot( vR2, viewPosition ) );",
+    "	vec3 vProjVtex;",
+    "	vProjVtex.xy = texDx * vProjVscr.x + texDy * vProjVscr.y;",
+    "	vProjVtex.z = dot( surfNormal, viewPosition );",
+    "	return parallaxMap( vProjVtex );",
+    "}",
+    "void main() {",
+    "	vec2 mapUv = perturbUv( -vViewPosition, normalize( vNormal ), normalize( vViewPosition ) );",
+    "	gl_FragColor = texture2D( map, mapUv );",
+    "}"
+  ].join("\n")
 };
-
-export { ParallaxShader };
+exports.ParallaxShader = ParallaxShader;

package/shaders/ParallaxShader.mjs

@@ -0,0 +1,113 @@
+const ParallaxShader = {
+  modes: {
+    none: "NO_PARALLAX",
+    basic: "USE_BASIC_PARALLAX",
+    steep: "USE_STEEP_PARALLAX",
+    occlusion: "USE_OCLUSION_PARALLAX",
+    relief: "USE_RELIEF_PARALLAX"
+  },
+  uniforms: {
+    bumpMap: { value: null },
+    map: { value: null },
+    parallaxScale: { value: null },
+    parallaxMinLayers: { value: null },
+    parallaxMaxLayers: { value: null }
+  },
+  vertexShader: [
+    "varying vec2 vUv;",
+    "varying vec3 vViewPosition;",
+    "varying vec3 vNormal;",
+    "void main() {",
+    "	vUv = uv;",
+    "	vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );",
+    "	vViewPosition = -mvPosition.xyz;",
+    "	vNormal = normalize( normalMatrix * normal );",
+    "	gl_Position = projectionMatrix * mvPosition;",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "uniform sampler2D bumpMap;",
+    "uniform sampler2D map;",
+    "uniform float parallaxScale;",
+    "uniform float parallaxMinLayers;",
+    "uniform float parallaxMaxLayers;",
+    "varying vec2 vUv;",
+    "varying vec3 vViewPosition;",
+    "varying vec3 vNormal;",
+    "#ifdef USE_BASIC_PARALLAX",
+    "	vec2 parallaxMap( in vec3 V ) {",
+    "		float initialHeight = texture2D( bumpMap, vUv ).r;",
+    "		vec2 texCoordOffset = parallaxScale * V.xy * initialHeight;",
+    "		return vUv - texCoordOffset;",
+    "	}",
+    "#else",
+    "	vec2 parallaxMap( in vec3 V ) {",
+    "		float numLayers = mix( parallaxMaxLayers, parallaxMinLayers, abs( dot( vec3( 0.0, 0.0, 1.0 ), V ) ) );",
+    "		float layerHeight = 1.0 / numLayers;",
+    "		float currentLayerHeight = 0.0;",
+    "		vec2 dtex = parallaxScale * V.xy / V.z / numLayers;",
+    "		vec2 currentTextureCoords = vUv;",
+    "		float heightFromTexture = texture2D( bumpMap, currentTextureCoords ).r;",
+    "		for ( int i = 0; i < 30; i += 1 ) {",
+    "			if ( heightFromTexture <= currentLayerHeight ) {",
+    "				break;",
+    "			}",
+    "			currentLayerHeight += layerHeight;",
+    "			currentTextureCoords -= dtex;",
+    "			heightFromTexture = texture2D( bumpMap, currentTextureCoords ).r;",
+    "		}",
+    "		#ifdef USE_STEEP_PARALLAX",
+    "			return currentTextureCoords;",
+    "		#elif defined( USE_RELIEF_PARALLAX )",
+    "			vec2 deltaTexCoord = dtex / 2.0;",
+    "			float deltaHeight = layerHeight / 2.0;",
+    "			currentTextureCoords += deltaTexCoord;",
+    "			currentLayerHeight -= deltaHeight;",
+    "			const int numSearches = 5;",
+    "			for ( int i = 0; i < numSearches; i += 1 ) {",
+    "				deltaTexCoord /= 2.0;",
+    "				deltaHeight /= 2.0;",
+    "				heightFromTexture = texture2D( bumpMap, currentTextureCoords ).r;",
+    "				if( heightFromTexture > currentLayerHeight ) {",
+    "					currentTextureCoords -= deltaTexCoord;",
+    "					currentLayerHeight += deltaHeight;",
+    "				} else {",
+    "					currentTextureCoords += deltaTexCoord;",
+    "					currentLayerHeight -= deltaHeight;",
+    "				}",
+    "			}",
+    "			return currentTextureCoords;",
+    "		#elif defined( USE_OCLUSION_PARALLAX )",
+    "			vec2 prevTCoords = currentTextureCoords + dtex;",
+    "			float nextH = heightFromTexture - currentLayerHeight;",
+    "			float prevH = texture2D( bumpMap, prevTCoords ).r - currentLayerHeight + layerHeight;",
+    "			float weight = nextH / ( nextH - prevH );",
+    "			return prevTCoords * weight + currentTextureCoords * ( 1.0 - weight );",
+    "		#else",
+    "			return vUv;",
+    "		#endif",
+    "	}",
+    "#endif",
+    "vec2 perturbUv( vec3 surfPosition, vec3 surfNormal, vec3 viewPosition ) {",
+    "	vec2 texDx = dFdx( vUv );",
+    "	vec2 texDy = dFdy( vUv );",
+    "	vec3 vSigmaX = dFdx( surfPosition );",
+    "	vec3 vSigmaY = dFdy( surfPosition );",
+    "	vec3 vR1 = cross( vSigmaY, surfNormal );",
+    "	vec3 vR2 = cross( surfNormal, vSigmaX );",
+    "	float fDet = dot( vSigmaX, vR1 );",
+    "	vec2 vProjVscr = ( 1.0 / fDet ) * vec2( dot( vR1, viewPosition ), dot( vR2, viewPosition ) );",
+    "	vec3 vProjVtex;",
+    "	vProjVtex.xy = texDx * vProjVscr.x + texDy * vProjVscr.y;",
+    "	vProjVtex.z = dot( surfNormal, viewPosition );",
+    "	return parallaxMap( vProjVtex );",
+    "}",
+    "void main() {",
+    "	vec2 mapUv = perturbUv( -vViewPosition, normalize( vNormal ), normalize( vViewPosition ) );",
+    "	gl_FragColor = texture2D( map, mapUv );",
+    "}"
+  ].join("\n")
+};
+export {
+  ParallaxShader
+};

package/shaders/PixelShader.js

@@ -1,20 +1,28 @@
-/**
- * Pixelation shader
- */
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
 const PixelShader = {
   uniforms: {
-    tDiffuse: {
-      value: null
-    },
-    resolution: {
-      value: null
-    },
-    pixelSize: {
-      value: 1
-    }
+    tDiffuse: { value: null },
+    resolution: { value: null },
+    pixelSize: { value: 1 }
   },
-  vertexShader: ['varying highp vec2 vUv;', 'void main() {', 'vUv = uv;', 'gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );', '}'].join('\n'),
-  fragmentShader: ['uniform sampler2D tDiffuse;', 'uniform float pixelSize;', 'uniform vec2 resolution;', 'varying highp vec2 vUv;', 'void main(){', 'vec2 dxy = pixelSize / resolution;', 'vec2 coord = dxy * floor( vUv / dxy );', 'gl_FragColor = texture2D(tDiffuse, coord);', '}'].join('\n')
+  vertexShader: [
+    "varying highp vec2 vUv;",
+    "void main() {",
+    "vUv = uv;",
+    "gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "uniform sampler2D tDiffuse;",
+    "uniform float pixelSize;",
+    "uniform vec2 resolution;",
+    "varying highp vec2 vUv;",
+    "void main(){",
+    "vec2 dxy = pixelSize / resolution;",
+    "vec2 coord = dxy * floor( vUv / dxy );",
+    "gl_FragColor = texture2D(tDiffuse, coord);",
+    "}"
+  ].join("\n")
 };
-
-export { PixelShader };
+exports.PixelShader = PixelShader;

package/shaders/PixelShader.mjs

@@ -0,0 +1,28 @@
+const PixelShader = {
+  uniforms: {
+    tDiffuse: { value: null },
+    resolution: { value: null },
+    pixelSize: { value: 1 }
+  },
+  vertexShader: [
+    "varying highp vec2 vUv;",
+    "void main() {",
+    "vUv = uv;",
+    "gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "uniform sampler2D tDiffuse;",
+    "uniform float pixelSize;",
+    "uniform vec2 resolution;",
+    "varying highp vec2 vUv;",
+    "void main(){",
+    "vec2 dxy = pixelSize / resolution;",
+    "vec2 coord = dxy * floor( vUv / dxy );",
+    "gl_FragColor = texture2D(tDiffuse, coord);",
+    "}"
+  ].join("\n")
+};
+export {
+  PixelShader
+};

package/shaders/RGBShiftShader.js

@@ -1,26 +1,30 @@
-/**
- * RGB Shift Shader
- * Shifts red and blue channels from center in opposite directions
- * Ported from http://kriss.cx/tom/2009/05/rgb-shift/
- * by Tom Butterworth / http://kriss.cx/tom/
- *
- * amount: shift distance (1 is width of input)
- * angle: shift angle in radians
- */
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
 const RGBShiftShader = {
   uniforms: {
-    tDiffuse: {
-      value: null
-    },
-    amount: {
-      value: 0.005
-    },
-    angle: {
-      value: 0.0
-    }
+    tDiffuse: { value: null },
+    amount: { value: 5e-3 },
+    angle: { value: 0 }
   },
-  vertexShader: ['varying vec2 vUv;', 'void main() {', '	vUv = uv;', '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );', '}'].join('\n'),
-  fragmentShader: ['uniform sampler2D tDiffuse;', 'uniform float amount;', 'uniform float angle;', 'varying vec2 vUv;', 'void main() {', '	vec2 offset = amount * vec2( cos(angle), sin(angle));', '	vec4 cr = texture2D(tDiffuse, vUv + offset);', '	vec4 cga = texture2D(tDiffuse, vUv);', '	vec4 cb = texture2D(tDiffuse, vUv - offset);', '	gl_FragColor = vec4(cr.r, cga.g, cb.b, cga.a);', '}'].join('\n')
+  vertexShader: [
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vUv = uv;",
+    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "uniform sampler2D tDiffuse;",
+    "uniform float amount;",
+    "uniform float angle;",
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vec2 offset = amount * vec2( cos(angle), sin(angle));",
+    "	vec4 cr = texture2D(tDiffuse, vUv + offset);",
+    "	vec4 cga = texture2D(tDiffuse, vUv);",
+    "	vec4 cb = texture2D(tDiffuse, vUv - offset);",
+    "	gl_FragColor = vec4(cr.r, cga.g, cb.b, cga.a);",
+    "}"
+  ].join("\n")
 };
-
-export { RGBShiftShader };
+exports.RGBShiftShader = RGBShiftShader;

package/shaders/RGBShiftShader.mjs

@@ -0,0 +1,30 @@
+const RGBShiftShader = {
+  uniforms: {
+    tDiffuse: { value: null },
+    amount: { value: 5e-3 },
+    angle: { value: 0 }
+  },
+  vertexShader: [
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vUv = uv;",
+    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "uniform sampler2D tDiffuse;",
+    "uniform float amount;",
+    "uniform float angle;",
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vec2 offset = amount * vec2( cos(angle), sin(angle));",
+    "	vec4 cr = texture2D(tDiffuse, vUv + offset);",
+    "	vec4 cga = texture2D(tDiffuse, vUv);",
+    "	vec4 cb = texture2D(tDiffuse, vUv - offset);",
+    "	gl_FragColor = vec4(cr.r, cga.g, cb.b, cga.a);",
+    "}"
+  ].join("\n")
+};
+export {
+  RGBShiftShader
+};

package/shaders/SAOShader.js

@@ -1,5 +1,6 @@
-import { Vector2, Matrix4 } from 'three';
-
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const THREE = require("three");
 const SAOShader = {
   defines: {
     NUM_SAMPLES: 7,
@@ -10,51 +11,134 @@ const SAOShader = {
     PERSPECTIVE_CAMERA: 1
   },
   uniforms: {
-    tDepth: {
-      value: null
-    },
-    tDiffuse: {
-      value: null
-    },
-    tNormal: {
-      value: null
-    },
-    size: {
-      value: new Vector2(512, 512)
-    },
-    cameraNear: {
-      value: 1
-    },
-    cameraFar: {
-      value: 100
-    },
-    cameraProjectionMatrix: {
-      value: new Matrix4()
-    },
-    cameraInverseProjectionMatrix: {
-      value: new Matrix4()
-    },
-    scale: {
-      value: 1.0
-    },
-    intensity: {
-      value: 0.1
-    },
-    bias: {
-      value: 0.5
-    },
-    minResolution: {
-      value: 0.0
-    },
-    kernelRadius: {
-      value: 100.0
-    },
-    randomSeed: {
-      value: 0.0
-    }
+    tDepth: { value: null },
+    tDiffuse: { value: null },
+    tNormal: { value: null },
+    size: { value: new THREE.Vector2(512, 512) },
+    cameraNear: { value: 1 },
+    cameraFar: { value: 100 },
+    cameraProjectionMatrix: { value: new THREE.Matrix4() },
+    cameraInverseProjectionMatrix: { value: new THREE.Matrix4() },
+    scale: { value: 1 },
+    intensity: { value: 0.1 },
+    bias: { value: 0.5 },
+    minResolution: { value: 0 },
+    kernelRadius: { value: 100 },
+    randomSeed: { value: 0 }
   },
-  vertexShader: ['varying vec2 vUv;', 'void main() {', '	vUv = uv;', '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );', '}'].join('\n'),
-  fragmentShader: ['#include <common>', 'varying vec2 vUv;', '#if DIFFUSE_TEXTURE == 1', 'uniform sampler2D tDiffuse;', '#endif', 'uniform sampler2D tDepth;', '#if NORMAL_TEXTURE == 1', 'uniform sampler2D tNormal;', '#endif', 'uniform float cameraNear;', 'uniform float cameraFar;', 'uniform mat4 cameraProjectionMatrix;', 'uniform mat4 cameraInverseProjectionMatrix;', 'uniform float scale;', 'uniform float intensity;', 'uniform float bias;', 'uniform float kernelRadius;', 'uniform float minResolution;', 'uniform vec2 size;', 'uniform float randomSeed;', '// RGBA depth', '#include <packing>', 'vec4 getDefaultColor( const in vec2 screenPosition ) {', '	#if DIFFUSE_TEXTURE == 1', '	return texture2D( tDiffuse, vUv );', '	#else', '	return vec4( 1.0 );', '	#endif', '}', 'float getDepth( const in vec2 screenPosition ) {', '	#if DEPTH_PACKING == 1', '	return unpackRGBAToDepth( texture2D( tDepth, screenPosition ) );', '	#else', '	return texture2D( tDepth, screenPosition ).x;', '	#endif', '}', 'float getViewZ( const in float depth ) {', '	#if PERSPECTIVE_CAMERA == 1', '	return perspectiveDepthToViewZ( depth, cameraNear, cameraFar );', '	#else', '	return orthographicDepthToViewZ( depth, cameraNear, cameraFar );', '	#endif', '}', 'vec3 getViewPosition( const in vec2 screenPosition, const in float depth, const in float viewZ ) {', '	float clipW = cameraProjectionMatrix[2][3] * viewZ + cameraProjectionMatrix[3][3];', '	vec4 clipPosition = vec4( ( vec3( screenPosition, depth ) - 0.5 ) * 2.0, 1.0 );', '	clipPosition *= clipW; // unprojection.', '	return ( cameraInverseProjectionMatrix * clipPosition ).xyz;', '}', 'vec3 getViewNormal( const in vec3 viewPosition, const in vec2 screenPosition ) {', '	#if NORMAL_TEXTURE == 1', '	return unpackRGBToNormal( texture2D( tNormal, screenPosition ).xyz );', '	#else', '	return normalize( cross( dFdx( viewPosition ), dFdy( viewPosition ) ) );', '	#endif', '}', 'float scaleDividedByCameraFar;', 'float minResolutionMultipliedByCameraFar;', 'float getOcclusion( const in vec3 centerViewPosition, const in vec3 centerViewNormal, const in vec3 sampleViewPosition ) {', '	vec3 viewDelta = sampleViewPosition - centerViewPosition;', '	float viewDistance = length( viewDelta );', '	float scaledScreenDistance = scaleDividedByCameraFar * viewDistance;', '	return max(0.0, (dot(centerViewNormal, viewDelta) - minResolutionMultipliedByCameraFar) / scaledScreenDistance - bias) / (1.0 + pow2( scaledScreenDistance ) );', '}', '// moving costly divides into consts', 'const float ANGLE_STEP = PI2 * float( NUM_RINGS ) / float( NUM_SAMPLES );', 'const float INV_NUM_SAMPLES = 1.0 / float( NUM_SAMPLES );', 'float getAmbientOcclusion( const in vec3 centerViewPosition ) {', '	// precompute some variables require in getOcclusion.', '	scaleDividedByCameraFar = scale / cameraFar;', '	minResolutionMultipliedByCameraFar = minResolution * cameraFar;', '	vec3 centerViewNormal = getViewNormal( centerViewPosition, vUv );', '	// jsfiddle that shows sample pattern: https://jsfiddle.net/a16ff1p7/', '	float angle = rand( vUv + randomSeed ) * PI2;', '	vec2 radius = vec2( kernelRadius * INV_NUM_SAMPLES ) / size;', '	vec2 radiusStep = radius;', '	float occlusionSum = 0.0;', '	float weightSum = 0.0;', '	for( int i = 0; i < NUM_SAMPLES; i ++ ) {', '		vec2 sampleUv = vUv + vec2( cos( angle ), sin( angle ) ) * radius;', '		radius += radiusStep;', '		angle += ANGLE_STEP;', '		float sampleDepth = getDepth( sampleUv );', '		if( sampleDepth >= ( 1.0 - EPSILON ) ) {', '			continue;', '		}', '		float sampleViewZ = getViewZ( sampleDepth );', '		vec3 sampleViewPosition = getViewPosition( sampleUv, sampleDepth, sampleViewZ );', '		occlusionSum += getOcclusion( centerViewPosition, centerViewNormal, sampleViewPosition );', '		weightSum += 1.0;', '	}', '	if( weightSum == 0.0 ) discard;', '	return occlusionSum * ( intensity / weightSum );', '}', 'void main() {', '	float centerDepth = getDepth( vUv );', '	if( centerDepth >= ( 1.0 - EPSILON ) ) {', '		discard;', '	}', '	float centerViewZ = getViewZ( centerDepth );', '	vec3 viewPosition = getViewPosition( vUv, centerDepth, centerViewZ );', '	float ambientOcclusion = getAmbientOcclusion( viewPosition );', '	gl_FragColor = getDefaultColor( vUv );', '	gl_FragColor.xyz *=  1.0 - ambientOcclusion;', '}'].join('\n')
+  vertexShader: [
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vUv = uv;",
+    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "#include <common>",
+    "varying vec2 vUv;",
+    "#if DIFFUSE_TEXTURE == 1",
+    "uniform sampler2D tDiffuse;",
+    "#endif",
+    "uniform sampler2D tDepth;",
+    "#if NORMAL_TEXTURE == 1",
+    "uniform sampler2D tNormal;",
+    "#endif",
+    "uniform float cameraNear;",
+    "uniform float cameraFar;",
+    "uniform mat4 cameraProjectionMatrix;",
+    "uniform mat4 cameraInverseProjectionMatrix;",
+    "uniform float scale;",
+    "uniform float intensity;",
+    "uniform float bias;",
+    "uniform float kernelRadius;",
+    "uniform float minResolution;",
+    "uniform vec2 size;",
+    "uniform float randomSeed;",
+    "// RGBA depth",
+    "#include <packing>",
+    "vec4 getDefaultColor( const in vec2 screenPosition ) {",
+    "	#if DIFFUSE_TEXTURE == 1",
+    "	return texture2D( tDiffuse, vUv );",
+    "	#else",
+    "	return vec4( 1.0 );",
+    "	#endif",
+    "}",
+    "float getDepth( const in vec2 screenPosition ) {",
+    "	#if DEPTH_PACKING == 1",
+    "	return unpackRGBAToDepth( texture2D( tDepth, screenPosition ) );",
+    "	#else",
+    "	return texture2D( tDepth, screenPosition ).x;",
+    "	#endif",
+    "}",
+    "float getViewZ( const in float depth ) {",
+    "	#if PERSPECTIVE_CAMERA == 1",
+    "	return perspectiveDepthToViewZ( depth, cameraNear, cameraFar );",
+    "	#else",
+    "	return orthographicDepthToViewZ( depth, cameraNear, cameraFar );",
+    "	#endif",
+    "}",
+    "vec3 getViewPosition( const in vec2 screenPosition, const in float depth, const in float viewZ ) {",
+    "	float clipW = cameraProjectionMatrix[2][3] * viewZ + cameraProjectionMatrix[3][3];",
+    "	vec4 clipPosition = vec4( ( vec3( screenPosition, depth ) - 0.5 ) * 2.0, 1.0 );",
+    "	clipPosition *= clipW; // unprojection.",
+    "	return ( cameraInverseProjectionMatrix * clipPosition ).xyz;",
+    "}",
+    "vec3 getViewNormal( const in vec3 viewPosition, const in vec2 screenPosition ) {",
+    "	#if NORMAL_TEXTURE == 1",
+    "	return unpackRGBToNormal( texture2D( tNormal, screenPosition ).xyz );",
+    "	#else",
+    "	return normalize( cross( dFdx( viewPosition ), dFdy( viewPosition ) ) );",
+    "	#endif",
+    "}",
+    "float scaleDividedByCameraFar;",
+    "float minResolutionMultipliedByCameraFar;",
+    "float getOcclusion( const in vec3 centerViewPosition, const in vec3 centerViewNormal, const in vec3 sampleViewPosition ) {",
+    "	vec3 viewDelta = sampleViewPosition - centerViewPosition;",
+    "	float viewDistance = length( viewDelta );",
+    "	float scaledScreenDistance = scaleDividedByCameraFar * viewDistance;",
+    "	return max(0.0, (dot(centerViewNormal, viewDelta) - minResolutionMultipliedByCameraFar) / scaledScreenDistance - bias) / (1.0 + pow2( scaledScreenDistance ) );",
+    "}",
+    "// moving costly divides into consts",
+    "const float ANGLE_STEP = PI2 * float( NUM_RINGS ) / float( NUM_SAMPLES );",
+    "const float INV_NUM_SAMPLES = 1.0 / float( NUM_SAMPLES );",
+    "float getAmbientOcclusion( const in vec3 centerViewPosition ) {",
+    "	// precompute some variables require in getOcclusion.",
+    "	scaleDividedByCameraFar = scale / cameraFar;",
+    "	minResolutionMultipliedByCameraFar = minResolution * cameraFar;",
+    "	vec3 centerViewNormal = getViewNormal( centerViewPosition, vUv );",
+    "	// jsfiddle that shows sample pattern: https://jsfiddle.net/a16ff1p7/",
+    "	float angle = rand( vUv + randomSeed ) * PI2;",
+    "	vec2 radius = vec2( kernelRadius * INV_NUM_SAMPLES ) / size;",
+    "	vec2 radiusStep = radius;",
+    "	float occlusionSum = 0.0;",
+    "	float weightSum = 0.0;",
+    "	for( int i = 0; i < NUM_SAMPLES; i ++ ) {",
+    "		vec2 sampleUv = vUv + vec2( cos( angle ), sin( angle ) ) * radius;",
+    "		radius += radiusStep;",
+    "		angle += ANGLE_STEP;",
+    "		float sampleDepth = getDepth( sampleUv );",
+    "		if( sampleDepth >= ( 1.0 - EPSILON ) ) {",
+    "			continue;",
+    "		}",
+    "		float sampleViewZ = getViewZ( sampleDepth );",
+    "		vec3 sampleViewPosition = getViewPosition( sampleUv, sampleDepth, sampleViewZ );",
+    "		occlusionSum += getOcclusion( centerViewPosition, centerViewNormal, sampleViewPosition );",
+    "		weightSum += 1.0;",
+    "	}",
+    "	if( weightSum == 0.0 ) discard;",
+    "	return occlusionSum * ( intensity / weightSum );",
+    "}",
+    "void main() {",
+    "	float centerDepth = getDepth( vUv );",
+    "	if( centerDepth >= ( 1.0 - EPSILON ) ) {",
+    "		discard;",
+    "	}",
+    "	float centerViewZ = getViewZ( centerDepth );",
+    "	vec3 viewPosition = getViewPosition( vUv, centerDepth, centerViewZ );",
+    "	float ambientOcclusion = getAmbientOcclusion( viewPosition );",
+    "	gl_FragColor = getDefaultColor( vUv );",
+    "	gl_FragColor.xyz *=  1.0 - ambientOcclusion;",
+    "}"
+  ].join("\n")
 };
-
-export { SAOShader };
+exports.SAOShader = SAOShader;