Trang chủ Khám phá Trợ giúp
Đăng nhập
javascript
/
three.js
mirror of https://github.com/tazdij/three.js.git
2
0
Fork 0
Các tập tin Các vấn đề 0 Wiki
Browse Source

Intial refactoring for WebGLShaders (See #4129)

- split up files
- added new files descriptions to docs
Joshua Koo 11 năm trước cách đây
mục cha
bedeb31a22
commit
0bb85dc25d
10 tập tin đã thay đổi với 1539 bổ sung và 1377 xóa
View chưa được định nghĩa Hiển thị tình trạng sai khác
  1. 3 7
      docs/api/renderers/shaders/ShaderChunk.html
  2. 27 0
      docs/api/renderers/shaders/ShaderLib.html
  3. 28 0
      docs/api/renderers/shaders/UniformsLib.html
  4. 26 0
      docs/api/renderers/shaders/UniformsUtils.html
  5. 3 1368
      src/renderers/shaders/ShaderChunk.js
  6. 1276 0
      src/renderers/shaders/ShaderLib.js
  7. 102 0
      src/renderers/shaders/UniformsLib.js
  8. 66 0
      src/renderers/shaders/UniformsUtils.js
  9. 4 1
      utils/build/includes/common.json
  10. 4 1
      utils/build/includes/webgl.json

+ 3 - 7
docs/api/renderers/WebGLShaders.html → docs/api/renderers/shaders/ShaderChunk.html
Xem Tập Tin 

@@ -2,20 +2,16 @@
 
 <html lang="en">
 
 <html lang="en">
 
 	<head>
 
 	<head>
 
 		<meta charset="utf-8" />
 
 		<meta charset="utf-8" />
 
-		<script src="../../list.js"></script>
 
-		<script src="../../page.js"></script>
 
+		<script src="../../../list.js"></script>
 
+		<script src="../../../page.js"></script>
 
 		<link type="text/css" rel="stylesheet" href="../../page.css" />
 
 		<link type="text/css" rel="stylesheet" href="../../page.css" />
 
 	</head>
 
 	</head>
 
 	<body>
 
 	<body>
 
 		<h1>[name]</h1>
 
 		<h1>[name]</h1>
 
 
 
-		<div class="desc">todo</div>
 
+		<div class="desc">Shader chunks for WebLG Shader library</div>
 
 
 
 
 
-		<h2>Constructor</h2>
 
-
 
-		<h3>[name]()</h3>
 
-
 
 
 
 		<h2>Properties</h2>
 
 		<h2>Properties</h2>

+ 27 - 0
docs/api/renderers/shaders/ShaderLib.html
Xem Tập Tin 

@@ -0,0 +1,27 @@
 
+<!DOCTYPE html>
 
+<html lang="en">
 
+	<head>
 
+		<meta charset="utf-8" />
 
+		<script src="../../../list.js"></script>
 
+		<script src="../../../page.js"></script>
 
+		<link type="text/css" rel="stylesheet" href="../../page.css" />
 
+	</head>
 
+	<body>
 
+		<h1>[name]</h1>
 
+
 
+		<div class="desc">Webgl Shader Library for three.js</div>
 
+
 
+
 
+		<h2>Properties</h2>
 
+
 
+
 
+
 
+		<h2>Methods</h2>
 
+
 
+
 
+
 
+		<h2>Source</h2>
 
+
 
+		[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
 
+	</body>
 
+</html>

+ 28 - 0
docs/api/renderers/shaders/UniformsLib.html
Xem Tập Tin 

@@ -0,0 +1,28 @@
 
+<!DOCTYPE html>
 
+<html lang="en">
 
+	<head>
 
+		<meta charset="utf-8" />
 
+		<script src="../../../list.js"></script>
 
+		<script src="../../../page.js"></script>
 
+		<link type="text/css" rel="stylesheet" href="../../page.css" />
 
+	</head>
 
+	<body>
 
+		<h1>[name]</h1>
 
+
 
+		<div class="desc">Uniforms library for shared webgl shaders</div>
 
+
 
+
 
+
 
+		<h2>Properties</h2>
 
+
 
+
 
+
 
+		<h2>Methods</h2>
 
+
 
+
 
+
 
+		<h2>Source</h2>
 
+
 
+		[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
 
+	</body>
 
+</html>

+ 26 - 0
docs/api/renderers/shaders/UniformsUtils.html
Xem Tập Tin 

@@ -0,0 +1,26 @@
 
+<!DOCTYPE html>
 
+<html lang="en">
 
+	<head>
 
+		<meta charset="utf-8" />
 
+		<script src="../../../list.js"></script>
 
+		<script src="../../../page.js"></script>
 
+		<link type="text/css" rel="stylesheet" href="../../page.css" />
 
+	</head>
 
+	<body>
 
+		<h1>[name]</h1>
 
+
 
+		<div class="desc">Uniform Utilities. Support merging and cloning of uniform variables</div>
 
+
 
+		<h2>Properties</h2>
 
+
 
+
 
+
 
+		<h2>Methods</h2>
 
+
 
+
 
+
 
+		<h2>Source</h2>
 
+
 
+		[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
 
+	</body>
 
+</html>

+ 3 - 1368
src/renderers/WebGLShaders.js → src/renderers/shaders/ShaderChunk.js
Xem Tập Tin 

@@ -1,10 +1,12 @@
 
 /**
 
 /**
 
+ * Shader chunks for WebLG Shader library
 
+ * 
  * @author alteredq / http://alteredqualia.com/
 
  * @author alteredq / http://alteredqualia.com/
 
  * @author mrdoob / http://mrdoob.com/
 
  * @author mrdoob / http://mrdoob.com/
 
  * @author mikael emtinger / http://gomo.se/
 
  * @author mikael emtinger / http://gomo.se/
 
  */
 
  */
 
 
 
-THREE.ShaderChunk = {
 
+ THREE.ShaderChunk = {
 
 
 
 	// FOG
 
 	// FOG
 
 
 
@@ -1835,1370 +1837,3 @@ THREE.UniformsUtils = {
 
 	}
 
 	}
 
 
 
 };
 
 };
 
-
 
-THREE.UniformsLib = {
 
-
 
-	common: {
 
-
 
-		"diffuse" : { type: "c", value: new THREE.Color( 0xeeeeee ) },
 
-		"opacity" : { type: "f", value: 1.0 },
 
-
 
-		"map" : { type: "t", value: null },
 
-		"offsetRepeat" : { type: "v4", value: new THREE.Vector4( 0, 0, 1, 1 ) },
 
-
 
-		"lightMap" : { type: "t", value: null },
 
-		"specularMap" : { type: "t", value: null },
 
-
 
-		"envMap" : { type: "t", value: null },
 
-		"flipEnvMap" : { type: "f", value: -1 },
 
-		"useRefract" : { type: "i", value: 0 },
 
-		"reflectivity" : { type: "f", value: 1.0 },
 
-		"refractionRatio" : { type: "f", value: 0.98 },
 
-		"combine" : { type: "i", value: 0 },
 
-
 
-		"morphTargetInfluences" : { type: "f", value: 0 }
 
-
 
-	},
 
-
 
-	bump: {
 
-
 
-		"bumpMap" : { type: "t", value: null },
 
-		"bumpScale" : { type: "f", value: 1 }
 
-
 
-	},
 
-
 
-	normalmap: {
 
-
 
-		"normalMap" : { type: "t", value: null },
 
-		"normalScale" : { type: "v2", value: new THREE.Vector2( 1, 1 ) }
 
-	},
 
-
 
-	fog : {
 
-
 
-		"fogDensity" : { type: "f", value: 0.00025 },
 
-		"fogNear" : { type: "f", value: 1 },
 
-		"fogFar" : { type: "f", value: 2000 },
 
-		"fogColor" : { type: "c", value: new THREE.Color( 0xffffff ) }
 
-
 
-	},
 
-
 
-	lights: {
 
-
 
-		"ambientLightColor" : { type: "fv", value: [] },
 
-
 
-		"directionalLightDirection" : { type: "fv", value: [] },
 
-		"directionalLightColor" : { type: "fv", value: [] },
 
-
 
-		"hemisphereLightDirection" : { type: "fv", value: [] },
 
-		"hemisphereLightSkyColor" : { type: "fv", value: [] },
 
-		"hemisphereLightGroundColor" : { type: "fv", value: [] },
 
-
 
-		"pointLightColor" : { type: "fv", value: [] },
 
-		"pointLightPosition" : { type: "fv", value: [] },
 
-		"pointLightDistance" : { type: "fv1", value: [] },
 
-
 
-		"spotLightColor" : { type: "fv", value: [] },
 
-		"spotLightPosition" : { type: "fv", value: [] },
 
-		"spotLightDirection" : { type: "fv", value: [] },
 
-		"spotLightDistance" : { type: "fv1", value: [] },
 
-		"spotLightAngleCos" : { type: "fv1", value: [] },
 
-		"spotLightExponent" : { type: "fv1", value: [] }
 
-
 
-	},
 
-
 
-	particle: {
 
-
 
-		"psColor" : { type: "c", value: new THREE.Color( 0xeeeeee ) },
 
-		"opacity" : { type: "f", value: 1.0 },
 
-		"size" : { type: "f", value: 1.0 },
 
-		"scale" : { type: "f", value: 1.0 },
 
-		"map" : { type: "t", value: null },
 
-
 
-		"fogDensity" : { type: "f", value: 0.00025 },
 
-		"fogNear" : { type: "f", value: 1 },
 
-		"fogFar" : { type: "f", value: 2000 },
 
-		"fogColor" : { type: "c", value: new THREE.Color( 0xffffff ) }
 
-
 
-	},
 
-
 
-	shadowmap: {
 
-
 
-		"shadowMap": { type: "tv", value: [] },
 
-		"shadowMapSize": { type: "v2v", value: [] },
 
-
 
-		"shadowBias" : { type: "fv1", value: [] },
 
-		"shadowDarkness": { type: "fv1", value: [] },
 
-
 
-		"shadowMatrix" : { type: "m4v", value: [] }
 
-
 
-	}
 
-
 
-};
 
-
 
-THREE.ShaderLib = {
 
-
 
-	'basic': {
 
-
 
-		uniforms: THREE.UniformsUtils.merge( [
 
-
 
-			THREE.UniformsLib[ "common" ],
 
-			THREE.UniformsLib[ "fog" ],
 
-			THREE.UniformsLib[ "shadowmap" ]
 
-
 
-		] ),
 
-
 
-		vertexShader: [
 
-
 
-			THREE.ShaderChunk[ "map_pars_vertex" ],
 
-			THREE.ShaderChunk[ "lightmap_pars_vertex" ],
 
-			THREE.ShaderChunk[ "envmap_pars_vertex" ],
 
-			THREE.ShaderChunk[ "color_pars_vertex" ],
 
-			THREE.ShaderChunk[ "morphtarget_pars_vertex" ],
 
-			THREE.ShaderChunk[ "skinning_pars_vertex" ],
 
-			THREE.ShaderChunk[ "shadowmap_pars_vertex" ],
 
-
 
-			"void main() {",
 
-
 
-				THREE.ShaderChunk[ "map_vertex" ],
 
-				THREE.ShaderChunk[ "lightmap_vertex" ],
 
-				THREE.ShaderChunk[ "color_vertex" ],
 
-				THREE.ShaderChunk[ "skinbase_vertex" ],
 
-
 
-				"#ifdef USE_ENVMAP",
 
-
 
-				THREE.ShaderChunk[ "morphnormal_vertex" ],
 
-				THREE.ShaderChunk[ "skinnormal_vertex" ],
 
-				THREE.ShaderChunk[ "defaultnormal_vertex" ],
 
-
 
-				"#endif",
 
-
 
-				THREE.ShaderChunk[ "morphtarget_vertex" ],
 
-				THREE.ShaderChunk[ "skinning_vertex" ],
 
-				THREE.ShaderChunk[ "default_vertex" ],
 
-
 
-				THREE.ShaderChunk[ "worldpos_vertex" ],
 
-				THREE.ShaderChunk[ "envmap_vertex" ],
 
-				THREE.ShaderChunk[ "shadowmap_vertex" ],
 
-
 
-			"}"
 
-
 
-		].join("\n"),
 
-
 
-		fragmentShader: [
 
-
 
-			"uniform vec3 diffuse;",
 
-			"uniform float opacity;",
 
-
 
-			THREE.ShaderChunk[ "color_pars_fragment" ],
 
-			THREE.ShaderChunk[ "map_pars_fragment" ],
 
-			THREE.ShaderChunk[ "lightmap_pars_fragment" ],
 
-			THREE.ShaderChunk[ "envmap_pars_fragment" ],
 
-			THREE.ShaderChunk[ "fog_pars_fragment" ],
 
-			THREE.ShaderChunk[ "shadowmap_pars_fragment" ],
 
-			THREE.ShaderChunk[ "specularmap_pars_fragment" ],
 
-
 
-			"void main() {",
 
-
 
-				"gl_FragColor = vec4( diffuse, opacity );",
 
-
 
-				THREE.ShaderChunk[ "map_fragment" ],
 
-				THREE.ShaderChunk[ "alphatest_fragment" ],
 
-				THREE.ShaderChunk[ "specularmap_fragment" ],
 
-				THREE.ShaderChunk[ "lightmap_fragment" ],
 
-				THREE.ShaderChunk[ "color_fragment" ],
 
-				THREE.ShaderChunk[ "envmap_fragment" ],
 
-				THREE.ShaderChunk[ "shadowmap_fragment" ],
 
-
 
-				THREE.ShaderChunk[ "linear_to_gamma_fragment" ],
 
-
 
-				THREE.ShaderChunk[ "fog_fragment" ],
 
-
 
-			"}"
 
-
 
-		].join("\n")
 
-
 
-	},
 
-
 
-	'lambert': {
 
-
 
-		uniforms: THREE.UniformsUtils.merge( [
 
-
 
-			THREE.UniformsLib[ "common" ],
 
-			THREE.UniformsLib[ "fog" ],
 
-			THREE.UniformsLib[ "lights" ],
 
-			THREE.UniformsLib[ "shadowmap" ],
 
-
 
-			{
 
-				"ambient"  : { type: "c", value: new THREE.Color( 0xffffff ) },
 
-				"emissive" : { type: "c", value: new THREE.Color( 0x000000 ) },
 
-				"wrapRGB"  : { type: "v3", value: new THREE.Vector3( 1, 1, 1 ) }
 
-			}
 
-
 
-		] ),
 
-
 
-		vertexShader: [
 
-
 
-			"#define LAMBERT",
 
-
 
-			"varying vec3 vLightFront;",
 
-
 
-			"#ifdef DOUBLE_SIDED",
 
-
 
-				"varying vec3 vLightBack;",
 
-
 
-			"#endif",
 
-
 
-			THREE.ShaderChunk[ "map_pars_vertex" ],
 
-			THREE.ShaderChunk[ "lightmap_pars_vertex" ],
 
-			THREE.ShaderChunk[ "envmap_pars_vertex" ],
 
-			THREE.ShaderChunk[ "lights_lambert_pars_vertex" ],
 
-			THREE.ShaderChunk[ "color_pars_vertex" ],
 
-			THREE.ShaderChunk[ "morphtarget_pars_vertex" ],
 
-			THREE.ShaderChunk[ "skinning_pars_vertex" ],
 
-			THREE.ShaderChunk[ "shadowmap_pars_vertex" ],
 
-
 
-			"void main() {",
 
-
 
-				THREE.ShaderChunk[ "map_vertex" ],
 
-				THREE.ShaderChunk[ "lightmap_vertex" ],
 
-				THREE.ShaderChunk[ "color_vertex" ],
 
-
 
-				THREE.ShaderChunk[ "morphnormal_vertex" ],
 
-				THREE.ShaderChunk[ "skinbase_vertex" ],
 
-				THREE.ShaderChunk[ "skinnormal_vertex" ],
 
-				THREE.ShaderChunk[ "defaultnormal_vertex" ],
 
-
 
-				THREE.ShaderChunk[ "morphtarget_vertex" ],
 
-				THREE.ShaderChunk[ "skinning_vertex" ],
 
-				THREE.ShaderChunk[ "default_vertex" ],
 
-
 
-				THREE.ShaderChunk[ "worldpos_vertex" ],
 
-				THREE.ShaderChunk[ "envmap_vertex" ],
 
-				THREE.ShaderChunk[ "lights_lambert_vertex" ],
 
-				THREE.ShaderChunk[ "shadowmap_vertex" ],
 
-
 
-			"}"
 
-
 
-		].join("\n"),
 
-
 
-		fragmentShader: [
 
-
 
-			"uniform float opacity;",
 
-
 
-			"varying vec3 vLightFront;",
 
-
 
-			"#ifdef DOUBLE_SIDED",
 
-
 
-				"varying vec3 vLightBack;",
 
-
 
-			"#endif",
 
-
 
-			THREE.ShaderChunk[ "color_pars_fragment" ],
 
-			THREE.ShaderChunk[ "map_pars_fragment" ],
 
-			THREE.ShaderChunk[ "lightmap_pars_fragment" ],
 
-			THREE.ShaderChunk[ "envmap_pars_fragment" ],
 
-			THREE.ShaderChunk[ "fog_pars_fragment" ],
 
-			THREE.ShaderChunk[ "shadowmap_pars_fragment" ],
 
-			THREE.ShaderChunk[ "specularmap_pars_fragment" ],
 
-
 
-			"void main() {",
 
-
 
-				"gl_FragColor = vec4( vec3 ( 1.0 ), opacity );",
 
-
 
-				THREE.ShaderChunk[ "map_fragment" ],
 
-				THREE.ShaderChunk[ "alphatest_fragment" ],
 
-				THREE.ShaderChunk[ "specularmap_fragment" ],
 
-
 
-				"#ifdef DOUBLE_SIDED",
 
-
 
-					//"float isFront = float( gl_FrontFacing );",
 
-					//"gl_FragColor.xyz *= isFront * vLightFront + ( 1.0 - isFront ) * vLightBack;",
 
-
 
-					"if ( gl_FrontFacing )",
 
-						"gl_FragColor.xyz *= vLightFront;",
 
-					"else",
 
-						"gl_FragColor.xyz *= vLightBack;",
 
-
 
-				"#else",
 
-
 
-					"gl_FragColor.xyz *= vLightFront;",
 
-
 
-				"#endif",
 
-
 
-				THREE.ShaderChunk[ "lightmap_fragment" ],
 
-				THREE.ShaderChunk[ "color_fragment" ],
 
-				THREE.ShaderChunk[ "envmap_fragment" ],
 
-				THREE.ShaderChunk[ "shadowmap_fragment" ],
 
-
 
-				THREE.ShaderChunk[ "linear_to_gamma_fragment" ],
 
-
 
-				THREE.ShaderChunk[ "fog_fragment" ],
 
-
 
-			"}"
 
-
 
-		].join("\n")
 
-
 
-	},
 
-
 
-	'phong': {
 
-
 
-		uniforms: THREE.UniformsUtils.merge( [
 
-
 
-			THREE.UniformsLib[ "common" ],
 
-			THREE.UniformsLib[ "bump" ],
 
-			THREE.UniformsLib[ "normalmap" ],
 
-			THREE.UniformsLib[ "fog" ],
 
-			THREE.UniformsLib[ "lights" ],
 
-			THREE.UniformsLib[ "shadowmap" ],
 
-
 
-			{
 
-				"ambient"  : { type: "c", value: new THREE.Color( 0xffffff ) },
 
-				"emissive" : { type: "c", value: new THREE.Color( 0x000000 ) },
 
-				"specular" : { type: "c", value: new THREE.Color( 0x111111 ) },
 
-				"shininess": { type: "f", value: 30 },
 
-				"wrapRGB"  : { type: "v3", value: new THREE.Vector3( 1, 1, 1 ) }
 
-			}
 
-
 
-		] ),
 
-
 
-		vertexShader: [
 
-
 
-			"#define PHONG",
 
-
 
-			"varying vec3 vViewPosition;",
 
-			"varying vec3 vNormal;",
 
-
 
-			THREE.ShaderChunk[ "map_pars_vertex" ],
 
-			THREE.ShaderChunk[ "lightmap_pars_vertex" ],
 
-			THREE.ShaderChunk[ "envmap_pars_vertex" ],
 
-			THREE.ShaderChunk[ "lights_phong_pars_vertex" ],
 
-			THREE.ShaderChunk[ "color_pars_vertex" ],
 
-			THREE.ShaderChunk[ "morphtarget_pars_vertex" ],
 
-			THREE.ShaderChunk[ "skinning_pars_vertex" ],
 
-			THREE.ShaderChunk[ "shadowmap_pars_vertex" ],
 
-
 
-			"void main() {",
 
-
 
-				THREE.ShaderChunk[ "map_vertex" ],
 
-				THREE.ShaderChunk[ "lightmap_vertex" ],
 
-				THREE.ShaderChunk[ "color_vertex" ],
 
-
 
-				THREE.ShaderChunk[ "morphnormal_vertex" ],
 
-				THREE.ShaderChunk[ "skinbase_vertex" ],
 
-				THREE.ShaderChunk[ "skinnormal_vertex" ],
 
-				THREE.ShaderChunk[ "defaultnormal_vertex" ],
 
-
 
-				"vNormal = normalize( transformedNormal );",
 
-
 
-				THREE.ShaderChunk[ "morphtarget_vertex" ],
 
-				THREE.ShaderChunk[ "skinning_vertex" ],
 
-				THREE.ShaderChunk[ "default_vertex" ],
 
-
 
-				"vViewPosition = -mvPosition.xyz;",
 
-
 
-				THREE.ShaderChunk[ "worldpos_vertex" ],
 
-				THREE.ShaderChunk[ "envmap_vertex" ],
 
-				THREE.ShaderChunk[ "lights_phong_vertex" ],
 
-				THREE.ShaderChunk[ "shadowmap_vertex" ],
 
-
 
-			"}"
 
-
 
-		].join("\n"),
 
-
 
-		fragmentShader: [
 
-
 
-			"uniform vec3 diffuse;",
 
-			"uniform float opacity;",
 
-
 
-			"uniform vec3 ambient;",
 
-			"uniform vec3 emissive;",
 
-			"uniform vec3 specular;",
 
-			"uniform float shininess;",
 
-
 
-			THREE.ShaderChunk[ "color_pars_fragment" ],
 
-			THREE.ShaderChunk[ "map_pars_fragment" ],
 
-			THREE.ShaderChunk[ "lightmap_pars_fragment" ],
 
-			THREE.ShaderChunk[ "envmap_pars_fragment" ],
 
-			THREE.ShaderChunk[ "fog_pars_fragment" ],
 
-			THREE.ShaderChunk[ "lights_phong_pars_fragment" ],
 
-			THREE.ShaderChunk[ "shadowmap_pars_fragment" ],
 
-			THREE.ShaderChunk[ "bumpmap_pars_fragment" ],
 
-			THREE.ShaderChunk[ "normalmap_pars_fragment" ],
 
-			THREE.ShaderChunk[ "specularmap_pars_fragment" ],
 
-
 
-			"void main() {",
 
-
 
-				"gl_FragColor = vec4( vec3 ( 1.0 ), opacity );",
 
-
 
-				THREE.ShaderChunk[ "map_fragment" ],
 
-				THREE.ShaderChunk[ "alphatest_fragment" ],
 
-				THREE.ShaderChunk[ "specularmap_fragment" ],
 
-
 
-				THREE.ShaderChunk[ "lights_phong_fragment" ],
 
-
 
-				THREE.ShaderChunk[ "lightmap_fragment" ],
 
-				THREE.ShaderChunk[ "color_fragment" ],
 
-				THREE.ShaderChunk[ "envmap_fragment" ],
 
-				THREE.ShaderChunk[ "shadowmap_fragment" ],
 
-
 
-				THREE.ShaderChunk[ "linear_to_gamma_fragment" ],
 
-
 
-				THREE.ShaderChunk[ "fog_fragment" ],
 
-
 
-			"}"
 
-
 
-		].join("\n")
 
-
 
-	},
 
-
 
-	'particle_basic': {
 
-
 
-		uniforms:  THREE.UniformsUtils.merge( [
 
-
 
-			THREE.UniformsLib[ "particle" ],
 
-			THREE.UniformsLib[ "shadowmap" ]
 
-
 
-		] ),
 
-
 
-		vertexShader: [
 
-
 
-			"uniform float size;",
 
-			"uniform float scale;",
 
-
 
-			THREE.ShaderChunk[ "color_pars_vertex" ],
 
-			THREE.ShaderChunk[ "shadowmap_pars_vertex" ],
 
-
 
-			"void main() {",
 
-
 
-				THREE.ShaderChunk[ "color_vertex" ],
 
-
 
-				"vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );",
 
-
 
-				"#ifdef USE_SIZEATTENUATION",
 
-					"gl_PointSize = size * ( scale / length( mvPosition.xyz ) );",
 
-				"#else",
 
-					"gl_PointSize = size;",
 
-				"#endif",
 
-
 
-				"gl_Position = projectionMatrix * mvPosition;",
 
-
 
-				THREE.ShaderChunk[ "worldpos_vertex" ],
 
-				THREE.ShaderChunk[ "shadowmap_vertex" ],
 
-
 
-			"}"
 
-
 
-		].join("\n"),
 
-
 
-		fragmentShader: [
 
-
 
-			"uniform vec3 psColor;",
 
-			"uniform float opacity;",
 
-
 
-			THREE.ShaderChunk[ "color_pars_fragment" ],
 
-			THREE.ShaderChunk[ "map_particle_pars_fragment" ],
 
-			THREE.ShaderChunk[ "fog_pars_fragment" ],
 
-			THREE.ShaderChunk[ "shadowmap_pars_fragment" ],
 
-
 
-			"void main() {",
 
-
 
-				"gl_FragColor = vec4( psColor, opacity );",
 
-
 
-				THREE.ShaderChunk[ "map_particle_fragment" ],
 
-				THREE.ShaderChunk[ "alphatest_fragment" ],
 
-				THREE.ShaderChunk[ "color_fragment" ],
 
-				THREE.ShaderChunk[ "shadowmap_fragment" ],
 
-				THREE.ShaderChunk[ "fog_fragment" ],
 
-
 
-			"}"
 
-
 
-		].join("\n")
 
-
 
-	},
 
-
 
-	'dashed': {
 
-
 
-		uniforms: THREE.UniformsUtils.merge( [
 
-
 
-			THREE.UniformsLib[ "common" ],
 
-			THREE.UniformsLib[ "fog" ],
 
-
 
-			{
 
-				"scale":     { type: "f", value: 1 },
 
-				"dashSize":  { type: "f", value: 1 },
 
-				"totalSize": { type: "f", value: 2 }
 
-			}
 
-
 
-		] ),
 
-
 
-		vertexShader: [
 
-
 
-			"uniform float scale;",
 
-			"attribute float lineDistance;",
 
-
 
-			"varying float vLineDistance;",
 
-
 
-			THREE.ShaderChunk[ "color_pars_vertex" ],
 
-
 
-			"void main() {",
 
-
 
-				THREE.ShaderChunk[ "color_vertex" ],
 
-
 
-				"vLineDistance = scale * lineDistance;",
 
-
 
-				"vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );",
 
-				"gl_Position = projectionMatrix * mvPosition;",
 
-
 
-			"}"
 
-
 
-		].join("\n"),
 
-
 
-		fragmentShader: [
 
-
 
-			"uniform vec3 diffuse;",
 
-			"uniform float opacity;",
 
-
 
-			"uniform float dashSize;",
 
-			"uniform float totalSize;",
 
-
 
-			"varying float vLineDistance;",
 
-
 
-			THREE.ShaderChunk[ "color_pars_fragment" ],
 
-			THREE.ShaderChunk[ "fog_pars_fragment" ],
 
-
 
-			"void main() {",
 
-
 
-				"if ( mod( vLineDistance, totalSize ) > dashSize ) {",
 
-
 
-					"discard;",
 
-
 
-				"}",
 
-
 
-				"gl_FragColor = vec4( diffuse, opacity );",
 
-
 
-				THREE.ShaderChunk[ "color_fragment" ],
 
-				THREE.ShaderChunk[ "fog_fragment" ],
 
-
 
-			"}"
 
-
 
-		].join("\n")
 
-
 
-	},
 
-
 
-	'depth': {
 
-
 
-		uniforms: {
 
-
 
-			"mNear": { type: "f", value: 1.0 },
 
-			"mFar" : { type: "f", value: 2000.0 },
 
-			"opacity" : { type: "f", value: 1.0 }
 
-
 
-		},
 
-
 
-		vertexShader: [
 
-
 
-			"void main() {",
 
-
 
-				"gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
 
-
 
-			"}"
 
-
 
-		].join("\n"),
 
-
 
-		fragmentShader: [
 
-
 
-			"uniform float mNear;",
 
-			"uniform float mFar;",
 
-			"uniform float opacity;",
 
-
 
-			"void main() {",
 
-
 
-				"float depth = gl_FragCoord.z / gl_FragCoord.w;",
 
-				"float color = 1.0 - smoothstep( mNear, mFar, depth );",
 
-				"gl_FragColor = vec4( vec3( color ), opacity );",
 
-
 
-			"}"
 
-
 
-		].join("\n")
 
-
 
-	},
 
-
 
-	'normal': {
 
-
 
-		uniforms: {
 
-
 
-			"opacity" : { type: "f", value: 1.0 }
 
-
 
-		},
 
-
 
-		vertexShader: [
 
-
 
-			"varying vec3 vNormal;",
 
-
 
-			THREE.ShaderChunk[ "morphtarget_pars_vertex" ],
 
-
 
-			"void main() {",
 
-
 
-				"vNormal = normalize( normalMatrix * normal );",
 
-
 
-				THREE.ShaderChunk[ "morphtarget_vertex" ],
 
-				THREE.ShaderChunk[ "default_vertex" ],
 
-
 
-			"}"
 
-
 
-		].join("\n"),
 
-
 
-		fragmentShader: [
 
-
 
-			"uniform float opacity;",
 
-			"varying vec3 vNormal;",
 
-
 
-			"void main() {",
 
-
 
-				"gl_FragColor = vec4( 0.5 * normalize( vNormal ) + 0.5, opacity );",
 
-
 
-			"}"
 
-
 
-		].join("\n")
 
-
 
-	},
 
-
 
-	/* -------------------------------------------------------------------------
 
-	//	Normal map shader
 
-	//		- Blinn-Phong
 
-	//		- normal + diffuse + specular + AO + displacement + reflection + shadow maps
 
-	//		- point and directional lights (use with "lights: true" material option)
 
-	 ------------------------------------------------------------------------- */
 
-
 
-	'normalmap' : {
 
-
 
-		uniforms: THREE.UniformsUtils.merge( [
 
-
 
-			THREE.UniformsLib[ "fog" ],
 
-			THREE.UniformsLib[ "lights" ],
 
-			THREE.UniformsLib[ "shadowmap" ],
 
-
 
-			{
 
-
 
-			"enableAO"		  : { type: "i", value: 0 },
 
-			"enableDiffuse"	  : { type: "i", value: 0 },
 
-			"enableSpecular"  : { type: "i", value: 0 },
 
-			"enableReflection": { type: "i", value: 0 },
 
-			"enableDisplacement": { type: "i", value: 0 },
 
-
 
-			"tDisplacement": { type: "t", value: null }, // must go first as this is vertex texture
 
-			"tDiffuse"	   : { type: "t", value: null },
 
-			"tCube"		   : { type: "t", value: null },
 
-			"tNormal"	   : { type: "t", value: null },
 
-			"tSpecular"	   : { type: "t", value: null },
 
-			"tAO"		   : { type: "t", value: null },
 
-
 
-			"uNormalScale": { type: "v2", value: new THREE.Vector2( 1, 1 ) },
 
-
 
-			"uDisplacementBias": { type: "f", value: 0.0 },
 
-			"uDisplacementScale": { type: "f", value: 1.0 },
 
-
 
-			"uDiffuseColor": { type: "c", value: new THREE.Color( 0xffffff ) },
 
-			"uSpecularColor": { type: "c", value: new THREE.Color( 0x111111 ) },
 
-			"uAmbientColor": { type: "c", value: new THREE.Color( 0xffffff ) },
 
-			"uShininess": { type: "f", value: 30 },
 
-			"uOpacity": { type: "f", value: 1 },
 
-
 
-			"useRefract": { type: "i", value: 0 },
 
-			"uRefractionRatio": { type: "f", value: 0.98 },
 
-			"uReflectivity": { type: "f", value: 0.5 },
 
-
 
-			"uOffset" : { type: "v2", value: new THREE.Vector2( 0, 0 ) },
 
-			"uRepeat" : { type: "v2", value: new THREE.Vector2( 1, 1 ) },
 
-
 
-			"wrapRGB"  : { type: "v3", value: new THREE.Vector3( 1, 1, 1 ) }
 
-
 
-			}
 
-
 
-		] ),
 
-
 
-		fragmentShader: [
 
-
 
-			"uniform vec3 uAmbientColor;",
 
-			"uniform vec3 uDiffuseColor;",
 
-			"uniform vec3 uSpecularColor;",
 
-			"uniform float uShininess;",
 
-			"uniform float uOpacity;",
 
-
 
-			"uniform bool enableDiffuse;",
 
-			"uniform bool enableSpecular;",
 
-			"uniform bool enableAO;",
 
-			"uniform bool enableReflection;",
 
-
 
-			"uniform sampler2D tDiffuse;",
 
-			"uniform sampler2D tNormal;",
 
-			"uniform sampler2D tSpecular;",
 
-			"uniform sampler2D tAO;",
 
-
 
-			"uniform samplerCube tCube;",
 
-
 
-			"uniform vec2 uNormalScale;",
 
-
 
-			"uniform bool useRefract;",
 
-			"uniform float uRefractionRatio;",
 
-			"uniform float uReflectivity;",
 
-
 
-			"varying vec3 vTangent;",
 
-			"varying vec3 vBinormal;",
 
-			"varying vec3 vNormal;",
 
-			"varying vec2 vUv;",
 
-
 
-			"uniform vec3 ambientLightColor;",
 
-
 
-			"#if MAX_DIR_LIGHTS > 0",
 
-
 
-				"uniform vec3 directionalLightColor[ MAX_DIR_LIGHTS ];",
 
-				"uniform vec3 directionalLightDirection[ MAX_DIR_LIGHTS ];",
 
-
 
-			"#endif",
 
-
 
-			"#if MAX_HEMI_LIGHTS > 0",
 
-
 
-				"uniform vec3 hemisphereLightSkyColor[ MAX_HEMI_LIGHTS ];",
 
-				"uniform vec3 hemisphereLightGroundColor[ MAX_HEMI_LIGHTS ];",
 
-				"uniform vec3 hemisphereLightDirection[ MAX_HEMI_LIGHTS ];",
 
-
 
-			"#endif",
 
-
 
-			"#if MAX_POINT_LIGHTS > 0",
 
-
 
-				"uniform vec3 pointLightColor[ MAX_POINT_LIGHTS ];",
 
-				"uniform vec3 pointLightPosition[ MAX_POINT_LIGHTS ];",
 
-				"uniform float pointLightDistance[ MAX_POINT_LIGHTS ];",
 
-
 
-			"#endif",
 
-
 
-			"#if MAX_SPOT_LIGHTS > 0",
 
-
 
-				"uniform vec3 spotLightColor[ MAX_SPOT_LIGHTS ];",
 
-				"uniform vec3 spotLightPosition[ MAX_SPOT_LIGHTS ];",
 
-				"uniform vec3 spotLightDirection[ MAX_SPOT_LIGHTS ];",
 
-				"uniform float spotLightAngleCos[ MAX_SPOT_LIGHTS ];",
 
-				"uniform float spotLightExponent[ MAX_SPOT_LIGHTS ];",
 
-				"uniform float spotLightDistance[ MAX_SPOT_LIGHTS ];",
 
-
 
-			"#endif",
 
-
 
-			"#ifdef WRAP_AROUND",
 
-
 
-				"uniform vec3 wrapRGB;",
 
-
 
-			"#endif",
 
-
 
-			"varying vec3 vWorldPosition;",
 
-			"varying vec3 vViewPosition;",
 
-
 
-			THREE.ShaderChunk[ "shadowmap_pars_fragment" ],
 
-			THREE.ShaderChunk[ "fog_pars_fragment" ],
 
-
 
-			"void main() {",
 
-
 
-				"gl_FragColor = vec4( vec3( 1.0 ), uOpacity );",
 
-
 
-				"vec3 specularTex = vec3( 1.0 );",
 
-
 
-				"vec3 normalTex = texture2D( tNormal, vUv ).xyz * 2.0 - 1.0;",
 
-				"normalTex.xy *= uNormalScale;",
 
-				"normalTex = normalize( normalTex );",
 
-
 
-				"if( enableDiffuse ) {",
 
-
 
-					"#ifdef GAMMA_INPUT",
 
-
 
-						"vec4 texelColor = texture2D( tDiffuse, vUv );",
 
-						"texelColor.xyz *= texelColor.xyz;",
 
-
 
-						"gl_FragColor = gl_FragColor * texelColor;",
 
-
 
-					"#else",
 
-
 
-						"gl_FragColor = gl_FragColor * texture2D( tDiffuse, vUv );",
 
-
 
-					"#endif",
 
-
 
-				"}",
 
-
 
-				"if( enableAO ) {",
 
-
 
-					"#ifdef GAMMA_INPUT",
 
-
 
-						"vec4 aoColor = texture2D( tAO, vUv );",
 
-						"aoColor.xyz *= aoColor.xyz;",
 
-
 
-						"gl_FragColor.xyz = gl_FragColor.xyz * aoColor.xyz;",
 
-
 
-					"#else",
 
-
 
-						"gl_FragColor.xyz = gl_FragColor.xyz * texture2D( tAO, vUv ).xyz;",
 
-
 
-					"#endif",
 
-
 
-				"}",
 
-
 
-				"if( enableSpecular )",
 
-					"specularTex = texture2D( tSpecular, vUv ).xyz;",
 
-
 
-				"mat3 tsb = mat3( normalize( vTangent ), normalize( vBinormal ), normalize( vNormal ) );",
 
-				"vec3 finalNormal = tsb * normalTex;",
 
-
 
-				"#ifdef FLIP_SIDED",
 
-
 
-					"finalNormal = -finalNormal;",
 
-
 
-				"#endif",
 
-
 
-				"vec3 normal = normalize( finalNormal );",
 
-				"vec3 viewPosition = normalize( vViewPosition );",
 
-
 
-				// point lights
 
-
 
-				"#if MAX_POINT_LIGHTS > 0",
 
-
 
-					"vec3 pointDiffuse = vec3( 0.0 );",
 
-					"vec3 pointSpecular = vec3( 0.0 );",
 
-
 
-					"for ( int i = 0; i < MAX_POINT_LIGHTS; i ++ ) {",
 
-
 
-						"vec4 lPosition = viewMatrix * vec4( pointLightPosition[ i ], 1.0 );",
 
-						"vec3 pointVector = lPosition.xyz + vViewPosition.xyz;",
 
-
 
-						"float pointDistance = 1.0;",
 
-						"if ( pointLightDistance[ i ] > 0.0 )",
 
-							"pointDistance = 1.0 - min( ( length( pointVector ) / pointLightDistance[ i ] ), 1.0 );",
 
-
 
-						"pointVector = normalize( pointVector );",
 
-
 
-						// diffuse
 
-
 
-						"#ifdef WRAP_AROUND",
 
-
 
-							"float pointDiffuseWeightFull = max( dot( normal, pointVector ), 0.0 );",
 
-							"float pointDiffuseWeightHalf = max( 0.5 * dot( normal, pointVector ) + 0.5, 0.0 );",
 
-
 
-							"vec3 pointDiffuseWeight = mix( vec3 ( pointDiffuseWeightFull ), vec3( pointDiffuseWeightHalf ), wrapRGB );",
 
-
 
-						"#else",
 
-
 
-							"float pointDiffuseWeight = max( dot( normal, pointVector ), 0.0 );",
 
-
 
-						"#endif",
 
-
 
-						"pointDiffuse += pointDistance * pointLightColor[ i ] * uDiffuseColor * pointDiffuseWeight;",
 
-
 
-						// specular
 
-
 
-						"vec3 pointHalfVector = normalize( pointVector + viewPosition );",
 
-						"float pointDotNormalHalf = max( dot( normal, pointHalfVector ), 0.0 );",
 
-						"float pointSpecularWeight = specularTex.r * max( pow( pointDotNormalHalf, uShininess ), 0.0 );",
 
-
 
-						"#ifdef PHYSICALLY_BASED_SHADING",
 
-
 
-							// 2.0 => 2.0001 is hack to work around ANGLE bug
 
-
 
-							"float specularNormalization = ( uShininess + 2.0001 ) / 8.0;",
 
-
 
-							"vec3 schlick = uSpecularColor + vec3( 1.0 - uSpecularColor ) * pow( 1.0 - dot( pointVector, pointHalfVector ), 5.0 );",
 
-							"pointSpecular += schlick * pointLightColor[ i ] * pointSpecularWeight * pointDiffuseWeight * pointDistance * specularNormalization;",
 
-
 
-						"#else",
 
-
 
-							"pointSpecular += pointDistance * pointLightColor[ i ] * uSpecularColor * pointSpecularWeight * pointDiffuseWeight;",
 
-
 
-						"#endif",
 
-
 
-					"}",
 
-
 
-				"#endif",
 
-
 
-				// spot lights
 
-
 
-				"#if MAX_SPOT_LIGHTS > 0",
 
-
 
-					"vec3 spotDiffuse = vec3( 0.0 );",
 
-					"vec3 spotSpecular = vec3( 0.0 );",
 
-
 
-					"for ( int i = 0; i < MAX_SPOT_LIGHTS; i ++ ) {",
 
-
 
-						"vec4 lPosition = viewMatrix * vec4( spotLightPosition[ i ], 1.0 );",
 
-						"vec3 spotVector = lPosition.xyz + vViewPosition.xyz;",
 
-
 
-						"float spotDistance = 1.0;",
 
-						"if ( spotLightDistance[ i ] > 0.0 )",
 
-							"spotDistance = 1.0 - min( ( length( spotVector ) / spotLightDistance[ i ] ), 1.0 );",
 
-
 
-						"spotVector = normalize( spotVector );",
 
-
 
-						"float spotEffect = dot( spotLightDirection[ i ], normalize( spotLightPosition[ i ] - vWorldPosition ) );",
 
-
 
-						"if ( spotEffect > spotLightAngleCos[ i ] ) {",
 
-
 
-							"spotEffect = max( pow( spotEffect, spotLightExponent[ i ] ), 0.0 );",
 
-
 
-							// diffuse
 
-
 
-							"#ifdef WRAP_AROUND",
 
-
 
-								"float spotDiffuseWeightFull = max( dot( normal, spotVector ), 0.0 );",
 
-								"float spotDiffuseWeightHalf = max( 0.5 * dot( normal, spotVector ) + 0.5, 0.0 );",
 
-
 
-								"vec3 spotDiffuseWeight = mix( vec3 ( spotDiffuseWeightFull ), vec3( spotDiffuseWeightHalf ), wrapRGB );",
 
-
 
-							"#else",
 
-
 
-								"float spotDiffuseWeight = max( dot( normal, spotVector ), 0.0 );",
 
-
 
-							"#endif",
 
-
 
-							"spotDiffuse += spotDistance * spotLightColor[ i ] * uDiffuseColor * spotDiffuseWeight * spotEffect;",
 
-
 
-							// specular
 
-
 
-							"vec3 spotHalfVector = normalize( spotVector + viewPosition );",
 
-							"float spotDotNormalHalf = max( dot( normal, spotHalfVector ), 0.0 );",
 
-							"float spotSpecularWeight = specularTex.r * max( pow( spotDotNormalHalf, uShininess ), 0.0 );",
 
-
 
-							"#ifdef PHYSICALLY_BASED_SHADING",
 
-
 
-								// 2.0 => 2.0001 is hack to work around ANGLE bug
 
-
 
-								"float specularNormalization = ( uShininess + 2.0001 ) / 8.0;",
 
-
 
-								"vec3 schlick = uSpecularColor + vec3( 1.0 - uSpecularColor ) * pow( 1.0 - dot( spotVector, spotHalfVector ), 5.0 );",
 
-								"spotSpecular += schlick * spotLightColor[ i ] * spotSpecularWeight * spotDiffuseWeight * spotDistance * specularNormalization * spotEffect;",
 
-
 
-							"#else",
 
-
 
-								"spotSpecular += spotDistance * spotLightColor[ i ] * uSpecularColor * spotSpecularWeight * spotDiffuseWeight * spotEffect;",
 
-
 
-							"#endif",
 
-
 
-						"}",
 
-
 
-					"}",
 
-
 
-				"#endif",
 
-
 
-				// directional lights
 
-
 
-				"#if MAX_DIR_LIGHTS > 0",
 
-
 
-					"vec3 dirDiffuse = vec3( 0.0 );",
 
-					"vec3 dirSpecular = vec3( 0.0 );",
 
-
 
-					"for( int i = 0; i < MAX_DIR_LIGHTS; i++ ) {",
 
-
 
-						"vec4 lDirection = viewMatrix * vec4( directionalLightDirection[ i ], 0.0 );",
 
-						"vec3 dirVector = normalize( lDirection.xyz );",
 
-
 
-						// diffuse
 
-
 
-						"#ifdef WRAP_AROUND",
 
-
 
-							"float directionalLightWeightingFull = max( dot( normal, dirVector ), 0.0 );",
 
-							"float directionalLightWeightingHalf = max( 0.5 * dot( normal, dirVector ) + 0.5, 0.0 );",
 
-
 
-							"vec3 dirDiffuseWeight = mix( vec3( directionalLightWeightingFull ), vec3( directionalLightWeightingHalf ), wrapRGB );",
 
-
 
-						"#else",
 
-
 
-							"float dirDiffuseWeight = max( dot( normal, dirVector ), 0.0 );",
 
-
 
-						"#endif",
 
-
 
-						"dirDiffuse += directionalLightColor[ i ] * uDiffuseColor * dirDiffuseWeight;",
 
-
 
-						// specular
 
-
 
-						"vec3 dirHalfVector = normalize( dirVector + viewPosition );",
 
-						"float dirDotNormalHalf = max( dot( normal, dirHalfVector ), 0.0 );",
 
-						"float dirSpecularWeight = specularTex.r * max( pow( dirDotNormalHalf, uShininess ), 0.0 );",
 
-
 
-						"#ifdef PHYSICALLY_BASED_SHADING",
 
-
 
-							// 2.0 => 2.0001 is hack to work around ANGLE bug
 
-
 
-							"float specularNormalization = ( uShininess + 2.0001 ) / 8.0;",
 
-
 
-							"vec3 schlick = uSpecularColor + vec3( 1.0 - uSpecularColor ) * pow( 1.0 - dot( dirVector, dirHalfVector ), 5.0 );",
 
-							"dirSpecular += schlick * directionalLightColor[ i ] * dirSpecularWeight * dirDiffuseWeight * specularNormalization;",
 
-
 
-						"#else",
 
-
 
-							"dirSpecular += directionalLightColor[ i ] * uSpecularColor * dirSpecularWeight * dirDiffuseWeight;",
 
-
 
-						"#endif",
 
-
 
-					"}",
 
-
 
-				"#endif",
 
-
 
-				// hemisphere lights
 
-
 
-				"#if MAX_HEMI_LIGHTS > 0",
 
-
 
-					"vec3 hemiDiffuse  = vec3( 0.0 );",
 
-					"vec3 hemiSpecular = vec3( 0.0 );" ,
 
-
 
-					"for( int i = 0; i < MAX_HEMI_LIGHTS; i ++ ) {",
 
-
 
-						"vec4 lDirection = viewMatrix * vec4( hemisphereLightDirection[ i ], 0.0 );",
 
-						"vec3 lVector = normalize( lDirection.xyz );",
 
-
 
-						// diffuse
 
-
 
-						"float dotProduct = dot( normal, lVector );",
 
-						"float hemiDiffuseWeight = 0.5 * dotProduct + 0.5;",
 
-
 
-						"vec3 hemiColor = mix( hemisphereLightGroundColor[ i ], hemisphereLightSkyColor[ i ], hemiDiffuseWeight );",
 
-
 
-						"hemiDiffuse += uDiffuseColor * hemiColor;",
 
-
 
-						// specular (sky light)
 
-
 
-
 
-						"vec3 hemiHalfVectorSky = normalize( lVector + viewPosition );",
 
-						"float hemiDotNormalHalfSky = 0.5 * dot( normal, hemiHalfVectorSky ) + 0.5;",
 
-						"float hemiSpecularWeightSky = specularTex.r * max( pow( hemiDotNormalHalfSky, uShininess ), 0.0 );",
 
-
 
-						// specular (ground light)
 
-
 
-						"vec3 lVectorGround = -lVector;",
 
-
 
-						"vec3 hemiHalfVectorGround = normalize( lVectorGround + viewPosition );",
 
-						"float hemiDotNormalHalfGround = 0.5 * dot( normal, hemiHalfVectorGround ) + 0.5;",
 
-						"float hemiSpecularWeightGround = specularTex.r * max( pow( hemiDotNormalHalfGround, uShininess ), 0.0 );",
 
-
 
-						"#ifdef PHYSICALLY_BASED_SHADING",
 
-
 
-							"float dotProductGround = dot( normal, lVectorGround );",
 
-
 
-							// 2.0 => 2.0001 is hack to work around ANGLE bug
 
-
 
-							"float specularNormalization = ( uShininess + 2.0001 ) / 8.0;",
 
-
 
-							"vec3 schlickSky = uSpecularColor + vec3( 1.0 - uSpecularColor ) * pow( 1.0 - dot( lVector, hemiHalfVectorSky ), 5.0 );",
 
-							"vec3 schlickGround = uSpecularColor + vec3( 1.0 - uSpecularColor ) * pow( 1.0 - dot( lVectorGround, hemiHalfVectorGround ), 5.0 );",
 
-							"hemiSpecular += hemiColor * specularNormalization * ( schlickSky * hemiSpecularWeightSky * max( dotProduct, 0.0 ) + schlickGround * hemiSpecularWeightGround * max( dotProductGround, 0.0 ) );",
 
-
 
-						"#else",
 
-
 
-							"hemiSpecular += uSpecularColor * hemiColor * ( hemiSpecularWeightSky + hemiSpecularWeightGround ) * hemiDiffuseWeight;",
 
-
 
-						"#endif",
 
-
 
-					"}",
 
-
 
-				"#endif",
 
-
 
-				// all lights contribution summation
 
-
 
-				"vec3 totalDiffuse = vec3( 0.0 );",
 
-				"vec3 totalSpecular = vec3( 0.0 );",
 
-
 
-				"#if MAX_DIR_LIGHTS > 0",
 
-
 
-					"totalDiffuse += dirDiffuse;",
 
-					"totalSpecular += dirSpecular;",
 
-
 
-				"#endif",
 
-
 
-				"#if MAX_HEMI_LIGHTS > 0",
 
-
 
-					"totalDiffuse += hemiDiffuse;",
 
-					"totalSpecular += hemiSpecular;",
 
-
 
-				"#endif",
 
-
 
-				"#if MAX_POINT_LIGHTS > 0",
 
-
 
-					"totalDiffuse += pointDiffuse;",
 
-					"totalSpecular += pointSpecular;",
 
-
 
-				"#endif",
 
-
 
-				"#if MAX_SPOT_LIGHTS > 0",
 
-
 
-					"totalDiffuse += spotDiffuse;",
 
-					"totalSpecular += spotSpecular;",
 
-
 
-				"#endif",
 
-
 
-				"#ifdef METAL",
 
-
 
-					"gl_FragColor.xyz = gl_FragColor.xyz * ( totalDiffuse + ambientLightColor * uAmbientColor + totalSpecular );",
 
-
 
-				"#else",
 
-
 
-					"gl_FragColor.xyz = gl_FragColor.xyz * ( totalDiffuse + ambientLightColor * uAmbientColor ) + totalSpecular;",
 
-
 
-				"#endif",
 
-
 
-				"if ( enableReflection ) {",
 
-
 
-					"vec3 vReflect;",
 
-					"vec3 cameraToVertex = normalize( vWorldPosition - cameraPosition );",
 
-
 
-					"if ( useRefract ) {",
 
-
 
-						"vReflect = refract( cameraToVertex, normal, uRefractionRatio );",
 
-
 
-					"} else {",
 
-
 
-						"vReflect = reflect( cameraToVertex, normal );",
 
-
 
-					"}",
 
-
 
-					"vec4 cubeColor = textureCube( tCube, vec3( -vReflect.x, vReflect.yz ) );",
 
-
 
-					"#ifdef GAMMA_INPUT",
 
-
 
-						"cubeColor.xyz *= cubeColor.xyz;",
 
-
 
-					"#endif",
 
-
 
-					"gl_FragColor.xyz = mix( gl_FragColor.xyz, cubeColor.xyz, specularTex.r * uReflectivity );",
 
-
 
-				"}",
 
-
 
-				THREE.ShaderChunk[ "shadowmap_fragment" ],
 
-				THREE.ShaderChunk[ "linear_to_gamma_fragment" ],
 
-				THREE.ShaderChunk[ "fog_fragment" ],
 
-
 
-			"}"
 
-
 
-		].join("\n"),
 
-
 
-		vertexShader: [
 
-
 
-			"attribute vec4 tangent;",
 
-
 
-			"uniform vec2 uOffset;",
 
-			"uniform vec2 uRepeat;",
 
-
 
-			"uniform bool enableDisplacement;",
 
-
 
-			"#ifdef VERTEX_TEXTURES",
 
-
 
-				"uniform sampler2D tDisplacement;",
 
-				"uniform float uDisplacementScale;",
 
-				"uniform float uDisplacementBias;",
 
-
 
-			"#endif",
 
-
 
-			"varying vec3 vTangent;",
 
-			"varying vec3 vBinormal;",
 
-			"varying vec3 vNormal;",
 
-			"varying vec2 vUv;",
 
-
 
-			"varying vec3 vWorldPosition;",
 
-			"varying vec3 vViewPosition;",
 
-
 
-			THREE.ShaderChunk[ "skinning_pars_vertex" ],
 
-			THREE.ShaderChunk[ "shadowmap_pars_vertex" ],
 
-
 
-			"void main() {",
 
-
 
-				THREE.ShaderChunk[ "skinbase_vertex" ],
 
-				THREE.ShaderChunk[ "skinnormal_vertex" ],
 
-
 
-				// normal, tangent and binormal vectors
 
-
 
-				"#ifdef USE_SKINNING",
 
-
 
-					"vNormal = normalize( normalMatrix * skinnedNormal.xyz );",
 
-
 
-					"vec4 skinnedTangent = skinMatrix * vec4( tangent.xyz, 0.0 );",
 
-					"vTangent = normalize( normalMatrix * skinnedTangent.xyz );",
 
-
 
-				"#else",
 
-
 
-					"vNormal = normalize( normalMatrix * normal );",
 
-					"vTangent = normalize( normalMatrix * tangent.xyz );",
 
-
 
-				"#endif",
 
-
 
-				"vBinormal = normalize( cross( vNormal, vTangent ) * tangent.w );",
 
-
 
-				"vUv = uv * uRepeat + uOffset;",
 
-
 
-				// displacement mapping
 
-
 
-				"vec3 displacedPosition;",
 
-
 
-				"#ifdef VERTEX_TEXTURES",
 
-
 
-					"if ( enableDisplacement ) {",
 
-
 
-						"vec3 dv = texture2D( tDisplacement, uv ).xyz;",
 
-						"float df = uDisplacementScale * dv.x + uDisplacementBias;",
 
-						"displacedPosition = position + normalize( normal ) * df;",
 
-
 
-					"} else {",
 
-
 
-						"#ifdef USE_SKINNING",
 
-
 
-							"vec4 skinVertex = vec4( position, 1.0 );",
 
-
 
-							"vec4 skinned  = boneMatX * skinVertex * skinWeight.x;",
 
-							"skinned 	  += boneMatY * skinVertex * skinWeight.y;",
 
-
 
-							"displacedPosition  = skinned.xyz;",
 
-
 
-						"#else",
 
-
 
-							"displacedPosition = position;",
 
-
 
-						"#endif",
 
-
 
-					"}",
 
-
 
-				"#else",
 
-
 
-					"#ifdef USE_SKINNING",
 
-
 
-						"vec4 skinVertex = vec4( position, 1.0 );",
 
-
 
-						"vec4 skinned  = boneMatX * skinVertex * skinWeight.x;",
 
-						"skinned 	  += boneMatY * skinVertex * skinWeight.y;",
 
-
 
-						"displacedPosition  = skinned.xyz;",
 
-
 
-					"#else",
 
-
 
-						"displacedPosition = position;",
 
-
 
-					"#endif",
 
-
 
-				"#endif",
 
-
 
-				//
 
-
 
-				"vec4 mvPosition = modelViewMatrix * vec4( displacedPosition, 1.0 );",
 
-				"vec4 worldPosition = modelMatrix * vec4( displacedPosition, 1.0 );",
 
-
 
-				"gl_Position = projectionMatrix * mvPosition;",
 
-
 
-				//
 
-
 
-				"vWorldPosition = worldPosition.xyz;",
 
-				"vViewPosition = -mvPosition.xyz;",
 
-
 
-				// shadows
 
-
 
-				"#ifdef USE_SHADOWMAP",
 
-
 
-					"for( int i = 0; i < MAX_SHADOWS; i ++ ) {",
 
-
 
-						"vShadowCoord[ i ] = shadowMatrix[ i ] * worldPosition;",
 
-
 
-					"}",
 
-
 
-				"#endif",
 
-
 
-			"}"
 
-
 
-		].join("\n")
 
-
 
-	},
 
-
 
-	/* -------------------------------------------------------------------------
 
-	//	Cube map shader
 
-	 ------------------------------------------------------------------------- */
 
-
 
-	'cube': {
 
-
 
-		uniforms: { "tCube": { type: "t", value: null },
 
-					"tFlip": { type: "f", value: -1 } },
 
-
 
-		vertexShader: [
 
-
 
-			"varying vec3 vWorldPosition;",
 
-
 
-			"void main() {",
 
-
 
-				"vec4 worldPosition = modelMatrix * vec4( position, 1.0 );",
 
-				"vWorldPosition = worldPosition.xyz;",
 
-
 
-				"gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
 
-
 
-			"}"
 
-
 
-		].join("\n"),
 
-
 
-		fragmentShader: [
 
-
 
-			"uniform samplerCube tCube;",
 
-			"uniform float tFlip;",
 
-
 
-			"varying vec3 vWorldPosition;",
 
-
 
-			"void main() {",
 
-
 
-				"gl_FragColor = textureCube( tCube, vec3( tFlip * vWorldPosition.x, vWorldPosition.yz ) );",
 
-
 
-			"}"
 
-
 
-		].join("\n")
 
-
 
-	},
 
-
 
-	// Depth encoding into RGBA texture
 
-	// 	based on SpiderGL shadow map example
 
-	// 		http://spidergl.org/example.php?id=6
 
-	// 	originally from
 
-	//		http://www.gamedev.net/topic/442138-packing-a-float-into-a-a8r8g8b8-texture-shader/page__whichpage__1%25EF%25BF%25BD
 
-	// 	see also here:
 
-	//		http://aras-p.info/blog/2009/07/30/encoding-floats-to-rgba-the-final/
 
-
 
-	'depthRGBA': {
 
-
 
-		uniforms: {},
 
-
 
-		vertexShader: [
 
-
 
-			THREE.ShaderChunk[ "morphtarget_pars_vertex" ],
 
-			THREE.ShaderChunk[ "skinning_pars_vertex" ],
 
-
 
-			"void main() {",
 
-
 
-				THREE.ShaderChunk[ "skinbase_vertex" ],
 
-				THREE.ShaderChunk[ "morphtarget_vertex" ],
 
-				THREE.ShaderChunk[ "skinning_vertex" ],
 
-				THREE.ShaderChunk[ "default_vertex" ],
 
-
 
-			"}"
 
-
 
-		].join("\n"),
 
-
 
-		fragmentShader: [
 
-
 
-			"vec4 pack_depth( const in float depth ) {",
 
-
 
-				"const vec4 bit_shift = vec4( 256.0 * 256.0 * 256.0, 256.0 * 256.0, 256.0, 1.0 );",
 
-				"const vec4 bit_mask  = vec4( 0.0, 1.0 / 256.0, 1.0 / 256.0, 1.0 / 256.0 );",
 
-				"vec4 res = fract( depth * bit_shift );",
 
-				"res -= res.xxyz * bit_mask;",
 
-				"return res;",
 
-
 
-			"}",
 
-
 
-			"void main() {",
 
-
 
-				"gl_FragData[ 0 ] = pack_depth( gl_FragCoord.z );",
 
-
 
-				//"gl_FragData[ 0 ] = pack_depth( gl_FragCoord.z / gl_FragCoord.w );",
 
-				//"float z = ( ( gl_FragCoord.z / gl_FragCoord.w ) - 3.0 ) / ( 4000.0 - 3.0 );",
 
-				//"gl_FragData[ 0 ] = pack_depth( z );",
 
-				//"gl_FragData[ 0 ] = vec4( z, z, z, 1.0 );",
 
-
 
-			"}"
 
-
 
-		].join("\n")
 
-
 
-	}
 
-
 
-};

+ 1276 - 0
src/renderers/shaders/ShaderLib.js
Xem Tập Tin 

@@ -0,0 +1,1276 @@
 
+/**
 
+ * Webgl Shader Library for three.js
 
+ *
 
+ * @author alteredq / http://alteredqualia.com/
 
+ * @author mrdoob / http://mrdoob.com/
 
+ * @author mikael emtinger / http://gomo.se/
 
+ */
 
+
 
+
 
+THREE.ShaderLib = {
 
+
 
+	'basic': {
 
+
 
+		uniforms: THREE.UniformsUtils.merge( [
 
+
 
+			THREE.UniformsLib[ "common" ],
 
+			THREE.UniformsLib[ "fog" ],
 
+			THREE.UniformsLib[ "shadowmap" ]
 
+
 
+		] ),
 
+
 
+		vertexShader: [
 
+
 
+			THREE.ShaderChunk[ "map_pars_vertex" ],
 
+			THREE.ShaderChunk[ "lightmap_pars_vertex" ],
 
+			THREE.ShaderChunk[ "envmap_pars_vertex" ],
 
+			THREE.ShaderChunk[ "color_pars_vertex" ],
 
+			THREE.ShaderChunk[ "morphtarget_pars_vertex" ],
 
+			THREE.ShaderChunk[ "skinning_pars_vertex" ],
 
+			THREE.ShaderChunk[ "shadowmap_pars_vertex" ],
 
+
 
+			"void main() {",
 
+
 
+				THREE.ShaderChunk[ "map_vertex" ],
 
+				THREE.ShaderChunk[ "lightmap_vertex" ],
 
+				THREE.ShaderChunk[ "color_vertex" ],
 
+				THREE.ShaderChunk[ "skinbase_vertex" ],
 
+
 
+				"#ifdef USE_ENVMAP",
 
+
 
+				THREE.ShaderChunk[ "morphnormal_vertex" ],
 
+				THREE.ShaderChunk[ "skinnormal_vertex" ],
 
+				THREE.ShaderChunk[ "defaultnormal_vertex" ],
 
+
 
+				"#endif",
 
+
 
+				THREE.ShaderChunk[ "morphtarget_vertex" ],
 
+				THREE.ShaderChunk[ "skinning_vertex" ],
 
+				THREE.ShaderChunk[ "default_vertex" ],
 
+
 
+				THREE.ShaderChunk[ "worldpos_vertex" ],
 
+				THREE.ShaderChunk[ "envmap_vertex" ],
 
+				THREE.ShaderChunk[ "shadowmap_vertex" ],
 
+
 
+			"}"
 
+
 
+		].join("\n"),
 
+
 
+		fragmentShader: [
 
+
 
+			"uniform vec3 diffuse;",
 
+			"uniform float opacity;",
 
+
 
+			THREE.ShaderChunk[ "color_pars_fragment" ],
 
+			THREE.ShaderChunk[ "map_pars_fragment" ],
 
+			THREE.ShaderChunk[ "lightmap_pars_fragment" ],
 
+			THREE.ShaderChunk[ "envmap_pars_fragment" ],
 
+			THREE.ShaderChunk[ "fog_pars_fragment" ],
 
+			THREE.ShaderChunk[ "shadowmap_pars_fragment" ],
 
+			THREE.ShaderChunk[ "specularmap_pars_fragment" ],
 
+
 
+			"void main() {",
 
+
 
+				"gl_FragColor = vec4( diffuse, opacity );",
 
+
 
+				THREE.ShaderChunk[ "map_fragment" ],
 
+				THREE.ShaderChunk[ "alphatest_fragment" ],
 
+				THREE.ShaderChunk[ "specularmap_fragment" ],
 
+				THREE.ShaderChunk[ "lightmap_fragment" ],
 
+				THREE.ShaderChunk[ "color_fragment" ],
 
+				THREE.ShaderChunk[ "envmap_fragment" ],
 
+				THREE.ShaderChunk[ "shadowmap_fragment" ],
 
+
 
+				THREE.ShaderChunk[ "linear_to_gamma_fragment" ],
 
+
 
+				THREE.ShaderChunk[ "fog_fragment" ],
 
+
 
+			"}"
 
+
 
+		].join("\n")
 
+
 
+	},
 
+
 
+	'lambert': {
 
+
 
+		uniforms: THREE.UniformsUtils.merge( [
 
+
 
+			THREE.UniformsLib[ "common" ],
 
+			THREE.UniformsLib[ "fog" ],
 
+			THREE.UniformsLib[ "lights" ],
 
+			THREE.UniformsLib[ "shadowmap" ],
 
+
 
+			{
 
+				"ambient"  : { type: "c", value: new THREE.Color( 0xffffff ) },
 
+				"emissive" : { type: "c", value: new THREE.Color( 0x000000 ) },
 
+				"wrapRGB"  : { type: "v3", value: new THREE.Vector3( 1, 1, 1 ) }
 
+			}
 
+
 
+		] ),
 
+
 
+		vertexShader: [
 
+
 
+			"#define LAMBERT",
 
+
 
+			"varying vec3 vLightFront;",
 
+
 
+			"#ifdef DOUBLE_SIDED",
 
+
 
+				"varying vec3 vLightBack;",
 
+
 
+			"#endif",
 
+
 
+			THREE.ShaderChunk[ "map_pars_vertex" ],
 
+			THREE.ShaderChunk[ "lightmap_pars_vertex" ],
 
+			THREE.ShaderChunk[ "envmap_pars_vertex" ],
 
+			THREE.ShaderChunk[ "lights_lambert_pars_vertex" ],
 
+			THREE.ShaderChunk[ "color_pars_vertex" ],
 
+			THREE.ShaderChunk[ "morphtarget_pars_vertex" ],
 
+			THREE.ShaderChunk[ "skinning_pars_vertex" ],
 
+			THREE.ShaderChunk[ "shadowmap_pars_vertex" ],
 
+
 
+			"void main() {",
 
+
 
+				THREE.ShaderChunk[ "map_vertex" ],
 
+				THREE.ShaderChunk[ "lightmap_vertex" ],
 
+				THREE.ShaderChunk[ "color_vertex" ],
 
+
 
+				THREE.ShaderChunk[ "morphnormal_vertex" ],
 
+				THREE.ShaderChunk[ "skinbase_vertex" ],
 
+				THREE.ShaderChunk[ "skinnormal_vertex" ],
 
+				THREE.ShaderChunk[ "defaultnormal_vertex" ],
 
+
 
+				THREE.ShaderChunk[ "morphtarget_vertex" ],
 
+				THREE.ShaderChunk[ "skinning_vertex" ],
 
+				THREE.ShaderChunk[ "default_vertex" ],
 
+
 
+				THREE.ShaderChunk[ "worldpos_vertex" ],
 
+				THREE.ShaderChunk[ "envmap_vertex" ],
 
+				THREE.ShaderChunk[ "lights_lambert_vertex" ],
 
+				THREE.ShaderChunk[ "shadowmap_vertex" ],
 
+
 
+			"}"
 
+
 
+		].join("\n"),
 
+
 
+		fragmentShader: [
 
+
 
+			"uniform float opacity;",
 
+
 
+			"varying vec3 vLightFront;",
 
+
 
+			"#ifdef DOUBLE_SIDED",
 
+
 
+				"varying vec3 vLightBack;",
 
+
 
+			"#endif",
 
+
 
+			THREE.ShaderChunk[ "color_pars_fragment" ],
 
+			THREE.ShaderChunk[ "map_pars_fragment" ],
 
+			THREE.ShaderChunk[ "lightmap_pars_fragment" ],
 
+			THREE.ShaderChunk[ "envmap_pars_fragment" ],
 
+			THREE.ShaderChunk[ "fog_pars_fragment" ],
 
+			THREE.ShaderChunk[ "shadowmap_pars_fragment" ],
 
+			THREE.ShaderChunk[ "specularmap_pars_fragment" ],
 
+
 
+			"void main() {",
 
+
 
+				"gl_FragColor = vec4( vec3 ( 1.0 ), opacity );",
 
+
 
+				THREE.ShaderChunk[ "map_fragment" ],
 
+				THREE.ShaderChunk[ "alphatest_fragment" ],
 
+				THREE.ShaderChunk[ "specularmap_fragment" ],
 
+
 
+				"#ifdef DOUBLE_SIDED",
 
+
 
+					//"float isFront = float( gl_FrontFacing );",
 
+					//"gl_FragColor.xyz *= isFront * vLightFront + ( 1.0 - isFront ) * vLightBack;",
 
+
 
+					"if ( gl_FrontFacing )",
 
+						"gl_FragColor.xyz *= vLightFront;",
 
+					"else",
 
+						"gl_FragColor.xyz *= vLightBack;",
 
+
 
+				"#else",
 
+
 
+					"gl_FragColor.xyz *= vLightFront;",
 
+
 
+				"#endif",
 
+
 
+				THREE.ShaderChunk[ "lightmap_fragment" ],
 
+				THREE.ShaderChunk[ "color_fragment" ],
 
+				THREE.ShaderChunk[ "envmap_fragment" ],
 
+				THREE.ShaderChunk[ "shadowmap_fragment" ],
 
+
 
+				THREE.ShaderChunk[ "linear_to_gamma_fragment" ],
 
+
 
+				THREE.ShaderChunk[ "fog_fragment" ],
 
+
 
+			"}"
 
+
 
+		].join("\n")
 
+
 
+	},
 
+
 
+	'phong': {
 
+
 
+		uniforms: THREE.UniformsUtils.merge( [
 
+
 
+			THREE.UniformsLib[ "common" ],
 
+			THREE.UniformsLib[ "bump" ],
 
+			THREE.UniformsLib[ "normalmap" ],
 
+			THREE.UniformsLib[ "fog" ],
 
+			THREE.UniformsLib[ "lights" ],
 
+			THREE.UniformsLib[ "shadowmap" ],
 
+
 
+			{
 
+				"ambient"  : { type: "c", value: new THREE.Color( 0xffffff ) },
 
+				"emissive" : { type: "c", value: new THREE.Color( 0x000000 ) },
 
+				"specular" : { type: "c", value: new THREE.Color( 0x111111 ) },
 
+				"shininess": { type: "f", value: 30 },
 
+				"wrapRGB"  : { type: "v3", value: new THREE.Vector3( 1, 1, 1 ) }
 
+			}
 
+
 
+		] ),
 
+
 
+		vertexShader: [
 
+
 
+			"#define PHONG",
 
+
 
+			"varying vec3 vViewPosition;",
 
+			"varying vec3 vNormal;",
 
+
 
+			THREE.ShaderChunk[ "map_pars_vertex" ],
 
+			THREE.ShaderChunk[ "lightmap_pars_vertex" ],
 
+			THREE.ShaderChunk[ "envmap_pars_vertex" ],
 
+			THREE.ShaderChunk[ "lights_phong_pars_vertex" ],
 
+			THREE.ShaderChunk[ "color_pars_vertex" ],
 
+			THREE.ShaderChunk[ "morphtarget_pars_vertex" ],
 
+			THREE.ShaderChunk[ "skinning_pars_vertex" ],
 
+			THREE.ShaderChunk[ "shadowmap_pars_vertex" ],
 
+
 
+			"void main() {",
 
+
 
+				THREE.ShaderChunk[ "map_vertex" ],
 
+				THREE.ShaderChunk[ "lightmap_vertex" ],
 
+				THREE.ShaderChunk[ "color_vertex" ],
 
+
 
+				THREE.ShaderChunk[ "morphnormal_vertex" ],
 
+				THREE.ShaderChunk[ "skinbase_vertex" ],
 
+				THREE.ShaderChunk[ "skinnormal_vertex" ],
 
+				THREE.ShaderChunk[ "defaultnormal_vertex" ],
 
+
 
+				"vNormal = normalize( transformedNormal );",
 
+
 
+				THREE.ShaderChunk[ "morphtarget_vertex" ],
 
+				THREE.ShaderChunk[ "skinning_vertex" ],
 
+				THREE.ShaderChunk[ "default_vertex" ],
 
+
 
+				"vViewPosition = -mvPosition.xyz;",
 
+
 
+				THREE.ShaderChunk[ "worldpos_vertex" ],
 
+				THREE.ShaderChunk[ "envmap_vertex" ],
 
+				THREE.ShaderChunk[ "lights_phong_vertex" ],
 
+				THREE.ShaderChunk[ "shadowmap_vertex" ],
 
+
 
+			"}"
 
+
 
+		].join("\n"),
 
+
 
+		fragmentShader: [
 
+
 
+			"uniform vec3 diffuse;",
 
+			"uniform float opacity;",
 
+
 
+			"uniform vec3 ambient;",
 
+			"uniform vec3 emissive;",
 
+			"uniform vec3 specular;",
 
+			"uniform float shininess;",
 
+
 
+			THREE.ShaderChunk[ "color_pars_fragment" ],
 
+			THREE.ShaderChunk[ "map_pars_fragment" ],
 
+			THREE.ShaderChunk[ "lightmap_pars_fragment" ],
 
+			THREE.ShaderChunk[ "envmap_pars_fragment" ],
 
+			THREE.ShaderChunk[ "fog_pars_fragment" ],
 
+			THREE.ShaderChunk[ "lights_phong_pars_fragment" ],
 
+			THREE.ShaderChunk[ "shadowmap_pars_fragment" ],
 
+			THREE.ShaderChunk[ "bumpmap_pars_fragment" ],
 
+			THREE.ShaderChunk[ "normalmap_pars_fragment" ],
 
+			THREE.ShaderChunk[ "specularmap_pars_fragment" ],
 
+
 
+			"void main() {",
 
+
 
+				"gl_FragColor = vec4( vec3 ( 1.0 ), opacity );",
 
+
 
+				THREE.ShaderChunk[ "map_fragment" ],
 
+				THREE.ShaderChunk[ "alphatest_fragment" ],
 
+				THREE.ShaderChunk[ "specularmap_fragment" ],
 
+
 
+				THREE.ShaderChunk[ "lights_phong_fragment" ],
 
+
 
+				THREE.ShaderChunk[ "lightmap_fragment" ],
 
+				THREE.ShaderChunk[ "color_fragment" ],
 
+				THREE.ShaderChunk[ "envmap_fragment" ],
 
+				THREE.ShaderChunk[ "shadowmap_fragment" ],
 
+
 
+				THREE.ShaderChunk[ "linear_to_gamma_fragment" ],
 
+
 
+				THREE.ShaderChunk[ "fog_fragment" ],
 
+
 
+			"}"
 
+
 
+		].join("\n")
 
+
 
+	},
 
+
 
+	'particle_basic': {
 
+
 
+		uniforms:  THREE.UniformsUtils.merge( [
 
+
 
+			THREE.UniformsLib[ "particle" ],
 
+			THREE.UniformsLib[ "shadowmap" ]
 
+
 
+		] ),
 
+
 
+		vertexShader: [
 
+
 
+			"uniform float size;",
 
+			"uniform float scale;",
 
+
 
+			THREE.ShaderChunk[ "color_pars_vertex" ],
 
+			THREE.ShaderChunk[ "shadowmap_pars_vertex" ],
 
+
 
+			"void main() {",
 
+
 
+				THREE.ShaderChunk[ "color_vertex" ],
 
+
 
+				"vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );",
 
+
 
+				"#ifdef USE_SIZEATTENUATION",
 
+					"gl_PointSize = size * ( scale / length( mvPosition.xyz ) );",
 
+				"#else",
 
+					"gl_PointSize = size;",
 
+				"#endif",
 
+
 
+				"gl_Position = projectionMatrix * mvPosition;",
 
+
 
+				THREE.ShaderChunk[ "worldpos_vertex" ],
 
+				THREE.ShaderChunk[ "shadowmap_vertex" ],
 
+
 
+			"}"
 
+
 
+		].join("\n"),
 
+
 
+		fragmentShader: [
 
+
 
+			"uniform vec3 psColor;",
 
+			"uniform float opacity;",
 
+
 
+			THREE.ShaderChunk[ "color_pars_fragment" ],
 
+			THREE.ShaderChunk[ "map_particle_pars_fragment" ],
 
+			THREE.ShaderChunk[ "fog_pars_fragment" ],
 
+			THREE.ShaderChunk[ "shadowmap_pars_fragment" ],
 
+
 
+			"void main() {",
 
+
 
+				"gl_FragColor = vec4( psColor, opacity );",
 
+
 
+				THREE.ShaderChunk[ "map_particle_fragment" ],
 
+				THREE.ShaderChunk[ "alphatest_fragment" ],
 
+				THREE.ShaderChunk[ "color_fragment" ],
 
+				THREE.ShaderChunk[ "shadowmap_fragment" ],
 
+				THREE.ShaderChunk[ "fog_fragment" ],
 
+
 
+			"}"
 
+
 
+		].join("\n")
 
+
 
+	},
 
+
 
+	'dashed': {
 
+
 
+		uniforms: THREE.UniformsUtils.merge( [
 
+
 
+			THREE.UniformsLib[ "common" ],
 
+			THREE.UniformsLib[ "fog" ],
 
+
 
+			{
 
+				"scale":     { type: "f", value: 1 },
 
+				"dashSize":  { type: "f", value: 1 },
 
+				"totalSize": { type: "f", value: 2 }
 
+			}
 
+
 
+		] ),
 
+
 
+		vertexShader: [
 
+
 
+			"uniform float scale;",
 
+			"attribute float lineDistance;",
 
+
 
+			"varying float vLineDistance;",
 
+
 
+			THREE.ShaderChunk[ "color_pars_vertex" ],
 
+
 
+			"void main() {",
 
+
 
+				THREE.ShaderChunk[ "color_vertex" ],
 
+
 
+				"vLineDistance = scale * lineDistance;",
 
+
 
+				"vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );",
 
+				"gl_Position = projectionMatrix * mvPosition;",
 
+
 
+			"}"
 
+
 
+		].join("\n"),
 
+
 
+		fragmentShader: [
 
+
 
+			"uniform vec3 diffuse;",
 
+			"uniform float opacity;",
 
+
 
+			"uniform float dashSize;",
 
+			"uniform float totalSize;",
 
+
 
+			"varying float vLineDistance;",
 
+
 
+			THREE.ShaderChunk[ "color_pars_fragment" ],
 
+			THREE.ShaderChunk[ "fog_pars_fragment" ],
 
+
 
+			"void main() {",
 
+
 
+				"if ( mod( vLineDistance, totalSize ) > dashSize ) {",
 
+
 
+					"discard;",
 
+
 
+				"}",
 
+
 
+				"gl_FragColor = vec4( diffuse, opacity );",
 
+
 
+				THREE.ShaderChunk[ "color_fragment" ],
 
+				THREE.ShaderChunk[ "fog_fragment" ],
 
+
 
+			"}"
 
+
 
+		].join("\n")
 
+
 
+	},
 
+
 
+	'depth': {
 
+
 
+		uniforms: {
 
+
 
+			"mNear": { type: "f", value: 1.0 },
 
+			"mFar" : { type: "f", value: 2000.0 },
 
+			"opacity" : { type: "f", value: 1.0 }
 
+
 
+		},
 
+
 
+		vertexShader: [
 
+
 
+			"void main() {",
 
+
 
+				"gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
 
+
 
+			"}"
 
+
 
+		].join("\n"),
 
+
 
+		fragmentShader: [
 
+
 
+			"uniform float mNear;",
 
+			"uniform float mFar;",
 
+			"uniform float opacity;",
 
+
 
+			"void main() {",
 
+
 
+				"float depth = gl_FragCoord.z / gl_FragCoord.w;",
 
+				"float color = 1.0 - smoothstep( mNear, mFar, depth );",
 
+				"gl_FragColor = vec4( vec3( color ), opacity );",
 
+
 
+			"}"
 
+
 
+		].join("\n")
 
+
 
+	},
 
+
 
+	'normal': {
 
+
 
+		uniforms: {
 
+
 
+			"opacity" : { type: "f", value: 1.0 }
 
+
 
+		},
 
+
 
+		vertexShader: [
 
+
 
+			"varying vec3 vNormal;",
 
+
 
+			THREE.ShaderChunk[ "morphtarget_pars_vertex" ],
 
+
 
+			"void main() {",
 
+
 
+				"vNormal = normalize( normalMatrix * normal );",
 
+
 
+				THREE.ShaderChunk[ "morphtarget_vertex" ],
 
+				THREE.ShaderChunk[ "default_vertex" ],
 
+
 
+			"}"
 
+
 
+		].join("\n"),
 
+
 
+		fragmentShader: [
 
+
 
+			"uniform float opacity;",
 
+			"varying vec3 vNormal;",
 
+
 
+			"void main() {",
 
+
 
+				"gl_FragColor = vec4( 0.5 * normalize( vNormal ) + 0.5, opacity );",
 
+
 
+			"}"
 
+
 
+		].join("\n")
 
+
 
+	},
 
+
 
+	/* -------------------------------------------------------------------------
 
+	//	Normal map shader
 
+	//		- Blinn-Phong
 
+	//		- normal + diffuse + specular + AO + displacement + reflection + shadow maps
 
+	//		- point and directional lights (use with "lights: true" material option)
 
+	 ------------------------------------------------------------------------- */
 
+
 
+	'normalmap' : {
 
+
 
+		uniforms: THREE.UniformsUtils.merge( [
 
+
 
+			THREE.UniformsLib[ "fog" ],
 
+			THREE.UniformsLib[ "lights" ],
 
+			THREE.UniformsLib[ "shadowmap" ],
 
+
 
+			{
 
+
 
+			"enableAO"		  : { type: "i", value: 0 },
 
+			"enableDiffuse"	  : { type: "i", value: 0 },
 
+			"enableSpecular"  : { type: "i", value: 0 },
 
+			"enableReflection": { type: "i", value: 0 },
 
+			"enableDisplacement": { type: "i", value: 0 },
 
+
 
+			"tDisplacement": { type: "t", value: null }, // must go first as this is vertex texture
 
+			"tDiffuse"	   : { type: "t", value: null },
 
+			"tCube"		   : { type: "t", value: null },
 
+			"tNormal"	   : { type: "t", value: null },
 
+			"tSpecular"	   : { type: "t", value: null },
 
+			"tAO"		   : { type: "t", value: null },
 
+
 
+			"uNormalScale": { type: "v2", value: new THREE.Vector2( 1, 1 ) },
 
+
 
+			"uDisplacementBias": { type: "f", value: 0.0 },
 
+			"uDisplacementScale": { type: "f", value: 1.0 },
 
+
 
+			"uDiffuseColor": { type: "c", value: new THREE.Color( 0xffffff ) },
 
+			"uSpecularColor": { type: "c", value: new THREE.Color( 0x111111 ) },
 
+			"uAmbientColor": { type: "c", value: new THREE.Color( 0xffffff ) },
 
+			"uShininess": { type: "f", value: 30 },
 
+			"uOpacity": { type: "f", value: 1 },
 
+
 
+			"useRefract": { type: "i", value: 0 },
 
+			"uRefractionRatio": { type: "f", value: 0.98 },
 
+			"uReflectivity": { type: "f", value: 0.5 },
 
+
 
+			"uOffset" : { type: "v2", value: new THREE.Vector2( 0, 0 ) },
 
+			"uRepeat" : { type: "v2", value: new THREE.Vector2( 1, 1 ) },
 
+
 
+			"wrapRGB"  : { type: "v3", value: new THREE.Vector3( 1, 1, 1 ) }
 
+
 
+			}
 
+
 
+		] ),
 
+
 
+		fragmentShader: [
 
+
 
+			"uniform vec3 uAmbientColor;",
 
+			"uniform vec3 uDiffuseColor;",
 
+			"uniform vec3 uSpecularColor;",
 
+			"uniform float uShininess;",
 
+			"uniform float uOpacity;",
 
+
 
+			"uniform bool enableDiffuse;",
 
+			"uniform bool enableSpecular;",
 
+			"uniform bool enableAO;",
 
+			"uniform bool enableReflection;",
 
+
 
+			"uniform sampler2D tDiffuse;",
 
+			"uniform sampler2D tNormal;",
 
+			"uniform sampler2D tSpecular;",
 
+			"uniform sampler2D tAO;",
 
+
 
+			"uniform samplerCube tCube;",
 
+
 
+			"uniform vec2 uNormalScale;",
 
+
 
+			"uniform bool useRefract;",
 
+			"uniform float uRefractionRatio;",
 
+			"uniform float uReflectivity;",
 
+
 
+			"varying vec3 vTangent;",
 
+			"varying vec3 vBinormal;",
 
+			"varying vec3 vNormal;",
 
+			"varying vec2 vUv;",
 
+
 
+			"uniform vec3 ambientLightColor;",
 
+
 
+			"#if MAX_DIR_LIGHTS > 0",
 
+
 
+				"uniform vec3 directionalLightColor[ MAX_DIR_LIGHTS ];",
 
+				"uniform vec3 directionalLightDirection[ MAX_DIR_LIGHTS ];",
 
+
 
+			"#endif",
 
+
 
+			"#if MAX_HEMI_LIGHTS > 0",
 
+
 
+				"uniform vec3 hemisphereLightSkyColor[ MAX_HEMI_LIGHTS ];",
 
+				"uniform vec3 hemisphereLightGroundColor[ MAX_HEMI_LIGHTS ];",
 
+				"uniform vec3 hemisphereLightDirection[ MAX_HEMI_LIGHTS ];",
 
+
 
+			"#endif",
 
+
 
+			"#if MAX_POINT_LIGHTS > 0",
 
+
 
+				"uniform vec3 pointLightColor[ MAX_POINT_LIGHTS ];",
 
+				"uniform vec3 pointLightPosition[ MAX_POINT_LIGHTS ];",
 
+				"uniform float pointLightDistance[ MAX_POINT_LIGHTS ];",
 
+
 
+			"#endif",
 
+
 
+			"#if MAX_SPOT_LIGHTS > 0",
 
+
 
+				"uniform vec3 spotLightColor[ MAX_SPOT_LIGHTS ];",
 
+				"uniform vec3 spotLightPosition[ MAX_SPOT_LIGHTS ];",
 
+				"uniform vec3 spotLightDirection[ MAX_SPOT_LIGHTS ];",
 
+				"uniform float spotLightAngleCos[ MAX_SPOT_LIGHTS ];",
 
+				"uniform float spotLightExponent[ MAX_SPOT_LIGHTS ];",
 
+				"uniform float spotLightDistance[ MAX_SPOT_LIGHTS ];",
 
+
 
+			"#endif",
 
+
 
+			"#ifdef WRAP_AROUND",
 
+
 
+				"uniform vec3 wrapRGB;",
 
+
 
+			"#endif",
 
+
 
+			"varying vec3 vWorldPosition;",
 
+			"varying vec3 vViewPosition;",
 
+
 
+			THREE.ShaderChunk[ "shadowmap_pars_fragment" ],
 
+			THREE.ShaderChunk[ "fog_pars_fragment" ],
 
+
 
+			"void main() {",
 
+
 
+				"gl_FragColor = vec4( vec3( 1.0 ), uOpacity );",
 
+
 
+				"vec3 specularTex = vec3( 1.0 );",
 
+
 
+				"vec3 normalTex = texture2D( tNormal, vUv ).xyz * 2.0 - 1.0;",
 
+				"normalTex.xy *= uNormalScale;",
 
+				"normalTex = normalize( normalTex );",
 
+
 
+				"if( enableDiffuse ) {",
 
+
 
+					"#ifdef GAMMA_INPUT",
 
+
 
+						"vec4 texelColor = texture2D( tDiffuse, vUv );",
 
+						"texelColor.xyz *= texelColor.xyz;",
 
+
 
+						"gl_FragColor = gl_FragColor * texelColor;",
 
+
 
+					"#else",
 
+
 
+						"gl_FragColor = gl_FragColor * texture2D( tDiffuse, vUv );",
 
+
 
+					"#endif",
 
+
 
+				"}",
 
+
 
+				"if( enableAO ) {",
 
+
 
+					"#ifdef GAMMA_INPUT",
 
+
 
+						"vec4 aoColor = texture2D( tAO, vUv );",
 
+						"aoColor.xyz *= aoColor.xyz;",
 
+
 
+						"gl_FragColor.xyz = gl_FragColor.xyz * aoColor.xyz;",
 
+
 
+					"#else",
 
+
 
+						"gl_FragColor.xyz = gl_FragColor.xyz * texture2D( tAO, vUv ).xyz;",
 
+
 
+					"#endif",
 
+
 
+				"}",
 
+
 
+				"if( enableSpecular )",
 
+					"specularTex = texture2D( tSpecular, vUv ).xyz;",
 
+
 
+				"mat3 tsb = mat3( normalize( vTangent ), normalize( vBinormal ), normalize( vNormal ) );",
 
+				"vec3 finalNormal = tsb * normalTex;",
 
+
 
+				"#ifdef FLIP_SIDED",
 
+
 
+					"finalNormal = -finalNormal;",
 
+
 
+				"#endif",
 
+
 
+				"vec3 normal = normalize( finalNormal );",
 
+				"vec3 viewPosition = normalize( vViewPosition );",
 
+
 
+				// point lights
 
+
 
+				"#if MAX_POINT_LIGHTS > 0",
 
+
 
+					"vec3 pointDiffuse = vec3( 0.0 );",
 
+					"vec3 pointSpecular = vec3( 0.0 );",
 
+
 
+					"for ( int i = 0; i < MAX_POINT_LIGHTS; i ++ ) {",
 
+
 
+						"vec4 lPosition = viewMatrix * vec4( pointLightPosition[ i ], 1.0 );",
 
+						"vec3 pointVector = lPosition.xyz + vViewPosition.xyz;",
 
+
 
+						"float pointDistance = 1.0;",
 
+						"if ( pointLightDistance[ i ] > 0.0 )",
 
+							"pointDistance = 1.0 - min( ( length( pointVector ) / pointLightDistance[ i ] ), 1.0 );",
 
+
 
+						"pointVector = normalize( pointVector );",
 
+
 
+						// diffuse
 
+
 
+						"#ifdef WRAP_AROUND",
 
+
 
+							"float pointDiffuseWeightFull = max( dot( normal, pointVector ), 0.0 );",
 
+							"float pointDiffuseWeightHalf = max( 0.5 * dot( normal, pointVector ) + 0.5, 0.0 );",
 
+
 
+							"vec3 pointDiffuseWeight = mix( vec3 ( pointDiffuseWeightFull ), vec3( pointDiffuseWeightHalf ), wrapRGB );",
 
+
 
+						"#else",
 
+
 
+							"float pointDiffuseWeight = max( dot( normal, pointVector ), 0.0 );",
 
+
 
+						"#endif",
 
+
 
+						"pointDiffuse += pointDistance * pointLightColor[ i ] * uDiffuseColor * pointDiffuseWeight;",
 
+
 
+						// specular
 
+
 
+						"vec3 pointHalfVector = normalize( pointVector + viewPosition );",
 
+						"float pointDotNormalHalf = max( dot( normal, pointHalfVector ), 0.0 );",
 
+						"float pointSpecularWeight = specularTex.r * max( pow( pointDotNormalHalf, uShininess ), 0.0 );",
 
+
 
+						"#ifdef PHYSICALLY_BASED_SHADING",
 
+
 
+							// 2.0 => 2.0001 is hack to work around ANGLE bug
 
+
 
+							"float specularNormalization = ( uShininess + 2.0001 ) / 8.0;",
 
+
 
+							"vec3 schlick = uSpecularColor + vec3( 1.0 - uSpecularColor ) * pow( 1.0 - dot( pointVector, pointHalfVector ), 5.0 );",
 
+							"pointSpecular += schlick * pointLightColor[ i ] * pointSpecularWeight * pointDiffuseWeight * pointDistance * specularNormalization;",
 
+
 
+						"#else",
 
+
 
+							"pointSpecular += pointDistance * pointLightColor[ i ] * uSpecularColor * pointSpecularWeight * pointDiffuseWeight;",
 
+
 
+						"#endif",
 
+
 
+					"}",
 
+
 
+				"#endif",
 
+
 
+				// spot lights
 
+
 
+				"#if MAX_SPOT_LIGHTS > 0",
 
+
 
+					"vec3 spotDiffuse = vec3( 0.0 );",
 
+					"vec3 spotSpecular = vec3( 0.0 );",
 
+
 
+					"for ( int i = 0; i < MAX_SPOT_LIGHTS; i ++ ) {",
 
+
 
+						"vec4 lPosition = viewMatrix * vec4( spotLightPosition[ i ], 1.0 );",
 
+						"vec3 spotVector = lPosition.xyz + vViewPosition.xyz;",
 
+
 
+						"float spotDistance = 1.0;",
 
+						"if ( spotLightDistance[ i ] > 0.0 )",
 
+							"spotDistance = 1.0 - min( ( length( spotVector ) / spotLightDistance[ i ] ), 1.0 );",
 
+
 
+						"spotVector = normalize( spotVector );",
 
+
 
+						"float spotEffect = dot( spotLightDirection[ i ], normalize( spotLightPosition[ i ] - vWorldPosition ) );",
 
+
 
+						"if ( spotEffect > spotLightAngleCos[ i ] ) {",
 
+
 
+							"spotEffect = max( pow( spotEffect, spotLightExponent[ i ] ), 0.0 );",
 
+
 
+							// diffuse
 
+
 
+							"#ifdef WRAP_AROUND",
 
+
 
+								"float spotDiffuseWeightFull = max( dot( normal, spotVector ), 0.0 );",
 
+								"float spotDiffuseWeightHalf = max( 0.5 * dot( normal, spotVector ) + 0.5, 0.0 );",
 
+
 
+								"vec3 spotDiffuseWeight = mix( vec3 ( spotDiffuseWeightFull ), vec3( spotDiffuseWeightHalf ), wrapRGB );",
 
+
 
+							"#else",
 
+
 
+								"float spotDiffuseWeight = max( dot( normal, spotVector ), 0.0 );",
 
+
 
+							"#endif",
 
+
 
+							"spotDiffuse += spotDistance * spotLightColor[ i ] * uDiffuseColor * spotDiffuseWeight * spotEffect;",
 
+
 
+							// specular
 
+
 
+							"vec3 spotHalfVector = normalize( spotVector + viewPosition );",
 
+							"float spotDotNormalHalf = max( dot( normal, spotHalfVector ), 0.0 );",
 
+							"float spotSpecularWeight = specularTex.r * max( pow( spotDotNormalHalf, uShininess ), 0.0 );",
 
+
 
+							"#ifdef PHYSICALLY_BASED_SHADING",
 
+
 
+								// 2.0 => 2.0001 is hack to work around ANGLE bug
 
+
 
+								"float specularNormalization = ( uShininess + 2.0001 ) / 8.0;",
 
+
 
+								"vec3 schlick = uSpecularColor + vec3( 1.0 - uSpecularColor ) * pow( 1.0 - dot( spotVector, spotHalfVector ), 5.0 );",
 
+								"spotSpecular += schlick * spotLightColor[ i ] * spotSpecularWeight * spotDiffuseWeight * spotDistance * specularNormalization * spotEffect;",
 
+
 
+							"#else",
 
+
 
+								"spotSpecular += spotDistance * spotLightColor[ i ] * uSpecularColor * spotSpecularWeight * spotDiffuseWeight * spotEffect;",
 
+
 
+							"#endif",
 
+
 
+						"}",
 
+
 
+					"}",
 
+
 
+				"#endif",
 
+
 
+				// directional lights
 
+
 
+				"#if MAX_DIR_LIGHTS > 0",
 
+
 
+					"vec3 dirDiffuse = vec3( 0.0 );",
 
+					"vec3 dirSpecular = vec3( 0.0 );",
 
+
 
+					"for( int i = 0; i < MAX_DIR_LIGHTS; i++ ) {",
 
+
 
+						"vec4 lDirection = viewMatrix * vec4( directionalLightDirection[ i ], 0.0 );",
 
+						"vec3 dirVector = normalize( lDirection.xyz );",
 
+
 
+						// diffuse
 
+
 
+						"#ifdef WRAP_AROUND",
 
+
 
+							"float directionalLightWeightingFull = max( dot( normal, dirVector ), 0.0 );",
 
+							"float directionalLightWeightingHalf = max( 0.5 * dot( normal, dirVector ) + 0.5, 0.0 );",
 
+
 
+							"vec3 dirDiffuseWeight = mix( vec3( directionalLightWeightingFull ), vec3( directionalLightWeightingHalf ), wrapRGB );",
 
+
 
+						"#else",
 
+
 
+							"float dirDiffuseWeight = max( dot( normal, dirVector ), 0.0 );",
 
+
 
+						"#endif",
 
+
 
+						"dirDiffuse += directionalLightColor[ i ] * uDiffuseColor * dirDiffuseWeight;",
 
+
 
+						// specular
 
+
 
+						"vec3 dirHalfVector = normalize( dirVector + viewPosition );",
 
+						"float dirDotNormalHalf = max( dot( normal, dirHalfVector ), 0.0 );",
 
+						"float dirSpecularWeight = specularTex.r * max( pow( dirDotNormalHalf, uShininess ), 0.0 );",
 
+
 
+						"#ifdef PHYSICALLY_BASED_SHADING",
 
+
 
+							// 2.0 => 2.0001 is hack to work around ANGLE bug
 
+
 
+							"float specularNormalization = ( uShininess + 2.0001 ) / 8.0;",
 
+
 
+							"vec3 schlick = uSpecularColor + vec3( 1.0 - uSpecularColor ) * pow( 1.0 - dot( dirVector, dirHalfVector ), 5.0 );",
 
+							"dirSpecular += schlick * directionalLightColor[ i ] * dirSpecularWeight * dirDiffuseWeight * specularNormalization;",
 
+
 
+						"#else",
 
+
 
+							"dirSpecular += directionalLightColor[ i ] * uSpecularColor * dirSpecularWeight * dirDiffuseWeight;",
 
+
 
+						"#endif",
 
+
 
+					"}",
 
+
 
+				"#endif",
 
+
 
+				// hemisphere lights
 
+
 
+				"#if MAX_HEMI_LIGHTS > 0",
 
+
 
+					"vec3 hemiDiffuse  = vec3( 0.0 );",
 
+					"vec3 hemiSpecular = vec3( 0.0 );" ,
 
+
 
+					"for( int i = 0; i < MAX_HEMI_LIGHTS; i ++ ) {",
 
+
 
+						"vec4 lDirection = viewMatrix * vec4( hemisphereLightDirection[ i ], 0.0 );",
 
+						"vec3 lVector = normalize( lDirection.xyz );",
 
+
 
+						// diffuse
 
+
 
+						"float dotProduct = dot( normal, lVector );",
 
+						"float hemiDiffuseWeight = 0.5 * dotProduct + 0.5;",
 
+
 
+						"vec3 hemiColor = mix( hemisphereLightGroundColor[ i ], hemisphereLightSkyColor[ i ], hemiDiffuseWeight );",
 
+
 
+						"hemiDiffuse += uDiffuseColor * hemiColor;",
 
+
 
+						// specular (sky light)
 
+
 
+
 
+						"vec3 hemiHalfVectorSky = normalize( lVector + viewPosition );",
 
+						"float hemiDotNormalHalfSky = 0.5 * dot( normal, hemiHalfVectorSky ) + 0.5;",
 
+						"float hemiSpecularWeightSky = specularTex.r * max( pow( hemiDotNormalHalfSky, uShininess ), 0.0 );",
 
+
 
+						// specular (ground light)
 
+
 
+						"vec3 lVectorGround = -lVector;",
 
+
 
+						"vec3 hemiHalfVectorGround = normalize( lVectorGround + viewPosition );",
 
+						"float hemiDotNormalHalfGround = 0.5 * dot( normal, hemiHalfVectorGround ) + 0.5;",
 
+						"float hemiSpecularWeightGround = specularTex.r * max( pow( hemiDotNormalHalfGround, uShininess ), 0.0 );",
 
+
 
+						"#ifdef PHYSICALLY_BASED_SHADING",
 
+
 
+							"float dotProductGround = dot( normal, lVectorGround );",
 
+
 
+							// 2.0 => 2.0001 is hack to work around ANGLE bug
 
+
 
+							"float specularNormalization = ( uShininess + 2.0001 ) / 8.0;",
 
+
 
+							"vec3 schlickSky = uSpecularColor + vec3( 1.0 - uSpecularColor ) * pow( 1.0 - dot( lVector, hemiHalfVectorSky ), 5.0 );",
 
+							"vec3 schlickGround = uSpecularColor + vec3( 1.0 - uSpecularColor ) * pow( 1.0 - dot( lVectorGround, hemiHalfVectorGround ), 5.0 );",
 
+							"hemiSpecular += hemiColor * specularNormalization * ( schlickSky * hemiSpecularWeightSky * max( dotProduct, 0.0 ) + schlickGround * hemiSpecularWeightGround * max( dotProductGround, 0.0 ) );",
 
+
 
+						"#else",
 
+
 
+							"hemiSpecular += uSpecularColor * hemiColor * ( hemiSpecularWeightSky + hemiSpecularWeightGround ) * hemiDiffuseWeight;",
 
+
 
+						"#endif",
 
+
 
+					"}",
 
+
 
+				"#endif",
 
+
 
+				// all lights contribution summation
 
+
 
+				"vec3 totalDiffuse = vec3( 0.0 );",
 
+				"vec3 totalSpecular = vec3( 0.0 );",
 
+
 
+				"#if MAX_DIR_LIGHTS > 0",
 
+
 
+					"totalDiffuse += dirDiffuse;",
 
+					"totalSpecular += dirSpecular;",
 
+
 
+				"#endif",
 
+
 
+				"#if MAX_HEMI_LIGHTS > 0",
 
+
 
+					"totalDiffuse += hemiDiffuse;",
 
+					"totalSpecular += hemiSpecular;",
 
+
 
+				"#endif",
 
+
 
+				"#if MAX_POINT_LIGHTS > 0",
 
+
 
+					"totalDiffuse += pointDiffuse;",
 
+					"totalSpecular += pointSpecular;",
 
+
 
+				"#endif",
 
+
 
+				"#if MAX_SPOT_LIGHTS > 0",
 
+
 
+					"totalDiffuse += spotDiffuse;",
 
+					"totalSpecular += spotSpecular;",
 
+
 
+				"#endif",
 
+
 
+				"#ifdef METAL",
 
+
 
+					"gl_FragColor.xyz = gl_FragColor.xyz * ( totalDiffuse + ambientLightColor * uAmbientColor + totalSpecular );",
 
+
 
+				"#else",
 
+
 
+					"gl_FragColor.xyz = gl_FragColor.xyz * ( totalDiffuse + ambientLightColor * uAmbientColor ) + totalSpecular;",
 
+
 
+				"#endif",
 
+
 
+				"if ( enableReflection ) {",
 
+
 
+					"vec3 vReflect;",
 
+					"vec3 cameraToVertex = normalize( vWorldPosition - cameraPosition );",
 
+
 
+					"if ( useRefract ) {",
 
+
 
+						"vReflect = refract( cameraToVertex, normal, uRefractionRatio );",
 
+
 
+					"} else {",
 
+
 
+						"vReflect = reflect( cameraToVertex, normal );",
 
+
 
+					"}",
 
+
 
+					"vec4 cubeColor = textureCube( tCube, vec3( -vReflect.x, vReflect.yz ) );",
 
+
 
+					"#ifdef GAMMA_INPUT",
 
+
 
+						"cubeColor.xyz *= cubeColor.xyz;",
 
+
 
+					"#endif",
 
+
 
+					"gl_FragColor.xyz = mix( gl_FragColor.xyz, cubeColor.xyz, specularTex.r * uReflectivity );",
 
+
 
+				"}",
 
+
 
+				THREE.ShaderChunk[ "shadowmap_fragment" ],
 
+				THREE.ShaderChunk[ "linear_to_gamma_fragment" ],
 
+				THREE.ShaderChunk[ "fog_fragment" ],
 
+
 
+			"}"
 
+
 
+		].join("\n"),
 
+
 
+		vertexShader: [
 
+
 
+			"attribute vec4 tangent;",
 
+
 
+			"uniform vec2 uOffset;",
 
+			"uniform vec2 uRepeat;",
 
+
 
+			"uniform bool enableDisplacement;",
 
+
 
+			"#ifdef VERTEX_TEXTURES",
 
+
 
+				"uniform sampler2D tDisplacement;",
 
+				"uniform float uDisplacementScale;",
 
+				"uniform float uDisplacementBias;",
 
+
 
+			"#endif",
 
+
 
+			"varying vec3 vTangent;",
 
+			"varying vec3 vBinormal;",
 
+			"varying vec3 vNormal;",
 
+			"varying vec2 vUv;",
 
+
 
+			"varying vec3 vWorldPosition;",
 
+			"varying vec3 vViewPosition;",
 
+
 
+			THREE.ShaderChunk[ "skinning_pars_vertex" ],
 
+			THREE.ShaderChunk[ "shadowmap_pars_vertex" ],
 
+
 
+			"void main() {",
 
+
 
+				THREE.ShaderChunk[ "skinbase_vertex" ],
 
+				THREE.ShaderChunk[ "skinnormal_vertex" ],
 
+
 
+				// normal, tangent and binormal vectors
 
+
 
+				"#ifdef USE_SKINNING",
 
+
 
+					"vNormal = normalize( normalMatrix * skinnedNormal.xyz );",
 
+
 
+					"vec4 skinnedTangent = skinMatrix * vec4( tangent.xyz, 0.0 );",
 
+					"vTangent = normalize( normalMatrix * skinnedTangent.xyz );",
 
+
 
+				"#else",
 
+
 
+					"vNormal = normalize( normalMatrix * normal );",
 
+					"vTangent = normalize( normalMatrix * tangent.xyz );",
 
+
 
+				"#endif",
 
+
 
+				"vBinormal = normalize( cross( vNormal, vTangent ) * tangent.w );",
 
+
 
+				"vUv = uv * uRepeat + uOffset;",
 
+
 
+				// displacement mapping
 
+
 
+				"vec3 displacedPosition;",
 
+
 
+				"#ifdef VERTEX_TEXTURES",
 
+
 
+					"if ( enableDisplacement ) {",
 
+
 
+						"vec3 dv = texture2D( tDisplacement, uv ).xyz;",
 
+						"float df = uDisplacementScale * dv.x + uDisplacementBias;",
 
+						"displacedPosition = position + normalize( normal ) * df;",
 
+
 
+					"} else {",
 
+
 
+						"#ifdef USE_SKINNING",
 
+
 
+							"vec4 skinVertex = vec4( position, 1.0 );",
 
+
 
+							"vec4 skinned  = boneMatX * skinVertex * skinWeight.x;",
 
+							"skinned 	  += boneMatY * skinVertex * skinWeight.y;",
 
+
 
+							"displacedPosition  = skinned.xyz;",
 
+
 
+						"#else",
 
+
 
+							"displacedPosition = position;",
 
+
 
+						"#endif",
 
+
 
+					"}",
 
+
 
+				"#else",
 
+
 
+					"#ifdef USE_SKINNING",
 
+
 
+						"vec4 skinVertex = vec4( position, 1.0 );",
 
+
 
+						"vec4 skinned  = boneMatX * skinVertex * skinWeight.x;",
 
+						"skinned 	  += boneMatY * skinVertex * skinWeight.y;",
 
+
 
+						"displacedPosition  = skinned.xyz;",
 
+
 
+					"#else",
 
+
 
+						"displacedPosition = position;",
 
+
 
+					"#endif",
 
+
 
+				"#endif",
 
+
 
+				//
 
+
 
+				"vec4 mvPosition = modelViewMatrix * vec4( displacedPosition, 1.0 );",
 
+				"vec4 worldPosition = modelMatrix * vec4( displacedPosition, 1.0 );",
 
+
 
+				"gl_Position = projectionMatrix * mvPosition;",
 
+
 
+				//
 
+
 
+				"vWorldPosition = worldPosition.xyz;",
 
+				"vViewPosition = -mvPosition.xyz;",
 
+
 
+				// shadows
 
+
 
+				"#ifdef USE_SHADOWMAP",
 
+
 
+					"for( int i = 0; i < MAX_SHADOWS; i ++ ) {",
 
+
 
+						"vShadowCoord[ i ] = shadowMatrix[ i ] * worldPosition;",
 
+
 
+					"}",
 
+
 
+				"#endif",
 
+
 
+			"}"
 
+
 
+		].join("\n")
 
+
 
+	},
 
+
 
+	/* -------------------------------------------------------------------------
 
+	//	Cube map shader
 
+	 ------------------------------------------------------------------------- */
 
+
 
+	'cube': {
 
+
 
+		uniforms: { "tCube": { type: "t", value: null },
 
+					"tFlip": { type: "f", value: -1 } },
 
+
 
+		vertexShader: [
 
+
 
+			"varying vec3 vWorldPosition;",
 
+
 
+			"void main() {",
 
+
 
+				"vec4 worldPosition = modelMatrix * vec4( position, 1.0 );",
 
+				"vWorldPosition = worldPosition.xyz;",
 
+
 
+				"gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
 
+
 
+			"}"
 
+
 
+		].join("\n"),
 
+
 
+		fragmentShader: [
 
+
 
+			"uniform samplerCube tCube;",
 
+			"uniform float tFlip;",
 
+
 
+			"varying vec3 vWorldPosition;",
 
+
 
+			"void main() {",
 
+
 
+				"gl_FragColor = textureCube( tCube, vec3( tFlip * vWorldPosition.x, vWorldPosition.yz ) );",
 
+
 
+			"}"
 
+
 
+		].join("\n")
 
+
 
+	},
 
+
 
+	// Depth encoding into RGBA texture
 
+	// 	based on SpiderGL shadow map example
 
+	// 		http://spidergl.org/example.php?id=6
 
+	// 	originally from
 
+	//		http://www.gamedev.net/topic/442138-packing-a-float-into-a-a8r8g8b8-texture-shader/page__whichpage__1%25EF%25BF%25BD
 
+	// 	see also here:
 
+	//		http://aras-p.info/blog/2009/07/30/encoding-floats-to-rgba-the-final/
 
+
 
+	'depthRGBA': {
 
+
 
+		uniforms: {},
 
+
 
+		vertexShader: [
 
+
 
+			THREE.ShaderChunk[ "morphtarget_pars_vertex" ],
 
+			THREE.ShaderChunk[ "skinning_pars_vertex" ],
 
+
 
+			"void main() {",
 
+
 
+				THREE.ShaderChunk[ "skinbase_vertex" ],
 
+				THREE.ShaderChunk[ "morphtarget_vertex" ],
 
+				THREE.ShaderChunk[ "skinning_vertex" ],
 
+				THREE.ShaderChunk[ "default_vertex" ],
 
+
 
+			"}"
 
+
 
+		].join("\n"),
 
+
 
+		fragmentShader: [
 
+
 
+			"vec4 pack_depth( const in float depth ) {",
 
+
 
+				"const vec4 bit_shift = vec4( 256.0 * 256.0 * 256.0, 256.0 * 256.0, 256.0, 1.0 );",
 
+				"const vec4 bit_mask  = vec4( 0.0, 1.0 / 256.0, 1.0 / 256.0, 1.0 / 256.0 );",
 
+				"vec4 res = fract( depth * bit_shift );",
 
+				"res -= res.xxyz * bit_mask;",
 
+				"return res;",
 
+
 
+			"}",
 
+
 
+			"void main() {",
 
+
 
+				"gl_FragData[ 0 ] = pack_depth( gl_FragCoord.z );",
 
+
 
+				//"gl_FragData[ 0 ] = pack_depth( gl_FragCoord.z / gl_FragCoord.w );",
 
+				//"float z = ( ( gl_FragCoord.z / gl_FragCoord.w ) - 3.0 ) / ( 4000.0 - 3.0 );",
 
+				//"gl_FragData[ 0 ] = pack_depth( z );",
 
+				//"gl_FragData[ 0 ] = vec4( z, z, z, 1.0 );",
 
+
 
+			"}"
 
+
 
+		].join("\n")
 
+
 
+	}
 
+
 
+};

+ 102 - 0
src/renderers/shaders/UniformsLib.js
Xem Tập Tin 

@@ -0,0 +1,102 @@
 
+/**
 
+ * Uniforms library for shared webgl shaders
 
+ */
 
+
 
+THREE.UniformsLib = {
 
+
 
+	common: {
 
+
 
+		"diffuse" : { type: "c", value: new THREE.Color( 0xeeeeee ) },
 
+		"opacity" : { type: "f", value: 1.0 },
 
+
 
+		"map" : { type: "t", value: null },
 
+		"offsetRepeat" : { type: "v4", value: new THREE.Vector4( 0, 0, 1, 1 ) },
 
+
 
+		"lightMap" : { type: "t", value: null },
 
+		"specularMap" : { type: "t", value: null },
 
+
 
+		"envMap" : { type: "t", value: null },
 
+		"flipEnvMap" : { type: "f", value: -1 },
 
+		"useRefract" : { type: "i", value: 0 },
 
+		"reflectivity" : { type: "f", value: 1.0 },
 
+		"refractionRatio" : { type: "f", value: 0.98 },
 
+		"combine" : { type: "i", value: 0 },
 
+
 
+		"morphTargetInfluences" : { type: "f", value: 0 }
 
+
 
+	},
 
+
 
+	bump: {
 
+
 
+		"bumpMap" : { type: "t", value: null },
 
+		"bumpScale" : { type: "f", value: 1 }
 
+
 
+	},
 
+
 
+	normalmap: {
 
+
 
+		"normalMap" : { type: "t", value: null },
 
+		"normalScale" : { type: "v2", value: new THREE.Vector2( 1, 1 ) }
 
+	},
 
+
 
+	fog : {
 
+
 
+		"fogDensity" : { type: "f", value: 0.00025 },
 
+		"fogNear" : { type: "f", value: 1 },
 
+		"fogFar" : { type: "f", value: 2000 },
 
+		"fogColor" : { type: "c", value: new THREE.Color( 0xffffff ) }
 
+
 
+	},
 
+
 
+	lights: {
 
+
 
+		"ambientLightColor" : { type: "fv", value: [] },
 
+
 
+		"directionalLightDirection" : { type: "fv", value: [] },
 
+		"directionalLightColor" : { type: "fv", value: [] },
 
+
 
+		"hemisphereLightDirection" : { type: "fv", value: [] },
 
+		"hemisphereLightSkyColor" : { type: "fv", value: [] },
 
+		"hemisphereLightGroundColor" : { type: "fv", value: [] },
 
+
 
+		"pointLightColor" : { type: "fv", value: [] },
 
+		"pointLightPosition" : { type: "fv", value: [] },
 
+		"pointLightDistance" : { type: "fv1", value: [] },
 
+
 
+		"spotLightColor" : { type: "fv", value: [] },
 
+		"spotLightPosition" : { type: "fv", value: [] },
 
+		"spotLightDirection" : { type: "fv", value: [] },
 
+		"spotLightDistance" : { type: "fv1", value: [] },
 
+		"spotLightAngleCos" : { type: "fv1", value: [] },
 
+		"spotLightExponent" : { type: "fv1", value: [] }
 
+
 
+	},
 
+
 
+	particle: {
 
+
 
+		"psColor" : { type: "c", value: new THREE.Color( 0xeeeeee ) },
 
+		"opacity" : { type: "f", value: 1.0 },
 
+		"size" : { type: "f", value: 1.0 },
 
+		"scale" : { type: "f", value: 1.0 },
 
+		"map" : { type: "t", value: null },
 
+
 
+		"fogDensity" : { type: "f", value: 0.00025 },
 
+		"fogNear" : { type: "f", value: 1 },
 
+		"fogFar" : { type: "f", value: 2000 },
 
+		"fogColor" : { type: "c", value: new THREE.Color( 0xffffff ) }
 
+
 
+	},
 
+
 
+	shadowmap: {
 
+
 
+		"shadowMap": { type: "tv", value: [] },
 
+		"shadowMapSize": { type: "v2v", value: [] },
 
+
 
+		"shadowBias" : { type: "fv1", value: [] },
 
+		"shadowDarkness": { type: "fv1", value: [] },
 
+
 
+		"shadowMatrix" : { type: "m4v", value: [] }
 
+
 
+	}
 
+
 
+};

+ 66 - 0
src/renderers/shaders/UniformsUtils.js
Xem Tập Tin 

@@ -0,0 +1,66 @@
 
+/**
 
+ * Uniform Utilities
 
+ */
 
+
 
+THREE.UniformsUtils = {
 
+
 
+	merge: function ( uniforms ) {
 
+
 
+		var u, p, tmp, merged = {};
 
+
 
+		for ( u = 0; u < uniforms.length; u ++ ) {
 
+
 
+			tmp = this.clone( uniforms[ u ] );
 
+
 
+			for ( p in tmp ) {
 
+
 
+				merged[ p ] = tmp[ p ];
 
+
 
+			}
 
+
 
+		}
 
+
 
+		return merged;
 
+
 
+	},
 
+
 
+	clone: function ( uniforms_src ) {
 
+
 
+		var u, p, parameter, parameter_src, uniforms_dst = {};
 
+
 
+		for ( u in uniforms_src ) {
 
+
 
+			uniforms_dst[ u ] = {};
 
+
 
+			for ( p in uniforms_src[ u ] ) {
 
+
 
+				parameter_src = uniforms_src[ u ][ p ];
 
+
 
+				if ( parameter_src instanceof THREE.Color ||
 
+					 parameter_src instanceof THREE.Vector2 ||
 
+					 parameter_src instanceof THREE.Vector3 ||
 
+					 parameter_src instanceof THREE.Vector4 ||
 
+					 parameter_src instanceof THREE.Matrix4 ||
 
+					 parameter_src instanceof THREE.Texture ) {
 
+
 
+					uniforms_dst[ u ][ p ] = parameter_src.clone();
 
+
 
+				} else if ( parameter_src instanceof Array ) {
 
+
 
+					uniforms_dst[ u ][ p ] = parameter_src.slice();
 
+
 
+				} else {
 
+
 
+					uniforms_dst[ u ][ p ] = parameter_src;
 
+
 
+				}
 
+
 
+			}
 
+
 
+		}
 
+
 
+		return uniforms_dst;
 
+
 
+	}
 
+
 
+};

+ 4 - 1
utils/build/includes/common.json
Xem Tập Tin 

@@ -78,7 +78,10 @@
 
 	"src/scenes/Fog.js",
 
 	"src/scenes/Fog.js",
 
 	"src/scenes/FogExp2.js",
 
 	"src/scenes/FogExp2.js",
 
 	"src/renderers/CanvasRenderer.js",
 
 	"src/renderers/CanvasRenderer.js",
 
-	"src/renderers/WebGLShaders.js",
 
+	"/src/renderers/shaders/ShaderChunk.js",
 
+	"/src/renderers/shaders/UniformsUtils.js",
 
+	"/src/renderers/shaders/UniformsLib.js",
 
+	"/src/renderers/shaders/ShaderLib.js",
 
 	"src/renderers/WebGLRenderer.js",
 
 	"src/renderers/WebGLRenderer.js",
 
 	"src/renderers/WebGLRenderTarget.js",
 
 	"src/renderers/WebGLRenderTarget.js",
 
 	"src/renderers/WebGLRenderTargetCube.js",
 
 	"src/renderers/WebGLRenderTargetCube.js",

+ 4 - 1
utils/build/includes/webgl.json
Xem Tập Tin 

@@ -69,7 +69,10 @@
 
 	"src/scenes/Scene.js",
 
 	"src/scenes/Scene.js",
 
 	"src/scenes/Fog.js",
 
 	"src/scenes/Fog.js",
 
 	"src/scenes/FogExp2.js",
 
 	"src/scenes/FogExp2.js",
 
-	"src/renderers/WebGLShaders.js",
 
+	"/src/renderers/shaders/ShaderChunk.js",
 
+	"/src/renderers/shaders/UniformsUtils.js",
 
+	"/src/renderers/shaders/UniformsLib.js",
 
+	"/src/renderers/shaders/ShaderLib.js",
 
 	"src/renderers/WebGLRenderer.js",
 
 	"src/renderers/WebGLRenderer.js",
 
 	"src/renderers/WebGLRenderTarget.js",
 
 	"src/renderers/WebGLRenderTarget.js",
 
 	"src/renderers/WebGLRenderTargetCube.js",
 
 	"src/renderers/WebGLRenderTargetCube.js",