samien
/
three.js
зеркало из https://github.com/mrdoob/three.js.git


			
							123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984
							<!DOCTYPE HTML>
<html lang="en">
	<head>
		<title>three.js webgl - deferred rendering</title>
		<meta charset="utf-8" />
		<meta name="viewport" content="width=device-width, user-scalable=no, minimum-scale=1.0, maximum-scale=1.0">
		<style>
			body {
				background-color: #000;
				margin: 0px;
				overflow: hidden;
			}

			#info {
				position: absolute;
				top: 0px; width: 100%;
				color: #ffffff;
				padding: 5px;
				font-family: Monospace;
				font-size: 13px;
				text-align: center;
			}

			a {
				color: #ff0080;
				text-decoration: none;
			}

			a:hover {
				color: #0080ff;
			}
		</style>
	</head>

	<body>
		<div id="info">
			<a href="http://threejs.org" target="_blank">three.js</a> - deferred point lights WebGL demo by <a href="http://de.redplant.de" target=_blank>redPlant</a>.<br />
			Walt Disney head by <a href="http://davidoreilly.com/post/18087489343/disneyhead" target="_blank">David OReilly</a><br>
			Point Light attenuation formula by <a href="http://imdoingitwrong.wordpress.com/tag/glsl/" target=_blank>Tom Madams</a>
		</div>
		<div id="container"></div>

		<script src="../build/three.min.js"></script>

		<script src="js/Detector.js"></script>
		<script src="js/libs/stats.min.js"></script>

		<script src="js/shaders/CopyShader.js"></script>

		<script src="js/postprocessing/EffectComposer.js"></script>
		<script src="js/postprocessing/RenderPass.js"></script>
		<script src="js/postprocessing/ShaderPass.js"></script>
		<script src="js/postprocessing/MaskPass.js"></script>

		<script src="js/controls/TrackballControls.js"></script>

		<script src="js/loaders/ctm/lzma.js"></script>
		<script src="js/loaders/ctm/ctm.js"></script>
		<script src="js/loaders/ctm/CTMLoader.js"></script>

		<script src="js/loaders/UTF8Loader.js"></script>
		<script src="js/loaders/MTLLoader.js"></script>

		<script>

			if ( ! Detector.webgl ) Detector.addGetWebGLMessage();

			var WIDTH = window.innerWidth;
			var HEIGHT = window.innerHeight;

			var NEAR = 1.0, FAR = 250.0;
			var VIEW_ANGLE = 45;
			var ASPECT = WIDTH / HEIGHT;

			// core

			var renderer, camera, controls, stats, clock;

			// scenes and scene nodes

			var lightScene, lightNode, scene, sceneNode, emitterScene, emitterNode, quadScene, quadNode;

			// rendertargets

			var rtColor, rtNormals, rtDepth, rtLightBuffer, rtEmitter;

			// composer

			var compColor, compNormals, compDepth, compLightBuffer, compFinal, compEmitter, compositePass;

			// materials

			var matNormal, matClipDepth, matBasic, matUnlit;

			var numLights = 50;
			var lights = new Array();

			// -----------------------
			// shader definitions
			// -----------------------

			var clipdepth_frag = ""+

			"varying vec4 clipPos;"+

			"void main() {"+

				"gl_FragColor = vec4( clipPos.z / clipPos.w, 1.0, 1.0, 1.0 );"+

			"}";


			var clipdepth_vert = "" +

			"varying vec4 clipPos;"+

			"void main() {"+

				"gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );"+
				"clipPos = gl_Position;"+

			"}";


			// -----------------------

			var normals_vert = "" +

			"varying vec3 normalView;"+

			"void main() {"+

				"gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );"+
				"normalView = normalize( normalMatrix * normal );"+

			"}";

			var normals_frag = "" +

			"varying vec3 normalView;"+

			"void main() {"+

				"gl_FragColor = vec4( vec3( normalView * 0.5 + 0.5 ), 1.0 );"+

			"}";

			// -----------------------

			var bump_vert = "" +

			"varying vec3 normalView;"+
			"varying vec2 vUv;"+
			"varying vec3 vViewPosition;"+

			"uniform vec4 offsetRepeat;"+

			"void main() {"+

				"vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );"+
				"gl_Position = projectionMatrix * mvPosition;"+
				"normalView = normalize( normalMatrix * normal );"+
				"vUv = uv * offsetRepeat.zw + offsetRepeat.xy;"+
				"vViewPosition = -mvPosition.xyz;"+

			"}";

			var bump_frag = "" +

			"#extension GL_OES_standard_derivatives : enable\n"+
			"varying vec3 normalView;"+
			"varying vec2 vUv;"+
			"varying vec3 vViewPosition;"+

			"uniform sampler2D bumpMap;"+
			"uniform float bumpScale;"+

			// Derivative maps - bump mapping unparametrized surfaces by Morten Mikkelsen
			//	http://mmikkelsen3d.blogspot.sk/2011/07/derivative-maps.html

			// Evaluate the derivative of the height w.r.t. screen-space using forward differencing (listing 2)

			"vec2 dHdxy_fwd() {"+

				"vec2 dSTdx = dFdx( vUv );"+
				"vec2 dSTdy = dFdy( vUv );"+

				"float Hll = bumpScale * texture2D( bumpMap, vUv ).x;"+
				"float dBx = bumpScale * texture2D( bumpMap, vUv + dSTdx ).x - Hll;"+
				"float dBy = bumpScale * texture2D( bumpMap, vUv + dSTdy ).x - Hll;"+

				"return vec2( dBx, dBy );"+

			"}"+

			"vec3 perturbNormalArb( vec3 surf_pos, vec3 surf_norm, vec2 dHdxy ) {"+

				"vec3 vSigmaX = dFdx( surf_pos );"+
				"vec3 vSigmaY = dFdy( surf_pos );"+
				"vec3 vN = surf_norm;"+		// normalized

				"vec3 R1 = cross( vSigmaY, vN );"+
				"vec3 R2 = cross( vN, vSigmaX );"+

				"float fDet = dot( vSigmaX, R1 );"+

				"vec3 vGrad = sign( fDet ) * ( dHdxy.x * R1 + dHdxy.y * R2 );"+
				"return normalize( abs( fDet ) * surf_norm - vGrad );"+

			"}"+

			"void main() {"+

				"vec3 normal = normalize( normalView );"+
				"normal = perturbNormalArb( -vViewPosition, normal, dHdxy_fwd() );"+
				"gl_FragColor = vec4( vec3( normal * 0.5 + 0.5 ), 1.0 );"+

			"}";

			// -----------------------

			var unlit_vert = "" +

			"varying vec4 clipPos;"+

			"void main() {"+

				"gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );"+
				"clipPos = gl_Position;"+

			"}";

			var unlit_frag = "" +

			"varying vec4 clipPos;"+
			"uniform sampler2D samplerDepth;"+

			"uniform float viewHeight;"+
			"uniform float viewWidth;"+

			"uniform vec3 lightColor;" +

			"void main() {"+

				"vec2 texCoord = gl_FragCoord.xy / vec2( viewWidth, viewHeight );"+
				"float z = texture2D( samplerDepth, texCoord ).x;"+
				"vec4 color = vec4( lightColor, 1.0 );"+
				"float depth = clipPos.z / clipPos.w;"+
				"if( depth > z && z > 0.0 ) color.w = 0.0;"+
				"gl_FragColor = color;"+

			"}";

			// -----------------------

			var deferredlight_vert = "" +

			"varying vec3 lightView;" +
			"uniform vec3 lightPos;" +
			"uniform mat4 matView;" +

			"void main() { " +

				"gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );"+
				"lightView = vec3( matView * vec4( lightPos, 1.0 ) );" +

			"}"

			var deferredlight_frag = "" +

			"varying vec3 lightView;"+

			"uniform sampler2D samplerColor;"+
			"uniform sampler2D samplerDepth;"+
			"uniform sampler2D samplerNormals;"+
			"uniform sampler2D samplerLightBuffer;"+

			"uniform float lightRadius;"+
			"uniform float lightIntensity;"+
			"uniform float viewHeight;"+
			"uniform float viewWidth;"+

			"uniform vec3 lightColor;"+

			"uniform mat4 matProjInverse;"+

			"void main() {"+

				"vec2 texCoord = gl_FragCoord.xy / vec2( viewWidth, viewHeight );"+

				"float z = texture2D( samplerDepth, texCoord ).x;"+

				"if ( z == 0.0 ) {"+

					"gl_FragColor = vec4( vec3( 0.0 ), 1.0 );"+
					"return;"+

				"}"+

				"float x = texCoord.x * 2.0 - 1.0;"+
				"float y = texCoord.y * 2.0 - 1.0;"+

				"vec4 projectedPos = vec4( x, y, z, 1.0 );"+

				"vec4 viewPos = matProjInverse * projectedPos;"+
				"viewPos.xyz /= viewPos.w;"+
				"viewPos.w = 1.0;"+

				"vec3 lightDir = lightView - viewPos.xyz;"+
				"float dist = length( lightDir );"+
				"lightDir = normalize( lightDir );"+

				"float cutoff = 0.3;"+
				"float denom = dist/lightRadius + 1.0;"+
				"float attenuation = 1.0 / ( denom * denom );"+
				"attenuation = ( attenuation - cutoff ) / ( 1.0 - cutoff );"+
				"attenuation = max( attenuation, 0.0 );"+

				"vec3 normal = texture2D( samplerNormals, texCoord ).xyz * 2.0 - 1.0;" +

				// wrap around lighting

				"float diffuseFull = max( dot( normal, lightDir ), 0.0 );" +
				"float diffuseHalf = max( 0.5 + 0.5 * dot( normal, lightDir ), 0.0 );" +

				"const vec3 wrapRGB = vec3( 0.8, 0.5, 0.5 );"+
				"vec3 diffuse = mix( vec3 ( diffuseFull ), vec3( diffuseHalf ), wrapRGB );"+

				// simple lighting

				//"float diffuseFull = max( dot( normal, lightDir ), 0.0 );" +
				//"vec3 diffuse = vec3 ( diffuseFull );"+

				// specular

				"const float shininess = 75.0;" +
				"const float specularIntensity = 0.4;"+

				"vec3 halfVector = normalize( lightDir - normalize( viewPos.xyz ) );" +
				"float dotNormalHalf = max( dot( normal, halfVector ), 0.0 );" +
				"vec3 specular = specularIntensity * max( pow( dotNormalHalf, shininess ), 0.0 ) * diffuse;" +

				// color

				"vec4 albedo = texture2D( samplerColor, texCoord );"+

				// combine

				"vec4 color = vec4( 0.0 );"+
				"color.xyz = albedo.xyz * lightColor * lightIntensity;"+
				"color.w = attenuation;"+
				"gl_FragColor = color * vec4( diffuse + specular, 1.0 );" +

			"}";

			var composite_vert = "" +

			"varying vec2 texCoord;"+

			"void main() {"+

				"vec4 pos = vec4( sign( position.xy ), 0.0, 1.0 );"+
				"texCoord = pos.xy * vec2( 0.5, 0.5 ) + 0.5;"+
				"gl_Position = pos;"+

			"}";

			var composite_frag = "" +

			"varying vec2 texCoord;"+
			"uniform sampler2D samplerLightBuffer;" +
			"uniform sampler2D samplerEmitter;" +
			"uniform vec3 lightPos;" +

			"void main() {" +

				"vec3 color = texture2D( samplerLightBuffer, texCoord ).xyz;" +
				"vec3 emitter = texture2D( samplerEmitter, texCoord ).xyz;"+

				"if ( emitter != vec3( 0.0 ) ) {"+

					"gl_FragColor = vec4( emitter, 1.0 );" +

				"} else {"+

					"gl_FragColor = vec4( sqrt( color ), 1.0 );" +

				"}"+

			"}"

			// -----------------------

			var normalShader = {

				uniforms: {},

				vertexShader: normals_vert,
				fragmentShader: normals_frag

			};

			// -----------------------

			var bumpShader = {

				uniforms: {

					bumpMap: 	{ type: "t", value: null },
					bumpScale:	{ type: "f", value: 1 },
					offsetRepeat : { type: "v4", value: new THREE.Vector4( 0, 0, 1, 1 ) }

				},

				vertexShader: bump_vert,
				fragmentShader: bump_frag

			};

			// -----------------------

			var clipDepthShader = {

				uniforms: {},

				vertexShader: clipdepth_vert,
				fragmentShader: clipdepth_frag

			};

			// -----------------------

			var unlitShader = {

				uniforms: {

					samplerDepth: { type: "t", value: null },
					viewWidth: { type: "f", value: WIDTH },
					viewHeight: { type: "f", value: HEIGHT },
					lightColor: { type: "v3", value: new THREE.Vector3( 0, 0, 0 ) }

				},

				vertexShader: unlit_vert,
				fragmentShader: unlit_frag

			};

			// -----------------------

			var lightShader = {

				uniforms: {

					samplerLightBuffer: { type: "t", value: null },
					samplerNormals: { type: "t", value: null },
					samplerDepth: { type: "t", value: null },
					samplerColor: { type: "t", value: null },
					matView : { type: "m4", value: new THREE.Matrix4() },
					matProjInverse : { type: "m4", value: new THREE.Matrix4() },
					viewWidth: { type: "f", value: WIDTH },
					viewHeight: { type: "f", value: HEIGHT },
					lightPos: { type: "v3", value: new THREE.Vector3( 0, 0, 0 ) },
					lightColor: { type: "v3", value: new THREE.Vector3( 0, 0, 0 ) },
					lightIntensity: { type: "f", value: 1.0 },
					lightRadius: { type: "f", value: 1.0 }

				},

				vertexShader: deferredlight_vert,
				fragmentShader: deferredlight_frag

			};

			// -----------------------

			var compositeShader = {

				uniforms: {

					samplerLightBuffer: { type: "t", value: null },
					samplerEmitter: { type: "t", value: null }
				},

				vertexShader: composite_vert,
				fragmentShader: composite_frag

			};

			// -----------------------------

			function bootstrap() {

				renderer = new THREE.WebGLRenderer( { alpha: false } );
				renderer.setSize( WIDTH, HEIGHT );
				renderer.setClearColorHex( 0x000000, 1 );

				var container = document.getElementById( 'container' );
				container.appendChild( renderer.domElement );

				// scene camera

				camera = new THREE.PerspectiveCamera( VIEW_ANGLE, ASPECT, NEAR, FAR );
				camera.position.z = 150;

				controls = new THREE.TrackballControls( camera, renderer.domElement );

				// scene for walt's head model

				scene = new THREE.Scene();
				sceneNode = new THREE.Object3D();
				scene.add( sceneNode );
				scene.add( camera );

				// scene for light proxy geometry

				lightScene = new THREE.Scene();
				lightNode = new THREE.Object3D();
				lightScene.add( lightNode );

				// scene for the coloured emitter spheres

				emitterScene = new THREE.Scene();
				emitterNode = new THREE.Object3D();
				emitterScene.add( emitterNode );

				// full screen quad for compositing

				quadScene = new THREE.Scene();
				quadNode = new THREE.Object3D();
				quadScene.add( quadNode );
				quadNode.add( new THREE.Mesh( new THREE.PlaneGeometry( 1, 1 ) ) );

				// stats

				stats = new Stats();
				stats.domElement.style.position = 'absolute';
				stats.domElement.style.top = '8px';
				stats.domElement.style.zIndex = 100;
				container.appendChild( stats.domElement );

				// clock

				clock = new THREE.Clock();

			}

			// -----------------------------

			function createRenderTargets() {

				var rtParamsFloat = { minFilter: THREE.NearestFilter, magFilter: THREE.NearestFilter, stencilBuffer: false,
							          format: THREE.RGBAFormat, type: THREE.FloatType };

				var rtParamsUByte = { minFilter: THREE.NearestFilter, magFilter: THREE.NearestFilter, stencilBuffer: false,
							          format: THREE.RGBFormat, type: THREE.UnsignedByteType };

				// ----------------------------------------------------------
				// g-buffer
				// ----------------------------------------------------------

				rtNormals = new THREE.WebGLRenderTarget( WIDTH, HEIGHT, rtParamsFloat );
				rtDepth = new THREE.WebGLRenderTarget( WIDTH, HEIGHT, rtParamsFloat );
				rtColor = new THREE.WebGLRenderTarget( WIDTH, HEIGHT, rtParamsUByte );

				var passNormals = new THREE.RenderPass( scene, camera );
				compNormals = new THREE.EffectComposer( renderer, rtNormals );
				compNormals.addPass( passNormals );

				var passDepth = new THREE.RenderPass( scene, camera );
				compDepth = new THREE.EffectComposer( renderer, rtDepth );
				compDepth.addPass( passDepth );

				var passColor = new THREE.RenderPass( scene, camera );
				compColor = new THREE.EffectComposer( renderer, rtColor );
				compColor.addPass( passColor );

				// ----------------------------------------------------------
				// light emitter spheres
				// ----------------------------------------------------------

				var emitterPass = new THREE.RenderPass( emitterScene, camera );
				rtEmitter = new THREE.WebGLRenderTarget( WIDTH, HEIGHT, rtParamsFloat );
				compEmitter = new THREE.EffectComposer( renderer, rtEmitter );
				compEmitter.addPass( emitterPass );

				// ----------------------------------------------------------
				// lighting pass
				// ----------------------------------------------------------

				rtLightBuffer = new THREE.WebGLRenderTarget( WIDTH, HEIGHT, rtParamsFloat );
				rtLightBuffer.generateMipmaps = false;

				var passLight = new THREE.RenderPass( lightScene, camera );
				compLightBuffer = new THREE.EffectComposer( renderer, rtLightBuffer );
				compLightBuffer.addPass( passLight );

				lightShader.uniforms[ 'samplerColor' ].value = compColor.renderTarget2;
				lightShader.uniforms[ 'samplerNormals' ].value = compNormals.renderTarget2;
				lightShader.uniforms[ 'samplerDepth' ].value = compDepth.renderTarget2;
				lightShader.uniforms[ 'samplerLightBuffer' ].value = rtLightBuffer;

				for ( var x = 0; x < numLights; x ++ ) {

					var light = lights[ x ];

					// setup material

					var matLight = new THREE.ShaderMaterial({

						uniforms:       THREE.UniformsUtils.clone( lightShader.uniforms ),
						vertexShader:   lightShader.vertexShader,
						fragmentShader: lightShader.fragmentShader

					});

					matLight.blending = THREE.AdditiveBlending;
					matLight.transparent = true;
					matLight.depthWrite = false;
					matLight.uniforms[ "lightPos" ].value = light.position;
					matLight.uniforms[ "lightRadius" ].value = light.distance;
					matLight.uniforms[ "lightIntensity" ].value = light.intensity;
					matLight.uniforms[ "lightColor" ].value = light.color;

					// setup proxy geometry for this light

					var geomLight = new THREE.SphereGeometry( light.distance, 16, 10 );
					var meshLight = new THREE.Mesh( geomLight, matLight );
					lightNode.add( meshLight );

					// create emitter sphere

					var geomEmitter = new THREE.SphereGeometry( 0.7, 7, 7 );
					var matEmitter = new THREE.ShaderMaterial({

						uniforms:       THREE.UniformsUtils.clone( unlitShader.uniforms ),
						vertexShader:   unlitShader.vertexShader,
						fragmentShader: unlitShader.fragmentShader

					});

					var meshEmitter = new THREE.Mesh( geomEmitter, matEmitter );
					meshEmitter.position = light.position;
					emitterNode.add( meshEmitter );

					// add emitter to light node

					meshLight.emitter = meshEmitter;

				}

				// ----------------------------------------------------------
				// composite
				// ----------------------------------------------------------

				compositeShader.uniforms['samplerLightBuffer'].value = compLightBuffer.renderTarget2;
				compositeShader.uniforms['samplerEmitter'].value = compEmitter.renderTarget2;

				compositePass = new THREE.ShaderPass( compositeShader );
				compositePass.needsSwap = true;
				compositePass.renderToScreen = true;

				compFinal = new THREE.EffectComposer( renderer );
				compFinal.addPass( compositePass );

			}

			// -----------------------------

			function initScene( object, y, scale ) {

				var shader = THREE.ShaderLib[ "basic" ];

				object.traverse( function( node ) {

					if ( node.material ) {

						// color material

						var uniforms = THREE.UniformsUtils.clone( shader.uniforms );
						var defines = { "USE_MAP": !!node.material.map, "GAMMA_INPUT": true };

						var material = new THREE.ShaderMaterial( { fragmentShader: shader.fragmentShader, vertexShader: shader.vertexShader, uniforms: uniforms, defines: defines } );
						uniforms.diffuse.value.copy( node.material.color );
						uniforms.map.value = node.material.map;

						if ( node.material.transparent ) {

							material.alphaTest = 0.1;

						}

						if ( node.material.name === "eyetrans" ) {

							material.visible = false;

						}

						node.properties.colorMaterial = material;

						// normal material

						if ( node.material.bumpMap ) {

							var uniforms = THREE.UniformsUtils.clone( bumpShader.uniforms );
							var normalMaterial = new THREE.ShaderMaterial( { uniforms: uniforms, vertexShader: bumpShader.vertexShader, fragmentShader: bumpShader.fragmentShader } );
							uniforms.bumpMap.value = node.material.bumpMap;
							uniforms.bumpScale.value = node.material.bumpScale;

							var offset = node.material.bumpMap.offset;
							var repeat = node.material.bumpMap.repeat;

							uniforms.offsetRepeat.value.set( offset.x, offset.y, repeat.x, repeat.y );

							node.properties.normalMaterial = normalMaterial;

						} else {

							node.properties.normalMaterial = matNormal;

						}

						// depth material

						node.properties.depthMaterial = matClipDepth;

					}

				} );

				object.position.y = y;
				object.scale.set( scale, scale, scale );
				sceneNode.add( object );

			}

			// -----------------------------

			function initMaterials() {


				matNormal = new THREE.ShaderMaterial({

					uniforms:       normalShader.uniforms,
					vertexShader:   normalShader.vertexShader,
					fragmentShader: normalShader.fragmentShader

				});

				matClipDepth = new THREE.ShaderMaterial({

					uniforms:       clipDepthShader.uniforms,
					vertexShader:   clipDepthShader.vertexShader,
					fragmentShader: clipDepthShader.fragmentShader

				});

			}

			// -----------------------------

			function initLights() {

				var distance = 25;

				// front light

				var light = new THREE.PointLight();

				light.color = new THREE.Vector3( 1, 1, 1 );
				light.intensity = 1.5;
				light.distance = 1.5 * distance;

				lights.push( light );

				// random lights

				for ( var i = 1; i < numLights; i ++ ) {

					var light = new THREE.PointLight();

					light.color = new THREE.Vector3( Math.random(), Math.random(), Math.random() ).normalize();
					light.intensity = 1.0;
					light.distance = distance;

					lights.push( light );

				}

			}

			// -----------------------------

			function animate() {

				var delta = clock.getDelta();

				requestAnimationFrame( animate );

				controls.update( delta );
				stats.update();
				render();

			}

			// -----------------------------

			function render() {

				// -----------------------------
				// g-buffer color
				// -----------------------------

				sceneNode.traverse( function( node ) {

					if ( node.material ) {

						node.material = node.properties.colorMaterial;

					}

				} );

				compColor.render();

				// -----------------------------
				// g-buffer depth
				// -----------------------------

				sceneNode.traverse( function( node ) {

					if ( node.material ) {

						node.material = node.properties.depthMaterial;

					}

				} );

				compDepth.render();

				// -----------------------------
				// g-buffer normals
				// -----------------------------

				sceneNode.traverse( function( node ) {

					if ( node.material ) {

						node.material = node.properties.normalMaterial;

					}

				} );

				compNormals.render();

				// -----------------------------
				// emitter pass
				// -----------------------------

				for ( var i = 0, il = lightNode.children.length; i < il; i ++ ) {

					var light = lightNode.children[ i ];
					var color = light.material.uniforms[ "lightColor" ].value;

					var emitter = light.emitter;
					emitter.material.uniforms[ "samplerDepth" ].value = compDepth.renderTarget2;
					emitter.material.uniforms[ "lightColor" ].value = color;

				}

				compEmitter.render();

				// -----------------------------
				// light pass
				// -----------------------------

				for ( var i = 0, il = lightNode.children.length; i < il; i ++ ) {

					camera.projectionMatrixInverse.getInverse( camera.projectionMatrix );
					lightNode.children[ i ].material.uniforms[ "matProjInverse" ].value = camera.projectionMatrixInverse;
					lightNode.children[ i ].material.uniforms[ "matView" ].value = camera.matrixWorldInverse;

				}

				var time = Date.now() * 0.0005;

				// update lights

				var x, y, z;

				for ( var i = 0; i < numLights; i ++ ) {

					var lightPosition = lightNode.children[ i ].material.uniforms[ "lightPos" ].value;

					if ( i > 0 ) {

						x = Math.sin( time + i * 1.7 ) * 30;
						y = Math.cos( time + i * 1.5 ) * 40;
						z = Math.cos( time + i * 1.3 ) * 30;

					} else {

						x = Math.sin( time * 3 ) * 20;
						y = 15;
						z = Math.cos( time * 3 ) * 25 + 10;

					}

					lightPosition.x = x;
					lightPosition.y = y;
					lightPosition.z = z;

					lightNode.children[ i ].emitter.position = lightPosition;
					lightNode.children[ i ].position = lightPosition;
					lightNode.children[ i ].frustumCulled = false;

				}

				compLightBuffer.render();

				// -----------------------------
				// composite pass
				// -----------------------------

				compFinal.render();

			}

			// -----------------------------
			// entry point
			// -----------------------------

			bootstrap();
			initMaterials();
			initLights();
			createRenderTargets();


			var loader = new THREE.UTF8Loader();

			/*
			loader.load( "models/utf8/ben_dds.js", function ( object ) {

				initScene( object, -75, 150 );
				animate();

			}, { normalizeRGB: true } );
			*/

			/*
			loader.load( "models/utf8/WaltHi.js", function ( object ) {

				initScene( object, -35, 1 );
				animate();

			}, { normalizeRGB: true } );
			*/

			var loader = new THREE.JSONLoader();
			loader.load( "obj/leeperrysmith/LeePerrySmith.js", function( geometry, materials ) {

				var mapColor = THREE.ImageUtils.loadTexture( "obj/leeperrysmith/Map-COL.jpg" );
				var mapHeight = THREE.ImageUtils.loadTexture( "obj/leeperrysmith/Infinite-Level_02_Disp_NoSmoothUV-4096.jpg" );
				mapHeight.repeat.set( 0.998, 0.998 );
				mapHeight.offset.set( 0.001, 0.001 )
				mapHeight.wrapS = mapHeight.wrapT = THREE.RepeatWrapping;
				mapHeight.anisotropy = 4;
				mapHeight.format = THREE.RGBFormat;

				var material = new THREE.MeshPhongMaterial( { map: mapColor, bumpMap: mapHeight, bumpScale: 2.5 } );

				var object = new THREE.Mesh( geometry, material );

				initScene( object, 0, 10 );
				animate();

			} );

		</script>
	</body>

</html>