super-three 0.147.1 → 0.152.0

package/examples/js/shaders/GodRaysShader.js

@@ -1,284 +0,0 @@
-( function () {
-
-	/**
- * God-rays (crepuscular rays)
- *
- * Similar implementation to the one used by Crytek for CryEngine 2 [Sousa2008].
- * Blurs a mask generated from the depth map along radial lines emanating from the light
- * source. The blur repeatedly applies a blur filter of increasing support but constant
- * sample count to produce a blur filter with large support.
- *
- * My implementation performs 3 passes, similar to the implementation from Sousa. I found
- * just 6 samples per pass produced acceptible results. The blur is applied three times,
- * with decreasing filter support. The result is equivalent to a single pass with
- * 6*6*6 = 216 samples.
- *
- * References:
- *
- * Sousa2008 - Crysis Next Gen Effects, GDC2008, http://www.crytek.com/sites/default/files/GDC08_SousaT_CrysisEffects.ppt
- */
-
-	const GodRaysDepthMaskShader = {
-		uniforms: {
-			tInput: {
-				value: null
-			}
-		},
-		vertexShader: /* glsl */`
-
-		varying vec2 vUv;
-
-		void main() {
-
-		 vUv = uv;
-		 gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
-
-	 }`,
-		fragmentShader: /* glsl */`
-
-		varying vec2 vUv;
-
-		uniform sampler2D tInput;
-
-		void main() {
-
-			gl_FragColor = vec4( 1.0 ) - texture2D( tInput, vUv );
-
-		}`
-	};
-
-	/**
- * The god-ray generation shader.
- *
- * First pass:
- *
- * The depth map is blurred along radial lines towards the "sun". The
- * output is written to a temporary render target (I used a 1/4 sized
- * target).
- *
- * Pass two & three:
- *
- * The results of the previous pass are re-blurred, each time with a
- * decreased distance between samples.
- */
-
-	const GodRaysGenerateShader = {
-		uniforms: {
-			tInput: {
-				value: null
-			},
-			fStepSize: {
-				value: 1.0
-			},
-			vSunPositionScreenSpace: {
-				value: new THREE.Vector3()
-			}
-		},
-		vertexShader: /* glsl */`
-
-		varying vec2 vUv;
-
-		void main() {
-
-		 vUv = uv;
-		 gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
-
-	 }`,
-		fragmentShader: /* glsl */`
-
-		#define TAPS_PER_PASS 6.0
-
-		varying vec2 vUv;
-
-		uniform sampler2D tInput;
-
-		uniform vec3 vSunPositionScreenSpace;
-		uniform float fStepSize; // filter step size
-
-		void main() {
-
-		// delta from current pixel to "sun" position
-
-			vec2 delta = vSunPositionScreenSpace.xy - vUv;
-			float dist = length( delta );
-
-		// Step vector (uv space)
-
-			vec2 stepv = fStepSize * delta / dist;
-
-		// Number of iterations between pixel and sun
-
-			float iters = dist/fStepSize;
-
-			vec2 uv = vUv.xy;
-			float col = 0.0;
-
-		// This breaks ANGLE in Chrome 22
-		//	- see http://code.google.com/p/chromium/issues/detail?id=153105
-
-		/*
-		// Unrolling didnt do much on my hardware (ATI Mobility Radeon 3450),
-		// so i've just left the loop
-
-		"for ( float i = 0.0; i < TAPS_PER_PASS; i += 1.0 ) {",
-
-		// Accumulate samples, making sure we dont walk past the light source.
-
-		// The check for uv.y < 1 would not be necessary with "border" UV wrap
-		// mode, with a black border color. I don't think this is currently
-		// exposed by three.js. As a result there might be artifacts when the
-		// sun is to the left, right or bottom of screen as these cases are
-		// not specifically handled.
-
-		"	col += ( i <= iters && uv.y < 1.0 ? texture2D( tInput, uv ).r : 0.0 );",
-		"	uv += stepv;",
-
-		"}",
-		*/
-
-		// Unrolling loop manually makes it work in ANGLE
-
-			float f = min( 1.0, max( vSunPositionScreenSpace.z / 1000.0, 0.0 ) ); // used to fade out godrays
-
-			if ( 0.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r * f;
-			uv += stepv;
-
-			if ( 1.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r * f;
-			uv += stepv;
-
-			if ( 2.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r * f;
-			uv += stepv;
-
-			if ( 3.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r * f;
-			uv += stepv;
-
-			if ( 4.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r * f;
-			uv += stepv;
-
-			if ( 5.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r * f;
-			uv += stepv;
-
-		// Should technically be dividing by 'iters but 'TAPS_PER_PASS' smooths out
-		// objectionable artifacts, in particular near the sun position. The side
-		// effect is that the result is darker than it should be around the sun, as
-		// TAPS_PER_PASS is greater than the number of samples actually accumulated.
-		// When the result is inverted (in the shader 'godrays_combine this produces
-		// a slight bright spot at the position of the sun, even when it is occluded.
-
-			gl_FragColor = vec4( col/TAPS_PER_PASS );
-			gl_FragColor.a = 1.0;
-
-		}`
-	};
-
-	/**
- * Additively applies god rays from texture tGodRays to a background (tColors).
- * fGodRayIntensity attenuates the god rays.
- */
-
-	const GodRaysCombineShader = {
-		uniforms: {
-			tColors: {
-				value: null
-			},
-			tGodRays: {
-				value: null
-			},
-			fGodRayIntensity: {
-				value: 0.69
-			}
-		},
-		vertexShader: /* glsl */`
-
-		varying vec2 vUv;
-
-		void main() {
-
-			vUv = uv;
-			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
-
-		}`,
-		fragmentShader: /* glsl */`
-
-		varying vec2 vUv;
-
-		uniform sampler2D tColors;
-		uniform sampler2D tGodRays;
-
-		uniform float fGodRayIntensity;
-
-		void main() {
-
-		// Since THREE.MeshDepthMaterial renders foreground objects white and background
-		// objects black, the god-rays will be white streaks. Therefore value is inverted
-		// before being combined with tColors
-
-			gl_FragColor = texture2D( tColors, vUv ) + fGodRayIntensity * vec4( 1.0 - texture2D( tGodRays, vUv ).r );
-			gl_FragColor.a = 1.0;
-
-		}`
-	};
-
-	/**
- * A dodgy sun/sky shader. Makes a bright spot at the sun location. Would be
- * cheaper/faster/simpler to implement this as a simple sun sprite.
- */
-
-	const GodRaysFakeSunShader = {
-		uniforms: {
-			vSunPositionScreenSpace: {
-				value: new THREE.Vector3()
-			},
-			fAspect: {
-				value: 1.0
-			},
-			sunColor: {
-				value: new THREE.Color( 0xffee00 )
-			},
-			bgColor: {
-				value: new THREE.Color( 0x000000 )
-			}
-		},
-		vertexShader: /* glsl */`
-
-		varying vec2 vUv;
-
-		void main() {
-
-			vUv = uv;
-			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
-
-		}`,
-		fragmentShader: /* glsl */`
-
-		varying vec2 vUv;
-
-		uniform vec3 vSunPositionScreenSpace;
-		uniform float fAspect;
-
-		uniform vec3 sunColor;
-		uniform vec3 bgColor;
-
-		void main() {
-
-			vec2 diff = vUv - vSunPositionScreenSpace.xy;
-
-		// Correct for aspect ratio
-
-			diff.x *= fAspect;
-
-			float prop = clamp( length( diff ) / 0.5, 0.0, 1.0 );
-			prop = 0.35 * pow( 1.0 - prop, 3.0 );
-
-			gl_FragColor.xyz = ( vSunPositionScreenSpace.z > 0.0 ) ? mix( sunColor, bgColor, 1.0 - prop ) : bgColor;
-			gl_FragColor.w = 1.0;
-
-		}`
-	};
-
-	THREE.GodRaysCombineShader = GodRaysCombineShader;
-	THREE.GodRaysDepthMaskShader = GodRaysDepthMaskShader;
-	THREE.GodRaysFakeSunShader = GodRaysFakeSunShader;
-	THREE.GodRaysGenerateShader = GodRaysGenerateShader;
-
-} )();

package/examples/js/shaders/HalftoneShader.js

@@ -1,336 +0,0 @@
-( function () {
-
-	/**
- * RGB Halftone shader for three.js.
- *	NOTE:
- * 		Shape (1 = Dot, 2 = Ellipse, 3 = Line, 4 = Square)
- *		Blending Mode (1 = Linear, 2 = Multiply, 3 = Add, 4 = Lighter, 5 = Darker)
- */
-
-	const HalftoneShader = {
-		uniforms: {
-			'tDiffuse': {
-				value: null
-			},
-			'shape': {
-				value: 1
-			},
-			'radius': {
-				value: 4
-			},
-			'rotateR': {
-				value: Math.PI / 12 * 1
-			},
-			'rotateG': {
-				value: Math.PI / 12 * 2
-			},
-			'rotateB': {
-				value: Math.PI / 12 * 3
-			},
-			'scatter': {
-				value: 0
-			},
-			'width': {
-				value: 1
-			},
-			'height': {
-				value: 1
-			},
-			'blending': {
-				value: 1
-			},
-			'blendingMode': {
-				value: 1
-			},
-			'greyscale': {
-				value: false
-			},
-			'disable': {
-				value: false
-			}
-		},
-		vertexShader: /* glsl */`
-
-		varying vec2 vUV;
-
-		void main() {
-
-			vUV = uv;
-			gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
-
-		}`,
-		fragmentShader: /* glsl */`
-
-		#define SQRT2_MINUS_ONE 0.41421356
-		#define SQRT2_HALF_MINUS_ONE 0.20710678
-		#define PI2 6.28318531
-		#define SHAPE_DOT 1
-		#define SHAPE_ELLIPSE 2
-		#define SHAPE_LINE 3
-		#define SHAPE_SQUARE 4
-		#define BLENDING_LINEAR 1
-		#define BLENDING_MULTIPLY 2
-		#define BLENDING_ADD 3
-		#define BLENDING_LIGHTER 4
-		#define BLENDING_DARKER 5
-		uniform sampler2D tDiffuse;
-		uniform float radius;
-		uniform float rotateR;
-		uniform float rotateG;
-		uniform float rotateB;
-		uniform float scatter;
-		uniform float width;
-		uniform float height;
-		uniform int shape;
-		uniform bool disable;
-		uniform float blending;
-		uniform int blendingMode;
-		varying vec2 vUV;
-		uniform bool greyscale;
-		const int samples = 8;
-
-		float blend( float a, float b, float t ) {
-
-		// linear blend
-			return a * ( 1.0 - t ) + b * t;
-
-		}
-
-		float hypot( float x, float y ) {
-
-		// vector magnitude
-			return sqrt( x * x + y * y );
-
-		}
-
-		float rand( vec2 seed ){
-
-		// get pseudo-random number
-			return fract( sin( dot( seed.xy, vec2( 12.9898, 78.233 ) ) ) * 43758.5453 );
-
-		}
-
-		float distanceToDotRadius( float channel, vec2 coord, vec2 normal, vec2 p, float angle, float rad_max ) {
-
-		// apply shape-specific transforms
-			float dist = hypot( coord.x - p.x, coord.y - p.y );
-			float rad = channel;
-
-			if ( shape == SHAPE_DOT ) {
-
-				rad = pow( abs( rad ), 1.125 ) * rad_max;
-
-			} else if ( shape == SHAPE_ELLIPSE ) {
-
-				rad = pow( abs( rad ), 1.125 ) * rad_max;
-
-				if ( dist != 0.0 ) {
-					float dot_p = abs( ( p.x - coord.x ) / dist * normal.x + ( p.y - coord.y ) / dist * normal.y );
-					dist = ( dist * ( 1.0 - SQRT2_HALF_MINUS_ONE ) ) + dot_p * dist * SQRT2_MINUS_ONE;
-				}
-
-			} else if ( shape == SHAPE_LINE ) {
-
-				rad = pow( abs( rad ), 1.5) * rad_max;
-				float dot_p = ( p.x - coord.x ) * normal.x + ( p.y - coord.y ) * normal.y;
-				dist = hypot( normal.x * dot_p, normal.y * dot_p );
-
-			} else if ( shape == SHAPE_SQUARE ) {
-
-				float theta = atan( p.y - coord.y, p.x - coord.x ) - angle;
-				float sin_t = abs( sin( theta ) );
-				float cos_t = abs( cos( theta ) );
-				rad = pow( abs( rad ), 1.4 );
-				rad = rad_max * ( rad + ( ( sin_t > cos_t ) ? rad - sin_t * rad : rad - cos_t * rad ) );
-
-			}
-
-			return rad - dist;
-
-		}
-
-		struct Cell {
-
-		// grid sample positions
-			vec2 normal;
-			vec2 p1;
-			vec2 p2;
-			vec2 p3;
-			vec2 p4;
-			float samp2;
-			float samp1;
-			float samp3;
-			float samp4;
-
-		};
-
-		vec4 getSample( vec2 point ) {
-
-		// multi-sampled point
-			vec4 tex = texture2D( tDiffuse, vec2( point.x / width, point.y / height ) );
-			float base = rand( vec2( floor( point.x ), floor( point.y ) ) ) * PI2;
-			float step = PI2 / float( samples );
-			float dist = radius * 0.66;
-
-			for ( int i = 0; i < samples; ++i ) {
-
-				float r = base + step * float( i );
-				vec2 coord = point + vec2( cos( r ) * dist, sin( r ) * dist );
-				tex += texture2D( tDiffuse, vec2( coord.x / width, coord.y / height ) );
-
-			}
-
-			tex /= float( samples ) + 1.0;
-			return tex;
-
-		}
-
-		float getDotColour( Cell c, vec2 p, int channel, float angle, float aa ) {
-
-		// get colour for given point
-			float dist_c_1, dist_c_2, dist_c_3, dist_c_4, res;
-
-			if ( channel == 0 ) {
-
-				c.samp1 = getSample( c.p1 ).r;
-				c.samp2 = getSample( c.p2 ).r;
-				c.samp3 = getSample( c.p3 ).r;
-				c.samp4 = getSample( c.p4 ).r;
-
-			} else if (channel == 1) {
-
-				c.samp1 = getSample( c.p1 ).g;
-				c.samp2 = getSample( c.p2 ).g;
-				c.samp3 = getSample( c.p3 ).g;
-				c.samp4 = getSample( c.p4 ).g;
-
-			} else {
-
-				c.samp1 = getSample( c.p1 ).b;
-				c.samp3 = getSample( c.p3 ).b;
-				c.samp2 = getSample( c.p2 ).b;
-				c.samp4 = getSample( c.p4 ).b;
-
-			}
-
-			dist_c_1 = distanceToDotRadius( c.samp1, c.p1, c.normal, p, angle, radius );
-			dist_c_2 = distanceToDotRadius( c.samp2, c.p2, c.normal, p, angle, radius );
-			dist_c_3 = distanceToDotRadius( c.samp3, c.p3, c.normal, p, angle, radius );
-			dist_c_4 = distanceToDotRadius( c.samp4, c.p4, c.normal, p, angle, radius );
-			res = ( dist_c_1 > 0.0 ) ? clamp( dist_c_1 / aa, 0.0, 1.0 ) : 0.0;
-			res += ( dist_c_2 > 0.0 ) ? clamp( dist_c_2 / aa, 0.0, 1.0 ) : 0.0;
-			res += ( dist_c_3 > 0.0 ) ? clamp( dist_c_3 / aa, 0.0, 1.0 ) : 0.0;
-			res += ( dist_c_4 > 0.0 ) ? clamp( dist_c_4 / aa, 0.0, 1.0 ) : 0.0;
-			res = clamp( res, 0.0, 1.0 );
-
-			return res;
-
-		}
-
-		Cell getReferenceCell( vec2 p, vec2 origin, float grid_angle, float step ) {
-
-		// get containing cell
-			Cell c;
-
-		// calc grid
-			vec2 n = vec2( cos( grid_angle ), sin( grid_angle ) );
-			float threshold = step * 0.5;
-			float dot_normal = n.x * ( p.x - origin.x ) + n.y * ( p.y - origin.y );
-			float dot_line = -n.y * ( p.x - origin.x ) + n.x * ( p.y - origin.y );
-			vec2 offset = vec2( n.x * dot_normal, n.y * dot_normal );
-			float offset_normal = mod( hypot( offset.x, offset.y ), step );
-			float normal_dir = ( dot_normal < 0.0 ) ? 1.0 : -1.0;
-			float normal_scale = ( ( offset_normal < threshold ) ? -offset_normal : step - offset_normal ) * normal_dir;
-			float offset_line = mod( hypot( ( p.x - offset.x ) - origin.x, ( p.y - offset.y ) - origin.y ), step );
-			float line_dir = ( dot_line < 0.0 ) ? 1.0 : -1.0;
-			float line_scale = ( ( offset_line < threshold ) ? -offset_line : step - offset_line ) * line_dir;
-
-		// get closest corner
-			c.normal = n;
-			c.p1.x = p.x - n.x * normal_scale + n.y * line_scale;
-			c.p1.y = p.y - n.y * normal_scale - n.x * line_scale;
-
-		// scatter
-			if ( scatter != 0.0 ) {
-
-				float off_mag = scatter * threshold * 0.5;
-				float off_angle = rand( vec2( floor( c.p1.x ), floor( c.p1.y ) ) ) * PI2;
-				c.p1.x += cos( off_angle ) * off_mag;
-				c.p1.y += sin( off_angle ) * off_mag;
-
-			}
-
-		// find corners
-			float normal_step = normal_dir * ( ( offset_normal < threshold ) ? step : -step );
-			float line_step = line_dir * ( ( offset_line < threshold ) ? step : -step );
-			c.p2.x = c.p1.x - n.x * normal_step;
-			c.p2.y = c.p1.y - n.y * normal_step;
-			c.p3.x = c.p1.x + n.y * line_step;
-			c.p3.y = c.p1.y - n.x * line_step;
-			c.p4.x = c.p1.x - n.x * normal_step + n.y * line_step;
-			c.p4.y = c.p1.y - n.y * normal_step - n.x * line_step;
-
-			return c;
-
-		}
-
-		float blendColour( float a, float b, float t ) {
-
-		// blend colours
-			if ( blendingMode == BLENDING_LINEAR ) {
-				return blend( a, b, 1.0 - t );
-			} else if ( blendingMode == BLENDING_ADD ) {
-				return blend( a, min( 1.0, a + b ), t );
-			} else if ( blendingMode == BLENDING_MULTIPLY ) {
-				return blend( a, max( 0.0, a * b ), t );
-			} else if ( blendingMode == BLENDING_LIGHTER ) {
-				return blend( a, max( a, b ), t );
-			} else if ( blendingMode == BLENDING_DARKER ) {
-				return blend( a, min( a, b ), t );
-			} else {
-				return blend( a, b, 1.0 - t );
-			}
-
-		}
-
-		void main() {
-
-			if ( ! disable ) {
-
-		// setup
-				vec2 p = vec2( vUV.x * width, vUV.y * height );
-				vec2 origin = vec2( 0, 0 );
-				float aa = ( radius < 2.5 ) ? radius * 0.5 : 1.25;
-
-		// get channel samples
-				Cell cell_r = getReferenceCell( p, origin, rotateR, radius );
-				Cell cell_g = getReferenceCell( p, origin, rotateG, radius );
-				Cell cell_b = getReferenceCell( p, origin, rotateB, radius );
-				float r = getDotColour( cell_r, p, 0, rotateR, aa );
-				float g = getDotColour( cell_g, p, 1, rotateG, aa );
-				float b = getDotColour( cell_b, p, 2, rotateB, aa );
-
-		// blend with original
-				vec4 colour = texture2D( tDiffuse, vUV );
-				r = blendColour( r, colour.r, blending );
-				g = blendColour( g, colour.g, blending );
-				b = blendColour( b, colour.b, blending );
-
-				if ( greyscale ) {
-					r = g = b = (r + b + g) / 3.0;
-				}
-
-				gl_FragColor = vec4( r, g, b, 1.0 );
-
-			} else {
-
-				gl_FragColor = texture2D( tDiffuse, vUV );
-
-			}
-
-		}`
-	};
-
-	THREE.HalftoneShader = HalftoneShader;
-
-} )();

package/examples/js/shaders/HorizontalBlurShader.js

@@ -1,59 +0,0 @@
-( function () {
-
-	/**
- * Two pass Gaussian blur filter (horizontal and vertical blur shaders)
- * - see http://www.cake23.de/traveling-wavefronts-lit-up.html
- *
- * - 9 samples per pass
- * - standard deviation 2.7
- * - "h" and "v" parameters should be set to "1 / width" and "1 / height"
- */
-
-	const HorizontalBlurShader = {
-		uniforms: {
-			'tDiffuse': {
-				value: null
-			},
-			'h': {
-				value: 1.0 / 512.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 h;
-
-		varying vec2 vUv;
-
-		void main() {
-
-			vec4 sum = vec4( 0.0 );
-
-			sum += texture2D( tDiffuse, vec2( vUv.x - 4.0 * h, vUv.y ) ) * 0.051;
-			sum += texture2D( tDiffuse, vec2( vUv.x - 3.0 * h, vUv.y ) ) * 0.0918;
-			sum += texture2D( tDiffuse, vec2( vUv.x - 2.0 * h, vUv.y ) ) * 0.12245;
-			sum += texture2D( tDiffuse, vec2( vUv.x - 1.0 * h, vUv.y ) ) * 0.1531;
-			sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y ) ) * 0.1633;
-			sum += texture2D( tDiffuse, vec2( vUv.x + 1.0 * h, vUv.y ) ) * 0.1531;
-			sum += texture2D( tDiffuse, vec2( vUv.x + 2.0 * h, vUv.y ) ) * 0.12245;
-			sum += texture2D( tDiffuse, vec2( vUv.x + 3.0 * h, vUv.y ) ) * 0.0918;
-			sum += texture2D( tDiffuse, vec2( vUv.x + 4.0 * h, vUv.y ) ) * 0.051;
-
-			gl_FragColor = sum;
-
-		}`
-	};
-
-	THREE.HorizontalBlurShader = HorizontalBlurShader;
-
-} )();