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


			
							123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448
							<!DOCTYPE html>
<html lang="en">
	<head>
		<title>three.js webgl - clipping planes</title>
		<meta charset="utf-8">
		<meta name="viewport" content="width=device-width, user-scalable=no, minimum-scale=1.0, maximum-scale=1.0">
		<link type="text/css" rel="stylesheet" href="main.css">
	</head>
	<body>

		<script type="module">
			import {
				AmbientLight,
				BoxBufferGeometry,
				Color,
				DirectionalLight,
				DoubleSide,
				Group,
				Matrix4,
				Mesh,
				MeshBasicMaterial,
				MeshPhongMaterial,
				PerspectiveCamera,
				Plane,
				PlaneBufferGeometry,
				Scene,
				SpotLight,
				Vector3,
				WebGLRenderer
			} from "../build/three.module.js";

			import Stats from './jsm/libs/stats.module.js';
			import { GUI } from './jsm/libs/dat.gui.module.js';

			import { OrbitControls } from './jsm/controls/OrbitControls.js';

			function planesFromMesh( vertices, indices ) {

				// creates a clipping volume from a convex triangular mesh
				// specified by the arrays 'vertices' and 'indices'

				var n = indices.length / 3,
					result = new Array( n );

				for ( var i = 0, j = 0; i < n; ++ i, j += 3 ) {

					var a = vertices[ indices[ j ] ],
						b = vertices[ indices[ j + 1 ] ],
						c = vertices[ indices[ j + 2 ] ];

					result[ i ] = new Plane().
						setFromCoplanarPoints( a, b, c );

				}

				return result;

			}

			function createPlanes( n ) {

				// creates an array of n uninitialized plane objects

				var result = new Array( n );

				for ( var i = 0; i !== n; ++ i )
					result[ i ] = new Plane();

				return result;

			}

			function assignTransformedPlanes( planesOut, planesIn, matrix ) {

				// sets an array of existing planes to transformed 'planesIn'

				for ( var i = 0, n = planesIn.length; i !== n; ++ i )
					planesOut[ i ].copy( planesIn[ i ] ).applyMatrix4( matrix );

			}

			function cylindricalPlanes( n, innerRadius ) {

				var result = createPlanes( n );

				for ( var i = 0; i !== n; ++ i ) {

					var plane = result[ i ],
						angle = i * Math.PI * 2 / n;

					plane.normal.set(
						Math.cos( angle ), 0, Math.sin( angle ) );

					plane.constant = innerRadius;

				}

				return result;

			}

			var planeToMatrix = ( function () {

				// creates a matrix that aligns X/Y to a given plane

				// temporaries:
				var xAxis = new Vector3(),
					yAxis = new Vector3(),
					trans = new Vector3();

				return function planeToMatrix( plane ) {

					var zAxis = plane.normal,
						matrix = new Matrix4();

					// Hughes & Moeller '99
					// "Building an Orthonormal Basis from a Unit Vector."

					if ( Math.abs( zAxis.x ) > Math.abs( zAxis.z ) ) {

						yAxis.set( - zAxis.y, zAxis.x, 0 );

					} else {

						yAxis.set( 0, - zAxis.z, zAxis.y );

					}

					xAxis.crossVectors( yAxis.normalize(), zAxis );

					plane.coplanarPoint( trans );
					return matrix.set(
						xAxis.x, yAxis.x, zAxis.x, trans.x,
						xAxis.y, yAxis.y, zAxis.y, trans.y,
						xAxis.z, yAxis.z, zAxis.z, trans.z,
						0,	 0, 0, 1 );

				};

			} )();


			// A regular tetrahedron for the clipping volume:

			var Vertices = [
					new Vector3( + 1, 0, + Math.SQRT1_2 ),
					new Vector3( - 1, 0, + Math.SQRT1_2 ),
					new Vector3( 0, + 1, - Math.SQRT1_2 ),
					new Vector3( 0, - 1, - Math.SQRT1_2 )
				],

				Indices = [
					0, 1, 2,	0, 2, 3,	0, 3, 1,	1, 3, 2
				],

				Planes = planesFromMesh( Vertices, Indices ),
				PlaneMatrices = Planes.map( planeToMatrix ),

				GlobalClippingPlanes = cylindricalPlanes( 5, 3.5 ),

				Empty = Object.freeze( [] );


			var camera, scene, renderer, startTime, stats,

				object, clipMaterial,
				volumeVisualization,
				globalClippingPlanes;

			function init() {

				camera = new PerspectiveCamera(
					36, window.innerWidth / window.innerHeight, 0.25, 16 );

				camera.position.set( 0, 1.5, 3 );

				scene = new Scene();

				// Lights

				scene.add( new AmbientLight( 0x505050 ) );

				var spotLight = new SpotLight( 0xffffff );
				spotLight.angle = Math.PI / 5;
				spotLight.penumbra = 0.2;
				spotLight.position.set( 2, 3, 3 );
				spotLight.castShadow = true;
				spotLight.shadow.camera.near = 3;
				spotLight.shadow.camera.far = 10;
				spotLight.shadow.mapSize.width = 1024;
				spotLight.shadow.mapSize.height = 1024;
				scene.add( spotLight );

				var dirLight = new DirectionalLight( 0x55505a, 1 );
				dirLight.position.set( 0, 2, 0 );
				dirLight.castShadow = true;
				dirLight.shadow.camera.near = 1;
				dirLight.shadow.camera.far = 10;

				dirLight.shadow.camera.right = 1;
				dirLight.shadow.camera.left = - 1;
				dirLight.shadow.camera.top	= 1;
				dirLight.shadow.camera.bottom = - 1;

				dirLight.shadow.mapSize.width = 1024;
				dirLight.shadow.mapSize.height = 1024;
				scene.add( dirLight );

				// Geometry

				clipMaterial = new MeshPhongMaterial( {
					color: 0xee0a10,
					shininess: 100,
					side: DoubleSide,
					// Clipping setup:
					clippingPlanes: createPlanes( Planes.length ),
					clipShadows: true
				} );

				object = new Group();

				var geometry = new BoxBufferGeometry( 0.18, 0.18, 0.18 );

				for ( var z = - 2; z <= 2; ++ z )
					for ( var y = - 2; y <= 2; ++ y )
						for ( var x = - 2; x <= 2; ++ x ) {

							var mesh = new Mesh( geometry, clipMaterial );
							mesh.position.set( x / 5, y / 5, z / 5 );
							mesh.castShadow = true;
							object.add( mesh );

						}

				scene.add( object );


				var planeGeometry =
						new PlaneBufferGeometry( 3, 3, 1, 1 ),

					color = new Color();

				volumeVisualization = new Group();
				volumeVisualization.visible = false;

				for ( var i = 0, n = Planes.length; i !== n; ++ i ) {

					var material = new MeshBasicMaterial( {
						color: color.setHSL( i / n, 0.5, 0.5 ).getHex(),
						side: DoubleSide,

						opacity: 0.2,
						transparent: true,

						// clip to the others to show the volume (wildly
						// intersecting transparent planes look bad)
						clippingPlanes: clipMaterial.clippingPlanes.
							filter( function ( _, j ) {

								return j !== i;

							} )

						// no need to enable shadow clipping - the plane
						// visualization does not cast shadows

					} );

					volumeVisualization.add(
						new Mesh( planeGeometry, material ) );

				}

				scene.add( volumeVisualization );


				var ground = new Mesh( planeGeometry,
					new MeshPhongMaterial( {
						color: 0xa0adaf, shininess: 150 } ) );
				ground.rotation.x = - Math.PI / 2;
				ground.scale.multiplyScalar( 3 );
				ground.receiveShadow = true;
				scene.add( ground );

				// Renderer

				var container = document.body;

				renderer = new WebGLRenderer();
				renderer.shadowMap.enabled = true;
				renderer.setPixelRatio( window.devicePixelRatio );
				renderer.setSize( window.innerWidth, window.innerHeight );
				window.addEventListener( 'resize', onWindowResize, false );
				container.appendChild( renderer.domElement );
				// Clipping setup:
				globalClippingPlanes = createPlanes( GlobalClippingPlanes.length );
				renderer.clippingPlanes = Empty;
				renderer.localClippingEnabled = true;

				// Stats

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

				// Controls

				var controls = new OrbitControls( camera, renderer.domElement );
				controls.target.set( 0, 1, 0 );
				controls.update();

				// GUI

				var gui = new GUI(),
					folder = gui.addFolder( "Local Clipping" ),
					props = {
						get 'Enabled'() {

							return renderer.localClippingEnabled;

						},
						set 'Enabled'( v ) {

							renderer.localClippingEnabled = v;
							if ( ! v ) volumeVisualization.visible = false;

						},

						get 'Shadows'() {

							return clipMaterial.clipShadows;

						},
						set 'Shadows'( v ) {

							clipMaterial.clipShadows = v;

						},

						get 'Visualize'() {

							return volumeVisualization.visible;

						},
						set 'Visualize'( v ) {

							if ( renderer.localClippingEnabled )
								volumeVisualization.visible = v;

						}
					};

				folder.add( props, 'Enabled' );
				folder.add( props, 'Shadows' );
				folder.add( props, 'Visualize' ).listen();

				gui.addFolder( "Global Clipping" ).
					add( {
						get 'Enabled'() {

							return renderer.clippingPlanes !== Empty;

						},
						set 'Enabled'( v ) {

							renderer.clippingPlanes = v ?
								globalClippingPlanes : Empty;

						}
					}, "Enabled" );


				// Start

				startTime = Date.now();

			}

			function onWindowResize() {

				camera.aspect = window.innerWidth / window.innerHeight;
				camera.updateProjectionMatrix();

				renderer.setSize( window.innerWidth, window.innerHeight );

			}

			function setObjectWorldMatrix( object, matrix ) {

				// set the orientation of an object based on a world matrix

				var parent = object.parent;
				scene.updateMatrixWorld();
				object.matrix.getInverse( parent.matrixWorld );
				object.applyMatrix( matrix );

			}

			var transform = new Matrix4(),
				tmpMatrix = new Matrix4();

			function animate() {

				var currentTime = Date.now(),
					time = ( currentTime - startTime ) / 1000;

				requestAnimationFrame( animate );

				object.position.y = 1;
				object.rotation.x = time * 0.5;
				object.rotation.y = time * 0.2;

				object.updateMatrix();
				transform.copy( object.matrix );

				var bouncy = Math.cos( time * .5 ) * 0.5 + 0.7;
				transform.multiply(
					tmpMatrix.makeScale( bouncy, bouncy, bouncy ) );

				assignTransformedPlanes(
					clipMaterial.clippingPlanes, Planes, transform );

				var planeMeshes = volumeVisualization.children;

				for ( var i = 0, n = planeMeshes.length; i !== n; ++ i ) {

					tmpMatrix.multiplyMatrices( transform, PlaneMatrices[ i ] );
					setObjectWorldMatrix( planeMeshes[ i ], tmpMatrix );

				}

				transform.makeRotationY( time * 0.1 );

				assignTransformedPlanes(
					globalClippingPlanes, GlobalClippingPlanes, transform );

				stats.begin();
				renderer.render( scene, camera );
				stats.end();

			}

			init();
			animate();

		</script>

	</body>
</html>