three-stdlib 2.8.9 → 2.8.12

package/shaders/BokehShader2.d.ts

@@ -1,41 +1,87 @@
-import { Uniform } from 'three';
-
-export interface BokehShaderUniforms {
-    textureWidth: Uniform;
-    textureHeight: Uniform;
-    focalDepth: Uniform;
-    focalLength: Uniform;
-    fstop: Uniform;
-    tColor: Uniform;
-    tDepth: Uniform;
-    maxblur: Uniform;
-    showFocus: Uniform;
-    manualdof: Uniform;
-    vignetting: Uniform;
-    depthblur: Uniform;
-    threshold: Uniform;
-    gain: Uniform;
-    bias: Uniform;
-    fringe: Uniform;
-    znear: Uniform;
-    zfar: Uniform;
-    noise: Uniform;
-    dithering: Uniform;
-    pentagon: Uniform;
-    shaderFocus: Uniform;
-    focusCoords: Uniform;
-}
-
-export const BokehShader: {
-    uniforms: BokehShaderUniforms;
+import { Vector2 } from 'three';
+export declare const BokehShader2: {
+    uniforms: {
+        textureWidth: {
+            value: number;
+        };
+        textureHeight: {
+            value: number;
+        };
+        focalDepth: {
+            value: number;
+        };
+        focalLength: {
+            value: number;
+        };
+        fstop: {
+            value: number;
+        };
+        tColor: {
+            value: null;
+        };
+        tDepth: {
+            value: null;
+        };
+        maxblur: {
+            value: number;
+        };
+        showFocus: {
+            value: number;
+        };
+        manualdof: {
+            value: number;
+        };
+        vignetting: {
+            value: number;
+        };
+        depthblur: {
+            value: number;
+        };
+        threshold: {
+            value: number;
+        };
+        gain: {
+            value: number;
+        };
+        bias: {
+            value: number;
+        };
+        fringe: {
+            value: number;
+        };
+        znear: {
+            value: number;
+        };
+        zfar: {
+            value: number;
+        };
+        noise: {
+            value: number;
+        };
+        dithering: {
+            value: number;
+        };
+        pentagon: {
+            value: number;
+        };
+        shaderFocus: {
+            value: number;
+        };
+        focusCoords: {
+            value: Vector2;
+        };
+    };
     vertexShader: string;
     fragmentShader: string;
 };
-
-export const BokehDepthShader: {
+export declare const BokehDepthShader: {
     uniforms: {
-        mNear: Uniform;
-        mFar: Uniform;
+        mNear: {
+            value: number;
+        };
+        mFar: {
+            value: number;
+        };
     };
     vertexShader: string;
     fragmentShader: string;

package/shaders/BokehShader2.js

@@ -8,7 +8,7 @@ import { Vector2 } from 'three';
  * Requires #define RINGS and SAMPLES integers
  */
 
-var BokehShader2 = {
+const BokehShader2 = {
   uniforms: {
     textureWidth: {
       value: 1.0
@@ -83,7 +83,7 @@ var BokehShader2 = {
   vertexShader: ['varying vec2 vUv;', 'void main() {', '	vUv = uv;', '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );', '}'].join('\n'),
   fragmentShader: ['#include <common>', 'varying vec2 vUv;', 'uniform sampler2D tColor;', 'uniform sampler2D tDepth;', 'uniform float textureWidth;', 'uniform float textureHeight;', 'uniform float focalDepth;  //focal distance value in meters, but you may use autofocus option below', 'uniform float focalLength; //focal length in mm', 'uniform float fstop; //f-stop value', 'uniform bool showFocus; //show debug focus point and focal range (red = focal point, green = focal range)', '/*', 'make sure that these two values are the same for your camera, otherwise distances will be wrong.', '*/', 'uniform float znear; // camera clipping start', 'uniform float zfar; // camera clipping end', '//------------------------------------------', '//user variables', 'const int samples = SAMPLES; //samples on the first ring', 'const int rings = RINGS; //ring count', 'const int maxringsamples = rings * samples;', 'uniform bool manualdof; // manual dof calculation', 'float ndofstart = 1.0; // near dof blur start', 'float ndofdist = 2.0; // near dof blur falloff distance', 'float fdofstart = 1.0; // far dof blur start', 'float fdofdist = 3.0; // far dof blur falloff distance', 'float CoC = 0.03; //circle of confusion size in mm (35mm film = 0.03mm)', 'uniform bool vignetting; // use optical lens vignetting', 'float vignout = 1.3; // vignetting outer border', 'float vignin = 0.0; // vignetting inner border', 'float vignfade = 22.0; // f-stops till vignete fades', 'uniform bool shaderFocus;', '// disable if you use external focalDepth value', 'uniform vec2 focusCoords;', '// autofocus point on screen (0.0,0.0 - left lower corner, 1.0,1.0 - upper right)', '// if center of screen use vec2(0.5, 0.5);', 'uniform float maxblur;', '//clamp value of max blur (0.0 = no blur, 1.0 default)', 'uniform float threshold; // highlight threshold;', 'uniform float gain; // highlight gain;', 'uniform float bias; // bokeh edge bias', 'uniform float fringe; // bokeh chromatic aberration / fringing', 'uniform bool noise; //use noise instead of pattern for sample dithering', 'uniform float dithering;', 'uniform bool depthblur; // blur the depth buffer', 'float dbsize = 1.25; // depth blur size', '/*', 'next part is experimental', 'not looking good with small sample and ring count', 'looks okay starting from samples = 4, rings = 4', '*/', 'uniform bool pentagon; //use pentagon as bokeh shape?', 'float feather = 0.4; //pentagon shape feather', '//------------------------------------------', 'float penta(vec2 coords) {', '	//pentagonal shape', '	float scale = float(rings) - 1.3;', '	vec4  HS0 = vec4( 1.0,         0.0,         0.0,  1.0);', '	vec4  HS1 = vec4( 0.309016994, 0.951056516, 0.0,  1.0);', '	vec4  HS2 = vec4(-0.809016994, 0.587785252, 0.0,  1.0);', '	vec4  HS3 = vec4(-0.809016994,-0.587785252, 0.0,  1.0);', '	vec4  HS4 = vec4( 0.309016994,-0.951056516, 0.0,  1.0);', '	vec4  HS5 = vec4( 0.0        ,0.0         , 1.0,  1.0);', '	vec4  one = vec4( 1.0 );', '	vec4 P = vec4((coords),vec2(scale, scale));', '	vec4 dist = vec4(0.0);', '	float inorout = -4.0;', '	dist.x = dot( P, HS0 );', '	dist.y = dot( P, HS1 );', '	dist.z = dot( P, HS2 );', '	dist.w = dot( P, HS3 );', '	dist = smoothstep( -feather, feather, dist );', '	inorout += dot( dist, one );', '	dist.x = dot( P, HS4 );', '	dist.y = HS5.w - abs( P.z );', '	dist = smoothstep( -feather, feather, dist );', '	inorout += dist.x;', '	return clamp( inorout, 0.0, 1.0 );', '}', 'float bdepth(vec2 coords) {', '	// Depth buffer blur', '	float d = 0.0;', '	float kernel[9];', '	vec2 offset[9];', '	vec2 wh = vec2(1.0/textureWidth,1.0/textureHeight) * dbsize;', '	offset[0] = vec2(-wh.x,-wh.y);', '	offset[1] = vec2( 0.0, -wh.y);', '	offset[2] = vec2( wh.x -wh.y);', '	offset[3] = vec2(-wh.x,  0.0);', '	offset[4] = vec2( 0.0,   0.0);', '	offset[5] = vec2( wh.x,  0.0);', '	offset[6] = vec2(-wh.x, wh.y);', '	offset[7] = vec2( 0.0,  wh.y);', '	offset[8] = vec2( wh.x, wh.y);', '	kernel[0] = 1.0/16.0;   kernel[1] = 2.0/16.0;   kernel[2] = 1.0/16.0;', '	kernel[3] = 2.0/16.0;   kernel[4] = 4.0/16.0;   kernel[5] = 2.0/16.0;', '	kernel[6] = 1.0/16.0;   kernel[7] = 2.0/16.0;   kernel[8] = 1.0/16.0;', '	for( int i=0; i<9; i++ ) {', '		float tmp = texture2D(tDepth, coords + offset[i]).r;', '		d += tmp * kernel[i];', '	}', '	return d;', '}', 'vec3 color(vec2 coords,float blur) {', '	//processing the sample', '	vec3 col = vec3(0.0);', '	vec2 texel = vec2(1.0/textureWidth,1.0/textureHeight);', '	col.r = texture2D(tColor,coords + vec2(0.0,1.0)*texel*fringe*blur).r;', '	col.g = texture2D(tColor,coords + vec2(-0.866,-0.5)*texel*fringe*blur).g;', '	col.b = texture2D(tColor,coords + vec2(0.866,-0.5)*texel*fringe*blur).b;', '	vec3 lumcoeff = vec3(0.299,0.587,0.114);', '	float lum = dot(col.rgb, lumcoeff);', '	float thresh = max((lum-threshold)*gain, 0.0);', '	return col+mix(vec3(0.0),col,thresh*blur);', '}', 'vec3 debugFocus(vec3 col, float blur, float depth) {', '	float edge = 0.002*depth; //distance based edge smoothing', '	float m = clamp(smoothstep(0.0,edge,blur),0.0,1.0);', '	float e = clamp(smoothstep(1.0-edge,1.0,blur),0.0,1.0);', '	col = mix(col,vec3(1.0,0.5,0.0),(1.0-m)*0.6);', '	col = mix(col,vec3(0.0,0.5,1.0),((1.0-e)-(1.0-m))*0.2);', '	return col;', '}', 'float linearize(float depth) {', '	return -zfar * znear / (depth * (zfar - znear) - zfar);', '}', 'float vignette() {', '	float dist = distance(vUv.xy, vec2(0.5,0.5));', '	dist = smoothstep(vignout+(fstop/vignfade), vignin+(fstop/vignfade), dist);', '	return clamp(dist,0.0,1.0);', '}', 'float gather(float i, float j, int ringsamples, inout vec3 col, float w, float h, float blur) {', '	float rings2 = float(rings);', '	float step = PI*2.0 / float(ringsamples);', '	float pw = cos(j*step)*i;', '	float ph = sin(j*step)*i;', '	float p = 1.0;', '	if (pentagon) {', '		p = penta(vec2(pw,ph));', '	}', '	col += color(vUv.xy + vec2(pw*w,ph*h), blur) * mix(1.0, i/rings2, bias) * p;', '	return 1.0 * mix(1.0, i /rings2, bias) * p;', '}', 'void main() {', '	//scene depth calculation', '	float depth = linearize(texture2D(tDepth,vUv.xy).x);', '	// Blur depth?', '	if ( depthblur ) {', '		depth = linearize(bdepth(vUv.xy));', '	}', '	//focal plane calculation', '	float fDepth = focalDepth;', '	if (shaderFocus) {', '		fDepth = linearize(texture2D(tDepth,focusCoords).x);', '	}', '	// dof blur factor calculation', '	float blur = 0.0;', '	if (manualdof) {', '		float a = depth-fDepth; // Focal plane', '		float b = (a-fdofstart)/fdofdist; // Far DoF', '		float c = (-a-ndofstart)/ndofdist; // Near Dof', '		blur = (a>0.0) ? b : c;', '	} else {', '		float f = focalLength; // focal length in mm', '		float d = fDepth*1000.0; // focal plane in mm', '		float o = depth*1000.0; // depth in mm', '		float a = (o*f)/(o-f);', '		float b = (d*f)/(d-f);', '		float c = (d-f)/(d*fstop*CoC);', '		blur = abs(a-b)*c;', '	}', '	blur = clamp(blur,0.0,1.0);', '	// calculation of pattern for dithering', '	vec2 noise = vec2(rand(vUv.xy), rand( vUv.xy + vec2( 0.4, 0.6 ) ) )*dithering*blur;', '	// getting blur x and y step factor', '	float w = (1.0/textureWidth)*blur*maxblur+noise.x;', '	float h = (1.0/textureHeight)*blur*maxblur+noise.y;', '	// calculation of final color', '	vec3 col = vec3(0.0);', '	if(blur < 0.05) {', '		//some optimization thingy', '		col = texture2D(tColor, vUv.xy).rgb;', '	} else {', '		col = texture2D(tColor, vUv.xy).rgb;', '		float s = 1.0;', '		int ringsamples;', '		for (int i = 1; i <= rings; i++) {', '			/*unboxstart*/', '			ringsamples = i * samples;', '			for (int j = 0 ; j < maxringsamples ; j++) {', '				if (j >= ringsamples) break;', '				s += gather(float(i), float(j), ringsamples, col, w, h, blur);', '			}', '			/*unboxend*/', '		}', '		col /= s; //divide by sample count', '	}', '	if (showFocus) {', '		col = debugFocus(col, blur, depth);', '	}', '	if (vignetting) {', '		col *= vignette();', '	}', '	gl_FragColor.rgb = col;', '	gl_FragColor.a = 1.0;', '} '].join('\n')
 };
-var BokehDepthShader = {
+const BokehDepthShader = {
   uniforms: {
     mNear: {
       value: 1.0

package/shaders/BrightnessContrastShader.cjs.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var r={uniforms:{tDiffuse:{value:null},brightness:{value:0},contrast:{value:0}},vertexShader:["varying vec2 vUv;","void main() {","\tvUv = uv;","\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );","}"].join("\n"),fragmentShader:["uniform sampler2D tDiffuse;","uniform float brightness;","uniform float contrast;","varying vec2 vUv;","void main() {","\tgl_FragColor = texture2D( tDiffuse, vUv );","\tgl_FragColor.rgb += brightness;","\tif (contrast > 0.0) {","\t\tgl_FragColor.rgb = (gl_FragColor.rgb - 0.5) / (1.0 - contrast) + 0.5;","\t} else {","\t\tgl_FragColor.rgb = (gl_FragColor.rgb - 0.5) * (1.0 + contrast) + 0.5;","\t}","}"].join("\n")};exports.BrightnessContrastShader=r;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const r={uniforms:{tDiffuse:{value:null},brightness:{value:0},contrast:{value:0}},vertexShader:["varying vec2 vUv;","void main() {","\tvUv = uv;","\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );","}"].join("\n"),fragmentShader:["uniform sampler2D tDiffuse;","uniform float brightness;","uniform float contrast;","varying vec2 vUv;","void main() {","\tgl_FragColor = texture2D( tDiffuse, vUv );","\tgl_FragColor.rgb += brightness;","\tif (contrast > 0.0) {","\t\tgl_FragColor.rgb = (gl_FragColor.rgb - 0.5) / (1.0 - contrast) + 0.5;","\t} else {","\t\tgl_FragColor.rgb = (gl_FragColor.rgb - 0.5) * (1.0 + contrast) + 0.5;","\t}","}"].join("\n")};exports.BrightnessContrastShader=r;

package/shaders/BrightnessContrastShader.d.ts

@@ -1,10 +1,14 @@
-import { Uniform } from 'three';
-
-export const BrightnessContrastShader: {
+export declare const BrightnessContrastShader: {
     uniforms: {
-        tDiffuse: Uniform;
-        brightness: Uniform;
-        contrast: Uniform;
+        tDiffuse: {
+            value: null;
+        };
+        brightness: {
+            value: number;
+        };
+        contrast: {
+            value: number;
+        };
     };
     vertexShader: string;
     fragmentShader: string;

package/shaders/BrightnessContrastShader.js

@@ -4,7 +4,7 @@
  * brightness: -1 to 1 (-1 is solid black, 0 is no change, and 1 is solid white)
  * contrast: -1 to 1 (-1 is solid gray, 0 is no change, and 1 is maximum contrast)
  */
-var BrightnessContrastShader = {
+const BrightnessContrastShader = {
   uniforms: {
     tDiffuse: {
       value: null

package/shaders/ColorCorrectionShader.cjs.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("three"),r={uniforms:{tDiffuse:{value:null},powRGB:{value:new e.Vector3(2,2,2)},mulRGB:{value:new e.Vector3(1,1,1)},addRGB:{value:new e.Vector3(0,0,0)}},vertexShader:["varying vec2 vUv;","void main() {","\tvUv = uv;","\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );","}"].join("\n"),fragmentShader:["uniform sampler2D tDiffuse;","uniform vec3 powRGB;","uniform vec3 mulRGB;","uniform vec3 addRGB;","varying vec2 vUv;","void main() {","\tgl_FragColor = texture2D( tDiffuse, vUv );","\tgl_FragColor.rgb = mulRGB * pow( ( gl_FragColor.rgb + addRGB ), powRGB );","}"].join("\n")};exports.ColorCorrectionShader=r;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("three");const r={uniforms:{tDiffuse:{value:null},powRGB:{value:new e.Vector3(2,2,2)},mulRGB:{value:new e.Vector3(1,1,1)},addRGB:{value:new e.Vector3(0,0,0)}},vertexShader:["varying vec2 vUv;","void main() {","\tvUv = uv;","\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );","}"].join("\n"),fragmentShader:["uniform sampler2D tDiffuse;","uniform vec3 powRGB;","uniform vec3 mulRGB;","uniform vec3 addRGB;","varying vec2 vUv;","void main() {","\tgl_FragColor = texture2D( tDiffuse, vUv );","\tgl_FragColor.rgb = mulRGB * pow( ( gl_FragColor.rgb + addRGB ), powRGB );","}"].join("\n")};exports.ColorCorrectionShader=r;

package/shaders/ColorCorrectionShader.d.ts

@@ -1,11 +1,18 @@
-import { Uniform } from 'three';
-
-export const ColorCorrectionShader: {
+import { Vector3 } from 'three';
+export declare const ColorCorrectionShader: {
     uniforms: {
-        tDiffuse: Uniform;
-        powRGB: Uniform;
-        mulRGB: Uniform;
-        addRGB: Uniform;
+        tDiffuse: {
+            value: null;
+        };
+        powRGB: {
+            value: Vector3;
+        };
+        mulRGB: {
+            value: Vector3;
+        };
+        addRGB: {
+            value: Vector3;
+        };
     };
     vertexShader: string;
     fragmentShader: string;

package/shaders/ColorCorrectionShader.js

@@ -4,7 +4,7 @@ import { Vector3 } from 'three';
  * Color correction
  */
 
-var ColorCorrectionShader = {
+const ColorCorrectionShader = {
   uniforms: {
     tDiffuse: {
       value: null

package/shaders/ColorifyShader.cjs.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e={uniforms:{tDiffuse:{value:null},color:{value:new(require("three").Color)(16777215)}},vertexShader:["varying vec2 vUv;","void main() {","\tvUv = uv;","\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );","}"].join("\n"),fragmentShader:["uniform vec3 color;","uniform sampler2D tDiffuse;","varying vec2 vUv;","void main() {","\tvec4 texel = texture2D( tDiffuse, vUv );","\tvec3 luma = vec3( 0.299, 0.587, 0.114 );","\tfloat v = dot( texel.xyz, luma );","\tgl_FragColor = vec4( v * color, texel.w );","}"].join("\n")};exports.ColorifyShader=e;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const e={uniforms:{tDiffuse:{value:null},color:{value:new(require("three").Color)(16777215)}},vertexShader:["varying vec2 vUv;","void main() {","\tvUv = uv;","\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );","}"].join("\n"),fragmentShader:["uniform vec3 color;","uniform sampler2D tDiffuse;","varying vec2 vUv;","void main() {","\tvec4 texel = texture2D( tDiffuse, vUv );","\tvec3 luma = vec3( 0.299, 0.587, 0.114 );","\tfloat v = dot( texel.xyz, luma );","\tgl_FragColor = vec4( v * color, texel.w );","}"].join("\n")};exports.ColorifyShader=e;

package/shaders/ColorifyShader.d.ts

@@ -1,9 +1,12 @@
-import { Uniform } from 'three';
-
-export const ColorifyShader: {
+import { Color } from 'three';
+export declare const ColorifyShader: {
     uniforms: {
-        tDiffuse: Uniform;
-        color: Uniform;
+        tDiffuse: {
+            value: null;
+        };
+        color: {
+            value: Color;
+        };
     };
     vertexShader: string;
     fragmentShader: string;

package/shaders/ColorifyShader.js

@@ -4,7 +4,7 @@ import { Color } from 'three';
  * Colorify shader
  */
 
-var ColorifyShader = {
+const ColorifyShader = {
   uniforms: {
     tDiffuse: {
       value: null

package/shaders/ConvolutionShader.cjs.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e={defines:{KERNEL_SIZE_FLOAT:"25.0",KERNEL_SIZE_INT:"25"},uniforms:{tDiffuse:{value:null},uImageIncrement:{value:new(require("three").Vector2)(.001953125,0)},cKernel:{value:[]}},vertexShader:["uniform vec2 uImageIncrement;","varying vec2 vUv;","void main() {","\tvUv = uv - ( ( KERNEL_SIZE_FLOAT - 1.0 ) / 2.0 ) * uImageIncrement;","\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );","}"].join("\n"),fragmentShader:["uniform float cKernel[ KERNEL_SIZE_INT ];","uniform sampler2D tDiffuse;","uniform vec2 uImageIncrement;","varying vec2 vUv;","void main() {","\tvec2 imageCoord = vUv;","\tvec4 sum = vec4( 0.0, 0.0, 0.0, 0.0 );","\tfor( int i = 0; i < KERNEL_SIZE_INT; i ++ ) {","\t\tsum += texture2D( tDiffuse, imageCoord ) * cKernel[ i ];","\t\timageCoord += uImageIncrement;","\t}","\tgl_FragColor = sum;","}"].join("\n"),buildKernel:function(e){function r(e,r){return Math.exp(-e*e/(2*r*r))}var n,t,i,o,u=2*Math.ceil(3*e)+1;for(u>25&&(u=25),o=.5*(u-1),t=new Array(u),i=0,n=0;n<u;++n)t[n]=r(n-o,e),i+=t[n];for(n=0;n<u;++n)t[n]/=i;return t}};exports.ConvolutionShader=e;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const e={defines:{KERNEL_SIZE_FLOAT:"25.0",KERNEL_SIZE_INT:"25"},uniforms:{tDiffuse:{value:null},uImageIncrement:{value:new(require("three").Vector2)(.001953125,0)},cKernel:{value:[]}},vertexShader:["uniform vec2 uImageIncrement;","varying vec2 vUv;","void main() {","\tvUv = uv - ( ( KERNEL_SIZE_FLOAT - 1.0 ) / 2.0 ) * uImageIncrement;","\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );","}"].join("\n"),fragmentShader:["uniform float cKernel[ KERNEL_SIZE_INT ];","uniform sampler2D tDiffuse;","uniform vec2 uImageIncrement;","varying vec2 vUv;","void main() {","\tvec2 imageCoord = vUv;","\tvec4 sum = vec4( 0.0, 0.0, 0.0, 0.0 );","\tfor( int i = 0; i < KERNEL_SIZE_INT; i ++ ) {","\t\tsum += texture2D( tDiffuse, imageCoord ) * cKernel[ i ];","\t\timageCoord += uImageIncrement;","\t}","\tgl_FragColor = sum;","}"].join("\n"),buildKernel:function(e){function t(e,t){return Math.exp(-e*e/(2*t*t))}const r=Math.min(2*Math.ceil(3*e)+1,25),n=.5*(r-1),i=new Array(r);let o=0;for(let u=0;u<r;++u)i[u]=t(u-n,e),o+=i[u];for(let e=0;e<r;++e)i[e]/=o;return i}};exports.ConvolutionShader=e;

package/shaders/ConvolutionShader.d.ts

@@ -1,17 +1,16 @@
-import { Uniform } from '../../../src/core/Uniform';
-
-export const ConvolutionShader: {
-    defines: {
-        KERNEL_SIZE_FLOAT: string;
-        KERNEL_SIZE_INT: string;
-    };
-    uniforms: {
-        tDiffuse: Uniform;
-        uImageIncrement: Uniform;
-        cKernel: Uniform;
-    };
-    vertexShader: string;
-    fragmentShader: string;
-
-    buildKernel(sigma: number): number[];
+import { Vector2 } from 'three';
+import type { IUniform, Texture } from 'three';
+import type { IShader } from './types';
+export declare type ConvolutionShaderDefines = {
+    KERNEL_SIZE_FLOAT: string;
+    KERNEL_SIZE_INT: string;
 };
+export declare type ConvolutionShaderUniforms = {
+    cKernel: IUniform<number[]>;
+    tDiffuse: IUniform<Texture | null>;
+    uImageIncrement: IUniform<Vector2>;
+};
+export interface IConvolutionShader extends IShader<ConvolutionShaderUniforms, ConvolutionShaderDefines> {
+    buildKernel: (sigma: number) => number[];
+}
+export declare const ConvolutionShader: IConvolutionShader;

package/shaders/ConvolutionShader.js

@@ -6,7 +6,7 @@ import { Vector2 } from 'three';
  * http://o3d.googlecode.com/svn/trunk/samples/convolution.html
  */
 
-var ConvolutionShader = {
+const ConvolutionShader = {
   defines: {
     KERNEL_SIZE_FLOAT: '25.0',
     KERNEL_SIZE_INT: '25'
@@ -30,24 +30,19 @@ var ConvolutionShader = {
       return Math.exp(-(x * x) / (2.0 * sigma * sigma));
     }
 
-    var i,
-        values,
-        sum,
-        halfWidth,
-        kMaxKernelSize = 25,
-        kernelSize = 2 * Math.ceil(sigma * 3.0) + 1;
-    if (kernelSize > kMaxKernelSize) kernelSize = kMaxKernelSize;
-    halfWidth = (kernelSize - 1) * 0.5;
-    values = new Array(kernelSize);
-    sum = 0.0;
-
-    for (i = 0; i < kernelSize; ++i) {
+    const kMaxKernelSize = 25;
+    const kernelSize = Math.min(2 * Math.ceil(sigma * 3.0) + 1, kMaxKernelSize);
+    const halfWidth = (kernelSize - 1) * 0.5;
+    const values = new Array(kernelSize);
+    let sum = 0.0;
+
+    for (let i = 0; i < kernelSize; ++i) {
       values[i] = gauss(i - halfWidth, sigma);
       sum += values[i];
     } // normalize the kernel
 
 
-    for (i = 0; i < kernelSize; ++i) values[i] /= sum;
+    for (let i = 0; i < kernelSize; ++i) values[i] /= sum;
 
     return values;
   }

package/shaders/CopyShader.d.ts

@@ -1,13 +1,9 @@
-declare const CopyShader: {
-    uniforms: {
-        tDiffuse: {
-            value: null;
-        };
-        opacity: {
-            value: number;
-        };
-    };
-    vertexShader: string;
-    fragmentShader: string;
+import type { IUniform, Texture } from 'three';
+import type { IShader } from './types';
+export declare type CopyShaderUniforms = {
+    opacity: IUniform<number>;
+    tDiffuse: IUniform<Texture | null>;
 };
-export { CopyShader };
+export interface ICopyShader extends IShader<CopyShaderUniforms> {
+}
+export declare const CopyShader: ICopyShader;

package/shaders/DOFMipMapShader.cjs.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e={uniforms:{tColor:{value:null},tDepth:{value:null},focus:{value:1},maxblur:{value:1}},vertexShader:["varying vec2 vUv;","void main() {","\tvUv = uv;","\tgl_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() {","\tvec4 depth = texture2D( tDepth, vUv );","\tfloat factor = depth.x - focus;","\tvec4 col = texture2D( tColor, vUv, 2.0 * maxblur * abs( focus - depth.x ) );","\tgl_FragColor = col;","\tgl_FragColor.a = 1.0;","}"].join("\n")};exports.DOFMipMapShader=e;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const o={uniforms:{tColor:{value:null},tDepth:{value:null},focus:{value:1},maxblur:{value:1}},vertexShader:["varying vec2 vUv;","void main() {","\tvUv = uv;","\tgl_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() {","\tvec4 depth = texture2D( tDepth, vUv );","\tfloat factor = depth.x - focus;","\tvec4 col = texture2D( tColor, vUv, 2.0 * maxblur * abs( focus - depth.x ) );","\tgl_FragColor = col;","\tgl_FragColor.a = 1.0;","}"].join("\n")};exports.DOFMipMapShader=o;

package/shaders/DOFMipMapShader.d.ts

@@ -1,11 +1,17 @@
-import { Uniform } from 'three';
-
-export const DOFMipMapShader: {
+export declare const DOFMipMapShader: {
     uniforms: {
-        tColor: Uniform;
-        tDepth: Uniform;
-        focus: Uniform;
-        maxblur: Uniform;
+        tColor: {
+            value: null;
+        };
+        tDepth: {
+            value: null;
+        };
+        focus: {
+            value: number;
+        };
+        maxblur: {
+            value: number;
+        };
     };
     vertexShader: string;
     fragmentShader: string;

package/shaders/DOFMipMapShader.js

@@ -3,7 +3,7 @@
  * - from Matt Handley @applmak
  * - requires power-of-2 sized render target with enabled mipmaps
  */
-var DOFMipMapShader = {
+const DOFMipMapShader = {
   uniforms: {
     tColor: {
       value: null

package/shaders/DepthLimitedBlurShader.cjs.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("three"),t={defines:{KERNEL_RADIUS:4,DEPTH_PACKING:1,PERSPECTIVE_CAMERA:1},uniforms:{tDiffuse:{value:null},size:{value:new e.Vector2(512,512)},sampleUvOffsets:{value:[new e.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() {","\tvUv = uv;","\tvInvSize = 1.0 / size;","\tgl_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 ) {","\t#if DEPTH_PACKING == 1","\treturn unpackRGBAToDepth( texture2D( tDepth, screenPosition ) );","\t#else","\treturn texture2D( tDepth, screenPosition ).x;","\t#endif","}","float getViewZ( const in float depth ) {","\t#if PERSPECTIVE_CAMERA == 1","\treturn perspectiveDepthToViewZ( depth, cameraNear, cameraFar );","\t#else","\treturn orthographicDepthToViewZ( depth, cameraNear, cameraFar );","\t#endif","}","void main() {","\tfloat depth = getDepth( vUv );","\tif( depth >= ( 1.0 - EPSILON ) ) {","\t\tdiscard;","\t}","\tfloat centerViewZ = -getViewZ( depth );","\tbool rBreak = false, lBreak = false;","\tfloat weightSum = sampleWeights[0];","\tvec4 diffuseSum = texture2D( tDiffuse, vUv ) * weightSum;","\tfor( int i = 1; i <= KERNEL_RADIUS; i ++ ) {","\t\tfloat sampleWeight = sampleWeights[i];","\t\tvec2 sampleUvOffset = sampleUvOffsets[i] * vInvSize;","\t\tvec2 sampleUv = vUv + sampleUvOffset;","\t\tfloat viewZ = -getViewZ( getDepth( sampleUv ) );","\t\tif( abs( viewZ - centerViewZ ) > depthCutoff ) rBreak = true;","\t\tif( ! rBreak ) {","\t\t\tdiffuseSum += texture2D( tDiffuse, sampleUv ) * sampleWeight;","\t\t\tweightSum += sampleWeight;","\t\t}","\t\tsampleUv = vUv - sampleUvOffset;","\t\tviewZ = -getViewZ( getDepth( sampleUv ) );","\t\tif( abs( viewZ - centerViewZ ) > depthCutoff ) lBreak = true;","\t\tif( ! lBreak ) {","\t\t\tdiffuseSum += texture2D( tDiffuse, sampleUv ) * sampleWeight;","\t\t\tweightSum += sampleWeight;","\t\t}","\t}","\tgl_FragColor = diffuseSum / weightSum;","}"].join("\n")},i={createSampleWeights:function(e,t){var i=function(e,t){return Math.exp(-e*e/(t*t*2))/(Math.sqrt(2*Math.PI)*t)},a=[];for(let r=0;r<=e;r++)a.push(i(r,t));return a},createSampleOffsets:function(e,t){var i=[];for(let a=0;a<=e;a++)i.push(t.clone().multiplyScalar(a));return i},configure:function(e,t,a,r){e.defines.KERNEL_RADIUS=t,e.uniforms.sampleUvOffsets.value=i.createSampleOffsets(t,r),e.uniforms.sampleWeights.value=i.createSampleWeights(t,a),e.needsUpdate=!0}};exports.BlurShaderUtils=i,exports.DepthLimitedBlurShader=t;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("three");const t={defines:{KERNEL_RADIUS:4,DEPTH_PACKING:1,PERSPECTIVE_CAMERA:1},uniforms:{tDiffuse:{value:null},size:{value:new e.Vector2(512,512)},sampleUvOffsets:{value:[new e.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() {","\tvUv = uv;","\tvInvSize = 1.0 / size;","\tgl_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 ) {","\t#if DEPTH_PACKING == 1","\treturn unpackRGBAToDepth( texture2D( tDepth, screenPosition ) );","\t#else","\treturn texture2D( tDepth, screenPosition ).x;","\t#endif","}","float getViewZ( const in float depth ) {","\t#if PERSPECTIVE_CAMERA == 1","\treturn perspectiveDepthToViewZ( depth, cameraNear, cameraFar );","\t#else","\treturn orthographicDepthToViewZ( depth, cameraNear, cameraFar );","\t#endif","}","void main() {","\tfloat depth = getDepth( vUv );","\tif( depth >= ( 1.0 - EPSILON ) ) {","\t\tdiscard;","\t}","\tfloat centerViewZ = -getViewZ( depth );","\tbool rBreak = false, lBreak = false;","\tfloat weightSum = sampleWeights[0];","\tvec4 diffuseSum = texture2D( tDiffuse, vUv ) * weightSum;","\tfor( int i = 1; i <= KERNEL_RADIUS; i ++ ) {","\t\tfloat sampleWeight = sampleWeights[i];","\t\tvec2 sampleUvOffset = sampleUvOffsets[i] * vInvSize;","\t\tvec2 sampleUv = vUv + sampleUvOffset;","\t\tfloat viewZ = -getViewZ( getDepth( sampleUv ) );","\t\tif( abs( viewZ - centerViewZ ) > depthCutoff ) rBreak = true;","\t\tif( ! rBreak ) {","\t\t\tdiffuseSum += texture2D( tDiffuse, sampleUv ) * sampleWeight;","\t\t\tweightSum += sampleWeight;","\t\t}","\t\tsampleUv = vUv - sampleUvOffset;","\t\tviewZ = -getViewZ( getDepth( sampleUv ) );","\t\tif( abs( viewZ - centerViewZ ) > depthCutoff ) lBreak = true;","\t\tif( ! lBreak ) {","\t\t\tdiffuseSum += texture2D( tDiffuse, sampleUv ) * sampleWeight;","\t\t\tweightSum += sampleWeight;","\t\t}","\t}","\tgl_FragColor = diffuseSum / weightSum;","}"].join("\n")},a={createSampleWeights:(e,t)=>{const a=(e,t)=>Math.exp(-e*e/(t*t*2))/(Math.sqrt(2*Math.PI)*t),i=[];for(let r=0;r<=e;r++)i.push(a(r,t));return i},createSampleOffsets:(e,t)=>{const a=[];for(let i=0;i<=e;i++)a.push(t.clone().multiplyScalar(i));return a},configure:(e,t,i,r)=>{e.defines.KERNEL_RADIUS=t,e.uniforms.sampleUvOffsets.value=a.createSampleOffsets(t,r),e.uniforms.sampleWeights.value=a.createSampleWeights(t,i),e.needsUpdate=!0}};exports.BlurShaderUtils=a,exports.DepthLimitedBlurShader=t;

package/shaders/DepthLimitedBlurShader.d.ts

@@ -1,27 +1,28 @@
-import { Uniform, Vector2, Material } from 'three';
-
-export const DepthLimitedBlurShader: {
-    defines: {
-        KERNEL_RADIUS: number;
-        DEPTH_PACKING: number;
-        PERSPECTIVE_CAMERA: number;
-    };
-    uniforms: {
-        tDiffuse: Uniform;
-        size: Uniform;
-        sampleUvOffsets: Uniform;
-        sampleWeights: Uniform;
-        tDepth: Uniform;
-        cameraNear: Uniform;
-        cameraFar: Uniform;
-        depthCutoff: Uniform;
-    };
-    vertexShader: string;
-    fragmentShader: string;
+import { Vector2 } from 'three';
+import type { IUniform, Texture } from 'three';
+import type { IShader } from './types';
+export declare type DepthLimitedBlurShaderDefines = {
+    DEPTH_PACKING: number;
+    KERNEL_RADIUS: number;
+    PERSPECTIVE_CAMERA: number;
 };
-
-export const BlurShaderUtils: {
-    createSampleWeights(kernelRadius: number, stdDev: number): number[];
-    createSampleOffsets(kernelRadius: number, uvIncrement: Vector2): Vector2[];
-    configure(configure: Material, kernelRadius: number, stdDev: number, uvIncrement: Vector2): void;
+export declare type DepthLimitedBlurShaderUniforms = {
+    cameraFar: IUniform<number>;
+    cameraNear: IUniform<number>;
+    depthCutoff: IUniform<number>;
+    sampleUvOffsets: IUniform<Vector2[]>;
+    sampleWeights: IUniform<number[]>;
+    size: IUniform<Vector2>;
+    tDepth: IUniform<Texture | null>;
+    tDiffuse: IUniform<Texture | null>;
+};
+export interface IDepthLimitedBlurShader extends IShader<DepthLimitedBlurShaderUniforms, DepthLimitedBlurShaderDefines> {
+    defines: DepthLimitedBlurShaderDefines;
+    needsUpdate?: boolean;
+}
+export declare const DepthLimitedBlurShader: IDepthLimitedBlurShader;
+export declare const BlurShaderUtils: {
+    createSampleWeights: (kernelRadius: number, stdDev: number) => number[];
+    createSampleOffsets: (kernelRadius: number, uvIncrement: Vector2) => Vector2[];
+    configure: (shader: IDepthLimitedBlurShader, kernelRadius: number, stdDev: number, uvIncrement: Vector2) => void;
 };

package/shaders/DepthLimitedBlurShader.js

@@ -1,10 +1,6 @@
 import { Vector2 } from 'three';
 
-/**
- * TODO
- */
-
-var DepthLimitedBlurShader = {
+const DepthLimitedBlurShader = {
   defines: {
     KERNEL_RADIUS: 4,
     DEPTH_PACKING: 1,
@@ -39,13 +35,13 @@ var DepthLimitedBlurShader = {
   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')
 };
-var BlurShaderUtils = {
-  createSampleWeights: function (kernelRadius, stdDev) {
-    var gaussian = function (x, stdDev) {
+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);
     };
 
-    var weights = [];
+    const weights = [];
 
     for (let i = 0; i <= kernelRadius; i++) {
       weights.push(gaussian(i, stdDev));
@@ -53,8 +49,8 @@ var BlurShaderUtils = {
 
     return weights;
   },
-  createSampleOffsets: function (kernelRadius, uvIncrement) {
-    var offsets = [];
+  createSampleOffsets: (kernelRadius, uvIncrement) => {
+    const offsets = [];
 
     for (let i = 0; i <= kernelRadius; i++) {
       offsets.push(uvIncrement.clone().multiplyScalar(i));
@@ -62,11 +58,11 @@ var BlurShaderUtils = {
 
     return offsets;
   },
-  configure: function (material, kernelRadius, stdDev, uvIncrement) {
-    material.defines['KERNEL_RADIUS'] = kernelRadius;
-    material.uniforms['sampleUvOffsets'].value = BlurShaderUtils.createSampleOffsets(kernelRadius, uvIncrement);
-    material.uniforms['sampleWeights'].value = BlurShaderUtils.createSampleWeights(kernelRadius, stdDev);
-    material.needsUpdate = true;
+  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;
   }
 };
 

package/shaders/DigitalGlitch.cjs.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var t={uniforms:{tDiffuse:{value:null},tDisp:{value:null},byp:{value:0},amount:{value:.08},angle:{value:.02},seed:{value:.02},seed_x:{value:.02},seed_y:{value:.02},distortion_x:{value:.5},distortion_y:{value:.6},col_s:{value:.05}},vertexShader:["varying vec2 vUv;","void main() {","\tvUv = uv;","\tgl_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){","\treturn fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);","}","void main() {","\tif(byp<1) {","\t\tvec2 p = vUv;","\t\tfloat xs = floor(gl_FragCoord.x / 0.5);","\t\tfloat ys = floor(gl_FragCoord.y / 0.5);","\t\tvec4 normal = texture2D (tDisp, p*seed*seed);","\t\tif(p.y<distortion_x+col_s && p.y>distortion_x-col_s*seed) {","\t\t\tif(seed_x>0.){","\t\t\t\tp.y = 1. - (p.y + distortion_y);","\t\t\t}","\t\t\telse {","\t\t\t\tp.y = distortion_y;","\t\t\t}","\t\t}","\t\tif(p.x<distortion_y+col_s && p.x>distortion_y-col_s*seed) {","\t\t\tif(seed_y>0.){","\t\t\t\tp.x=distortion_x;","\t\t\t}","\t\t\telse {","\t\t\t\tp.x = 1. - (p.x + distortion_x);","\t\t\t}","\t\t}","\t\tp.x+=normal.x*seed_x*(seed/5.);","\t\tp.y+=normal.y*seed_y*(seed/5.);","\t\tvec2 offset = amount * vec2( cos(angle), sin(angle));","\t\tvec4 cr = texture2D(tDiffuse, p + offset);","\t\tvec4 cga = texture2D(tDiffuse, p);","\t\tvec4 cb = texture2D(tDiffuse, p - offset);","\t\tgl_FragColor = vec4(cr.r, cga.g, cb.b, cga.a);","\t\tvec4 snow = 200.*amount*vec4(rand(vec2(xs * seed,ys * seed*50.))*0.2);","\t\tgl_FragColor = gl_FragColor+ snow;","\t}","\telse {","\t\tgl_FragColor=texture2D (tDiffuse, vUv);","\t}","}"].join("\n")};exports.DigitalGlitch=t;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const t={uniforms:{tDiffuse:{value:null},tDisp:{value:null},byp:{value:0},amount:{value:.08},angle:{value:.02},seed:{value:.02},seed_x:{value:.02},seed_y:{value:.02},distortion_x:{value:.5},distortion_y:{value:.6},col_s:{value:.05}},vertexShader:["varying vec2 vUv;","void main() {","\tvUv = uv;","\tgl_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){","\treturn fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);","}","void main() {","\tif(byp<1) {","\t\tvec2 p = vUv;","\t\tfloat xs = floor(gl_FragCoord.x / 0.5);","\t\tfloat ys = floor(gl_FragCoord.y / 0.5);","\t\tvec4 normal = texture2D (tDisp, p*seed*seed);","\t\tif(p.y<distortion_x+col_s && p.y>distortion_x-col_s*seed) {","\t\t\tif(seed_x>0.){","\t\t\t\tp.y = 1. - (p.y + distortion_y);","\t\t\t}","\t\t\telse {","\t\t\t\tp.y = distortion_y;","\t\t\t}","\t\t}","\t\tif(p.x<distortion_y+col_s && p.x>distortion_y-col_s*seed) {","\t\t\tif(seed_y>0.){","\t\t\t\tp.x=distortion_x;","\t\t\t}","\t\t\telse {","\t\t\t\tp.x = 1. - (p.x + distortion_x);","\t\t\t}","\t\t}","\t\tp.x+=normal.x*seed_x*(seed/5.);","\t\tp.y+=normal.y*seed_y*(seed/5.);","\t\tvec2 offset = amount * vec2( cos(angle), sin(angle));","\t\tvec4 cr = texture2D(tDiffuse, p + offset);","\t\tvec4 cga = texture2D(tDiffuse, p);","\t\tvec4 cb = texture2D(tDiffuse, p - offset);","\t\tgl_FragColor = vec4(cr.r, cga.g, cb.b, cga.a);","\t\tvec4 snow = 200.*amount*vec4(rand(vec2(xs * seed,ys * seed*50.))*0.2);","\t\tgl_FragColor = gl_FragColor+ snow;","\t}","\telse {","\t\tgl_FragColor=texture2D (tDiffuse, vUv);","\t}","}"].join("\n")};exports.DigitalGlitch=t;

package/shaders/DigitalGlitch.d.ts

@@ -1,18 +1,38 @@
-import { Uniform } from 'three';
-
-export const DigitalGlitch: {
+export declare const DigitalGlitch: {
     uniforms: {
-        tDiffuse: Uniform;
-        tDisp: Uniform;
-        byp: Uniform;
-        amount: Uniform;
-        angle: Uniform;
-        seed: Uniform;
-        seed_x: Uniform;
-        seed_y: Uniform;
-        distortion_x: Uniform;
-        distortion_y: Uniform;
-        col_s: Uniform;
+        tDiffuse: {
+            value: null;
+        };
+        tDisp: {
+            value: null;
+        };
+        byp: {
+            value: number;
+        };
+        amount: {
+            value: number;
+        };
+        angle: {
+            value: number;
+        };
+        seed: {
+            value: number;
+        };
+        seed_x: {
+            value: number;
+        };
+        seed_y: {
+            value: number;
+        };
+        distortion_x: {
+            value: number;
+        };
+        distortion_y: {
+            value: number;
+        };
+        col_s: {
+            value: number;
+        };
     };
     vertexShader: string;
     fragmentShader: string;