@needle-tools/three 0.146.10 → 0.153.0

package/examples/js/shaders/BrightnessContrastShader.js

@@ -1,58 +0,0 @@
-( 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

@@ -1,52 +0,0 @@
-( 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

@@ -1,47 +0,0 @@
-( 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

@@ -1,92 +0,0 @@
-( 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

@@ -1,45 +0,0 @@
-( 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

@@ -1,60 +0,0 @@
-( 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

@@ -1,173 +0,0 @@
-( 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

@@ -1,127 +0,0 @@
-( 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;
-
-} )();