three-stdlib 2.22.5 → 2.22.7

package/shaders/HalftoneShader.js

@@ -1,69 +0,0 @@
-/**
- * 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: ['varying vec2 vUV;', 'void main() {', '	vUV = uv;', '	gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);', '}'].join('\n'),
-  fragmentShader: ['#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 );', '	}', '}'].join('\n')
-};
-
-export { HalftoneShader };

package/shaders/HorizontalBlurShader.cjs.js

@@ -1 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const e={uniforms:{tDiffuse:{value:null},h:{value:1/512}},vertexShader:"\n      varying vec2 vUv;\n\n      void main() {\n\n        vUv = uv;\n        gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n\n      }\n  ",fragmentShader:"\n    uniform sampler2D tDiffuse;\n    uniform float h;\n\n    varying vec2 vUv;\n\n    void main() {\n\n    \tvec4 sum = vec4( 0.0 );\n\n    \tsum += texture2D( tDiffuse, vec2( vUv.x - 4.0 * h, vUv.y ) ) * 0.051;\n    \tsum += texture2D( tDiffuse, vec2( vUv.x - 3.0 * h, vUv.y ) ) * 0.0918;\n    \tsum += texture2D( tDiffuse, vec2( vUv.x - 2.0 * h, vUv.y ) ) * 0.12245;\n    \tsum += texture2D( tDiffuse, vec2( vUv.x - 1.0 * h, vUv.y ) ) * 0.1531;\n    \tsum += texture2D( tDiffuse, vec2( vUv.x, vUv.y ) ) * 0.1633;\n    \tsum += texture2D( tDiffuse, vec2( vUv.x + 1.0 * h, vUv.y ) ) * 0.1531;\n    \tsum += texture2D( tDiffuse, vec2( vUv.x + 2.0 * h, vUv.y ) ) * 0.12245;\n    \tsum += texture2D( tDiffuse, vec2( vUv.x + 3.0 * h, vUv.y ) ) * 0.0918;\n    \tsum += texture2D( tDiffuse, vec2( vUv.x + 4.0 * h, vUv.y ) ) * 0.051;\n\n    \tgl_FragColor = sum;\n\n    }\n  "};exports.HorizontalBlurShader=e;

package/shaders/HorizontalBlurShader.d.ts

@@ -1,9 +0,0 @@
-import type { IUniform, Texture } from 'three';
-import type { IShader } from './types';
-export declare type HorizontalBlurShaderUniforms = {
-    tDiffuse: IUniform<Texture | null>;
-    h: IUniform<number>;
-};
-export interface IHorizontalBlurShader extends IShader<HorizontalBlurShaderUniforms> {
-}
-export declare const HorizontalBlurShader: IHorizontalBlurShader;

package/shaders/HorizontalBlurShader.js

@@ -1,59 +0,0 @@
-/**
- * Two pass Gaussian blur filter (horizontal and vertical blur shaders)
- * - described in http://www.gamerendering.com/2008/10/11/gaussian-blur-filter-shader/
- *   and used in 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;
-
-    }
-  `
-};
-
-export { HorizontalBlurShader };

package/shaders/HorizontalTiltShiftShader.cjs.js

@@ -1 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const v={uniforms:{tDiffuse:{value:null},h:{value:1/512},r:{value:.35}},vertexShader:["varying vec2 vUv;","void main() {","\tvUv = uv;","\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );","}"].join("\n"),fragmentShader:["uniform sampler2D tDiffuse;","uniform float h;","uniform float r;","varying vec2 vUv;","void main() {","\tvec4 sum = vec4( 0.0 );","\tfloat hh = h * abs( r - vUv.y );","\tsum += texture2D( tDiffuse, vec2( vUv.x - 4.0 * hh, vUv.y ) ) * 0.051;","\tsum += texture2D( tDiffuse, vec2( vUv.x - 3.0 * hh, vUv.y ) ) * 0.0918;","\tsum += texture2D( tDiffuse, vec2( vUv.x - 2.0 * hh, vUv.y ) ) * 0.12245;","\tsum += texture2D( tDiffuse, vec2( vUv.x - 1.0 * hh, vUv.y ) ) * 0.1531;","\tsum += texture2D( tDiffuse, vec2( vUv.x, vUv.y ) ) * 0.1633;","\tsum += texture2D( tDiffuse, vec2( vUv.x + 1.0 * hh, vUv.y ) ) * 0.1531;","\tsum += texture2D( tDiffuse, vec2( vUv.x + 2.0 * hh, vUv.y ) ) * 0.12245;","\tsum += texture2D( tDiffuse, vec2( vUv.x + 3.0 * hh, vUv.y ) ) * 0.0918;","\tsum += texture2D( tDiffuse, vec2( vUv.x + 4.0 * hh, vUv.y ) ) * 0.051;","\tgl_FragColor = sum;","}"].join("\n")};exports.HorizontalTiltShiftShader=v;

package/shaders/HorizontalTiltShiftShader.d.ts

@@ -1,15 +0,0 @@
-export declare const HorizontalTiltShiftShader: {
-    uniforms: {
-        tDiffuse: {
-            value: null;
-        };
-        h: {
-            value: number;
-        };
-        r: {
-            value: number;
-        };
-    };
-    vertexShader: string;
-    fragmentShader: string;
-};

package/shaders/HorizontalTiltShiftShader.js

@@ -1,25 +0,0 @@
-/**
- * Simple fake tilt-shift effect, modulating two pass Gaussian blur (see above) by vertical position
- *
- * - 9 samples per pass
- * - standard deviation 2.7
- * - "h" and "v" parameters should be set to "1 / width" and "1 / height"
- * - "r" parameter control where "focused" horizontal line lies
- */
-const HorizontalTiltShiftShader = {
-  uniforms: {
-    tDiffuse: {
-      value: null
-    },
-    h: {
-      value: 1.0 / 512.0
-    },
-    r: {
-      value: 0.35
-    }
-  },
-  vertexShader: ['varying vec2 vUv;', 'void main() {', '	vUv = uv;', '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );', '}'].join('\n'),
-  fragmentShader: ['uniform sampler2D tDiffuse;', 'uniform float h;', 'uniform float r;', 'varying vec2 vUv;', 'void main() {', '	vec4 sum = vec4( 0.0 );', '	float hh = h * abs( r - vUv.y );', '	sum += texture2D( tDiffuse, vec2( vUv.x - 4.0 * hh, vUv.y ) ) * 0.051;', '	sum += texture2D( tDiffuse, vec2( vUv.x - 3.0 * hh, vUv.y ) ) * 0.0918;', '	sum += texture2D( tDiffuse, vec2( vUv.x - 2.0 * hh, vUv.y ) ) * 0.12245;', '	sum += texture2D( tDiffuse, vec2( vUv.x - 1.0 * hh, vUv.y ) ) * 0.1531;', '	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y ) ) * 0.1633;', '	sum += texture2D( tDiffuse, vec2( vUv.x + 1.0 * hh, vUv.y ) ) * 0.1531;', '	sum += texture2D( tDiffuse, vec2( vUv.x + 2.0 * hh, vUv.y ) ) * 0.12245;', '	sum += texture2D( tDiffuse, vec2( vUv.x + 3.0 * hh, vUv.y ) ) * 0.0918;', '	sum += texture2D( tDiffuse, vec2( vUv.x + 4.0 * hh, vUv.y ) ) * 0.051;', '	gl_FragColor = sum;', '}'].join('\n')
-};
-
-export { HorizontalTiltShiftShader };

package/shaders/HueSaturationShader.cjs.js

@@ -1 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const t={uniforms:{tDiffuse:{value:null},hue:{value:0},saturation:{value:0}},vertexShader:["varying vec2 vUv;","void main() {","\tvUv = uv;","\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );","}"].join("\n"),fragmentShader:["uniform sampler2D tDiffuse;","uniform float hue;","uniform float saturation;","varying vec2 vUv;","void main() {","\tgl_FragColor = texture2D( tDiffuse, vUv );","\tfloat angle = hue * 3.14159265;","\tfloat s = sin(angle), c = cos(angle);","\tvec3 weights = (vec3(2.0 * c, -sqrt(3.0) * s - c, sqrt(3.0) * s - c) + 1.0) / 3.0;","\tfloat len = length(gl_FragColor.rgb);","\tgl_FragColor.rgb = vec3(","\t\tdot(gl_FragColor.rgb, weights.xyz),","\t\tdot(gl_FragColor.rgb, weights.zxy),","\t\tdot(gl_FragColor.rgb, weights.yzx)","\t);","\tfloat average = (gl_FragColor.r + gl_FragColor.g + gl_FragColor.b) / 3.0;","\tif (saturation > 0.0) {","\t\tgl_FragColor.rgb += (average - gl_FragColor.rgb) * (1.0 - 1.0 / (1.001 - saturation));","\t} else {","\t\tgl_FragColor.rgb += (average - gl_FragColor.rgb) * (-saturation);","\t}","}"].join("\n")};exports.HueSaturationShader=t;

package/shaders/HueSaturationShader.d.ts

@@ -1,15 +0,0 @@
-export declare const HueSaturationShader: {
-    uniforms: {
-        tDiffuse: {
-            value: null;
-        };
-        hue: {
-            value: number;
-        };
-        saturation: {
-            value: number;
-        };
-    };
-    vertexShader: string;
-    fragmentShader: string;
-};

package/shaders/HueSaturationShader.js

@@ -1,25 +0,0 @@
-/**
- * Hue and saturation adjustment
- * https://github.com/evanw/glfx.js
- * hue: -1 to 1 (-1 is 180 degrees in the negative direction, 0 is no change, etc.
- * saturation: -1 to 1 (-1 is solid gray, 0 is no change, and 1 is maximum contrast)
- */
-const HueSaturationShader = {
-  uniforms: {
-    tDiffuse: {
-      value: null
-    },
-    hue: {
-      value: 0
-    },
-    saturation: {
-      value: 0
-    }
-  },
-  vertexShader: ['varying vec2 vUv;', 'void main() {', '	vUv = uv;', '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );', '}'].join('\n'),
-  fragmentShader: ['uniform sampler2D tDiffuse;', 'uniform float hue;', 'uniform float saturation;', 'varying vec2 vUv;', 'void main() {', '	gl_FragColor = texture2D( tDiffuse, vUv );', // hue
-  '	float angle = hue * 3.14159265;', '	float s = sin(angle), c = cos(angle);', '	vec3 weights = (vec3(2.0 * c, -sqrt(3.0) * s - c, sqrt(3.0) * s - c) + 1.0) / 3.0;', '	float len = length(gl_FragColor.rgb);', '	gl_FragColor.rgb = vec3(', '		dot(gl_FragColor.rgb, weights.xyz),', '		dot(gl_FragColor.rgb, weights.zxy),', '		dot(gl_FragColor.rgb, weights.yzx)', '	);', // saturation
-  '	float average = (gl_FragColor.r + gl_FragColor.g + gl_FragColor.b) / 3.0;', '	if (saturation > 0.0) {', '		gl_FragColor.rgb += (average - gl_FragColor.rgb) * (1.0 - 1.0 / (1.001 - saturation));', '	} else {', '		gl_FragColor.rgb += (average - gl_FragColor.rgb) * (-saturation);', '	}', '}'].join('\n')
-};
-
-export { HueSaturationShader };

package/shaders/KaleidoShader.cjs.js

@@ -1 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const e={uniforms:{tDiffuse:{value:null},sides:{value:6},angle:{value:0}},vertexShader:["varying vec2 vUv;","void main() {","\tvUv = uv;","\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );","}"].join("\n"),fragmentShader:["uniform sampler2D tDiffuse;","uniform float sides;","uniform float angle;","varying vec2 vUv;","void main() {","\tvec2 p = vUv - 0.5;","\tfloat r = length(p);","\tfloat a = atan(p.y, p.x) + angle;","\tfloat tau = 2. * 3.1416 ;","\ta = mod(a, tau/sides);","\ta = abs(a - tau/sides/2.) ;","\tp = r * vec2(cos(a), sin(a));","\tvec4 color = texture2D(tDiffuse, p + 0.5);","\tgl_FragColor = color;","}"].join("\n")};exports.KaleidoShader=e;

package/shaders/KaleidoShader.d.ts

@@ -1,15 +0,0 @@
-export declare const KaleidoShader: {
-    uniforms: {
-        tDiffuse: {
-            value: null;
-        };
-        sides: {
-            value: number;
-        };
-        angle: {
-            value: number;
-        };
-    };
-    vertexShader: string;
-    fragmentShader: string;
-};

package/shaders/KaleidoShader.js

@@ -1,26 +0,0 @@
-/**
- * Kaleidoscope Shader
- * Radial reflection around center point
- * Ported from: http://pixelshaders.com/editor/
- * by Toby Schachman / http://tobyschachman.com/
- *
- * sides: number of reflections
- * angle: initial angle in radians
- */
-const KaleidoShader = {
-  uniforms: {
-    tDiffuse: {
-      value: null
-    },
-    sides: {
-      value: 6.0
-    },
-    angle: {
-      value: 0.0
-    }
-  },
-  vertexShader: ['varying vec2 vUv;', 'void main() {', '	vUv = uv;', '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );', '}'].join('\n'),
-  fragmentShader: ['uniform sampler2D tDiffuse;', 'uniform float sides;', 'uniform float angle;', 'varying vec2 vUv;', 'void main() {', '	vec2 p = vUv - 0.5;', '	float r = length(p);', '	float a = atan(p.y, p.x) + angle;', '	float tau = 2. * 3.1416 ;', '	a = mod(a, tau/sides);', '	a = abs(a - tau/sides/2.) ;', '	p = r * vec2(cos(a), sin(a));', '	vec4 color = texture2D(tDiffuse, p + 0.5);', '	gl_FragColor = color;', '}'].join('\n')
-};
-
-export { KaleidoShader };

package/shaders/LuminosityHighPassShader.cjs.js

@@ -1 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const t={shaderID:"luminosityHighPass",uniforms:{tDiffuse:{value:null},luminosityThreshold:{value:1},smoothWidth:{value:1},defaultColor:{value:new(require("three").Color)(0)},defaultOpacity:{value:0}},vertexShader:["varying vec2 vUv;","void main() {","\tvUv = uv;","\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );","}"].join("\n"),fragmentShader:["uniform sampler2D tDiffuse;","uniform vec3 defaultColor;","uniform float defaultOpacity;","uniform float luminosityThreshold;","uniform float smoothWidth;","varying vec2 vUv;","void main() {","\tvec4 texel = texture2D( tDiffuse, vUv );","\tvec3 luma = vec3( 0.299, 0.587, 0.114 );","\tfloat v = dot( texel.xyz, luma );","\tvec4 outputColor = vec4( defaultColor.rgb, defaultOpacity );","\tfloat alpha = smoothstep( luminosityThreshold, luminosityThreshold + smoothWidth, v );","\tgl_FragColor = mix( outputColor, texel, alpha );","}"].join("\n")};exports.LuminosityHighPassShader=t;

package/shaders/LuminosityHighPassShader.d.ts

@@ -1,23 +0,0 @@
-import { Color } from 'three';
-export declare const LuminosityHighPassShader: {
-    shaderID: string;
-    uniforms: {
-        tDiffuse: {
-            value: null;
-        };
-        luminosityThreshold: {
-            value: number;
-        };
-        smoothWidth: {
-            value: number;
-        };
-        defaultColor: {
-            value: Color;
-        };
-        defaultOpacity: {
-            value: number;
-        };
-    };
-    vertexShader: string;
-    fragmentShader: string;
-};

package/shaders/LuminosityHighPassShader.js

@@ -1,31 +0,0 @@
-import { Color } from 'three';
-
-/**
- * Luminosity
- * http://en.wikipedia.org/wiki/Luminosity
- */
-
-const LuminosityHighPassShader = {
-  shaderID: 'luminosityHighPass',
-  uniforms: {
-    tDiffuse: {
-      value: null
-    },
-    luminosityThreshold: {
-      value: 1.0
-    },
-    smoothWidth: {
-      value: 1.0
-    },
-    defaultColor: {
-      value: new Color(0x000000)
-    },
-    defaultOpacity: {
-      value: 0.0
-    }
-  },
-  vertexShader: ['varying vec2 vUv;', 'void main() {', '	vUv = uv;', '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );', '}'].join('\n'),
-  fragmentShader: ['uniform sampler2D tDiffuse;', 'uniform vec3 defaultColor;', 'uniform float defaultOpacity;', 'uniform float luminosityThreshold;', 'uniform float smoothWidth;', '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 );', '	vec4 outputColor = vec4( defaultColor.rgb, defaultOpacity );', '	float alpha = smoothstep( luminosityThreshold, luminosityThreshold + smoothWidth, v );', '	gl_FragColor = mix( outputColor, texel, alpha );', '}'].join('\n')
-};
-
-export { LuminosityHighPassShader };

package/shaders/LuminosityShader.cjs.js

@@ -1 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const e={uniforms:{tDiffuse:{value:null}},vertexShader:["varying vec2 vUv;","void main() {","\tvUv = uv;","\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );","}"].join("\n"),fragmentShader:["#include <common>","uniform sampler2D tDiffuse;","varying vec2 vUv;","void main() {","\tvec4 texel = texture2D( tDiffuse, vUv );","\tfloat l = linearToRelativeLuminance( texel.rgb );","\tgl_FragColor = vec4( l, l, l, texel.w );","}"].join("\n")};exports.LuminosityShader=e;

package/shaders/LuminosityShader.d.ts

@@ -1,9 +0,0 @@
-export declare const LuminosityShader: {
-    uniforms: {
-        tDiffuse: {
-            value: null;
-        };
-    };
-    vertexShader: string;
-    fragmentShader: string;
-};

package/shaders/LuminosityShader.js

@@ -1,15 +0,0 @@
-/**
- * Luminosity
- * http://en.wikipedia.org/wiki/Luminosity
- */
-const LuminosityShader = {
-  uniforms: {
-    tDiffuse: {
-      value: null
-    }
-  },
-  vertexShader: ['varying vec2 vUv;', 'void main() {', '	vUv = uv;', '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );', '}'].join('\n'),
-  fragmentShader: ['#include <common>', 'uniform sampler2D tDiffuse;', 'varying vec2 vUv;', 'void main() {', '	vec4 texel = texture2D( tDiffuse, vUv );', '	float l = linearToRelativeLuminance( texel.rgb );', '	gl_FragColor = vec4( l, l, l, texel.w );', '}'].join('\n')
-};
-
-export { LuminosityShader };

package/shaders/MirrorShader.cjs.js

@@ -1 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const e={uniforms:{tDiffuse:{value:null},side:{value:1}},vertexShader:["varying vec2 vUv;","void main() {","\tvUv = uv;","\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );","}"].join("\n"),fragmentShader:["uniform sampler2D tDiffuse;","uniform int side;","varying vec2 vUv;","void main() {","\tvec2 p = vUv;","\tif (side == 0){","\t\tif (p.x > 0.5) p.x = 1.0 - p.x;","\t}else if (side == 1){","\t\tif (p.x < 0.5) p.x = 1.0 - p.x;","\t}else if (side == 2){","\t\tif (p.y < 0.5) p.y = 1.0 - p.y;","\t}else if (side == 3){","\t\tif (p.y > 0.5) p.y = 1.0 - p.y;","\t} ","\tvec4 color = texture2D(tDiffuse, p);","\tgl_FragColor = color;","}"].join("\n")};exports.MirrorShader=e;

package/shaders/MirrorShader.d.ts

@@ -1,12 +0,0 @@
-export declare const MirrorShader: {
-    uniforms: {
-        tDiffuse: {
-            value: null;
-        };
-        side: {
-            value: number;
-        };
-    };
-    vertexShader: string;
-    fragmentShader: string;
-};

package/shaders/MirrorShader.js

@@ -1,20 +0,0 @@
-/**
- * Mirror Shader
- * Copies half the input to the other half
- *
- * side: side of input to mirror (0 = left, 1 = right, 2 = top, 3 = bottom)
- */
-const MirrorShader = {
-  uniforms: {
-    tDiffuse: {
-      value: null
-    },
-    side: {
-      value: 1
-    }
-  },
-  vertexShader: ['varying vec2 vUv;', 'void main() {', '	vUv = uv;', '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );', '}'].join('\n'),
-  fragmentShader: ['uniform sampler2D tDiffuse;', 'uniform int side;', 'varying vec2 vUv;', 'void main() {', '	vec2 p = vUv;', '	if (side == 0){', '		if (p.x > 0.5) p.x = 1.0 - p.x;', '	}else if (side == 1){', '		if (p.x < 0.5) p.x = 1.0 - p.x;', '	}else if (side == 2){', '		if (p.y < 0.5) p.y = 1.0 - p.y;', '	}else if (side == 3){', '		if (p.y > 0.5) p.y = 1.0 - p.y;', '	} ', '	vec4 color = texture2D(tDiffuse, p);', '	gl_FragColor = color;', '}'].join('\n')
-};
-
-export { MirrorShader };

package/shaders/NormalMapShader.cjs.js

@@ -1 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("three");const t={uniforms:{heightMap:{value:null},resolution:{value:new e.Vector2(512,512)},scale:{value:new e.Vector2(1,1)},height:{value:.05}},vertexShader:["varying vec2 vUv;","void main() {","\tvUv = uv;","\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );","}"].join("\n"),fragmentShader:["uniform float height;","uniform vec2 resolution;","uniform sampler2D heightMap;","varying vec2 vUv;","void main() {","\tfloat val = texture2D( heightMap, vUv ).x;","\tfloat valU = texture2D( heightMap, vUv + vec2( 1.0 / resolution.x, 0.0 ) ).x;","\tfloat valV = texture2D( heightMap, vUv + vec2( 0.0, 1.0 / resolution.y ) ).x;","\tgl_FragColor = vec4( ( 0.5 * normalize( vec3( val - valU, val - valV, height  ) ) + 0.5 ), 1.0 );","}"].join("\n")};exports.NormalMapShader=t;

package/shaders/NormalMapShader.d.ts

@@ -1,19 +0,0 @@
-import { Vector2 } from 'three';
-export declare const NormalMapShader: {
-    uniforms: {
-        heightMap: {
-            value: null;
-        };
-        resolution: {
-            value: Vector2;
-        };
-        scale: {
-            value: Vector2;
-        };
-        height: {
-            value: number;
-        };
-    };
-    vertexShader: string;
-    fragmentShader: string;
-};

package/shaders/NormalMapShader.js

@@ -1,27 +0,0 @@
-import { Vector2 } from 'three';
-
-/**
- * Normal map shader
- * - compute normals from heightmap
- */
-
-const NormalMapShader = {
-  uniforms: {
-    heightMap: {
-      value: null
-    },
-    resolution: {
-      value: new Vector2(512, 512)
-    },
-    scale: {
-      value: new Vector2(1, 1)
-    },
-    height: {
-      value: 0.05
-    }
-  },
-  vertexShader: ['varying vec2 vUv;', 'void main() {', '	vUv = uv;', '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );', '}'].join('\n'),
-  fragmentShader: ['uniform float height;', 'uniform vec2 resolution;', 'uniform sampler2D heightMap;', 'varying vec2 vUv;', 'void main() {', '	float val = texture2D( heightMap, vUv ).x;', '	float valU = texture2D( heightMap, vUv + vec2( 1.0 / resolution.x, 0.0 ) ).x;', '	float valV = texture2D( heightMap, vUv + vec2( 0.0, 1.0 / resolution.y ) ).x;', '	gl_FragColor = vec4( ( 0.5 * normalize( vec3( val - valU, val - valV, height  ) ) + 0.5 ), 1.0 );', '}'].join('\n')
-};
-
-export { NormalMapShader };

package/shaders/ParallaxShader.cjs.js

@@ -1 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const t={modes:{none:"NO_PARALLAX",basic:"USE_BASIC_PARALLAX",steep:"USE_STEEP_PARALLAX",occlusion:"USE_OCLUSION_PARALLAX",relief:"USE_RELIEF_PARALLAX"},uniforms:{bumpMap:{value:null},map:{value:null},parallaxScale:{value:null},parallaxMinLayers:{value:null},parallaxMaxLayers:{value:null}},vertexShader:["varying vec2 vUv;","varying vec3 vViewPosition;","varying vec3 vNormal;","void main() {","\tvUv = uv;","\tvec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );","\tvViewPosition = -mvPosition.xyz;","\tvNormal = normalize( normalMatrix * normal );","\tgl_Position = projectionMatrix * mvPosition;","}"].join("\n"),fragmentShader:["uniform sampler2D bumpMap;","uniform sampler2D map;","uniform float parallaxScale;","uniform float parallaxMinLayers;","uniform float parallaxMaxLayers;","varying vec2 vUv;","varying vec3 vViewPosition;","varying vec3 vNormal;","#ifdef USE_BASIC_PARALLAX","\tvec2 parallaxMap( in vec3 V ) {","\t\tfloat initialHeight = texture2D( bumpMap, vUv ).r;","\t\tvec2 texCoordOffset = parallaxScale * V.xy * initialHeight;","\t\treturn vUv - texCoordOffset;","\t}","#else","\tvec2 parallaxMap( in vec3 V ) {","\t\tfloat numLayers = mix( parallaxMaxLayers, parallaxMinLayers, abs( dot( vec3( 0.0, 0.0, 1.0 ), V ) ) );","\t\tfloat layerHeight = 1.0 / numLayers;","\t\tfloat currentLayerHeight = 0.0;","\t\tvec2 dtex = parallaxScale * V.xy / V.z / numLayers;","\t\tvec2 currentTextureCoords = vUv;","\t\tfloat heightFromTexture = texture2D( bumpMap, currentTextureCoords ).r;","\t\tfor ( int i = 0; i < 30; i += 1 ) {","\t\t\tif ( heightFromTexture <= currentLayerHeight ) {","\t\t\t\tbreak;","\t\t\t}","\t\t\tcurrentLayerHeight += layerHeight;","\t\t\tcurrentTextureCoords -= dtex;","\t\t\theightFromTexture = texture2D( bumpMap, currentTextureCoords ).r;","\t\t}","\t\t#ifdef USE_STEEP_PARALLAX","\t\t\treturn currentTextureCoords;","\t\t#elif defined( USE_RELIEF_PARALLAX )","\t\t\tvec2 deltaTexCoord = dtex / 2.0;","\t\t\tfloat deltaHeight = layerHeight / 2.0;","\t\t\tcurrentTextureCoords += deltaTexCoord;","\t\t\tcurrentLayerHeight -= deltaHeight;","\t\t\tconst int numSearches = 5;","\t\t\tfor ( int i = 0; i < numSearches; i += 1 ) {","\t\t\t\tdeltaTexCoord /= 2.0;","\t\t\t\tdeltaHeight /= 2.0;","\t\t\t\theightFromTexture = texture2D( bumpMap, currentTextureCoords ).r;","\t\t\t\tif( heightFromTexture > currentLayerHeight ) {","\t\t\t\t\tcurrentTextureCoords -= deltaTexCoord;","\t\t\t\t\tcurrentLayerHeight += deltaHeight;","\t\t\t\t} else {","\t\t\t\t\tcurrentTextureCoords += deltaTexCoord;","\t\t\t\t\tcurrentLayerHeight -= deltaHeight;","\t\t\t\t}","\t\t\t}","\t\t\treturn currentTextureCoords;","\t\t#elif defined( USE_OCLUSION_PARALLAX )","\t\t\tvec2 prevTCoords = currentTextureCoords + dtex;","\t\t\tfloat nextH = heightFromTexture - currentLayerHeight;","\t\t\tfloat prevH = texture2D( bumpMap, prevTCoords ).r - currentLayerHeight + layerHeight;","\t\t\tfloat weight = nextH / ( nextH - prevH );","\t\t\treturn prevTCoords * weight + currentTextureCoords * ( 1.0 - weight );","\t\t#else","\t\t\treturn vUv;","\t\t#endif","\t}","#endif","vec2 perturbUv( vec3 surfPosition, vec3 surfNormal, vec3 viewPosition ) {","\tvec2 texDx = dFdx( vUv );","\tvec2 texDy = dFdy( vUv );","\tvec3 vSigmaX = dFdx( surfPosition );","\tvec3 vSigmaY = dFdy( surfPosition );","\tvec3 vR1 = cross( vSigmaY, surfNormal );","\tvec3 vR2 = cross( surfNormal, vSigmaX );","\tfloat fDet = dot( vSigmaX, vR1 );","\tvec2 vProjVscr = ( 1.0 / fDet ) * vec2( dot( vR1, viewPosition ), dot( vR2, viewPosition ) );","\tvec3 vProjVtex;","\tvProjVtex.xy = texDx * vProjVscr.x + texDy * vProjVscr.y;","\tvProjVtex.z = dot( surfNormal, viewPosition );","\treturn parallaxMap( vProjVtex );","}","void main() {","\tvec2 mapUv = perturbUv( -vViewPosition, normalize( vNormal ), normalize( vViewPosition ) );","\tgl_FragColor = texture2D( map, mapUv );","}"].join("\n")};exports.ParallaxShader=t;

package/shaders/ParallaxShader.d.ts

@@ -1,28 +0,0 @@
-export declare const ParallaxShader: {
-    modes: {
-        none: string;
-        basic: string;
-        steep: string;
-        occlusion: string;
-        relief: string;
-    };
-    uniforms: {
-        bumpMap: {
-            value: null;
-        };
-        map: {
-            value: null;
-        };
-        parallaxScale: {
-            value: null;
-        };
-        parallaxMinLayers: {
-            value: null;
-        };
-        parallaxMaxLayers: {
-            value: null;
-        };
-    };
-    vertexShader: string;
-    fragmentShader: string;
-};

package/shaders/ParallaxShader.js

@@ -1,54 +0,0 @@
-// Parallax Occlusion shaders from
-//    http://sunandblackcat.com/tipFullView.php?topicid=28
-// No tangent-space transforms logic based on
-//   http://mmikkelsen3d.blogspot.sk/2012/02/parallaxpoc-mapping-and-no-tangent.html
-const ParallaxShader = {
-  // Ordered from fastest to best quality.
-  modes: {
-    none: 'NO_PARALLAX',
-    basic: 'USE_BASIC_PARALLAX',
-    steep: 'USE_STEEP_PARALLAX',
-    occlusion: 'USE_OCLUSION_PARALLAX',
-    // a.k.a. POM
-    relief: 'USE_RELIEF_PARALLAX'
-  },
-  uniforms: {
-    bumpMap: {
-      value: null
-    },
-    map: {
-      value: null
-    },
-    parallaxScale: {
-      value: null
-    },
-    parallaxMinLayers: {
-      value: null
-    },
-    parallaxMaxLayers: {
-      value: null
-    }
-  },
-  vertexShader: ['varying vec2 vUv;', 'varying vec3 vViewPosition;', 'varying vec3 vNormal;', 'void main() {', '	vUv = uv;', '	vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );', '	vViewPosition = -mvPosition.xyz;', '	vNormal = normalize( normalMatrix * normal );', '	gl_Position = projectionMatrix * mvPosition;', '}'].join('\n'),
-  fragmentShader: ['uniform sampler2D bumpMap;', 'uniform sampler2D map;', 'uniform float parallaxScale;', 'uniform float parallaxMinLayers;', 'uniform float parallaxMaxLayers;', 'varying vec2 vUv;', 'varying vec3 vViewPosition;', 'varying vec3 vNormal;', '#ifdef USE_BASIC_PARALLAX', '	vec2 parallaxMap( in vec3 V ) {', '		float initialHeight = texture2D( bumpMap, vUv ).r;', // No Offset Limitting: messy, floating output at grazing angles.
-  //"vec2 texCoordOffset = parallaxScale * V.xy / V.z * initialHeight;",
-  // Offset Limiting
-  '		vec2 texCoordOffset = parallaxScale * V.xy * initialHeight;', '		return vUv - texCoordOffset;', '	}', '#else', '	vec2 parallaxMap( in vec3 V ) {', // Determine number of layers from angle between V and N
-  '		float numLayers = mix( parallaxMaxLayers, parallaxMinLayers, abs( dot( vec3( 0.0, 0.0, 1.0 ), V ) ) );', '		float layerHeight = 1.0 / numLayers;', '		float currentLayerHeight = 0.0;', // Shift of texture coordinates for each iteration
-  '		vec2 dtex = parallaxScale * V.xy / V.z / numLayers;', '		vec2 currentTextureCoords = vUv;', '		float heightFromTexture = texture2D( bumpMap, currentTextureCoords ).r;', // while ( heightFromTexture > currentLayerHeight )
-  // Infinite loops are not well supported. Do a "large" finite
-  // loop, but not too large, as it slows down some compilers.
-  '		for ( int i = 0; i < 30; i += 1 ) {', '			if ( heightFromTexture <= currentLayerHeight ) {', '				break;', '			}', '			currentLayerHeight += layerHeight;', // Shift texture coordinates along vector V
-  '			currentTextureCoords -= dtex;', '			heightFromTexture = texture2D( bumpMap, currentTextureCoords ).r;', '		}', '		#ifdef USE_STEEP_PARALLAX', '			return currentTextureCoords;', '		#elif defined( USE_RELIEF_PARALLAX )', '			vec2 deltaTexCoord = dtex / 2.0;', '			float deltaHeight = layerHeight / 2.0;', // Return to the mid point of previous layer
-  '			currentTextureCoords += deltaTexCoord;', '			currentLayerHeight -= deltaHeight;', // Binary search to increase precision of Steep Parallax Mapping
-  '			const int numSearches = 5;', '			for ( int i = 0; i < numSearches; i += 1 ) {', '				deltaTexCoord /= 2.0;', '				deltaHeight /= 2.0;', '				heightFromTexture = texture2D( bumpMap, currentTextureCoords ).r;', // Shift along or against vector V
-  '				if( heightFromTexture > currentLayerHeight ) {', // Below the surface
-  '					currentTextureCoords -= deltaTexCoord;', '					currentLayerHeight += deltaHeight;', '				} else {', // above the surface
-  '					currentTextureCoords += deltaTexCoord;', '					currentLayerHeight -= deltaHeight;', '				}', '			}', '			return currentTextureCoords;', '		#elif defined( USE_OCLUSION_PARALLAX )', '			vec2 prevTCoords = currentTextureCoords + dtex;', // Heights for linear interpolation
-  '			float nextH = heightFromTexture - currentLayerHeight;', '			float prevH = texture2D( bumpMap, prevTCoords ).r - currentLayerHeight + layerHeight;', // Proportions for linear interpolation
-  '			float weight = nextH / ( nextH - prevH );', // Interpolation of texture coordinates
-  '			return prevTCoords * weight + currentTextureCoords * ( 1.0 - weight );', '		#else', // NO_PARALLAX
-  '			return vUv;', '		#endif', '	}', '#endif', 'vec2 perturbUv( vec3 surfPosition, vec3 surfNormal, vec3 viewPosition ) {', '	vec2 texDx = dFdx( vUv );', '	vec2 texDy = dFdy( vUv );', '	vec3 vSigmaX = dFdx( surfPosition );', '	vec3 vSigmaY = dFdy( surfPosition );', '	vec3 vR1 = cross( vSigmaY, surfNormal );', '	vec3 vR2 = cross( surfNormal, vSigmaX );', '	float fDet = dot( vSigmaX, vR1 );', '	vec2 vProjVscr = ( 1.0 / fDet ) * vec2( dot( vR1, viewPosition ), dot( vR2, viewPosition ) );', '	vec3 vProjVtex;', '	vProjVtex.xy = texDx * vProjVscr.x + texDy * vProjVscr.y;', '	vProjVtex.z = dot( surfNormal, viewPosition );', '	return parallaxMap( vProjVtex );', '}', 'void main() {', '	vec2 mapUv = perturbUv( -vViewPosition, normalize( vNormal ), normalize( vViewPosition ) );', '	gl_FragColor = texture2D( map, mapUv );', '}'].join('\n')
-};
-
-export { ParallaxShader };

package/shaders/PixelShader.cjs.js

@@ -1 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const e={uniforms:{tDiffuse:{value:null},resolution:{value:null},pixelSize:{value:1}},vertexShader:["varying highp vec2 vUv;","void main() {","vUv = uv;","gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );","}"].join("\n"),fragmentShader:["uniform sampler2D tDiffuse;","uniform float pixelSize;","uniform vec2 resolution;","varying highp vec2 vUv;","void main(){","vec2 dxy = pixelSize / resolution;","vec2 coord = dxy * floor( vUv / dxy );","gl_FragColor = texture2D(tDiffuse, coord);","}"].join("\n")};exports.PixelShader=e;

package/shaders/PixelShader.d.ts

@@ -1,15 +0,0 @@
-export declare const PixelShader: {
-    uniforms: {
-        tDiffuse: {
-            value: null;
-        };
-        resolution: {
-            value: null;
-        };
-        pixelSize: {
-            value: number;
-        };
-    };
-    vertexShader: string;
-    fragmentShader: string;
-};

package/shaders/PixelShader.js

@@ -1,20 +0,0 @@
-/**
- * Pixelation shader
- */
-const PixelShader = {
-  uniforms: {
-    tDiffuse: {
-      value: null
-    },
-    resolution: {
-      value: null
-    },
-    pixelSize: {
-      value: 1
-    }
-  },
-  vertexShader: ['varying highp vec2 vUv;', 'void main() {', 'vUv = uv;', 'gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );', '}'].join('\n'),
-  fragmentShader: ['uniform sampler2D tDiffuse;', 'uniform float pixelSize;', 'uniform vec2 resolution;', 'varying highp vec2 vUv;', 'void main(){', 'vec2 dxy = pixelSize / resolution;', 'vec2 coord = dxy * floor( vUv / dxy );', 'gl_FragColor = texture2D(tDiffuse, coord);', '}'].join('\n')
-};
-
-export { PixelShader };