@needle-tools/three 0.145.0

package/examples/js/shaders/BrightnessContrastShader.js

@@ -0,0 +1,61 @@
+( function () {
+
+	/**
+ * Brightness and contrast adjustment
+ * https://github.com/evanw/glfx.js
+ * 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)
+ */
+	const BrightnessContrastShader = {
+		uniforms: {
+			'tDiffuse': {
+				value: null
+			},
+			'brightness': {
+				value: 0
+			},
+			'contrast': {
+				value: 0
+			}
+		},
+		vertexShader:
+  /* glsl */
+  `
+
+		varying vec2 vUv;
+
+		void main() {
+
+			vUv = uv;
+
+			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+
+		}`,
+		fragmentShader:
+  /* glsl */
+  `
+
+		uniform sampler2D tDiffuse;
+		uniform float brightness;
+		uniform float contrast;
+
+		varying vec2 vUv;
+
+		void main() {
+
+			gl_FragColor = texture2D( tDiffuse, vUv );
+
+			gl_FragColor.rgb += brightness;
+
+			if (contrast > 0.0) {
+				gl_FragColor.rgb = (gl_FragColor.rgb - 0.5) / (1.0 - contrast) + 0.5;
+			} else {
+				gl_FragColor.rgb = (gl_FragColor.rgb - 0.5) * (1.0 + contrast) + 0.5;
+			}
+
+		}`
+	};
+
+	THREE.BrightnessContrastShader = BrightnessContrastShader;
+
+} )();

package/examples/js/shaders/ColorCorrectionShader.js

@@ -0,0 +1,56 @@
+( function () {
+
+	/**
+ * Color correction
+ */
+
+	const ColorCorrectionShader = {
+		uniforms: {
+			'tDiffuse': {
+				value: null
+			},
+			'powRGB': {
+				value: new THREE.Vector3( 2, 2, 2 )
+			},
+			'mulRGB': {
+				value: new THREE.Vector3( 1, 1, 1 )
+			},
+			'addRGB': {
+				value: new THREE.Vector3( 0, 0, 0 )
+			}
+		},
+		vertexShader:
+  /* glsl */
+  `
+
+		varying vec2 vUv;
+
+		void main() {
+
+			vUv = uv;
+
+			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+
+		}`,
+		fragmentShader:
+  /* glsl */
+  `
+
+		uniform sampler2D tDiffuse;
+		uniform vec3 powRGB;
+		uniform vec3 mulRGB;
+		uniform vec3 addRGB;
+
+		varying vec2 vUv;
+
+		void main() {
+
+			gl_FragColor = texture2D( tDiffuse, vUv );
+			gl_FragColor.rgb = mulRGB * pow( ( gl_FragColor.rgb + addRGB ), powRGB );
+
+		}`
+	};
+
+	THREE.ColorCorrectionShader = ColorCorrectionShader;
+
+} )();

package/examples/js/shaders/ColorifyShader.js

@@ -0,0 +1,51 @@
+( function () {
+
+	/**
+ * Colorify shader
+ */
+
+	const ColorifyShader = {
+		uniforms: {
+			'tDiffuse': {
+				value: null
+			},
+			'color': {
+				value: new THREE.Color( 0xffffff )
+			}
+		},
+		vertexShader:
+  /* glsl */
+  `
+
+		varying vec2 vUv;
+
+		void main() {
+
+			vUv = uv;
+			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+
+		}`,
+		fragmentShader:
+  /* glsl */
+  `
+
+		uniform vec3 color;
+		uniform sampler2D tDiffuse;
+
+		varying vec2 vUv;
+
+		void main() {
+
+			vec4 texel = texture2D( tDiffuse, vUv );
+
+			vec3 luma = vec3( 0.299, 0.587, 0.114 );
+			float v = dot( texel.xyz, luma );
+
+			gl_FragColor = vec4( v * color, texel.w );
+
+		}`
+	};
+
+	THREE.ColorifyShader = ColorifyShader;
+
+} )();

package/examples/js/shaders/ConvolutionShader.js

@@ -0,0 +1,97 @@
+( function () {
+
+	/**
+ * Convolution shader
+ * ported from o3d sample to WebGL / GLSL
+ */
+
+	const ConvolutionShader = {
+		defines: {
+			'KERNEL_SIZE_FLOAT': '25.0',
+			'KERNEL_SIZE_INT': '25'
+		},
+		uniforms: {
+			'tDiffuse': {
+				value: null
+			},
+			'uImageIncrement': {
+				value: new THREE.Vector2( 0.001953125, 0.0 )
+			},
+			'cKernel': {
+				value: []
+			}
+		},
+		vertexShader:
+  /* glsl */
+  `
+
+		uniform vec2 uImageIncrement;
+
+		varying vec2 vUv;
+
+		void main() {
+
+			vUv = uv - ( ( KERNEL_SIZE_FLOAT - 1.0 ) / 2.0 ) * uImageIncrement;
+			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+
+		}`,
+		fragmentShader:
+  /* glsl */
+  `
+
+		uniform float cKernel[ KERNEL_SIZE_INT ];
+
+		uniform sampler2D tDiffuse;
+		uniform vec2 uImageIncrement;
+
+		varying vec2 vUv;
+
+		void main() {
+
+			vec2 imageCoord = vUv;
+			vec4 sum = vec4( 0.0, 0.0, 0.0, 0.0 );
+
+			for( int i = 0; i < KERNEL_SIZE_INT; i ++ ) {
+
+				sum += texture2D( tDiffuse, imageCoord ) * cKernel[ i ];
+				imageCoord += uImageIncrement;
+
+			}
+
+			gl_FragColor = sum;
+
+		}`,
+		buildKernel: function ( sigma ) {
+
+			// We lop off the sqrt(2 * pi) * sigma term, since we're going to normalize anyway.
+			const kMaxKernelSize = 25;
+			let kernelSize = 2 * Math.ceil( sigma * 3.0 ) + 1;
+			if ( kernelSize > kMaxKernelSize ) kernelSize = 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 ( let i = 0; i < kernelSize; ++ i ) values[ i ] /= sum;
+
+			return values;
+
+		}
+	};
+
+	function gauss( x, sigma ) {
+
+		return Math.exp( - ( x * x ) / ( 2.0 * sigma * sigma ) );
+
+	}
+
+	THREE.ConvolutionShader = ConvolutionShader;
+
+} )();

package/examples/js/shaders/CopyShader.js

@@ -0,0 +1,48 @@
+( function () {
+
+	/**
+ * Full-screen textured quad shader
+ */
+	const CopyShader = {
+		uniforms: {
+			'tDiffuse': {
+				value: null
+			},
+			'opacity': {
+				value: 1.0
+			}
+		},
+		vertexShader:
+  /* glsl */
+  `
+
+		varying vec2 vUv;
+
+		void main() {
+
+			vUv = uv;
+			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+
+		}`,
+		fragmentShader:
+  /* glsl */
+  `
+
+		uniform float opacity;
+
+		uniform sampler2D tDiffuse;
+
+		varying vec2 vUv;
+
+		void main() {
+
+			gl_FragColor = texture2D( tDiffuse, vUv );
+			gl_FragColor.a *= opacity;
+
+
+		}`
+	};
+
+	THREE.CopyShader = CopyShader;
+
+} )();

package/examples/js/shaders/DOFMipMapShader.js

@@ -0,0 +1,63 @@
+( function () {
+
+	/**
+ * Depth-of-field shader using mipmaps
+ * - from Matt Handley @applmak
+ * - requires power-of-2 sized render target with enabled mipmaps
+ */
+	const DOFMipMapShader = {
+		uniforms: {
+			'tColor': {
+				value: null
+			},
+			'tDepth': {
+				value: null
+			},
+			'focus': {
+				value: 1.0
+			},
+			'maxblur': {
+				value: 1.0
+			}
+		},
+		vertexShader:
+  /* glsl */
+  `
+
+		varying vec2 vUv;
+
+		void main() {
+
+			vUv = uv;
+			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+
+		}`,
+		fragmentShader:
+  /* glsl */
+  `
+
+		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;
+
+		}`
+	};
+
+	THREE.DOFMipMapShader = DOFMipMapShader;
+
+} )();

package/examples/js/shaders/DepthLimitedBlurShader.js

@@ -0,0 +1,180 @@
+( function () {
+
+	/**
+ * TODO
+ */
+
+	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.0 ]
+			},
+			'tDepth': {
+				value: null
+			},
+			'cameraNear': {
+				value: 10
+			},
+			'cameraFar': {
+				value: 1000
+			},
+			'depthCutoff': {
+				value: 10
+			}
+		},
+		vertexShader:
+  /* glsl */
+  `
+
+		#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 );
+		}`,
+		fragmentShader:
+  /* glsl */
+  `
+
+		#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;
+		}`
+	};
+	const BlurShaderUtils = {
+		createSampleWeights: function ( kernelRadius, stdDev ) {
+
+			const weights = [];
+
+			for ( let i = 0; i <= kernelRadius; i ++ ) {
+
+				weights.push( gaussian( i, stdDev ) );
+
+			}
+
+			return weights;
+
+		},
+		createSampleOffsets: function ( kernelRadius, uvIncrement ) {
+
+			const offsets = [];
+
+			for ( let i = 0; i <= kernelRadius; i ++ ) {
+
+				offsets.push( uvIncrement.clone().multiplyScalar( i ) );
+
+			}
+
+			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;
+
+		}
+	};
+
+	function gaussian( x, stdDev ) {
+
+		return Math.exp( - ( x * x ) / ( 2.0 * ( stdDev * stdDev ) ) ) / ( Math.sqrt( 2.0 * Math.PI ) * stdDev );
+
+	}
+
+	THREE.BlurShaderUtils = BlurShaderUtils;
+	THREE.DepthLimitedBlurShader = DepthLimitedBlurShader;
+
+} )();

package/examples/js/shaders/DigitalGlitch.js

@@ -0,0 +1,130 @@
+( function () {
+
+	/**
+ * 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
+ */
+	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:
+  /* glsl */
+  `
+
+		varying vec2 vUv;
+		void main() {
+			vUv = uv;
+			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+		}`,
+		fragmentShader:
+  /* glsl */
+  `
+
+		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
+				float disp = texture2D(tDisp, p*seed*seed).r;
+				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+=disp*seed_x*(seed/5.);
+				p.y+=disp*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);
+			}
+		}`
+	};
+
+	THREE.DigitalGlitch = DigitalGlitch;
+
+} )();