super-three 0.147.0 → 0.152.0

package/examples/js/shaders/SobelOperatorShader.js

@@ -1,88 +0,0 @@
-( function () {
-
-	/**
- * Sobel Edge Detection (see https://youtu.be/uihBwtPIBxM)
- *
- * As mentioned in the video the Sobel operator expects a grayscale image as input.
- *
- */
-
-	const SobelOperatorShader = {
-		uniforms: {
-			'tDiffuse': {
-				value: null
-			},
-			'resolution': {
-				value: new THREE.Vector2()
-			}
-		},
-		vertexShader: /* glsl */`
-
-		varying vec2 vUv;
-
-		void main() {
-
-			vUv = uv;
-
-			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
-
-		}`,
-		fragmentShader: /* glsl */`
-
-		uniform sampler2D tDiffuse;
-		uniform vec2 resolution;
-		varying vec2 vUv;
-
-		void main() {
-
-			vec2 texel = vec2( 1.0 / resolution.x, 1.0 / resolution.y );
-
-		// kernel definition (in glsl matrices are filled in column-major order)
-
-			const mat3 Gx = mat3( -1, -2, -1, 0, 0, 0, 1, 2, 1 ); // x direction kernel
-			const mat3 Gy = mat3( -1, 0, 1, -2, 0, 2, -1, 0, 1 ); // y direction kernel
-
-		// fetch the 3x3 neighbourhood of a fragment
-
-		// first column
-
-			float tx0y0 = texture2D( tDiffuse, vUv + texel * vec2( -1, -1 ) ).r;
-			float tx0y1 = texture2D( tDiffuse, vUv + texel * vec2( -1,  0 ) ).r;
-			float tx0y2 = texture2D( tDiffuse, vUv + texel * vec2( -1,  1 ) ).r;
-
-		// second column
-
-			float tx1y0 = texture2D( tDiffuse, vUv + texel * vec2(  0, -1 ) ).r;
-			float tx1y1 = texture2D( tDiffuse, vUv + texel * vec2(  0,  0 ) ).r;
-			float tx1y2 = texture2D( tDiffuse, vUv + texel * vec2(  0,  1 ) ).r;
-
-		// third column
-
-			float tx2y0 = texture2D( tDiffuse, vUv + texel * vec2(  1, -1 ) ).r;
-			float tx2y1 = texture2D( tDiffuse, vUv + texel * vec2(  1,  0 ) ).r;
-			float tx2y2 = texture2D( tDiffuse, vUv + texel * vec2(  1,  1 ) ).r;
-
-		// gradient value in x direction
-
-			float valueGx = Gx[0][0] * tx0y0 + Gx[1][0] * tx1y0 + Gx[2][0] * tx2y0 +
-				Gx[0][1] * tx0y1 + Gx[1][1] * tx1y1 + Gx[2][1] * tx2y1 +
-				Gx[0][2] * tx0y2 + Gx[1][2] * tx1y2 + Gx[2][2] * tx2y2;
-
-		// gradient value in y direction
-
-			float valueGy = Gy[0][0] * tx0y0 + Gy[1][0] * tx1y0 + Gy[2][0] * tx2y0 +
-				Gy[0][1] * tx0y1 + Gy[1][1] * tx1y1 + Gy[2][1] * tx2y1 +
-				Gy[0][2] * tx0y2 + Gy[1][2] * tx1y2 + Gy[2][2] * tx2y2;
-
-		// magnitute of the total gradient
-
-			float G = sqrt( ( valueGx * valueGx ) + ( valueGy * valueGy ) );
-
-			gl_FragColor = vec4( vec3( G ), 1 );
-
-		}`
-	};
-
-	THREE.SobelOperatorShader = SobelOperatorShader;
-
-} )();

package/examples/js/shaders/SubsurfaceScatteringShader.js

@@ -1,49 +0,0 @@
-( function () {
-
-	/**
- * ------------------------------------------------------------------------------------------
- * Subsurface Scattering shader
- * Based on GDC 2011 – Approximating Translucency for a Fast, Cheap and Convincing Subsurface Scattering Look
- * https://colinbarrebrisebois.com/2011/03/07/gdc-2011-approximating-translucency-for-a-fast-cheap-and-convincing-subsurface-scattering-look/
- *------------------------------------------------------------------------------------------
- */
-
-	function replaceAll( string, find, replace ) {
-
-		return string.split( find ).join( replace );
-
-	}
-
-	const meshphong_frag_head = THREE.ShaderChunk[ 'meshphong_frag' ].slice( 0, THREE.ShaderChunk[ 'meshphong_frag' ].indexOf( 'void main() {' ) );
-	const meshphong_frag_body = THREE.ShaderChunk[ 'meshphong_frag' ].slice( THREE.ShaderChunk[ 'meshphong_frag' ].indexOf( 'void main() {' ) );
-	const SubsurfaceScatteringShader = {
-		uniforms: THREE.UniformsUtils.merge( [ THREE.ShaderLib[ 'phong' ].uniforms, {
-			'thicknessMap': {
-				value: null
-			},
-			'thicknessColor': {
-				value: new THREE.Color( 0xffffff )
-			},
-			'thicknessDistortion': {
-				value: 0.1
-			},
-			'thicknessAmbient': {
-				value: 0.0
-			},
-			'thicknessAttenuation': {
-				value: 0.1
-			},
-			'thicknessPower': {
-				value: 2.0
-			},
-			'thicknessScale': {
-				value: 10.0
-			}
-		} ] ),
-		vertexShader: [ '#define USE_UV', THREE.ShaderChunk[ 'meshphong_vert' ] ].join( '\n' ),
-		fragmentShader: [ '#define USE_UV', '#define SUBSURFACE', meshphong_frag_head, 'uniform sampler2D thicknessMap;', 'uniform float thicknessPower;', 'uniform float thicknessScale;', 'uniform float thicknessDistortion;', 'uniform float thicknessAmbient;', 'uniform float thicknessAttenuation;', 'uniform vec3 thicknessColor;', 'void RE_Direct_Scattering(const in IncidentLight directLight, const in vec2 uv, const in GeometricContext geometry, inout ReflectedLight reflectedLight) {', '	vec3 thickness = thicknessColor * texture2D(thicknessMap, uv).r;', '	vec3 scatteringHalf = normalize(directLight.direction + (geometry.normal * thicknessDistortion));', '	float scatteringDot = pow(saturate(dot(geometry.viewDir, -scatteringHalf)), thicknessPower) * thicknessScale;', '	vec3 scatteringIllu = (scatteringDot + thicknessAmbient) * thickness;', '	reflectedLight.directDiffuse += scatteringIllu * thicknessAttenuation * directLight.color;', '}', meshphong_frag_body.replace( '#include <lights_fragment_begin>', replaceAll( THREE.ShaderChunk[ 'lights_fragment_begin' ], 'RE_Direct( directLight, geometry, material, reflectedLight );', [ 'RE_Direct( directLight, geometry, material, reflectedLight );', '#if defined( SUBSURFACE ) && defined( USE_UV )', ' RE_Direct_Scattering(directLight, vUv, geometry, reflectedLight);', '#endif' ].join( '\n' ) ) ) ].join( '\n' )
-	};
-
-	THREE.SubsurfaceScatteringShader = SubsurfaceScatteringShader;
-
-} )();

package/examples/js/shaders/TechnicolorShader.js

@@ -1,43 +0,0 @@
-( function () {
-
-	/**
- * Technicolor Shader
- * Simulates the look of the two-strip technicolor process popular in early 20th century films.
- * More historical info here: http://www.widescreenmuseum.com/oldcolor/technicolor1.htm
- * Demo here: http://charliehoey.com/technicolor_shader/shader_test.html
- */
-
-	const TechnicolorShader = {
-		uniforms: {
-			'tDiffuse': {
-				value: null
-			}
-		},
-		vertexShader: /* glsl */`
-
-		varying vec2 vUv;
-
-		void main() {
-
-			vUv = uv;
-			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
-
-		}`,
-		fragmentShader: /* glsl */`
-
-		uniform sampler2D tDiffuse;
-		varying vec2 vUv;
-
-		void main() {
-
-			vec4 tex = texture2D( tDiffuse, vec2( vUv.x, vUv.y ) );
-			vec4 newTex = vec4(tex.r, (tex.g + tex.b) * .5, (tex.g + tex.b) * .5, 1.0);
-
-			gl_FragColor = newTex;
-
-		}`
-	};
-
-	THREE.TechnicolorShader = TechnicolorShader;
-
-} )();

package/examples/js/shaders/ToneMapShader.js

@@ -1,84 +0,0 @@
-( function () {
-
-	/**
- * Full-screen tone-mapping shader based on http://www.cis.rit.edu/people/faculty/ferwerda/publications/sig02_paper.pdf
- */
-
-	const ToneMapShader = {
-		uniforms: {
-			'tDiffuse': {
-				value: null
-			},
-			'averageLuminance': {
-				value: 1.0
-			},
-			'luminanceMap': {
-				value: null
-			},
-			'maxLuminance': {
-				value: 16.0
-			},
-			'minLuminance': {
-				value: 0.01
-			},
-			'middleGrey': {
-				value: 0.6
-			}
-		},
-		vertexShader: /* glsl */`
-
-		varying vec2 vUv;
-
-		void main() {
-
-			vUv = uv;
-			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
-
-		}`,
-		fragmentShader: /* glsl */`
-
-		#include <common>
-
-		uniform sampler2D tDiffuse;
-
-		varying vec2 vUv;
-
-		uniform float middleGrey;
-		uniform float minLuminance;
-		uniform float maxLuminance;
-		#ifdef ADAPTED_LUMINANCE
-			uniform sampler2D luminanceMap;
-		#else
-			uniform float averageLuminance;
-		#endif
-
-		vec3 ToneMap( vec3 vColor ) {
-			#ifdef ADAPTED_LUMINANCE
-				// Get the calculated average luminance
-				float fLumAvg = texture2D(luminanceMap, vec2(0.5, 0.5)).r;
-			#else
-				float fLumAvg = averageLuminance;
-			#endif
-
-			// Calculate the luminance of the current pixel
-			float fLumPixel = luminance( vColor );
-
-			// Apply the modified operator (Eq. 4)
-			float fLumScaled = (fLumPixel * middleGrey) / max( minLuminance, fLumAvg );
-
-			float fLumCompressed = (fLumScaled * (1.0 + (fLumScaled / (maxLuminance * maxLuminance)))) / (1.0 + fLumScaled);
-			return fLumCompressed * vColor;
-		}
-
-		void main() {
-
-			vec4 texel = texture2D( tDiffuse, vUv );
-
-			gl_FragColor = vec4( ToneMap( texel.xyz ), texel.w );
-
-		}`
-	};
-
-	THREE.ToneMapShader = ToneMapShader;
-
-} )();

package/examples/js/shaders/ToonShader.js

@@ -1,335 +0,0 @@
-( function () {
-
-	/**
- * Currently contains:
- *
- *	toon1
- *	toon2
- *	hatching
- *	dotted
- */
-
-	const ToonShader1 = {
-		uniforms: {
-			'uDirLightPos': {
-				value: new THREE.Vector3()
-			},
-			'uDirLightColor': {
-				value: new THREE.Color( 0xeeeeee )
-			},
-			'uAmbientLightColor': {
-				value: new THREE.Color( 0x050505 )
-			},
-			'uBaseColor': {
-				value: new THREE.Color( 0xffffff )
-			}
-		},
-		vertexShader: /* glsl */`
-
-		varying vec3 vNormal;
-		varying vec3 vRefract;
-
-		void main() {
-
-			vec4 worldPosition = modelMatrix * vec4( position, 1.0 );
-			vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );
-			vec3 worldNormal = normalize ( mat3( modelMatrix[0].xyz, modelMatrix[1].xyz, modelMatrix[2].xyz ) * normal );
-
-			vNormal = normalize( normalMatrix * normal );
-
-			vec3 I = worldPosition.xyz - cameraPosition;
-			vRefract = refract( normalize( I ), worldNormal, 1.02 );
-
-			gl_Position = projectionMatrix * mvPosition;
-
-		}`,
-		fragmentShader: /* glsl */`
-
-		uniform vec3 uBaseColor;
-
-		uniform vec3 uDirLightPos;
-		uniform vec3 uDirLightColor;
-
-		uniform vec3 uAmbientLightColor;
-
-		varying vec3 vNormal;
-
-		varying vec3 vRefract;
-
-		void main() {
-
-			float directionalLightWeighting = max( dot( normalize( vNormal ), uDirLightPos ), 0.0);
-			vec3 lightWeighting = uAmbientLightColor + uDirLightColor * directionalLightWeighting;
-
-			float intensity = smoothstep( - 0.5, 1.0, pow( length(lightWeighting), 20.0 ) );
-			intensity += length(lightWeighting) * 0.2;
-
-			float cameraWeighting = dot( normalize( vNormal ), vRefract );
-			intensity += pow( 1.0 - length( cameraWeighting ), 6.0 );
-			intensity = intensity * 0.2 + 0.3;
-
-			if ( intensity < 0.50 ) {
-
-				gl_FragColor = vec4( 2.0 * intensity * uBaseColor, 1.0 );
-
-			} else {
-
-				gl_FragColor = vec4( 1.0 - 2.0 * ( 1.0 - intensity ) * ( 1.0 - uBaseColor ), 1.0 );
-
-		}
-
-		}`
-	};
-	const ToonShader2 = {
-		uniforms: {
-			'uDirLightPos': {
-				value: new THREE.Vector3()
-			},
-			'uDirLightColor': {
-				value: new THREE.Color( 0xeeeeee )
-			},
-			'uAmbientLightColor': {
-				value: new THREE.Color( 0x050505 )
-			},
-			'uBaseColor': {
-				value: new THREE.Color( 0xeeeeee )
-			},
-			'uLineColor1': {
-				value: new THREE.Color( 0x808080 )
-			},
-			'uLineColor2': {
-				value: new THREE.Color( 0x000000 )
-			},
-			'uLineColor3': {
-				value: new THREE.Color( 0x000000 )
-			},
-			'uLineColor4': {
-				value: new THREE.Color( 0x000000 )
-			}
-		},
-		vertexShader: /* glsl */`
-
-		varying vec3 vNormal;
-
-		void main() {
-
-			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
-			vNormal = normalize( normalMatrix * normal );
-
-		}`,
-		fragmentShader: /* glsl */`
-
-		uniform vec3 uBaseColor;
-		uniform vec3 uLineColor1;
-		uniform vec3 uLineColor2;
-		uniform vec3 uLineColor3;
-		uniform vec3 uLineColor4;
-
-		uniform vec3 uDirLightPos;
-		uniform vec3 uDirLightColor;
-
-		uniform vec3 uAmbientLightColor;
-
-		varying vec3 vNormal;
-
-		void main() {
-
-			float camera = max( dot( normalize( vNormal ), vec3( 0.0, 0.0, 1.0 ) ), 0.4);
-			float light = max( dot( normalize( vNormal ), uDirLightPos ), 0.0);
-
-			gl_FragColor = vec4( uBaseColor, 1.0 );
-
-			if ( length(uAmbientLightColor + uDirLightColor * light) < 1.00 ) {
-
-				gl_FragColor *= vec4( uLineColor1, 1.0 );
-
-			}
-
-			if ( length(uAmbientLightColor + uDirLightColor * camera) < 0.50 ) {
-
-				gl_FragColor *= vec4( uLineColor2, 1.0 );
-
-			}
-
-		}`
-	};
-	const ToonShaderHatching = {
-		uniforms: {
-			'uDirLightPos': {
-				value: new THREE.Vector3()
-			},
-			'uDirLightColor': {
-				value: new THREE.Color( 0xeeeeee )
-			},
-			'uAmbientLightColor': {
-				value: new THREE.Color( 0x050505 )
-			},
-			'uBaseColor': {
-				value: new THREE.Color( 0xffffff )
-			},
-			'uLineColor1': {
-				value: new THREE.Color( 0x000000 )
-			},
-			'uLineColor2': {
-				value: new THREE.Color( 0x000000 )
-			},
-			'uLineColor3': {
-				value: new THREE.Color( 0x000000 )
-			},
-			'uLineColor4': {
-				value: new THREE.Color( 0x000000 )
-			}
-		},
-		vertexShader: /* glsl */`
-
-		varying vec3 vNormal;
-
-		void main() {
-
-			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
-			vNormal = normalize( normalMatrix * normal );
-
-		}`,
-		fragmentShader: /* glsl */`
-
-		uniform vec3 uBaseColor;
-		uniform vec3 uLineColor1;
-		uniform vec3 uLineColor2;
-		uniform vec3 uLineColor3;
-		uniform vec3 uLineColor4;
-
-		uniform vec3 uDirLightPos;
-		uniform vec3 uDirLightColor;
-
-		uniform vec3 uAmbientLightColor;
-
-		varying vec3 vNormal;
-
-		void main() {
-
-			float directionalLightWeighting = max( dot( normalize(vNormal), uDirLightPos ), 0.0);
-			vec3 lightWeighting = uAmbientLightColor + uDirLightColor * directionalLightWeighting;
-
-			gl_FragColor = vec4( uBaseColor, 1.0 );
-
-			if ( length(lightWeighting) < 1.00 ) {
-
-				if ( mod(gl_FragCoord.x + gl_FragCoord.y, 10.0) == 0.0) {
-
-					gl_FragColor = vec4( uLineColor1, 1.0 );
-
-				}
-
-			}
-
-			if ( length(lightWeighting) < 0.75 ) {
-
-				if (mod(gl_FragCoord.x - gl_FragCoord.y, 10.0) == 0.0) {
-
-					gl_FragColor = vec4( uLineColor2, 1.0 );
-
-				}
-
-			}
-
-			if ( length(lightWeighting) < 0.50 ) {
-
-				if (mod(gl_FragCoord.x + gl_FragCoord.y - 5.0, 10.0) == 0.0) {
-
-					gl_FragColor = vec4( uLineColor3, 1.0 );
-
-				}
-
-			}
-
-			if ( length(lightWeighting) < 0.3465 ) {
-
-				if (mod(gl_FragCoord.x - gl_FragCoord.y - 5.0, 10.0) == 0.0) {
-
-					gl_FragColor = vec4( uLineColor4, 1.0 );
-
-			}
-
-			}
-
-		}`
-	};
-	const ToonShaderDotted = {
-		uniforms: {
-			'uDirLightPos': {
-				value: new THREE.Vector3()
-			},
-			'uDirLightColor': {
-				value: new THREE.Color( 0xeeeeee )
-			},
-			'uAmbientLightColor': {
-				value: new THREE.Color( 0x050505 )
-			},
-			'uBaseColor': {
-				value: new THREE.Color( 0xffffff )
-			},
-			'uLineColor1': {
-				value: new THREE.Color( 0x000000 )
-			}
-		},
-		vertexShader: /* glsl */`
-
-		varying vec3 vNormal;
-
-		void main() {
-
-			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
-			vNormal = normalize( normalMatrix * normal );
-
-		}`,
-		fragmentShader: /* glsl */`
-
-		uniform vec3 uBaseColor;
-		uniform vec3 uLineColor1;
-		uniform vec3 uLineColor2;
-		uniform vec3 uLineColor3;
-		uniform vec3 uLineColor4;
-
-		uniform vec3 uDirLightPos;
-		uniform vec3 uDirLightColor;
-
-		uniform vec3 uAmbientLightColor;
-
-		varying vec3 vNormal;
-
-		void main() {
-
-		float directionalLightWeighting = max( dot( normalize(vNormal), uDirLightPos ), 0.0);
-		vec3 lightWeighting = uAmbientLightColor + uDirLightColor * directionalLightWeighting;
-
-		gl_FragColor = vec4( uBaseColor, 1.0 );
-
-		if ( length(lightWeighting) < 1.00 ) {
-
-				if ( ( mod(gl_FragCoord.x, 4.001) + mod(gl_FragCoord.y, 4.0) ) > 6.00 ) {
-
-					gl_FragColor = vec4( uLineColor1, 1.0 );
-
-				}
-
-			}
-
-			if ( length(lightWeighting) < 0.50 ) {
-
-				if ( ( mod(gl_FragCoord.x + 2.0, 4.001) + mod(gl_FragCoord.y + 2.0, 4.0) ) > 6.00 ) {
-
-					gl_FragColor = vec4( uLineColor1, 1.0 );
-
-				}
-
-			}
-
-		}`
-	};
-
-	THREE.ToonShader1 = ToonShader1;
-	THREE.ToonShader2 = ToonShader2;
-	THREE.ToonShaderDotted = ToonShaderDotted;
-	THREE.ToonShaderHatching = ToonShaderHatching;
-
-} )();

package/examples/js/shaders/TriangleBlurShader.js

@@ -1,70 +0,0 @@
-( function () {
-
-	/**
- * Triangle blur shader
- * based on glfx.js triangle blur shader
- * https://github.com/evanw/glfx.js
- *
- * A basic blur filter, which convolves the image with a
- * pyramid filter. The pyramid filter is separable and is applied as two
- * perpendicular triangle filters.
- */
-
-	const TriangleBlurShader = {
-		uniforms: {
-			'texture': {
-				value: null
-			},
-			'delta': {
-				value: new THREE.Vector2( 1, 1 )
-			}
-		},
-		vertexShader: /* glsl */`
-
-		varying vec2 vUv;
-
-		void main() {
-
-			vUv = uv;
-			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
-
-		}`,
-		fragmentShader: /* glsl */`
-
-		#include <common>
-
-		#define ITERATIONS 10.0
-
-		uniform sampler2D texture;
-		uniform vec2 delta;
-
-		varying vec2 vUv;
-
-		void main() {
-
-			vec4 color = vec4( 0.0 );
-
-			float total = 0.0;
-
-		// randomize the lookup values to hide the fixed number of samples
-
-			float offset = rand( vUv );
-
-			for ( float t = -ITERATIONS; t <= ITERATIONS; t ++ ) {
-
-				float percent = ( t + offset - 0.5 ) / ITERATIONS;
-				float weight = 1.0 - abs( percent );
-
-				color += texture2D( texture, vUv + delta * percent ) * weight;
-				total += weight;
-
-			}
-
-			gl_FragColor = color / total;
-
-		}`
-	};
-
-	THREE.TriangleBlurShader = TriangleBlurShader;
-
-} )();

package/examples/js/shaders/UnpackDepthRGBAShader.js

@@ -1,47 +0,0 @@
-( function () {
-
-	/**
- * Unpack RGBA depth shader
- * - show RGBA encoded depth as monochrome color
- */
-
-	const UnpackDepthRGBAShader = {
-		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;
-
-		#include <packing>
-
-		void main() {
-
-			float depth = 1.0 - unpackRGBAToDepth( texture2D( tDiffuse, vUv ) );
-			gl_FragColor = vec4( vec3( depth ), opacity );
-
-		}`
-	};
-
-	THREE.UnpackDepthRGBAShader = UnpackDepthRGBAShader;
-
-} )();