three-stdlib 2.25.0 → 2.25.1

package/shaders/HorizontalBlurShader.js

@@ -1,49 +0,0 @@
-const HorizontalBlurShader = {
-  uniforms: {
-    tDiffuse: { value: null },
-    h: { value: 1 / 512 }
-  },
-  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

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const HorizontalTiltShiftShader = {
-  uniforms: {
-    tDiffuse: { value: null },
-    h: { value: 1 / 512 },
-    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")
-};
-exports.HorizontalTiltShiftShader = HorizontalTiltShiftShader;

package/shaders/HorizontalTiltShiftShader.js

@@ -1,37 +0,0 @@
-const HorizontalTiltShiftShader = {
-  uniforms: {
-    tDiffuse: { value: null },
-    h: { value: 1 / 512 },
-    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

@@ -1,43 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-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")
-};
-exports.HueSaturationShader = HueSaturationShader;

package/shaders/HueSaturationShader.js

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

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const KaleidoShader = {
-  uniforms: {
-    tDiffuse: { value: null },
-    sides: { value: 6 },
-    angle: { 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 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;

package/shaders/KaleidoShader.js

@@ -1,34 +0,0 @@
-const KaleidoShader = {
-  uniforms: {
-    tDiffuse: { value: null },
-    sides: { value: 6 },
-    angle: { 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 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

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const THREE = require("three");
-const LuminosityHighPassShader = {
-  shaderID: "luminosityHighPass",
-  uniforms: {
-    tDiffuse: { value: null },
-    luminosityThreshold: { value: 1 },
-    smoothWidth: { value: 1 },
-    defaultColor: { value: /* @__PURE__ */ new THREE.Color(0) },
-    defaultOpacity: { 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 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;

package/shaders/LuminosityHighPassShader.js

@@ -1,37 +0,0 @@
-import { Color } from "three";
-const LuminosityHighPassShader = {
-  shaderID: "luminosityHighPass",
-  uniforms: {
-    tDiffuse: { value: null },
-    luminosityThreshold: { value: 1 },
-    smoothWidth: { value: 1 },
-    defaultColor: { value: /* @__PURE__ */ new Color(0) },
-    defaultOpacity: { 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 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

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-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")
-};
-exports.LuminosityShader = LuminosityShader;

package/shaders/LuminosityShader.js

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

@@ -1,35 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-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")
-};
-exports.MirrorShader = MirrorShader;

package/shaders/MirrorShader.js

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

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const THREE = require("three");
-const NormalMapShader = {
-  uniforms: {
-    heightMap: { value: null },
-    resolution: { value: /* @__PURE__ */ new THREE.Vector2(512, 512) },
-    scale: { value: /* @__PURE__ */ new THREE.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")
-};
-exports.NormalMapShader = NormalMapShader;

package/shaders/NormalMapShader.js

@@ -1,31 +0,0 @@
-import { Vector2 } from "three";
-const NormalMapShader = {
-  uniforms: {
-    heightMap: { value: null },
-    resolution: { value: /* @__PURE__ */ new Vector2(512, 512) },
-    scale: { value: /* @__PURE__ */ 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

@@ -1,133 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-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")
-};
-exports.ParallaxShader = ParallaxShader;