three-stdlib 2.22.7 → 2.22.9

package/dist/shaders/CopyShader.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+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")
+};
+exports.CopyShader = CopyShader;

package/dist/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/dist/shaders/DOFMipMapShader.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Depth-of-field shader using mipmaps
+ * - from Matt Handley @applmak
+ * - requires power-of-2 sized render target with enabled mipmaps
+ */
+export declare const DOFMipMapShader: {
+    uniforms: {
+        tColor: {
+            value: null;
+        };
+        tDepth: {
+            value: null;
+        };
+        focus: {
+            value: number;
+        };
+        maxblur: {
+            value: number;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/dist/shaders/DOFMipMapShader.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+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")
+};
+exports.DOFMipMapShader = DOFMipMapShader;

package/dist/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/dist/shaders/DepthLimitedBlurShader.d.ts

@@ -0,0 +1,28 @@
+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 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/dist/shaders/DepthLimitedBlurShader.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+const DepthLimitedBlurShader = {
+  defines: {
+    KERNEL_RADIUS: 4,
+    DEPTH_PACKING: 1,
+    PERSPECTIVE_CAMERA: 1
+  },
+  uniforms: {
+    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")
+};
+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;
+  }
+};
+exports.BlurShaderUtils = BlurShaderUtils;
+exports.DepthLimitedBlurShader = DepthLimitedBlurShader;

package/dist/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/dist/shaders/DigitalGlitch.d.ts

@@ -0,0 +1,39 @@
+export declare const DigitalGlitch: {
+    uniforms: {
+        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;
+};

package/dist/shaders/DigitalGlitch.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, 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 }
+  },
+  vertexShader: `varying vec2 vUv;
+     void main() {
+     	 vUv = uv;
+     	 gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+     }`,
+  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);
+     	}
+    }`
+};
+exports.DigitalGlitch = DigitalGlitch;

package/dist/shaders/DigitalGlitch.mjs

@@ -0,0 +1,85 @@
+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 }
+  },
+  vertexShader: `varying vec2 vUv;
+     void main() {
+     	 vUv = uv;
+     	 gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+     }`,
+  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);
+     	}
+    }`
+};
+export {
+  DigitalGlitch
+};

package/dist/shaders/DotScreenShader.d.ts

@@ -0,0 +1,27 @@
+import { Vector2 } from 'three';
+/**
+ * Dot screen shader
+ * based on glfx.js sepia shader
+ * https://github.com/evanw/glfx.js
+ */
+export declare const DotScreenShader: {
+    uniforms: {
+        tDiffuse: {
+            value: null;
+        };
+        tSize: {
+            value: Vector2;
+        };
+        center: {
+            value: Vector2;
+        };
+        angle: {
+            value: number;
+        };
+        scale: {
+            value: number;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/dist/shaders/DotScreenShader.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+const DotScreenShader = {
+  uniforms: {
+    tDiffuse: { value: null },
+    tSize: { value: new THREE.Vector2(256, 256) },
+    center: { value: new THREE.Vector2(0.5, 0.5) },
+    angle: { value: 1.57 },
+    scale: { value: 1 }
+  },
+  vertexShader: [
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vUv = uv;",
+    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "uniform vec2 center;",
+    "uniform float angle;",
+    "uniform float scale;",
+    "uniform vec2 tSize;",
+    "uniform sampler2D tDiffuse;",
+    "varying vec2 vUv;",
+    "float pattern() {",
+    "	float s = sin( angle ), c = cos( angle );",
+    "	vec2 tex = vUv * tSize - center;",
+    "	vec2 point = vec2( c * tex.x - s * tex.y, s * tex.x + c * tex.y ) * scale;",
+    "	return ( sin( point.x ) * sin( point.y ) ) * 4.0;",
+    "}",
+    "void main() {",
+    "	vec4 color = texture2D( tDiffuse, vUv );",
+    "	float average = ( color.r + color.g + color.b ) / 3.0;",
+    "	gl_FragColor = vec4( vec3( average * 10.0 - 5.0 + pattern() ), color.a );",
+    "}"
+  ].join("\n")
+};
+exports.DotScreenShader = DotScreenShader;