three-stdlib 2.16.0 → 2.16.2

package/shaders/HorizontalTiltShiftShader.js

@@ -1,37 +1,25 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+/**
+ * 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 / 512 },
-    r: { value: 0.35 }
+    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")
+  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')
 };
-exports.HorizontalTiltShiftShader = HorizontalTiltShiftShader;
+
+export { HorizontalTiltShiftShader };

package/shaders/HueSaturationShader.cjs.js

@@ -0,0 +1 @@
+"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.js

@@ -1,41 +1,25 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+/**
+ * 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 }
+    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 );",
-    "	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)",
-    "	);",
-    "	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")
+  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')
 };
-exports.HueSaturationShader = HueSaturationShader;
+
+export { HueSaturationShader };

package/shaders/KaleidoShader.cjs.js

@@ -0,0 +1 @@
+"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.js

@@ -1,34 +1,26 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+/**
+ * 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 },
-    angle: { value: 0 }
+    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")
+  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')
 };
-exports.KaleidoShader = KaleidoShader;
+
+export { KaleidoShader };

package/shaders/LuminosityHighPassShader.cjs.js

@@ -0,0 +1 @@
+"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.js

@@ -1,37 +1,31 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const THREE = require("three");
+import { Color } from 'three';
+
+/**
+ * Luminosity
+ * http://en.wikipedia.org/wiki/Luminosity
+ */
+
 const LuminosityHighPassShader = {
-  shaderID: "luminosityHighPass",
+  shaderID: 'luminosityHighPass',
   uniforms: {
-    tDiffuse: { value: null },
-    luminosityThreshold: { value: 1 },
-    smoothWidth: { value: 1 },
-    defaultColor: { value: new THREE.Color(0) },
-    defaultOpacity: { value: 0 }
+    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")
+  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')
 };
-exports.LuminosityHighPassShader = LuminosityHighPassShader;
+
+export { LuminosityHighPassShader };

package/shaders/LuminosityShader.cjs.js

@@ -0,0 +1 @@
+"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.js

@@ -1,25 +1,15 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+/**
+ * Luminosity
+ * http://en.wikipedia.org/wiki/Luminosity
+ */
 const LuminosityShader = {
   uniforms: {
-    tDiffuse: { value: null }
+    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")
+  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')
 };
-exports.LuminosityShader = LuminosityShader;
+
+export { LuminosityShader };

package/shaders/MirrorShader.cjs.js

@@ -0,0 +1 @@
+"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.js

@@ -1,35 +1,20 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+/**
+ * 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 }
+    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")
+  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')
 };
-exports.MirrorShader = MirrorShader;
+
+export { MirrorShader };

package/shaders/NormalMapShader.cjs.js

@@ -0,0 +1 @@
+"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.js

@@ -1,31 +1,27 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const THREE = require("three");
+import { Vector2 } from 'three';
+
+/**
+ * Normal map shader
+ * - compute normals from heightmap
+ */
+
 const NormalMapShader = {
   uniforms: {
-    heightMap: { value: null },
-    resolution: { value: new THREE.Vector2(512, 512) },
-    scale: { value: new THREE.Vector2(1, 1) },
-    height: { value: 0.05 }
+    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")
+  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')
 };
-exports.NormalMapShader = NormalMapShader;
+
+export { NormalMapShader };

package/shaders/ParallaxShader.cjs.js

@@ -0,0 +1 @@
+"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.js

@@ -1,113 +1,54 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+// 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",
-    relief: "USE_RELIEF_PARALLAX"
+    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 }
+    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;",
-    "		vec2 texCoordOffset = parallaxScale * V.xy * initialHeight;",
-    "		return vUv - texCoordOffset;",
-    "	}",
-    "#else",
-    "	vec2 parallaxMap( in vec3 V ) {",
-    "		float numLayers = mix( parallaxMaxLayers, parallaxMinLayers, abs( dot( vec3( 0.0, 0.0, 1.0 ), V ) ) );",
-    "		float layerHeight = 1.0 / numLayers;",
-    "		float currentLayerHeight = 0.0;",
-    "		vec2 dtex = parallaxScale * V.xy / V.z / numLayers;",
-    "		vec2 currentTextureCoords = vUv;",
-    "		float heightFromTexture = texture2D( bumpMap, currentTextureCoords ).r;",
-    "		for ( int i = 0; i < 30; i += 1 ) {",
-    "			if ( heightFromTexture <= currentLayerHeight ) {",
-    "				break;",
-    "			}",
-    "			currentLayerHeight += layerHeight;",
-    "			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;",
-    "			currentTextureCoords += deltaTexCoord;",
-    "			currentLayerHeight -= deltaHeight;",
-    "			const int numSearches = 5;",
-    "			for ( int i = 0; i < numSearches; i += 1 ) {",
-    "				deltaTexCoord /= 2.0;",
-    "				deltaHeight /= 2.0;",
-    "				heightFromTexture = texture2D( bumpMap, currentTextureCoords ).r;",
-    "				if( heightFromTexture > currentLayerHeight ) {",
-    "					currentTextureCoords -= deltaTexCoord;",
-    "					currentLayerHeight += deltaHeight;",
-    "				} else {",
-    "					currentTextureCoords += deltaTexCoord;",
-    "					currentLayerHeight -= deltaHeight;",
-    "				}",
-    "			}",
-    "			return currentTextureCoords;",
-    "		#elif defined( USE_OCLUSION_PARALLAX )",
-    "			vec2 prevTCoords = currentTextureCoords + dtex;",
-    "			float nextH = heightFromTexture - currentLayerHeight;",
-    "			float prevH = texture2D( bumpMap, prevTCoords ).r - currentLayerHeight + layerHeight;",
-    "			float weight = nextH / ( nextH - prevH );",
-    "			return prevTCoords * weight + currentTextureCoords * ( 1.0 - weight );",
-    "		#else",
-    "			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")
+  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')
 };
-exports.ParallaxShader = ParallaxShader;
+
+export { ParallaxShader };

package/shaders/PixelShader.cjs.js

@@ -0,0 +1 @@
+"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;