New example: break objects by throwing balls (#9493)

* New webgl_physics_brick demo. Cutting a convex by a plane works, but it must be refactored to work from Geometry, not from "segmentedobject"

* webgl_physics_brick: Splitting a convex mesh with a plane works.

* webgl_physics_brick: Preparing to refactor objects

* webgl_physics_brick: Refactored objects to hang on the THREE.Object3d

* webgl_physics_brick: Radial subdivision works. To do: non-radial one.

* webgl_physics_brick: Non-radial subdivision works.

* 'breaking things' example works.

* added webgl_physics_convex_break to example index. Aded a pyramid.

* webgl_physics_convex_break: Add friction

* webgl_physics_convex_break: Add velocity and angular vel. from parent.

* webgl_physics_convex_break: Change guideline comment.

* webgl_physics_convex_break: Changed page title.

examples/files.js

@@ -184,6 +184,7 @@ var files = {
 		"webgl_physics_rope",
 		"webgl_physics_cloth",
 		"webgl_physics_volume",
+		"webgl_physics_convex_break",
 		"webgl_points_billboards",
 		"webgl_points_billboards_colors",
 		"webgl_points_dynamic",

examples/js/ConvexObjectBreaker.js

@@ -0,0 +1,489 @@
+/**
+ * @author yomboprime https://github.com/yomboprime
+ *
+ * @fileoverview This class can be used to subdivide a convex Geometry object into pieces.
+ *
+ * Usage:
+ *
+ * Use the function prepareBreakableObject to prepare a Mesh object to be broken.
+ *
+ * Then, call the various functions to subdivide the object (subdivideByImpact, cutByPlane)
+ *
+ * Sub-objects that are product of subdivision don't need prepareBreakableObject to be called on them.
+ *
+ * Requisites for the object:
+ *
+ *  - Mesh object must have a Geometry (not BufferGeometry) and a Material
+ *
+ *  - The Geometry must be convex (this is not tested in the library). You can create convex
+ *  Geometries with THREE.ConvexGeometry. The BoxGeometry, SphereGeometry and other convex primitives
+ *  can also be used.
+ *
+ * Note: This lib adds member variables to object's userData member and to its vertices.
+ * (see prepareBreakableObject function)
+ * Use with caution and read the code when using with other libs.
+ *
+ * @param {double} minSizeForBreak Min size a debris can have to break.
+ * @param {double} smallDelta Max distance to consider that a point belongs to a plane.
+ * 
+  */
+
+THREE.ConvexObjectBreaker = function( minSizeForBreak, smallDelta ) {
+
+	this.minSizeForBreak = minSizeForBreak || 1.4;
+	this.smallDelta = smallDelta || 0.0001;
+
+	this.tempLine1 = new THREE.Line3();
+	this.tempPlane1 = new THREE.Plane();
+	this.tempPlane2 = new THREE.Plane();
+	this.tempCM1 = new THREE.Vector3();
+	this.tempCM2 = new THREE.Vector3();
+	this.tempVector3 = new THREE.Vector3();
+	this.tempVector3_2 = new THREE.Vector3();
+	this.tempVector3_3 = new THREE.Vector3();
+	this.tempResultObjects = { object1: null, object2: null };
+
+	this.segments = [];
+	var n = 30 * 30;
+	for ( var i = 0; i < n; i++ ) {
+		this.segments[ i ] = false;
+	}
+
+};
+
+THREE.ConvexObjectBreaker.prototype = {
+
+	constructor: THREE.ConvexObjectBreaker,
+
+	prepareBreakableObject: function( object, mass, velocity, angularVelocity, breakable ) {
+
+		// object is a THREE.Object3d (normally a Mesh), must have a Geometry, and it must be convex.
+		// Its material property is propagated to its children (sub-pieces)
+		// mass must be > 0
+
+		// Create vertices mark
+		var vertices = object.geometry.vertices;
+		for ( var i = 0, il = vertices.length; i < il; i++ ) {
+			vertices[ i ].mark = 0;
+		}
+
+		var userData = object.userData;
+		userData.mass = mass;
+		userData.velocity = velocity.clone();
+		userData.angularVelocity = angularVelocity.clone();
+		userData.breakable = breakable;
+
+	},
+
+	/*
+	 * @param {int} maxRadialIterations Iterations for radial cuts.
+	 * @param {int} maxRandomIterations Max random iterations for not-radial cuts
+	 * @param {double} minSizeForRadialSubdivision Min size a debris can have to break in radial subdivision.
+	 *
+	 * Returns the array of pieces
+	 */
+	subdivideByImpact: function( object, pointOfImpact, normal, maxRadialIterations, maxRandomIterations, minSizeForRadialSubdivision ) {
+
+		var debris = [];
+
+		var tempPlane1 = this.tempPlane1;
+		var tempPlane2 = this.tempPlane2;
+
+		this.tempVector3.addVectors( pointOfImpact, normal );
+		tempPlane1.setFromCoplanarPoints( pointOfImpact, object.position, this.tempVector3 );
+
+		var maxTotalIterations = maxRandomIterations + maxRadialIterations;
+
+		var scope = this;
+
+		function subdivideRadial( subObject, startAngle, endAngle, numIterations ) {
+
+			if ( Math.random() < numIterations * 0.05 || numIterations > maxTotalIterations ) {
+
+				debris.push( subObject );
+
+				return;
+				
+			}
+			
+			var angle = Math.PI;
+
+			if ( numIterations === 0 ) {
+
+				tempPlane2.normal.copy( tempPlane1.normal );
+				tempPlane2.constant = tempPlane1.constant;
+
+			}
+			else {
+
+				if ( numIterations <= maxRadialIterations ) {
+					
+					angle = ( endAngle - startAngle ) * ( 0.2 + 0.6 * Math.random() ) + startAngle;
+
+					// Rotate tempPlane2 at impact point around normal axis and the angle
+					scope.tempVector3_2.copy( object.position ).sub( pointOfImpact ).applyAxisAngle( normal, angle ).add( pointOfImpact );
+					tempPlane2.setFromCoplanarPoints( pointOfImpact, scope.tempVector3, scope.tempVector3_2 );
+
+				}
+				else {
+
+					angle = ( ( 0.5 * ( numIterations & 1 ) ) + 0.2 * ( 2 - Math.random() ) ) * Math.PI;
+
+					// Rotate tempPlane2 at object position around normal axis and the angle
+					scope.tempVector3_2.copy( pointOfImpact ).sub( subObject.position ).applyAxisAngle( normal, angle ).add( subObject.position );
+					scope.tempVector3_3.copy( normal ).add( subObject.position );
+					tempPlane2.setFromCoplanarPoints( subObject.position, scope.tempVector3_3, scope.tempVector3_2 );
+
+				}
+
+			}
+
+			// Perform the cut
+			scope.cutByPlane( subObject, tempPlane2, scope.tempResultObjects );
+
+			var obj1 = scope.tempResultObjects.object1;
+			var obj2 = scope.tempResultObjects.object2;
+
+			if ( obj1 ) {
+
+				subdivideRadial( obj1, startAngle, angle, numIterations + 1 );
+
+			}
+
+			if ( obj2 ) {
+
+				subdivideRadial( obj2, angle, endAngle, numIterations + 1 );
+
+			}
+
+		}
+
+		subdivideRadial( object, 0, 2 * Math.PI, 0 );
+
+		return debris;
+
+	},
+
+	cutByPlane: function( object, plane, output ) {
+
+		// Returns breakable objects in output.object1 and output.object2 members, the resulting 2 pieces of the cut.
+		// object2 can be null if the plane doesn't cut the object.
+		// object1 can be null only in case of internal error
+		// Returned value is number of pieces, 0 for error.
+
+		var geometry = object.geometry;
+		var points = geometry.vertices;
+		var faces = geometry.faces;
+
+		var numPoints = points.length;
+
+		var points1 = [];
+		var points2 = [];
+
+		var delta = this.smallDelta;
+
+		// Reset vertices mark
+		for ( var i = 0; i < numPoints; i++ ) {
+			points[ i ].mark = 0;
+		}
+
+		// Reset segments mark
+		var numPointPairs = numPoints * numPoints;
+		for ( var i = 0; i < numPointPairs; i++ ) {
+			this.segments[ i ] = false;
+		}
+
+		// Iterate through the faces to mark edges shared by coplanar faces
+		for ( var i = 0, il = faces.length - 1; i < il; i++ ) {
+
+			var face1 = faces[ i ];
+
+			for ( var j = i + 1, jl = faces.length; j < jl; j++ ) {
+
+				var face2 = faces[ j ];
+
+				var coplanar = 1 - face1.normal.dot( face2.normal ) < delta;
+
+				if ( coplanar ) {
+
+					var a1 = face1.a;
+					var b1 = face1.b;
+					var c1 = face1.c;
+					var a2 = face2.a;
+					var b2 = face2.b;
+					var c2 = face2.c;
+
+
+					if ( a1 === a2 || a1 === b2 || a1 === c2 ) {
+						if ( b1 === a2 || b1 === b2 || b1 === c2 ) {
+							this.segments[ a1 * numPoints + b1 ] = true;
+							this.segments[ b1 * numPoints + a1 ] = true;
+						}
+						else {
+							this.segments[ c1 * numPoints + a1 ] = true;
+							this.segments[ a1 * numPoints + c1 ] = true;
+						}
+					}
+					else if ( b1 === a2 || b1 === b2 || b1 === c2 ) {
+						this.segments[ c1 * numPoints + b1 ] = true;
+						this.segments[ b1 * numPoints + c1 ] = true;
+					}
+
+				}
+
+			}
+
+		}
+
+		// Transform the plane to object local space
+		var localPlane = this.tempPlane1;
+		object.updateMatrix();
+		THREE.ConvexObjectBreaker.transformPlaneToLocalSpace( plane, object.matrix, localPlane );
+
+		// Iterate through the faces adding points to both pieces
+		for ( var i = 0, il = faces.length; i < il; i ++ ) {
+
+			var face = faces[ i ];
+
+			for ( var segment = 0; segment < 3; segment++ ) {
+
+				var i0 = segment === 0 ? face.a : ( segment === 1 ? face.b : face.c );
+				var i1 = segment === 0 ? face.b : ( segment === 1 ? face.c : face.a );
+
+				var segmentState = this.segments[ i0 * numPoints + i1 ];
+
+				if ( segmentState ) {
+					// The segment already has been processed in another face
+					continue;
+				}
+
+				// Mark segment as processed (also inverted segment)
+				this.segments[ i0 * numPoints + i1 ] = true;
+				this.segments[ i1 * numPoints + i0 ] = true;
+
+				var p0 = points[ i0 ];
+				var p1 = points[ i1 ];
+
+				if ( p0.mark === 0 ) {
+
+					var d = localPlane.distanceToPoint( p0 );
+
+					// mark: 1 for negative side, 2 for positive side, 3 for coplanar point
+					if ( d > delta ) {
+						p0.mark = 2;
+						points2.push( p0 );
+					}
+					else if ( d < - delta ) {
+						p0.mark = 1;
+						points1.push( p0 );
+					}
+					else {
+						p0.mark = 3;
+						points1.push( p0 );
+						var p0_2 = p0.clone();
+						p0_2.mark = 3;
+						points2.push( p0_2 );
+					}
+
+				}
+
+				if ( p1.mark === 0 ) {
+
+					var d = localPlane.distanceToPoint( p1 );
+
+					// mark: 1 for negative side, 2 for positive side, 3 for coplanar point
+					if ( d > delta ) {
+						p1.mark = 2;
+						points2.push( p1 );
+					}
+					else if ( d < - delta ) {
+						p1.mark = 1;
+						points1.push( p1 );
+					}
+					else {
+						p1.mark = 3;
+						points1.push( p1 );
+						var p1_2 = p1.clone();
+						p1_2.mark = 3;
+						points2.push( p1_2 );
+					}
+
+				}
+
+				var mark0 = p0.mark;
+				var mark1 = p1.mark;
+
+				if ( ( mark0 === 1 && mark1 === 2 ) || ( mark0 === 2 && mark1 === 1 ) ) {
+
+					// Intersection of segment with the plane
+
+					this.tempLine1.start.copy( p0 );
+					this.tempLine1.end.copy( p1 );
+					var intersection = localPlane.intersectLine( this.tempLine1 );
+					if ( intersection === undefined ) {
+						// Shouldn't happen
+						console.error( "Internal error: segment does not intersect plane." );
+						output.segmentedObject1 = null;
+						output.segmentedObject2 = null;
+						return 0;
+					}
+
+					intersection.mark = 1;
+					points1.push( intersection );
+					var intersection_2 = intersection.clone();
+					intersection_2.mark = 2;
+					points2.push( intersection_2 );
+
+				}
+
+			}
+
+		}
+
+		// Calculate debris mass (very fast and imprecise):
+		var newMass = object.userData.mass * 0.5;
+
+		// Calculate debris Center of Mass (again fast and imprecise)
+		this.tempCM1.set( 0, 0, 0 );
+		var radius1 = 0;
+		var numPoints1 = points1.length;
+		if ( numPoints1 > 0 ) {
+			for ( var i = 0; i < numPoints1; i++ ) {
+				this.tempCM1.add( points1[ i ] );
+			}
+			this.tempCM1.divideScalar( numPoints1 );
+			for ( var i = 0; i < numPoints1; i++ ) {
+				var p = points1[ i ];
+				p.sub( this.tempCM1 );
+				radius1 = Math.max( radius1, p.x, p.y, p.z );
+			}
+			this.tempCM1.add( object.position );
+		}
+
+		this.tempCM2.set( 0, 0, 0 );
+		var radius2 = 0;
+		var numPoints2 = points2.length;
+		if ( numPoints2 > 0 ) {
+			for ( var i = 0; i < numPoints2; i++ ) {
+				this.tempCM2.add( points2[ i ] );
+			}
+			this.tempCM2.divideScalar( numPoints2 );
+			for ( var i = 0; i < numPoints2; i++ ) {
+				var p = points2[ i ];
+				p.sub( this.tempCM2 );
+				radius2 = Math.max( radius2, p.x, p.y, p.z );
+			}
+			this.tempCM2.add( object.position );
+		}
+
+		var object1 = null;
+		var object2 = null;
+
+		var numObjects = 0;
+
+		if ( numPoints1 > 4 ) {
+
+			object1 = new THREE.Mesh( new THREE.ConvexGeometry( points1 ), object.material );
+			object1.position.copy( this.tempCM1 );
+			object1.quaternion.copy( object.quaternion );
+
+			this.prepareBreakableObject( object1, newMass, object.userData.velocity, object.userData.angularVelocity, 2 * radius1 > this.minSizeForBreak );
+
+			numObjects++;
+
+		}
+
+		if ( numPoints2 > 4 ) {
+
+			object2 = new THREE.Mesh( new THREE.ConvexGeometry( points2 ), object.material );
+			object2.position.copy( this.tempCM2 );
+			object2.quaternion.copy( object.quaternion );
+
+			this.prepareBreakableObject( object2, newMass, object.userData.velocity, object.userData.angularVelocity, 2 * radius2 > this.minSizeForBreak );
+
+			numObjects++;
+
+		}
+
+
+		output.object1 = object1;
+		output.object2 = object2;
+
+		return numObjects;
+
+	}
+
+};
+
+THREE.ConvexObjectBreaker.transformFreeVector = function( v, m ) {
+
+	// input:
+	// vector interpreted as a free vector
+	// THREE.Matrix4 orthogonal matrix (matrix without scale)
+
+	var x = v.x, y = v.y, z = v.z;
+	var e = m.elements;
+
+	v.x = e[ 0 ] * x + e[ 4 ] * y + e[ 8 ]  * z;
+	v.y = e[ 1 ] * x + e[ 5 ] * y + e[ 9 ]  * z;
+	v.z = e[ 2 ] * x + e[ 6 ] * y + e[ 10 ] * z;
+
+	return v;
+
+};
+
+THREE.ConvexObjectBreaker.transformFreeVectorInverse = function( v, m ) {
+
+	// input:
+	// vector interpreted as a free vector
+	// THREE.Matrix4 orthogonal matrix (matrix without scale)
+
+	var x = v.x, y = v.y, z = v.z;
+	var e = m.elements;
+
+	v.x = e[ 0 ] * x + e[ 1 ] * y + e[ 2 ]  * z;
+	v.y = e[ 4 ] * x + e[ 5 ] * y + e[ 6 ]  * z;
+	v.z = e[ 8 ] * x + e[ 9 ] * y + e[ 10 ] * z;
+
+	return v;
+
+};
+
+THREE.ConvexObjectBreaker.transformTiedVectorInverse = function( v, m ) {
+
+	// input:
+	// vector interpreted as a tied (ordinary) vector
+	// THREE.Matrix4 orthogonal matrix (matrix without scale)
+
+	var x = v.x, y = v.y, z = v.z;
+	var e = m.elements;
+
+	v.x = e[ 0 ] * x + e[ 1 ] * y + e[ 2 ]  * z - e[ 12 ];
+	v.y = e[ 4 ] * x + e[ 5 ] * y + e[ 6 ]  * z - e[ 13 ];
+	v.z = e[ 8 ] * x + e[ 9 ] * y + e[ 10 ] * z - e[ 14 ];
+
+	return v;
+
+};
+
+THREE.ConvexObjectBreaker.transformPlaneToLocalSpace = function() {
+
+	var v1 = new THREE.Vector3();
+	var m1 = new THREE.Matrix3();
+
+	return function transformPlaneToLocalSpace( plane, m, resultPlane ) {
+
+		resultPlane.normal.copy( plane.normal );
+		resultPlane.constant = plane.constant;
+
+		var referencePoint = THREE.ConvexObjectBreaker.transformTiedVectorInverse( plane.coplanarPoint( v1 ), m );
+
+		THREE.ConvexObjectBreaker.transformFreeVectorInverse( resultPlane.normal, m );
+
+		// recalculate constant (like in setFromNormalAndCoplanarPoint)
+		resultPlane.constant = - referencePoint.dot( resultPlane.normal );
+
+
+	};
+
+}();

examples/webgl_physics_convex_break.html

@@ -0,0 +1,561 @@
+<html lang="en">
+    <head>
+        <title>Convex object breaking example</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 {
+                color: #61443e;
+                font-family:Monospace;
+                font-size:13px;
+                text-align:center;
+
+                background-color: #bfd1e5;
+                margin: 0px;
+                overflow: hidden;
+            }
+
+            #info {
+                position: absolute;
+                top: 0px; width: 100%;
+                padding: 5px;
+            }
+
+            a {
+                color: #a06851;
+            }
+
+        </style>
+    </head>
+    <body>
+	<div id="info">Physics threejs demo with convex objects breaking in real time<br />Press mouse to throw balls and move the camera.</div>
+        <div id="container"><br /><br /><br /><br /><br />Loading...</div>
+
+	<script src="../build/three.js"></script>
+	<script src="js/libs/ammo.js"></script>
+	<script src="js/controls/OrbitControls.js"></script>
+        <script src="js/Detector.js"></script>
+	<script src="js/libs/stats.min.js"></script>
+	<script src="js/ConvexObjectBreaker.js"></script>
+	<script src="js/geometries/ConvexGeometry.js"></script>
+
+        <script>
+
+		// Detects webgl
+		if ( ! Detector.webgl ) {
+		    Detector.addGetWebGLMessage();
+		    document.getElementById( 'container' ).innerHTML = "";
+		}
+
+		// - Global variables -
+
+		// Graphics variables
+		var container, stats;
+		var camera, controls, scene, renderer;
+		var textureLoader;
+		var clock = new THREE.Clock();
+
+		var mouseCoords = new THREE.Vector2();
+		var raycaster = new THREE.Raycaster();
+		var ballMaterial = new THREE.MeshPhongMaterial( { color: 0x202020 } );
+
+		// Physics variables
+		var gravityConstant = 7.8;
+		var collisionConfiguration;
+		var dispatcher;
+		var broadphase;
+		var solver;
+		var physicsWorld;
+		var margin = 0.05;
+
+		var convexBreaker = new THREE.ConvexObjectBreaker();
+
+		// Rigid bodies include all movable objects
+		var rigidBodies = [];
+
+		var pos = new THREE.Vector3();
+		var quat = new THREE.Quaternion();
+		var transformAux1 = new Ammo.btTransform();
+		var tempBtVec3_1 = new Ammo.btVector3( 0, 0, 0 );
+
+		var time = 0;
+
+		var objectsToRemove = [];
+		for ( var i = 0; i < 500; i++ ) {
+		    objectsToRemove[ i ] = null;
+		}
+		var numObjectsToRemove = 0;
+
+		var impactPoint = new THREE.Vector3();
+		var impactNormal = new THREE.Vector3();
+
+		// - Main code -
+
+		init();
+		animate();
+
+
+		// - Functions -
+
+		function init() {
+
+			initGraphics();
+
+			initPhysics();
+
+			createObjects();
+
+			initInput();
+
+		}
+
+		function initGraphics() {
+
+			container = document.getElementById( 'container' );
+
+			camera = new THREE.PerspectiveCamera( 60, window.innerWidth / window.innerHeight, 0.2, 2000 );
+
+			scene = new THREE.Scene();
+
+			camera.position.x = -14;
+			camera.position.y = 8;
+			camera.position.z =  16;
+
+			controls = new THREE.OrbitControls( camera );
+			controls.target.y = 2;
+
+			renderer = new THREE.WebGLRenderer();
+			renderer.setClearColor( 0xbfd1e5 );
+			renderer.setPixelRatio( window.devicePixelRatio );
+			renderer.setSize( window.innerWidth, window.innerHeight );
+			renderer.shadowMap.enabled = true;
+
+			textureLoader = new THREE.TextureLoader();
+
+			var ambientLight = new THREE.AmbientLight( 0x707070 );
+			scene.add( ambientLight );
+
+			var light = new THREE.DirectionalLight( 0xffffff, 1 );
+			light.position.set( -10, 18, 5 );
+			light.castShadow = true;
+			var d = 14;
+			light.shadow.camera.left = -d;
+			light.shadow.camera.right = d;
+			light.shadow.camera.top = d;
+			light.shadow.camera.bottom = -d;
+
+			light.shadow.camera.near = 2;
+			light.shadow.camera.far = 50;
+
+			light.shadow.mapSize.x = 1024;
+			light.shadow.mapSize.y = 1024;
+
+			scene.add( light );
+
+
+			container.innerHTML = "";
+
+			container.appendChild( renderer.domElement );
+
+			stats = new Stats();
+			stats.domElement.style.position = 'absolute';
+			stats.domElement.style.top = '0px';
+			container.appendChild( stats.domElement );
+
+			//
+
+			window.addEventListener( 'resize', onWindowResize, false );
+
+		}
+
+		function initPhysics() {
+
+			// Physics configuration
+
+			collisionConfiguration = new Ammo.btDefaultCollisionConfiguration();
+			dispatcher = new Ammo.btCollisionDispatcher( collisionConfiguration );
+			broadphase = new Ammo.btDbvtBroadphase();
+			solver = new Ammo.btSequentialImpulseConstraintSolver();
+			physicsWorld = new Ammo.btDiscreteDynamicsWorld( dispatcher, broadphase, solver, collisionConfiguration );
+			physicsWorld.setGravity( new Ammo.btVector3( 0, - gravityConstant, 0 ) );
+
+		}
+
+		function createObject( mass, halfExtents, pos, quat, material ) {
+
+			var object = new THREE.Mesh( new THREE.BoxGeometry( halfExtents.x * 2, halfExtents.y * 2, halfExtents.z * 2 ), material );
+			object.position.copy( pos );
+			object.quaternion.copy( quat );
+			convexBreaker.prepareBreakableObject( object, mass, new THREE.Vector3(), new THREE.Vector3(), true );
+			createDebrisFromBreakableObject( object );
+
+		}
+
+		function createObjects() {
+
+			// Ground
+			pos.set( 0, - 0.5, 0 );
+			quat.set( 0, 0, 0, 1 );
+			var ground = createParalellepipedWithPhysics( 40, 1, 40, 0, pos, quat, new THREE.MeshPhongMaterial( { color: 0xFFFFFF } ) );
+			ground.receiveShadow = true;
+			textureLoader.load( "textures/grid.png", function( texture ) {
+				texture.wrapS = THREE.RepeatWrapping;
+				texture.wrapT = THREE.RepeatWrapping;
+				texture.repeat.set( 40, 40 );
+				ground.material.map = texture;
+				ground.material.needsUpdate = true;
+			} );
+
+			// Tower 1
+			var towerMass = 1000;
+			var towerHalfExtents = new THREE.Vector3( 2, 5, 2 );
+			pos.set( -8, 5, 0 );
+			quat.set( 0, 0, 0, 1 );
+			createObject( towerMass, towerHalfExtents, pos, quat, createMaterial( 0xF0A024 ) );
+
+			// Tower 2
+			pos.set( 8, 5, 0 );
+			quat.set( 0, 0, 0, 1 );
+			createObject( towerMass, towerHalfExtents, pos, quat, createMaterial( 0xF4A321 ) );
+
+			//Bridge
+			var bridgeMass = 100;
+			var bridgeHalfExtents = new THREE.Vector3( 7, 0.2, 1.5 );
+			pos.set( 0, 10.2, 0 );
+			quat.set( 0, 0, 0, 1 );
+			createObject( bridgeMass, bridgeHalfExtents, pos, quat, createMaterial( 0xB38835 ) );
+
+			// Stones
+			var stoneMass = 120;
+			var stoneHalfExtents = new THREE.Vector3( 1, 2, 0.15 );
+			var numStones = 8;
+			quat.set( 0, 0, 0, 1 );
+			for ( var i = 0; i < numStones; i++ ) {
+
+			    pos.set( 0, 2, 15 * ( 0.5 - i / ( numStones + 1 ) ) );
+
+			    createObject( stoneMass, stoneHalfExtents, pos, quat, createMaterial( 0xB0B0B0 ) );
+
+			}
+
+			// Mountain
+			var mountainMass = 860;
+			var mountainHalfExtents = new THREE.Vector3( 4, 5, 4 );
+			pos.set( 5, mountainHalfExtents.y * 0.5, - 7 );
+			quat.set( 0, 0, 0, 1 );
+			var mountainPoints = [];
+			mountainPoints.push( new THREE.Vector3( mountainHalfExtents.x, - mountainHalfExtents.y, mountainHalfExtents.z ) );
+			mountainPoints.push( new THREE.Vector3( - mountainHalfExtents.x, - mountainHalfExtents.y, mountainHalfExtents.z ) );
+			mountainPoints.push( new THREE.Vector3( mountainHalfExtents.x, - mountainHalfExtents.y, - mountainHalfExtents.z ) );
+			mountainPoints.push( new THREE.Vector3( - mountainHalfExtents.x, - mountainHalfExtents.y, - mountainHalfExtents.z ) );
+			mountainPoints.push( new THREE.Vector3( 0, mountainHalfExtents.y, 0 ) );
+			var mountain = new THREE.Mesh( new THREE.ConvexGeometry( mountainPoints ), createMaterial( 0xFFB443 ) );
+			mountain.position.copy( pos );
+			mountain.quaternion.copy( quat );
+			convexBreaker.prepareBreakableObject( mountain, mountainMass, new THREE.Vector3(), new THREE.Vector3(), true );
+			createDebrisFromBreakableObject( mountain );
+
+		}
+
+		function createParalellepipedWithPhysics( sx, sy, sz, mass, pos, quat, material ) {
+
+			var object = new THREE.Mesh( new THREE.BoxGeometry( sx, sy, sz, 1, 1, 1 ), material );
+			var shape = new Ammo.btBoxShape( new Ammo.btVector3( sx * 0.5, sy * 0.5, sz * 0.5 ) );
+			shape.setMargin( margin );
+
+			createRigidBody( object, shape, mass, pos, quat );
+
+			return object;
+
+		}
+
+		function createDebrisFromBreakableObject( object ) {
+
+			object.castShadow = true;
+			object.receiveShadow = true;
+
+			var shape = createConvexHullPhysicsShape( object.geometry.vertices );
+			shape.setMargin( margin );
+
+			var body = createRigidBody( object, shape, object.userData.mass, null, null, object.userData.velocity, object.userData.angularVelocity );
+
+			// Set pointer back to the three object only in the debris objects
+			var btVecUserData = new Ammo.btVector3( 0, 0, 0 );
+			btVecUserData.threeObject = object;
+			body.setUserPointer( btVecUserData );
+
+		}
+
+		function removeDebris( object ) {
+
+			scene.remove( object );
+
+			physicsWorld.removeRigidBody( object.userData.physicsBody );
+
+		}
+
+		function createConvexHullPhysicsShape( points ) {
+
+			var shape = new Ammo.btConvexHullShape();
+
+			for ( var i = 0, il = points.length; i < il; i++ ) {
+				var p = points[ i ];
+				this.tempBtVec3_1.setValue( p.x, p.y, p.z );
+				var lastOne = ( i === ( il - 1 ) );
+				shape.addPoint( this.tempBtVec3_1, lastOne );
+			}
+
+			return shape;
+
+		}
+
+		function createRigidBody( object, physicsShape, mass, pos, quat, vel, angVel ) {
+
+			if ( pos ) {
+			    object.position.copy( pos );
+			}
+			else {
+			    pos = object.position;
+			}
+			if ( quat ) {
+			    object.quaternion.copy( quat );
+			}
+			else {
+			    quat = object.quaternion;
+			}
+
+			var transform = new Ammo.btTransform();
+			transform.setIdentity();
+			transform.setOrigin( new Ammo.btVector3( pos.x, pos.y, pos.z ) );
+			transform.setRotation( new Ammo.btQuaternion( quat.x, quat.y, quat.z, quat.w ) );
+			var motionState = new Ammo.btDefaultMotionState( transform );
+
+			var localInertia = new Ammo.btVector3( 0, 0, 0 );
+			physicsShape.calculateLocalInertia( mass, localInertia );
+
+			var rbInfo = new Ammo.btRigidBodyConstructionInfo( mass, motionState, physicsShape, localInertia );
+			var body = new Ammo.btRigidBody( rbInfo );
+
+			body.setFriction( 0.5 );
+
+			if ( vel ) {
+			    body.setLinearVelocity( new Ammo.btVector3( vel.x, vel.y, vel.z ) );
+			}
+			if ( angVel ) {
+			    body.setAngularVelocity( new Ammo.btVector3( angVel.x, angVel.y, angVel.z ) );
+			}
+
+			object.userData.physicsBody = body;
+			object.userData.collided = false;
+
+			scene.add( object );
+
+			if ( mass > 0 ) {
+				rigidBodies.push( object );
+
+				// Disable deactivation
+				body.setActivationState( 4 );
+			}
+
+			physicsWorld.addRigidBody( body );
+
+			return body;
+		}
+
+		function createRandomColor() {
+			return Math.floor( Math.random() * ( 1 << 24 ) );
+		}
+
+		function createMaterial( color ) {
+			color = color || createRandomColor();
+			return new THREE.MeshPhongMaterial( { color: color } );
+		}
+
+		function initInput() {
+
+			window.addEventListener( 'mousedown', function( event ) {
+
+				mouseCoords.set(
+					( event.clientX / window.innerWidth ) * 2 - 1,
+					- ( event.clientY / window.innerHeight ) * 2 + 1
+				);
+
+				raycaster.setFromCamera( mouseCoords, camera );
+
+				// Creates a ball and throws it
+				var ballMass = 35;
+				var ballRadius = 0.4;
+
+				var ball = new THREE.Mesh( new THREE.SphereGeometry( ballRadius, 14, 10 ), ballMaterial );
+				ball.castShadow = true;
+				ball.receiveShadow = true;
+				var ballShape = new Ammo.btSphereShape( ballRadius );
+				ballShape.setMargin( margin );
+				pos.copy( raycaster.ray.direction );
+				pos.add( raycaster.ray.origin );
+				quat.set( 0, 0, 0, 1 );
+				var ballBody = createRigidBody( ball, ballShape, ballMass, pos, quat );
+
+				pos.copy( raycaster.ray.direction );
+				pos.multiplyScalar( 24 );
+				ballBody.setLinearVelocity( new Ammo.btVector3( pos.x, pos.y, pos.z ) );
+
+			}, false );
+
+		}
+
+		function onWindowResize() {
+
+			camera.aspect = window.innerWidth / window.innerHeight;
+			camera.updateProjectionMatrix();
+
+			renderer.setSize( window.innerWidth, window.innerHeight );
+
+		}
+
+		function animate() {
+
+			requestAnimationFrame( animate );
+
+			render();
+			stats.update();
+
+		}
+
+		function render() {
+
+			var deltaTime = clock.getDelta();
+
+			updatePhysics( deltaTime );
+
+			controls.update( deltaTime );
+
+			renderer.render( scene, camera );
+
+			time += deltaTime;
+
+		}
+
+		function updatePhysics( deltaTime ) {
+
+			// Step world
+			physicsWorld.stepSimulation( deltaTime, 10 );
+
+			// Update rigid bodies
+			for ( var i = 0, il = rigidBodies.length; i < il; i++ ) {
+				var objThree = rigidBodies[ i ];
+				var objPhys = objThree.userData.physicsBody;
+				var ms = objPhys.getMotionState();
+				if ( ms ) {
+
+					ms.getWorldTransform( transformAux1 );
+					var p = transformAux1.getOrigin();
+					var q = transformAux1.getRotation();
+					objThree.position.set( p.x(), p.y(), p.z() );
+					objThree.quaternion.set( q.x(), q.y(), q.z(), q.w() );
+
+					objThree.userData.collided = false;
+
+				}
+			}
+
+			for ( var i = 0, il = dispatcher.getNumManifolds(); i < il; i ++ ) {
+
+				var contactManifold = dispatcher.getManifoldByIndexInternal( i );
+				var rb0 = contactManifold.getBody0();
+				var rb1 = contactManifold.getBody1();
+
+				var threeObject0 = Ammo.castObject( rb0.getUserPointer(), Ammo.btVector3 ).threeObject;
+				var threeObject1 = Ammo.castObject( rb1.getUserPointer(), Ammo.btVector3 ).threeObject;
+
+				if ( ! threeObject0 && ! threeObject1 ) {
+					continue;
+				}
+
+				var userData0 = threeObject0 ? threeObject0.userData : null;
+				var userData1 = threeObject1 ? threeObject1.userData : null;
+
+				var breakable0 = userData0 ? userData0.breakable : false;
+				var breakable1 = userData1 ? userData1.breakable : false;
+
+				var collided0 = userData0 ? userData0.collided : false;
+				var collided1 = userData1 ? userData1.collided : false;
+
+				if ( ( ! breakable0 && ! breakable1 ) || ( collided0 && collided1 ) ) {
+					continue;
+				}
+
+				var contact = false;
+				var maxImpulse = 0;
+				for ( var j = 0, jl = contactManifold.getNumContacts(); j < jl; j ++ ) {
+					var contactPoint = contactManifold.getContactPoint( j );
+					if ( contactPoint.getDistance() < 0 ) {
+						contact = true;
+						var impulse = contactPoint.getAppliedImpulse();
+						if ( impulse > maxImpulse ) {
+							maxImpulse = impulse;
+							var pos = contactPoint.get_m_positionWorldOnB();
+							var normal = contactPoint.get_m_normalWorldOnB();
+							impactPoint.set( pos.x(), pos.y(), pos.z() );
+							impactNormal.set( normal.x(), normal.y(), normal.z() );
+						}
+						break;
+					}
+				}
+
+				// If no point has contact, abort
+				if ( ! contact ) {
+					continue;
+				}
+
+				// Subdivision
+
+				var fractureImpulse = 250;
+
+				if ( breakable0 && !collided0 && maxImpulse > fractureImpulse ) {
+
+					var debris = convexBreaker.subdivideByImpact( threeObject0, impactPoint, impactNormal , 1, 2, 1.5 );
+
+					var numObjects = debris.length;
+					for ( var j = 0; j < numObjects; j++ ) {
+
+						createDebrisFromBreakableObject( debris[ j ] );
+
+					}
+
+					objectsToRemove[ numObjectsToRemove++ ] = threeObject0;
+					userData0.collided = true;
+
+				}
+
+				if ( breakable1 && !collided1 && maxImpulse > fractureImpulse ) {
+
+					var debris = convexBreaker.subdivideByImpact( threeObject1, impactPoint, impactNormal , 1, 2, 1.5 );
+
+					var numObjects = debris.length;
+					for ( var j = 0; j < numObjects; j++ ) {
+
+						createDebrisFromBreakableObject( debris[ j ] );
+
+					}
+
+					objectsToRemove[ numObjectsToRemove++ ] = threeObject1;
+					userData1.collided = true;
+
+				}
+
+			}
+
+			for ( var i = 0; i < numObjectsToRemove; i++ ) {
+
+			    removeDebris( objectsToRemove[ i ] );
+
+			}
+			numObjectsToRemove = 0;
+
+		}
+
+        </script>
+
+    </body>
+</html>