three-stdlib 2.15.1 → 2.15.2

package/shaders/CopyShader.js

@@ -1,17 +1,25 @@
-/**
- * Full-screen textured quad shader
- */
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
 const CopyShader = {
   uniforms: {
-    tDiffuse: {
-      value: null
-    },
-    opacity: {
-      value: 1.0
-    }
+    tDiffuse: { value: null },
+    opacity: { value: 1 }
   },
-  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;', 'void main() {', '	vec4 texel = texture2D( tDiffuse, vUv );', '	gl_FragColor = opacity * texel;', '}'].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;",
+    "void main() {",
+    "	vec4 texel = texture2D( tDiffuse, vUv );",
+    "	gl_FragColor = opacity * texel;",
+    "}"
+  ].join("\n")
 };
-
-export { CopyShader };
+exports.CopyShader = CopyShader;

package/shaders/CopyShader.mjs

@@ -0,0 +1,25 @@
+const CopyShader = {
+  uniforms: {
+    tDiffuse: { value: null },
+    opacity: { value: 1 }
+  },
+  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;",
+    "void main() {",
+    "	vec4 texel = texture2D( tDiffuse, vUv );",
+    "	gl_FragColor = opacity * texel;",
+    "}"
+  ].join("\n")
+};
+export {
+  CopyShader
+};

package/shaders/DOFMipMapShader.js

@@ -1,25 +1,32 @@
-/**
- * Depth-of-field shader using mipmaps
- * - from Matt Handley @applmak
- * - requires power-of-2 sized render target with enabled mipmaps
- */
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
 const DOFMipMapShader = {
   uniforms: {
-    tColor: {
-      value: null
-    },
-    tDepth: {
-      value: null
-    },
-    focus: {
-      value: 1.0
-    },
-    maxblur: {
-      value: 1.0
-    }
+    tColor: { value: null },
+    tDepth: { value: null },
+    focus: { value: 1 },
+    maxblur: { value: 1 }
   },
-  vertexShader: ['varying vec2 vUv;', 'void main() {', '	vUv = uv;', '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );', '}'].join('\n'),
-  fragmentShader: ['uniform float focus;', 'uniform float maxblur;', 'uniform sampler2D tColor;', 'uniform sampler2D tDepth;', 'varying vec2 vUv;', 'void main() {', '	vec4 depth = texture2D( tDepth, vUv );', '	float factor = depth.x - focus;', '	vec4 col = texture2D( tColor, vUv, 2.0 * maxblur * abs( focus - depth.x ) );', '	gl_FragColor = col;', '	gl_FragColor.a = 1.0;', '}'].join('\n')
+  vertexShader: [
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vUv = uv;",
+    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "uniform float focus;",
+    "uniform float maxblur;",
+    "uniform sampler2D tColor;",
+    "uniform sampler2D tDepth;",
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vec4 depth = texture2D( tDepth, vUv );",
+    "	float factor = depth.x - focus;",
+    "	vec4 col = texture2D( tColor, vUv, 2.0 * maxblur * abs( focus - depth.x ) );",
+    "	gl_FragColor = col;",
+    "	gl_FragColor.a = 1.0;",
+    "}"
+  ].join("\n")
 };
-
-export { DOFMipMapShader };
+exports.DOFMipMapShader = DOFMipMapShader;

package/shaders/DOFMipMapShader.mjs

@@ -0,0 +1,32 @@
+const DOFMipMapShader = {
+  uniforms: {
+    tColor: { value: null },
+    tDepth: { value: null },
+    focus: { value: 1 },
+    maxblur: { value: 1 }
+  },
+  vertexShader: [
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vUv = uv;",
+    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "uniform float focus;",
+    "uniform float maxblur;",
+    "uniform sampler2D tColor;",
+    "uniform sampler2D tDepth;",
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vec4 depth = texture2D( tDepth, vUv );",
+    "	float factor = depth.x - focus;",
+    "	vec4 col = texture2D( tColor, vUv, 2.0 * maxblur * abs( focus - depth.x ) );",
+    "	gl_FragColor = col;",
+    "	gl_FragColor.a = 1.0;",
+    "}"
+  ].join("\n")
+};
+export {
+  DOFMipMapShader
+};

package/shaders/DepthLimitedBlurShader.js

@@ -1,5 +1,6 @@
-import { Vector2 } from 'three';
-
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const THREE = require("three");
 const DepthLimitedBlurShader = {
   defines: {
     KERNEL_RADIUS: 4,
@@ -7,63 +8,107 @@ const DepthLimitedBlurShader = {
     PERSPECTIVE_CAMERA: 1
   },
   uniforms: {
-    tDiffuse: {
-      value: null
-    },
-    size: {
-      value: new Vector2(512, 512)
-    },
-    sampleUvOffsets: {
-      value: [new Vector2(0, 0)]
-    },
-    sampleWeights: {
-      value: [1.0]
-    },
-    tDepth: {
-      value: null
-    },
-    cameraNear: {
-      value: 10
-    },
-    cameraFar: {
-      value: 1000
-    },
-    depthCutoff: {
-      value: 10
-    }
+    tDiffuse: { value: null },
+    size: { value: new THREE.Vector2(512, 512) },
+    sampleUvOffsets: { value: [new THREE.Vector2(0, 0)] },
+    sampleWeights: { value: [1] },
+    tDepth: { value: null },
+    cameraNear: { value: 10 },
+    cameraFar: { value: 1e3 },
+    depthCutoff: { value: 10 }
   },
-  vertexShader: ['#include <common>', 'uniform vec2 size;', 'varying vec2 vUv;', 'varying vec2 vInvSize;', 'void main() {', '	vUv = uv;', '	vInvSize = 1.0 / size;', '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );', '}'].join('\n'),
-  fragmentShader: ['#include <common>', '#include <packing>', 'uniform sampler2D tDiffuse;', 'uniform sampler2D tDepth;', 'uniform float cameraNear;', 'uniform float cameraFar;', 'uniform float depthCutoff;', 'uniform vec2 sampleUvOffsets[ KERNEL_RADIUS + 1 ];', 'uniform float sampleWeights[ KERNEL_RADIUS + 1 ];', 'varying vec2 vUv;', 'varying vec2 vInvSize;', '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', '}', 'void main() {', '	float depth = getDepth( vUv );', '	if( depth >= ( 1.0 - EPSILON ) ) {', '		discard;', '	}', '	float centerViewZ = -getViewZ( depth );', '	bool rBreak = false, lBreak = false;', '	float weightSum = sampleWeights[0];', '	vec4 diffuseSum = texture2D( tDiffuse, vUv ) * weightSum;', '	for( int i = 1; i <= KERNEL_RADIUS; i ++ ) {', '		float sampleWeight = sampleWeights[i];', '		vec2 sampleUvOffset = sampleUvOffsets[i] * vInvSize;', '		vec2 sampleUv = vUv + sampleUvOffset;', '		float viewZ = -getViewZ( getDepth( sampleUv ) );', '		if( abs( viewZ - centerViewZ ) > depthCutoff ) rBreak = true;', '		if( ! rBreak ) {', '			diffuseSum += texture2D( tDiffuse, sampleUv ) * sampleWeight;', '			weightSum += sampleWeight;', '		}', '		sampleUv = vUv - sampleUvOffset;', '		viewZ = -getViewZ( getDepth( sampleUv ) );', '		if( abs( viewZ - centerViewZ ) > depthCutoff ) lBreak = true;', '		if( ! lBreak ) {', '			diffuseSum += texture2D( tDiffuse, sampleUv ) * sampleWeight;', '			weightSum += sampleWeight;', '		}', '	}', '	gl_FragColor = diffuseSum / weightSum;', '}'].join('\n')
+  vertexShader: [
+    "#include <common>",
+    "uniform vec2 size;",
+    "varying vec2 vUv;",
+    "varying vec2 vInvSize;",
+    "void main() {",
+    "	vUv = uv;",
+    "	vInvSize = 1.0 / size;",
+    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "#include <common>",
+    "#include <packing>",
+    "uniform sampler2D tDiffuse;",
+    "uniform sampler2D tDepth;",
+    "uniform float cameraNear;",
+    "uniform float cameraFar;",
+    "uniform float depthCutoff;",
+    "uniform vec2 sampleUvOffsets[ KERNEL_RADIUS + 1 ];",
+    "uniform float sampleWeights[ KERNEL_RADIUS + 1 ];",
+    "varying vec2 vUv;",
+    "varying vec2 vInvSize;",
+    "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",
+    "}",
+    "void main() {",
+    "	float depth = getDepth( vUv );",
+    "	if( depth >= ( 1.0 - EPSILON ) ) {",
+    "		discard;",
+    "	}",
+    "	float centerViewZ = -getViewZ( depth );",
+    "	bool rBreak = false, lBreak = false;",
+    "	float weightSum = sampleWeights[0];",
+    "	vec4 diffuseSum = texture2D( tDiffuse, vUv ) * weightSum;",
+    "	for( int i = 1; i <= KERNEL_RADIUS; i ++ ) {",
+    "		float sampleWeight = sampleWeights[i];",
+    "		vec2 sampleUvOffset = sampleUvOffsets[i] * vInvSize;",
+    "		vec2 sampleUv = vUv + sampleUvOffset;",
+    "		float viewZ = -getViewZ( getDepth( sampleUv ) );",
+    "		if( abs( viewZ - centerViewZ ) > depthCutoff ) rBreak = true;",
+    "		if( ! rBreak ) {",
+    "			diffuseSum += texture2D( tDiffuse, sampleUv ) * sampleWeight;",
+    "			weightSum += sampleWeight;",
+    "		}",
+    "		sampleUv = vUv - sampleUvOffset;",
+    "		viewZ = -getViewZ( getDepth( sampleUv ) );",
+    "		if( abs( viewZ - centerViewZ ) > depthCutoff ) lBreak = true;",
+    "		if( ! lBreak ) {",
+    "			diffuseSum += texture2D( tDiffuse, sampleUv ) * sampleWeight;",
+    "			weightSum += sampleWeight;",
+    "		}",
+    "	}",
+    "	gl_FragColor = diffuseSum / weightSum;",
+    "}"
+  ].join("\n")
 };
 const BlurShaderUtils = {
   createSampleWeights: (kernelRadius, stdDev) => {
-    const gaussian = (x, stdDev) => {
-      return Math.exp(-(x * x) / (2.0 * (stdDev * stdDev))) / (Math.sqrt(2.0 * Math.PI) * stdDev);
+    const gaussian = (x, stdDev2) => {
+      return Math.exp(-(x * x) / (2 * (stdDev2 * stdDev2))) / (Math.sqrt(2 * Math.PI) * stdDev2);
     };
-
     const weights = [];
-
     for (let i = 0; i <= kernelRadius; i++) {
       weights.push(gaussian(i, stdDev));
     }
-
     return weights;
   },
   createSampleOffsets: (kernelRadius, uvIncrement) => {
     const offsets = [];
-
     for (let i = 0; i <= kernelRadius; i++) {
       offsets.push(uvIncrement.clone().multiplyScalar(i));
     }
-
     return offsets;
   },
   configure: (shader, kernelRadius, stdDev, uvIncrement) => {
-    shader.defines['KERNEL_RADIUS'] = kernelRadius;
-    shader.uniforms['sampleUvOffsets'].value = BlurShaderUtils.createSampleOffsets(kernelRadius, uvIncrement);
-    shader.uniforms['sampleWeights'].value = BlurShaderUtils.createSampleWeights(kernelRadius, stdDev);
+    shader.defines["KERNEL_RADIUS"] = kernelRadius;
+    shader.uniforms["sampleUvOffsets"].value = BlurShaderUtils.createSampleOffsets(kernelRadius, uvIncrement);
+    shader.uniforms["sampleWeights"].value = BlurShaderUtils.createSampleWeights(kernelRadius, stdDev);
     shader.needsUpdate = true;
   }
 };
-
-export { BlurShaderUtils, DepthLimitedBlurShader };
+exports.BlurShaderUtils = BlurShaderUtils;
+exports.DepthLimitedBlurShader = DepthLimitedBlurShader;

package/shaders/DepthLimitedBlurShader.mjs

@@ -0,0 +1,114 @@
+import { Vector2 } from "three";
+const DepthLimitedBlurShader = {
+  defines: {
+    KERNEL_RADIUS: 4,
+    DEPTH_PACKING: 1,
+    PERSPECTIVE_CAMERA: 1
+  },
+  uniforms: {
+    tDiffuse: { value: null },
+    size: { value: new Vector2(512, 512) },
+    sampleUvOffsets: { value: [new Vector2(0, 0)] },
+    sampleWeights: { value: [1] },
+    tDepth: { value: null },
+    cameraNear: { value: 10 },
+    cameraFar: { value: 1e3 },
+    depthCutoff: { value: 10 }
+  },
+  vertexShader: [
+    "#include <common>",
+    "uniform vec2 size;",
+    "varying vec2 vUv;",
+    "varying vec2 vInvSize;",
+    "void main() {",
+    "	vUv = uv;",
+    "	vInvSize = 1.0 / size;",
+    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "#include <common>",
+    "#include <packing>",
+    "uniform sampler2D tDiffuse;",
+    "uniform sampler2D tDepth;",
+    "uniform float cameraNear;",
+    "uniform float cameraFar;",
+    "uniform float depthCutoff;",
+    "uniform vec2 sampleUvOffsets[ KERNEL_RADIUS + 1 ];",
+    "uniform float sampleWeights[ KERNEL_RADIUS + 1 ];",
+    "varying vec2 vUv;",
+    "varying vec2 vInvSize;",
+    "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",
+    "}",
+    "void main() {",
+    "	float depth = getDepth( vUv );",
+    "	if( depth >= ( 1.0 - EPSILON ) ) {",
+    "		discard;",
+    "	}",
+    "	float centerViewZ = -getViewZ( depth );",
+    "	bool rBreak = false, lBreak = false;",
+    "	float weightSum = sampleWeights[0];",
+    "	vec4 diffuseSum = texture2D( tDiffuse, vUv ) * weightSum;",
+    "	for( int i = 1; i <= KERNEL_RADIUS; i ++ ) {",
+    "		float sampleWeight = sampleWeights[i];",
+    "		vec2 sampleUvOffset = sampleUvOffsets[i] * vInvSize;",
+    "		vec2 sampleUv = vUv + sampleUvOffset;",
+    "		float viewZ = -getViewZ( getDepth( sampleUv ) );",
+    "		if( abs( viewZ - centerViewZ ) > depthCutoff ) rBreak = true;",
+    "		if( ! rBreak ) {",
+    "			diffuseSum += texture2D( tDiffuse, sampleUv ) * sampleWeight;",
+    "			weightSum += sampleWeight;",
+    "		}",
+    "		sampleUv = vUv - sampleUvOffset;",
+    "		viewZ = -getViewZ( getDepth( sampleUv ) );",
+    "		if( abs( viewZ - centerViewZ ) > depthCutoff ) lBreak = true;",
+    "		if( ! lBreak ) {",
+    "			diffuseSum += texture2D( tDiffuse, sampleUv ) * sampleWeight;",
+    "			weightSum += sampleWeight;",
+    "		}",
+    "	}",
+    "	gl_FragColor = diffuseSum / weightSum;",
+    "}"
+  ].join("\n")
+};
+const BlurShaderUtils = {
+  createSampleWeights: (kernelRadius, stdDev) => {
+    const gaussian = (x, stdDev2) => {
+      return Math.exp(-(x * x) / (2 * (stdDev2 * stdDev2))) / (Math.sqrt(2 * Math.PI) * stdDev2);
+    };
+    const weights = [];
+    for (let i = 0; i <= kernelRadius; i++) {
+      weights.push(gaussian(i, stdDev));
+    }
+    return weights;
+  },
+  createSampleOffsets: (kernelRadius, uvIncrement) => {
+    const offsets = [];
+    for (let i = 0; i <= kernelRadius; i++) {
+      offsets.push(uvIncrement.clone().multiplyScalar(i));
+    }
+    return offsets;
+  },
+  configure: (shader, kernelRadius, stdDev, uvIncrement) => {
+    shader.defines["KERNEL_RADIUS"] = kernelRadius;
+    shader.uniforms["sampleUvOffsets"].value = BlurShaderUtils.createSampleOffsets(kernelRadius, uvIncrement);
+    shader.uniforms["sampleWeights"].value = BlurShaderUtils.createSampleWeights(kernelRadius, stdDev);
+    shader.needsUpdate = true;
+  }
+};
+export {
+  BlurShaderUtils,
+  DepthLimitedBlurShader
+};

package/shaders/DigitalGlitch.js

@@ -1,50 +1,78 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
 const DigitalGlitch = {
   uniforms: {
-    tDiffuse: {
-      value: null
-    },
-    //diffuse texture
-    tDisp: {
-      value: null
-    },
-    //displacement texture for digital glitch squares
-    byp: {
-      value: 0
-    },
-    //apply the glitch ?
-    amount: {
-      value: 0.08
-    },
-    angle: {
-      value: 0.02
-    },
-    seed: {
-      value: 0.02
-    },
-    seed_x: {
-      value: 0.02
-    },
-    //-1,1
-    seed_y: {
-      value: 0.02
-    },
-    //-1,1
-    distortion_x: {
-      value: 0.5
-    },
-    distortion_y: {
-      value: 0.6
-    },
-    col_s: {
-      value: 0.05
-    }
+    tDiffuse: { value: null },
+    tDisp: { value: null },
+    byp: { value: 0 },
+    amount: { value: 0.08 },
+    angle: { value: 0.02 },
+    seed: { value: 0.02 },
+    seed_x: { value: 0.02 },
+    seed_y: { value: 0.02 },
+    distortion_x: { value: 0.5 },
+    distortion_y: { value: 0.6 },
+    col_s: { value: 0.05 }
   },
-  vertexShader: ['varying vec2 vUv;', 'void main() {', '	vUv = uv;', '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );', '}'].join('\n'),
-  fragmentShader: ['uniform int byp;', //should we apply the glitch ?
-  'uniform sampler2D tDiffuse;', 'uniform sampler2D tDisp;', 'uniform float amount;', 'uniform float angle;', 'uniform float seed;', 'uniform float seed_x;', 'uniform float seed_y;', 'uniform float distortion_x;', 'uniform float distortion_y;', 'uniform float col_s;', 'varying vec2 vUv;', 'float rand(vec2 co){', '	return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);', '}', 'void main() {', '	if(byp<1) {', '		vec2 p = vUv;', '		float xs = floor(gl_FragCoord.x / 0.5);', '		float ys = floor(gl_FragCoord.y / 0.5);', //based on staffantans glitch shader for unity https://github.com/staffantan/unityglitch
-  '		vec4 normal = texture2D (tDisp, p*seed*seed);', '		if(p.y<distortion_x+col_s && p.y>distortion_x-col_s*seed) {', '			if(seed_x>0.){', '				p.y = 1. - (p.y + distortion_y);', '			}', '			else {', '				p.y = distortion_y;', '			}', '		}', '		if(p.x<distortion_y+col_s && p.x>distortion_y-col_s*seed) {', '			if(seed_y>0.){', '				p.x=distortion_x;', '			}', '			else {', '				p.x = 1. - (p.x + distortion_x);', '			}', '		}', '		p.x+=normal.x*seed_x*(seed/5.);', '		p.y+=normal.y*seed_y*(seed/5.);', //base from RGB shift shader
-  '		vec2 offset = amount * vec2( cos(angle), sin(angle));', '		vec4 cr = texture2D(tDiffuse, p + offset);', '		vec4 cga = texture2D(tDiffuse, p);', '		vec4 cb = texture2D(tDiffuse, p - offset);', '		gl_FragColor = vec4(cr.r, cga.g, cb.b, cga.a);', //add noise
-  '		vec4 snow = 200.*amount*vec4(rand(vec2(xs * seed,ys * seed*50.))*0.2);', '		gl_FragColor = gl_FragColor+ snow;', '	}', '	else {', '		gl_FragColor=texture2D (tDiffuse, vUv);', '	}', '}'].join('\n')
+  vertexShader: [
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vUv = uv;",
+    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "uniform int byp;",
+    "uniform sampler2D tDiffuse;",
+    "uniform sampler2D tDisp;",
+    "uniform float amount;",
+    "uniform float angle;",
+    "uniform float seed;",
+    "uniform float seed_x;",
+    "uniform float seed_y;",
+    "uniform float distortion_x;",
+    "uniform float distortion_y;",
+    "uniform float col_s;",
+    "varying vec2 vUv;",
+    "float rand(vec2 co){",
+    "	return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);",
+    "}",
+    "void main() {",
+    "	if(byp<1) {",
+    "		vec2 p = vUv;",
+    "		float xs = floor(gl_FragCoord.x / 0.5);",
+    "		float ys = floor(gl_FragCoord.y / 0.5);",
+    "		vec4 normal = texture2D (tDisp, p*seed*seed);",
+    "		if(p.y<distortion_x+col_s && p.y>distortion_x-col_s*seed) {",
+    "			if(seed_x>0.){",
+    "				p.y = 1. - (p.y + distortion_y);",
+    "			}",
+    "			else {",
+    "				p.y = distortion_y;",
+    "			}",
+    "		}",
+    "		if(p.x<distortion_y+col_s && p.x>distortion_y-col_s*seed) {",
+    "			if(seed_y>0.){",
+    "				p.x=distortion_x;",
+    "			}",
+    "			else {",
+    "				p.x = 1. - (p.x + distortion_x);",
+    "			}",
+    "		}",
+    "		p.x+=normal.x*seed_x*(seed/5.);",
+    "		p.y+=normal.y*seed_y*(seed/5.);",
+    "		vec2 offset = amount * vec2( cos(angle), sin(angle));",
+    "		vec4 cr = texture2D(tDiffuse, p + offset);",
+    "		vec4 cga = texture2D(tDiffuse, p);",
+    "		vec4 cb = texture2D(tDiffuse, p - offset);",
+    "		gl_FragColor = vec4(cr.r, cga.g, cb.b, cga.a);",
+    "		vec4 snow = 200.*amount*vec4(rand(vec2(xs * seed,ys * seed*50.))*0.2);",
+    "		gl_FragColor = gl_FragColor+ snow;",
+    "	}",
+    "	else {",
+    "		gl_FragColor=texture2D (tDiffuse, vUv);",
+    "	}",
+    "}"
+  ].join("\n")
 };
-
-export { DigitalGlitch };
+exports.DigitalGlitch = DigitalGlitch;

package/shaders/DigitalGlitch.mjs

@@ -0,0 +1,78 @@
+const DigitalGlitch = {
+  uniforms: {
+    tDiffuse: { value: null },
+    tDisp: { value: null },
+    byp: { value: 0 },
+    amount: { value: 0.08 },
+    angle: { value: 0.02 },
+    seed: { value: 0.02 },
+    seed_x: { value: 0.02 },
+    seed_y: { value: 0.02 },
+    distortion_x: { value: 0.5 },
+    distortion_y: { value: 0.6 },
+    col_s: { value: 0.05 }
+  },
+  vertexShader: [
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vUv = uv;",
+    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "uniform int byp;",
+    "uniform sampler2D tDiffuse;",
+    "uniform sampler2D tDisp;",
+    "uniform float amount;",
+    "uniform float angle;",
+    "uniform float seed;",
+    "uniform float seed_x;",
+    "uniform float seed_y;",
+    "uniform float distortion_x;",
+    "uniform float distortion_y;",
+    "uniform float col_s;",
+    "varying vec2 vUv;",
+    "float rand(vec2 co){",
+    "	return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);",
+    "}",
+    "void main() {",
+    "	if(byp<1) {",
+    "		vec2 p = vUv;",
+    "		float xs = floor(gl_FragCoord.x / 0.5);",
+    "		float ys = floor(gl_FragCoord.y / 0.5);",
+    "		vec4 normal = texture2D (tDisp, p*seed*seed);",
+    "		if(p.y<distortion_x+col_s && p.y>distortion_x-col_s*seed) {",
+    "			if(seed_x>0.){",
+    "				p.y = 1. - (p.y + distortion_y);",
+    "			}",
+    "			else {",
+    "				p.y = distortion_y;",
+    "			}",
+    "		}",
+    "		if(p.x<distortion_y+col_s && p.x>distortion_y-col_s*seed) {",
+    "			if(seed_y>0.){",
+    "				p.x=distortion_x;",
+    "			}",
+    "			else {",
+    "				p.x = 1. - (p.x + distortion_x);",
+    "			}",
+    "		}",
+    "		p.x+=normal.x*seed_x*(seed/5.);",
+    "		p.y+=normal.y*seed_y*(seed/5.);",
+    "		vec2 offset = amount * vec2( cos(angle), sin(angle));",
+    "		vec4 cr = texture2D(tDiffuse, p + offset);",
+    "		vec4 cga = texture2D(tDiffuse, p);",
+    "		vec4 cb = texture2D(tDiffuse, p - offset);",
+    "		gl_FragColor = vec4(cr.r, cga.g, cb.b, cga.a);",
+    "		vec4 snow = 200.*amount*vec4(rand(vec2(xs * seed,ys * seed*50.))*0.2);",
+    "		gl_FragColor = gl_FragColor+ snow;",
+    "	}",
+    "	else {",
+    "		gl_FragColor=texture2D (tDiffuse, vUv);",
+    "	}",
+    "}"
+  ].join("\n")
+};
+export {
+  DigitalGlitch
+};