javascript
/
three.js
mirrorاز https://github.com/tazdij/three.js.git


			
							123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161
							<!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: 20px; 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;
			}

			#stats { position: absolute; top:10px; left: 5px }
			#stats #fps { background: transparent !important }
			#stats #fps #fpsText { color: #aaa !important }
			#stats #fps #fpsGraph { display: none }
		</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> -
			<a href="http://www.ir-ltd.net/infinite-3d-head-scan-released/" target="_blank">Lee Perry-Smith</a> head -
			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/shaders/FXAAShader.js"></script>
		<script src="js/shaders/ColorCorrectionShader.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/UTF8Loader.js"></script>
		<script src="js/loaders/MTLLoader.js"></script>
		-->

		<script>

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

			var SCALE = 0.75;
			var MARGIN = 100;

			var WIDTH = window.innerWidth;
			var HEIGHT = window.innerHeight - 2 * MARGIN;

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

			var mouseX = 0;
			var mouseY = 0;

			var targetX = 0, targetY = 0;
			var angle = 0;
			var target = new THREE.Vector3( 0, 0, 0 );


			var windowHalfX = window.innerWidth / 2;
			var windowHalfY = window.innerHeight / 2;

			// 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, rtFinal;

			// composer

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

			// 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() {"+

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

			"}";


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

			var normals_vert = "" +

			"varying vec3 normalView;"+

			"void main() {"+

				"vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );"+
				"gl_Position = projectionMatrix * mvPosition;"+
				"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;" +
			"varying vec4 clipPos;" +
			"uniform vec3 lightPos;" +
			"uniform mat4 matView;" +

			"void main() { " +

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

			"}"

			var deferredlight_frag = "" +

			"varying vec3 lightView;"+
			"varying vec4 clipPos;" +

			"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;"+
				"float lightZ = clipPos.z / clipPos.w;"+

				/*
				"if ( z == 0.0 ) {"+

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

				"}"+
				*/

				"if ( z == 0.0 || lightZ > z ) discard;"+

				"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 );"+

				"if ( dist > lightRadius ) discard;" +

				"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 );"+
				"attenuation *= attenuation;"+

				"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.6, 0.2, 0.2 );"+
				"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 );" +

				// simple specular

				//"vec3 specular = specularIntensity * max( pow( dotNormalHalf, shininess ), 0.0 ) * diffuse;" +

				// physically based specular

				"vec3 specularColor = specularIntensity * vec3( 0.12 );"+

				"float specularNormalization = ( shininess + 2.0001 ) / 8.0;"+

				"vec3 schlick = specularColor + vec3( 1.0 - specularColor ) * pow( 1.0 - dot( lightDir, halfVector ), 5.0 );"+
				"vec3 specular = schlick * max( pow( dotNormalHalf, shininess ), 0.0 ) * diffuse * specularNormalization;"+

				// 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;"+
				"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: SCALE * WIDTH },
					viewHeight: { type: "f", value: SCALE * 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: SCALE * WIDTH },
					viewHeight: { type: "f", value: SCALE * 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 );


				renderer.domElement.style.position = "absolute";
				renderer.domElement.style.top = MARGIN + "px";
				renderer.domElement.style.left = "0px";


				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.LinearFilter, stencilBuffer: false,
							          format: THREE.RGBAFormat, type: THREE.FloatType };

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

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

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

				rtNormals.generateMipmaps = false;
				rtDepth.generateMipmaps = false;
				rtColor.generateMipmaps = false;
				rtFinal.generateMipmaps = false;

				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( SCALE * WIDTH, SCALE * HEIGHT, rtParamsUByte );
				rtEmitter.generateMipmaps = false;

				compEmitter = new THREE.EffectComposer( renderer, rtEmitter );
				compEmitter.addPass( emitterPass );

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

				rtLightBuffer = new THREE.WebGLRenderTarget( SCALE * WIDTH, SCALE * 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;

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

				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, 8 );
					var meshLight = new THREE.Mesh( geomLight, matLight );
					lightNode.add( meshLight );

					// create emitter sphere

					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;

				effectFXAA = new THREE.ShaderPass( THREE.FXAAShader );

				//effectFXAA.uniforms[ 'resolution' ].value.set( 1 / ( WIDTH ), 1 / ( HEIGHT ) );
				effectFXAA.uniforms[ 'resolution' ].value.set( 1 / ( SCALE * WIDTH ), 1 / ( SCALE * HEIGHT ) );
				//effectFXAA.renderToScreen = true;

				var effectColor = new THREE.ShaderPass( THREE.ColorCorrectionShader );
				effectColor.renderToScreen = true;

				effectColor.uniforms[ 'powRGB' ].value.set( 1, 1, 1 );
				effectColor.uniforms[ 'mulRGB' ].value.set( 2, 2, 2 );

				compFinal = new THREE.EffectComposer( renderer, rtFinal );
				compFinal.addPass( compositePass );
				compFinal.addPass( effectFXAA );
				compFinal.addPass( effectColor );

			}

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

			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.bumpMap ) {

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

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

						}

						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 = 40;

				// 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();

					// gamma to linear

					light.color.x *= light.color.x;
					light.color.y *= light.color.y;
					light.color.z *= light.color.z;

					light.intensity = 2.0;
					light.distance = distance;

					lights.push( light );

				}

			}

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

			function onDocumentMouseMove( event ) {

				mouseX = ( event.clientX - windowHalfX ) * 1;
				mouseY = ( event.clientY - windowHalfY ) * 1;

			}

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

			function animate() {

				var delta = clock.getDelta();

				requestAnimationFrame( animate );

				//controls.update( delta );

				targetX = mouseX * .001;
				targetY = mouseY * .001;

				angle += 0.05 * ( targetX - angle );

				camera.position.x = -Math.sin( angle ) * 150;
				camera.position.z = Math.cos( angle ) * 150;

				camera.lookAt( target );

				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
				// -----------------------------

				camera.projectionMatrixInverse.getInverse( camera.projectionMatrix );

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

					var uniforms = lightNode.children[ i ].material.uniforms;

					uniforms[ "matProjInverse" ].value = camera.projectionMatrixInverse;
					uniforms[ "matView" ].value = camera.matrixWorldInverse;

				}

				var time = Date.now() * 0.0005;

				// update lights

				var x, y, z;

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

					if ( i > 0 ) {

						x = Math.sin( time + i * 1.7 ) * 80;
						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;

					}

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

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

					light.emitter.position = lightPosition;
					light.position = lightPosition;
					light.frustumCulled = false;

				}

				compLightBuffer.render();

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

				compFinal.render( 0.1 );

			}

			// -----------------------------
			// 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 );

				// box

				var mapHeight2 = THREE.ImageUtils.loadTexture( "obj/lightmap/rocks.jpg" );
				mapHeight2.repeat.set( 3, 1.5 );
				mapHeight2.wrapS = mapHeight2.wrapT = THREE.RepeatWrapping;
				mapHeight2.anisotropy = 4;
				mapHeight2.format = THREE.RGBFormat;

				var mapHeight3 = THREE.ImageUtils.loadTexture( "textures/water.jpg" );
				mapHeight3.repeat.set( 16, 8 );
				mapHeight3.wrapS = mapHeight3.wrapT = THREE.RepeatWrapping;
				mapHeight3.anisotropy = 4;
				mapHeight3.format = THREE.RGBFormat;

				var geoPlane = new THREE.PlaneGeometry( 40, 20 );
				var matPlane = new THREE.MeshPhongMaterial( { color: 0xffffff, bumpMap: mapHeight2, bumpScale: 0.5 } );
				var matPlane2 = new THREE.MeshPhongMaterial( { color: 0x331919, bumpMap: mapHeight2, bumpScale: 1 } );
				var matPlane3 = new THREE.MeshPhongMaterial( { color: 0xffffff, bumpMap: mapHeight3, bumpScale: 1 } );

				// bottom

				var mesh = new THREE.Mesh( geoPlane, matPlane2 );
				mesh.position.z = -2;
				mesh.position.y = -6;
				mesh.rotation.x = -Math.PI/2;
				object.add( mesh );

				// top

				var mesh = new THREE.Mesh( geoPlane, matPlane3 );
				mesh.position.z = -2;
				mesh.position.y = 6;
				mesh.rotation.x = Math.PI/2;
				object.add( mesh );

				// back

				var mesh = new THREE.Mesh( geoPlane, matPlane );
				mesh.position.z = -4;
				mesh.position.y = 0;
				object.add( mesh );

				// right

				var mesh = new THREE.Mesh( geoPlane, matPlane );
				mesh.position.z = 0;
				mesh.position.y = 0;
				mesh.position.x = 13;
				mesh.rotation.y = -Math.PI/2;
				//object.add( mesh );

				// left

				var mesh = new THREE.Mesh( geoPlane, matPlane );
				mesh.position.z = 0;
				mesh.position.y = 0;
				mesh.position.x = -13;
				mesh.rotation.y = Math.PI/2;
				//object.add( mesh );

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

			} );

			document.addEventListener( 'mousemove', onDocumentMouseMove, false );

		</script>
	</body>

</html>