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


			
							123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422
							<!DOCTYPE html>
<html lang="en">
	<head>
		<title>three.js webgl - scenes transition</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 {
				font-family: Monospace;
				background-color: #f0f0f0;
				margin: 0px;
				overflow: hidden;
			}

			.info {
				position: absolute;
				background-color: black;
				opacity: 0.8;
				color: white;
				text-align: center;
				top: 0px;
				width: 100%;
			}

			a { color: #00ffff; }
		</style>
	</head>
	<body>

		<div class="info">
			<a href="http://threejs.org" target="_blank" rel="noopener">three.js</a> webgl scene transitions - by <a href="https://twitter.com/fernandojsg">fernandojsg</a> - <a href="https://github.com/kile/three.js-demos">github</a>
		</div>

		<div id="container"></div>

		<script src="../build/three.js"></script>
		<script src="js/libs/stats.min.js"></script>
		<script src="js/libs/dat.gui.min.js"></script>
		<script src="js/utils/BufferGeometryUtils.js"></script>

		<script>

			var container, stats;
			var renderer;
			var transition;

			var transitionParams = {
				"useTexture": true,
				"transition": 0.5,
				"transitionSpeed": 2.0,
				"texture": 5,
				"loopTexture": true,
				"animateTransition": true,
				"textureThreshold": 0.3
			};

			var clock = new THREE.Clock();

			init();
			animate();

			function init() {

				initGUI();

				container = document.getElementById( "container" );

				renderer = new THREE.WebGLRenderer( { antialias: true } );
				renderer.setPixelRatio( window.devicePixelRatio );
				renderer.setSize( window.innerWidth, window.innerHeight );
				container.appendChild( renderer.domElement );

				stats = new Stats();
				container.appendChild( stats.dom );

				var sceneA = new Scene( "cube", 5000, 1200, 120, new THREE.Vector3( 0, - 0.4, 0 ), 0xffffff );
				var sceneB = new Scene( "sphere", 500, 2000, 50, new THREE.Vector3( 0, 0.2, 0.1 ), 0x000000 );

				transition = new Transition( sceneA, sceneB );

			}

			function animate() {

				requestAnimationFrame( animate );

				render();
				stats.update();

			}

			function initGUI() {

				var gui = new dat.GUI();

				gui.add( transitionParams, "useTexture" ).onChange( function ( value ) {

					transition.useTexture( value );

				} );

				gui.add( transitionParams, 'loopTexture' );

				gui.add( transitionParams, 'texture', { Perlin: 0, Squares: 1, Cells: 2, Distort: 3, Gradient: 4, Radial: 5 } ).onChange( function ( value ) {

					transition.setTexture( value );

				} ).listen();

				gui.add( transitionParams, "textureThreshold", 0, 1, 0.01 ).onChange( function ( value ) {

					transition.setTextureThreshold( value );

				} );

				gui.add( transitionParams, "animateTransition" );
				gui.add( transitionParams, "transition", 0, 1, 0.01 ).listen();
				gui.add( transitionParams, "transitionSpeed", 0.5, 5, 0.01 );

			}


			function render() {

				transition.render( clock.getDelta() );

			}

			function generateGeometry( objectType, numObjects ) {

				function applyVertexColors( geometry, color ) {

					var position = geometry.attributes.position;
					var colors = [];

					for ( var i = 0; i < position.count; i ++ ) {

						colors.push( color.r, color.g, color.b );

					}

					geometry.addAttribute( 'color', new THREE.Float32BufferAttribute( colors, 3 ) );

				}

				var geometries = [];

				var matrix = new THREE.Matrix4();
				var position = new THREE.Vector3();
				var rotation = new THREE.Euler();
				var quaternion = new THREE.Quaternion();
				var scale = new THREE.Vector3();
				var color = new THREE.Color();

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

					position.x = Math.random() * 10000 - 5000;
					position.y = Math.random() * 6000 - 3000;
					position.z = Math.random() * 8000 - 4000;

					rotation.x = Math.random() * 2 * Math.PI;
					rotation.y = Math.random() * 2 * Math.PI;
					rotation.z = Math.random() * 2 * Math.PI;
					quaternion.setFromEuler( rotation, false );

					scale.x = Math.random() * 200 + 100;

					var geometry;

					if ( objectType === 'cube' ) {

						geometry = new THREE.BoxBufferGeometry( 1, 1, 1 );
						geometry = geometry.toNonIndexed(); // merging needs consistent buffer geometries
						scale.y = Math.random() * 200 + 100;
						scale.z = Math.random() * 200 + 100;
						color.setRGB( 0, 0, 0.1 + 0.9 * Math.random() );

					} else if ( objectType === 'sphere' ) {

						geometry = new THREE.IcosahedronBufferGeometry( 1, 1 );
						scale.y = scale.z = scale.x;
						color.setRGB( 0.1 + 0.9 * Math.random(), 0, 0 );

					}

					// give the geom's vertices a random color, to be displayed
					applyVertexColors( geometry, color );

					matrix.compose( position, quaternion, scale );
					geometry.applyMatrix( matrix );

					geometries.push( geometry );

				}

				return THREE.BufferGeometryUtils.mergeBufferGeometries( geometries );

			}

			function Scene( type, numObjects, cameraZ, fov, rotationSpeed, clearColor ) {

				this.clearColor = clearColor;

				this.camera = new THREE.PerspectiveCamera( fov, window.innerWidth / window.innerHeight, 1, 10000 );
				this.camera.position.z = cameraZ;

				// Setup scene
				this.scene = new THREE.Scene();
				this.scene.add( new THREE.AmbientLight( 0x555555 ) );

				var light = new THREE.SpotLight( 0xffffff, 1.5 );
				light.position.set( 0, 500, 2000 );
				this.scene.add( light );

				this.rotationSpeed = rotationSpeed;

				var defaultMaterial = new THREE.MeshPhongMaterial( { color: 0xffffff, flatShading: true, vertexColors: THREE.VertexColors } );
				this.mesh = new THREE.Mesh( generateGeometry( type, numObjects ), defaultMaterial );
				this.scene.add( this.mesh );

				var renderTargetParameters = { minFilter: THREE.LinearFilter, magFilter: THREE.LinearFilter, format: THREE.RGBFormat, stencilBuffer: false };
				this.fbo = new THREE.WebGLRenderTarget( window.innerWidth, window.innerHeight, renderTargetParameters );

				this.render = function ( delta, rtt ) {

					this.mesh.rotation.x += delta * this.rotationSpeed.x;
					this.mesh.rotation.y += delta * this.rotationSpeed.y;
					this.mesh.rotation.z += delta * this.rotationSpeed.z;

					renderer.setClearColor( this.clearColor );

					if ( rtt ) {

						renderer.setRenderTarget( this.fbo );
						renderer.clear();
						renderer.render( this.scene, this.camera );

					} else {

						renderer.setRenderTarget( null );
						renderer.render( this.scene, this.camera );

					}

				};

			}

			function Transition( sceneA, sceneB ) {

				this.scene = new THREE.Scene();

				this.cameraOrtho = new THREE.OrthographicCamera( window.innerWidth / - 2, window.innerWidth / 2, window.innerHeight / 2, window.innerHeight / - 2, - 10, 10 );

				this.textures = [];

				var loader = new THREE.TextureLoader();

				for ( var i = 0; i < 6; i ++ )
					this.textures[ i ] = loader.load( 'textures/transition/transition' + ( i + 1 ) + '.png' );

				this.quadmaterial = new THREE.ShaderMaterial( {

					uniforms: {

						tDiffuse1: {
							value: null
						},
						tDiffuse2: {
							value: null
						},
						mixRatio: {
							value: 0.0
						},
						threshold: {
							value: 0.1
						},
						useTexture: {
							value: 1
						},
						tMixTexture: {
							value: this.textures[ 0 ]
						}
					},
					vertexShader: [

						"varying vec2 vUv;",

						"void main() {",

						"vUv = vec2( uv.x, uv.y );",
						"gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",

						"}"

					].join( "\n" ),
					fragmentShader: [

						"uniform float mixRatio;",

						"uniform sampler2D tDiffuse1;",
						"uniform sampler2D tDiffuse2;",
						"uniform sampler2D tMixTexture;",

						"uniform int useTexture;",
						"uniform float threshold;",

						"varying vec2 vUv;",

						"void main() {",

						"	vec4 texel1 = texture2D( tDiffuse1, vUv );",
						"	vec4 texel2 = texture2D( tDiffuse2, vUv );",

						"	if (useTexture==1) {",

						"		vec4 transitionTexel = texture2D( tMixTexture, vUv );",
						"		float r = mixRatio * (1.0 + threshold * 2.0) - threshold;",
						"		float mixf=clamp((transitionTexel.r - r)*(1.0/threshold), 0.0, 1.0);",

						"		gl_FragColor = mix( texel1, texel2, mixf );",

						"	} else {",

						"		gl_FragColor = mix( texel2, texel1, mixRatio );",

						"	}",

						"}"

					].join( "\n" )

				} );

				var quadgeometry = new THREE.PlaneBufferGeometry( window.innerWidth, window.innerHeight );

				this.quad = new THREE.Mesh( quadgeometry, this.quadmaterial );
				this.scene.add( this.quad );

				// Link both scenes and their FBOs
				this.sceneA = sceneA;
				this.sceneB = sceneB;

				this.quadmaterial.uniforms.tDiffuse1.value = sceneA.fbo.texture;
				this.quadmaterial.uniforms.tDiffuse2.value = sceneB.fbo.texture;

				this.needChange = false;

				this.setTextureThreshold = function ( value ) {

					this.quadmaterial.uniforms.threshold.value = value;

				};

				this.useTexture = function ( value ) {

					this.quadmaterial.uniforms.useTexture.value = value ? 1 : 0;

				};

				this.setTexture = function ( i ) {

					this.quadmaterial.uniforms.tMixTexture.value = this.textures[ i ];

				};

				this.render = function ( delta ) {

					// Transition animation
					if ( transitionParams.animateTransition ) {

						var t = ( 1 + Math.sin( transitionParams.transitionSpeed * clock.getElapsedTime() / Math.PI ) ) / 2;
						transitionParams.transition = THREE.Math.smoothstep( t, 0.3, 0.7 );

						// Change the current alpha texture after each transition
						if ( transitionParams.loopTexture && ( transitionParams.transition == 0 || transitionParams.transition == 1 ) ) {

							if ( this.needChange ) {

								transitionParams.texture = ( transitionParams.texture + 1 ) % this.textures.length;
								this.quadmaterial.uniforms.tMixTexture.value = this.textures[ transitionParams.texture ];
								this.needChange = false;

							}

						} else
							this.needChange = true;

					}

					this.quadmaterial.uniforms.mixRatio.value = transitionParams.transition;

					// Prevent render both scenes when it's not necessary
					if ( transitionParams.transition == 0 ) {

						this.sceneB.render( delta, false );

					} else if ( transitionParams.transition == 1 ) {

						this.sceneA.render( delta, false );

					} else {

						// When 0<transition<1 render transition between two scenes

						this.sceneA.render( delta, true );
						this.sceneB.render( delta, true );
						renderer.setRenderTarget( null );
						renderer.clear();
						renderer.render( this.scene, this.cameraOrtho );

					}

				};

			}

		</script>

	</body>

</html>