text: window.Physijs = (function() {
  	'use strict';
  
  	var SUPPORT_TRANSFERABLE,
  		_is_simulating = false,
  		_Physijs = Physijs, // used for noConflict method
  		Physijs = {}, // object assigned to window.Physijs
  		Eventable, // class to provide simple event methods
  		getObjectId, // returns a unique ID for a Physijs mesh object
  		getEulerXYZFromQuaternion, getQuatertionFromEuler,
  		convertWorldPositionToObject, // Converts a world-space position to object-space
  		addObjectChildren,
  
  		_temp1, _temp2,
  		_temp_vector3_1 = new THREE.Vector3,
  		_temp_vector3_2 = new THREE.Vector3,
  		_temp_matrix4_1 = new THREE.Matrix4,
  		_quaternion_1 = new THREE.Quaternion,
  
  		// constants
  		MESSAGE_TYPES = {
  			WORLDREPORT: 0,
  			COLLISIONREPORT: 1,
  			VEHICLEREPORT: 2,
  			CONSTRAINTREPORT: 3
  		},
  		REPORT_ITEMSIZE = 14,
  		COLLISIONREPORT_ITEMSIZE = 5,
  		VEHICLEREPORT_ITEMSIZE = 9,
  		CONSTRAINTREPORT_ITEMSIZE = 6;
  
  	Physijs.scripts = {};
  
  	Eventable = function() {
  		this._eventListeners = {};
  	};
  	Eventable.prototype.addEventListener = function( event_name, callback ) {
  		if ( !this._eventListeners.hasOwnProperty( event_name ) ) {
  			this._eventListeners[event_name] = [];
  		}
  		this._eventListeners[event_name].push( callback );
  	};
  	Eventable.prototype.removeEventListener = function( event_name, callback ) {
  		var index;
  
  		if ( !this._eventListeners.hasOwnProperty( event_name ) ) return false;
  
  		if ( (index = this._eventListeners[event_name].indexOf( callback )) >= 0 ) {
  			this._eventListeners[event_name].splice( index, 1 );
  			return true;
  		}
  
  		return false;
  	};
  	Eventable.prototype.dispatchEvent = function( event_name ) {
  		var i,
  			parameters = Array.prototype.splice.call( arguments, 1 );
  
  		if ( this._eventListeners.hasOwnProperty( event_name ) ) {
  			for ( i = 0; i < this._eventListeners[event_name].length; i++ ) {
  				this._eventListeners[event_name][i].apply( this, parameters );
  			}
  		}
  	};
  	Eventable.make = function( obj ) {
  		obj.prototype.addEventListener = Eventable.prototype.addEventListener;
  		obj.prototype.removeEventListener = Eventable.prototype.removeEventListener;
  		obj.prototype.dispatchEvent = Eventable.prototype.dispatchEvent;
  	};
  
  	getObjectId = (function() {
  		var _id = 1;
  		return function() {
  			return _id++;
  		};
  	})();
  
  	getEulerXYZFromQuaternion = function ( x, y, z, w ) {
  		return new THREE.Vector3(
  			Math.atan2( 2 * ( x * w - y * z ), ( w * w - x * x - y * y + z * z ) ),
  			Math.asin( 2 *  ( x * z + y * w ) ),
  			Math.atan2( 2 * ( z * w - x * y ), ( w * w + x * x - y * y - z * z ) )
  		);
  	};
  
  	getQuatertionFromEuler = function( x, y, z ) {
  		var c1, s1, c2, s2, c3, s3, c1c2, s1s2;
  		c1 = Math.cos( y  );
  		s1 = Math.sin( y  );
  		c2 = Math.cos( -z );
  		s2 = Math.sin( -z );
  		c3 = Math.cos( x  );
  		s3 = Math.sin( x  );
  
  		c1c2 = c1 * c2;
  		s1s2 = s1 * s2;
  
  		return {
  			w: c1c2 * c3  - s1s2 * s3,
  			x: c1c2 * s3  + s1s2 * c3,
  			y: s1 * c2 * c3 + c1 * s2 * s3,
  			z: c1 * s2 * c3 - s1 * c2 * s3
  		};
  	};
  
  	convertWorldPositionToObject = function( position, object ) {
  		_temp_matrix4_1.identity(); // reset temp matrix
  
  		// Set the temp matrix's rotation to the object's rotation
  		_temp_matrix4_1.identity().makeRotationFromQuaternion( object.quaternion );
  
  		// Invert rotation matrix in order to "unrotate" a point back to object space
  		_temp_matrix4_1.getInverse( _temp_matrix4_1 );
  
  		// Yay! Temp vars!
  		_temp_vector3_1.copy( position );
  		_temp_vector3_2.copy( object.position );
  
  		// Apply the rotation
  
  		return _temp_vector3_1.sub( _temp_vector3_2 ).applyMatrix4( _temp_matrix4_1 );
  	};
  
  
  
  	// Physijs.noConflict
  	Physijs.noConflict = function() {
  		window.Physijs = _Physijs;
  		return Physijs;
  	};
  
  
  	// Physijs.createMaterial
  	Physijs.createMaterial = function( material, friction, restitution ) {
  		var physijs_material = function(){};
  		physijs_material.prototype = material;
  		physijs_material = new physijs_material;
  
  		physijs_material._physijs = {
  			id: material.id,
  			friction: friction === undefined ? .8 : friction,
  			restitution: restitution === undefined ? .2 : restitution
  		};
  
  		return physijs_material;
  	};
  
  
  	// Constraints
  	Physijs.PointConstraint = function( objecta, objectb, position ) {
  		if ( position === undefined ) {
  			position = objectb;
  			objectb = undefined;
  		}
  
  		this.type = 'point';
  		this.appliedImpulse = 0;
  		this.id = getObjectId();
  		this.objecta = objecta._physijs.id;
  		this.positiona = convertWorldPositionToObject( position, objecta ).clone();
  
  		if ( objectb ) {
  			this.objectb = objectb._physijs.id;
  			this.positionb = convertWorldPositionToObject( position, objectb ).clone();
  		}
  	};
  	Physijs.PointConstraint.prototype.getDefinition = function() {
  		return {
  			type: this.type,
  			id: this.id,
  			objecta: this.objecta,
  			objectb: this.objectb,
  			positiona: this.positiona,
  			positionb: this.positionb
  		};
  	};
  
  	Physijs.HingeConstraint = function( objecta, objectb, position, axis ) {
  		if ( axis === undefined ) {
  			axis = position;
  			position = objectb;
  			objectb = undefined;
  		}
  
  		this.type = 'hinge';
  		this.appliedImpulse = 0;
  		this.id = getObjectId();
  		this.scene = objecta.parent;
  		this.objecta = objecta._physijs.id;
  		this.positiona = convertWorldPositionToObject( position, objecta ).clone();
  		this.position = position.clone();
  		this.axis = axis;
  
  		if ( objectb ) {
  			this.objectb = objectb._physijs.id;
  			this.positionb = convertWorldPositionToObject( position, objectb ).clone();
  		}
  	};
  	Physijs.HingeConstraint.prototype.getDefinition = function() {
  		return {
  			type: this.type,
  			id: this.id,
  			objecta: this.objecta,
  			objectb: this.objectb,
  			positiona: this.positiona,
  			positionb: this.positionb,
  			axis: this.axis
  		};
  	};
  	/*
  	 * low = minimum angle in radians
  	 * high = maximum angle in radians
  	 * bias_factor = applied as a factor to constraint error
  	 * relaxation_factor = controls bounce (0.0 == no bounce)
  	 */
  	Physijs.HingeConstraint.prototype.setLimits = function( low, high, bias_factor, relaxation_factor ) {
  		this.scene.execute( 'hinge_setLimits', { constraint: this.id, low: low, high: high, bias_factor: bias_factor, relaxation_factor: relaxation_factor } );
  	};
  	Physijs.HingeConstraint.prototype.enableAngularMotor = function( velocity, acceleration ) {
  		this.scene.execute( 'hinge_enableAngularMotor', { constraint: this.id, velocity: velocity, acceleration: acceleration } );
  	};
  	Physijs.HingeConstraint.prototype.disableMotor = function( velocity, acceleration ) {
  		this.scene.execute( 'hinge_disableMotor', { constraint: this.id } );
  	};
  
  	Physijs.SliderConstraint = function( objecta, objectb, position, axis ) {
  		if ( axis === undefined ) {
  			axis = position;
  			position = objectb;
  			objectb = undefined;
  		}
  
  		this.type = 'slider';
  		this.appliedImpulse = 0;
  		this.id = getObjectId();
  		this.scene = objecta.parent;
  		this.objecta = objecta._physijs.id;
  		this.positiona = convertWorldPositionToObject( position, objecta ).clone();
  		this.axis = axis;
  
  		if ( objectb ) {
  			this.objectb = objectb._physijs.id;
  			this.positionb = convertWorldPositionToObject( position, objectb ).clone();
  		}
  	};
  	Physijs.SliderConstraint.prototype.getDefinition = function() {
  		return {
  			type: this.type,
  			id: this.id,
  			objecta: this.objecta,
  			objectb: this.objectb,
  			positiona: this.positiona,
  			positionb: this.positionb,
  			axis: this.axis
  		};
  	};
  	Physijs.SliderConstraint.prototype.setLimits = function( lin_lower, lin_upper, ang_lower, ang_upper ) {
  		this.scene.execute( 'slider_setLimits', { constraint: this.id, lin_lower: lin_lower, lin_upper: lin_upper, ang_lower: ang_lower, ang_upper: ang_upper } );
  	};
  	Physijs.SliderConstraint.prototype.setRestitution = function( linear, angular ) {
  		this.scene.execute(
  			'slider_setRestitution',
  			{
  				constraint: this.id,
  				linear: linear,
  				angular: angular
  			}
  		);
  	};
  	Physijs.SliderConstraint.prototype.enableLinearMotor = function( velocity, acceleration) {
  		this.scene.execute( 'slider_enableLinearMotor', { constraint: this.id, velocity: velocity, acceleration: acceleration } );
  	};
  	Physijs.SliderConstraint.prototype.disableLinearMotor = function() {
  		this.scene.execute( 'slider_disableLinearMotor', { constraint: this.id } );
  	};
  	Physijs.SliderConstraint.prototype.enableAngularMotor = function( velocity, acceleration ) {
  		this.scene.execute( 'slider_enableAngularMotor', { constraint: this.id, velocity: velocity, acceleration: acceleration } );
  	};
  	Physijs.SliderConstraint.prototype.disableAngularMotor = function() {
  		this.scene.execute( 'slider_disableAngularMotor', { constraint: this.id } );
  	};
  
  	Physijs.ConeTwistConstraint = function( objecta, objectb, position ) {
  		if ( position === undefined ) {
  			throw 'Both objects must be defined in a ConeTwistConstraint.';
  		}
  		this.type = 'conetwist';
  		this.appliedImpulse = 0;
  		this.id = getObjectId();
  		this.scene = objecta.parent;
  		this.objecta = objecta._physijs.id;
  		this.positiona = convertWorldPositionToObject( position, objecta ).clone();
  		this.objectb = objectb._physijs.id;
  		this.positionb = convertWorldPositionToObject( position, objectb ).clone();
  		this.axisa = { x: objecta.rotation.x, y: objecta.rotation.y, z: objecta.rotation.z };
  		this.axisb = { x: objectb.rotation.x, y: objectb.rotation.y, z: objectb.rotation.z };
  	};
  	Physijs.ConeTwistConstraint.prototype.getDefinition = function() {
  		return {
  			type: this.type,
  			id: this.id,
  			objecta: this.objecta,
  			objectb: this.objectb,
  			positiona: this.positiona,
  			positionb: this.positionb,
  			axisa: this.axisa,
  			axisb: this.axisb
  		};
  	};
  	Physijs.ConeTwistConstraint.prototype.setLimit = function( x, y, z ) {
  		this.scene.execute( 'conetwist_setLimit', { constraint: this.id, x: x, y: y, z: z } );
  	};
  	Physijs.ConeTwistConstraint.prototype.enableMotor = function() {
  		this.scene.execute( 'conetwist_enableMotor', { constraint: this.id } );
  	};
  	Physijs.ConeTwistConstraint.prototype.setMaxMotorImpulse = function( max_impulse ) {
  		this.scene.execute( 'conetwist_setMaxMotorImpulse', { constraint: this.id, max_impulse: max_impulse } );
  	};
  	Physijs.ConeTwistConstraint.prototype.setMotorTarget = function( target ) {
  		if ( target instanceof THREE.Vector3 ) {
  			target = new THREE.Quaternion().setFromEuler( new THREE.Euler( target.x, target.y, target.z ) );
  		} else if ( target instanceof THREE.Euler ) {
  			target = new THREE.Quaternion().setFromEuler( target );
  		} else if ( target instanceof THREE.Matrix4 ) {
  			target = new THREE.Quaternion().setFromRotationMatrix( target );
  		}
  		this.scene.execute( 'conetwist_setMotorTarget', { constraint: this.id, x: target.x, y: target.y, z: target.z, w: target.w } );
  	};
  	Physijs.ConeTwistConstraint.prototype.disableMotor = function() {
  		this.scene.execute( 'conetwist_disableMotor', { constraint: this.id } );
  	};
  
  	Physijs.DOFConstraint = function( objecta, objectb, position ) {
  		if ( position === undefined ) {
  			position = objectb;
  			objectb = undefined;
  		}
  		this.type = 'dof';
  		this.appliedImpulse = 0;
  		this.id = getObjectId();
  		this.scene = objecta.parent;
  		this.objecta = objecta._physijs.id;
  		this.positiona = convertWorldPositionToObject( position, objecta ).clone();
  		this.axisa = { x: objecta.rotation.x, y: objecta.rotation.y, z: objecta.rotation.z };
  
  		if ( objectb ) {
  			this.objectb = objectb._physijs.id;
  			this.positionb = convertWorldPositionToObject( position, objectb ).clone();
  			this.axisb = { x: objectb.rotation.x, y: objectb.rotation.y, z: objectb.rotation.z };
  		}
  	};
  	Physijs.DOFConstraint.prototype.getDefinition = function() {
  		return {
  			type: this.type,
  			id: this.id,
  			objecta: this.objecta,
  			objectb: this.objectb,
  			positiona: this.positiona,
  			positionb: this.positionb,
  			axisa: this.axisa,
  			axisb: this.axisb
  		};
  	};
  	Physijs.DOFConstraint.prototype.setLinearLowerLimit = function( limit ) {
  		this.scene.execute( 'dof_setLinearLowerLimit', { constraint: this.id, x: limit.x, y: limit.y, z: limit.z } );
  	};
  	Physijs.DOFConstraint.prototype.setLinearUpperLimit = function( limit ) {
  		this.scene.execute( 'dof_setLinearUpperLimit', { constraint: this.id, x: limit.x, y: limit.y, z: limit.z } );
  	};
  	Physijs.DOFConstraint.prototype.setAngularLowerLimit = function( limit ) {
  		this.scene.execute( 'dof_setAngularLowerLimit', { constraint: this.id, x: limit.x, y: limit.y, z: limit.z } );
  	};
  	Physijs.DOFConstraint.prototype.setAngularUpperLimit = function( limit ) {
  		this.scene.execute( 'dof_setAngularUpperLimit', { constraint: this.id, x: limit.x, y: limit.y, z: limit.z } );
  	};
  	Physijs.DOFConstraint.prototype.enableAngularMotor = function( which ) {
  		this.scene.execute( 'dof_enableAngularMotor', { constraint: this.id, which: which } );
  	};
  	Physijs.DOFConstraint.prototype.configureAngularMotor = function( which, low_angle, high_angle, velocity, max_force ) {
  		this.scene.execute( 'dof_configureAngularMotor', { constraint: this.id, which: which, low_angle: low_angle, high_angle: high_angle, velocity: velocity, max_force: max_force } );
  	};
  	Physijs.DOFConstraint.prototype.disableAngularMotor = function( which ) {
  		this.scene.execute( 'dof_disableAngularMotor', { constraint: this.id, which: which } );
  	};
  
  	// Physijs.Scene
  	Physijs.Scene = function( params ) {
  		var self = this;
  
  		Eventable.call( this );
  		THREE.Scene.call( this );
  
  		this._worker = new Worker( Physijs.scripts.worker || 'physijs_worker.js' );
  		this._worker.transferableMessage = this._worker.webkitPostMessage || this._worker.postMessage;
  		this._materials_ref_counts = {};
  		this._objects = {};
  		this._vehicles = {};
  		this._constraints = {};
  
  		var ab = new ArrayBuffer( 1 );
  		this._worker.transferableMessage( ab, [ab] );
  		SUPPORT_TRANSFERABLE = ( ab.byteLength === 0 );
  
  		this._worker.onmessage = function ( event ) {
  			var _temp,
  				data = event.data;
  
  			if ( data instanceof ArrayBuffer && data.byteLength !== 1 ) { // byteLength === 1 is the worker making a SUPPORT_TRANSFERABLE test
  				data = new Float32Array( data );
  			}
  
  			if ( data instanceof Float32Array ) {
  
  				// transferable object
  				switch ( data[0] ) {
  					case MESSAGE_TYPES.WORLDREPORT:
  						self._updateScene( data );
  						break;
  
  					case MESSAGE_TYPES.COLLISIONREPORT:
  						self._updateCollisions( data );
  						break;
  
  					case MESSAGE_TYPES.VEHICLEREPORT:
  						self._updateVehicles( data );
  						break;
  
  					case MESSAGE_TYPES.CONSTRAINTREPORT:
  						self._updateConstraints( data );
  						break;
  				}
  
  			} else {
  
  				if ( data.cmd ) {
  
  					// non-transferable object
  					switch ( data.cmd ) {
  						case 'objectReady':
  							_temp = data.params;
  							if ( self._objects[ _temp ] ) {
  								self._objects[ _temp ].dispatchEvent( 'ready' );
  							}
  							break;
  
  						case 'worldReady':
  							self.dispatchEvent( 'ready' );
  							break;
  
  						case 'vehicle':
  							window.test = data;
  							break;
  
  						default:
  							// Do nothing, just show the message
  							console.debug('Received: ' + data.cmd);
  							console.dir(data.params);
  							break;
  					}
  
  				} else {
  
  					switch ( data[0] ) {
  						case MESSAGE_TYPES.WORLDREPORT:
  							self._updateScene( data );
  							break;
  
  						case MESSAGE_TYPES.COLLISIONREPORT:
  							self._updateCollisions( data );
  							break;
  
  						case MESSAGE_TYPES.VEHICLEREPORT:
  							self._updateVehicles( data );
  							break;
  
  						case MESSAGE_TYPES.CONSTRAINTREPORT:
  							self._updateConstraints( data );
  							break;
  					}
  
  				}
  
  			}
  		};
  
  
  		params = params || {};
  		params.ammo = Physijs.scripts.ammo || 'ammo.js';
  		params.fixedTimeStep = params.fixedTimeStep || 1 / 60;
  		params.rateLimit = params.rateLimit || true;
  		this.execute( 'init', params );
  	};
  	Physijs.Scene.prototype = new THREE.Scene;
  	Physijs.Scene.prototype.constructor = Physijs.Scene;
  	Eventable.make( Physijs.Scene );
  
  	Physijs.Scene.prototype._updateScene = function( data ) {
  		var num_objects = data[1],
  			object,
  			i, offset;
  
  		for ( i = 0; i < num_objects; i++ ) {
  			offset = 2 + i * REPORT_ITEMSIZE;
  			object = this._objects[ data[ offset ] ];
  
  			if ( object === undefined ) {
  				continue;
  			}
  
  			if ( object.__dirtyPosition === false ) {
  				object.position.set(
  					data[ offset + 1 ],
  					data[ offset + 2 ],
  					data[ offset + 3 ]
  				);
  			}
  
  			if ( object.__dirtyRotation === false ) {
  				object.quaternion.set(
  					data[ offset + 4 ],
  					data[ offset + 5 ],
  					data[ offset + 6 ],
  					data[ offset + 7 ]
  				);
  			}
  
  			object._physijs.linearVelocity.set(
  				data[ offset + 8 ],
  				data[ offset + 9 ],
  				data[ offset + 10 ]
  			);
  
  			object._physijs.angularVelocity.set(
  				data[ offset + 11 ],
  				data[ offset + 12 ],
  				data[ offset + 13 ]
  			);
  
  		}
  
  		if ( SUPPORT_TRANSFERABLE ) {
  			// Give the typed array back to the worker
  			this._worker.transferableMessage( data.buffer, [data.buffer] );
  		}
  
  		_is_simulating = false;
  		this.dispatchEvent( 'update' );
  	};
  
  	Physijs.Scene.prototype._updateVehicles = function( data ) {
  		var vehicle, wheel,
  			i, offset;
  
  		for ( i = 0; i < ( data.length - 1 ) / VEHICLEREPORT_ITEMSIZE; i++ ) {
  			offset = 1 + i * VEHICLEREPORT_ITEMSIZE;
  			vehicle = this._vehicles[ data[ offset ] ];
  
  			if ( vehicle === undefined ) {
  				continue;
  			}
  
  			wheel = vehicle.wheels[ data[ offset + 1 ] ];
  
  			wheel.position.set(
  				data[ offset + 2 ],
  				data[ offset + 3 ],
  				data[ offset + 4 ]
  			);
  
  			wheel.quaternion.set(
  				data[ offset + 5 ],
  				data[ offset + 6 ],
  				data[ offset + 7 ],
  				data[ offset + 8 ]
  			);
  		}
  
  		if ( SUPPORT_TRANSFERABLE ) {
  			// Give the typed array back to the worker
  			this._worker.transferableMessage( data.buffer, [data.buffer] );
  		}
  	};
  
  	Physijs.Scene.prototype._updateConstraints = function( data ) {
  		var constraint, object,
  			i, offset;
  
  		for ( i = 0; i < ( data.length - 1 ) / CONSTRAINTREPORT_ITEMSIZE; i++ ) {
  			offset = 1 + i * CONSTRAINTREPORT_ITEMSIZE;
  			constraint = this._constraints[ data[ offset ] ];
  			object = this._objects[ data[ offset + 1 ] ];
  
  			if ( constraint === undefined || object === undefined ) {
  				continue;
  			}
  
  			_temp_vector3_1.set(
  				data[ offset + 2 ],
  				data[ offset + 3 ],
  				data[ offset + 4 ]
  			);
  			_temp_matrix4_1.extractRotation( object.matrix );
  			_temp_vector3_1.applyMatrix4( _temp_matrix4_1 );
  
  			constraint.positiona.addVectors( object.position, _temp_vector3_1 );
  			constraint.appliedImpulse = data[ offset + 5 ] ;
  		}
  
  		if ( SUPPORT_TRANSFERABLE ) {
  			// Give the typed array back to the worker
  			this._worker.transferableMessage( data.buffer, [data.buffer] );
  		}
  	};
  
  	Physijs.Scene.prototype._updateCollisions = function( data ) {
  		/**
  		 * #TODO
  		 * This is probably the worst way ever to handle collisions. The inherent evilness is a residual
  		 * effect from the previous version's evilness which mutated when switching to transferable objects.
  		 *
  		 * If you feel inclined to make this better, please do so.
  		 */
  
  		var i, j, offset, object, object2, id1, id2,
  			collisions = {}, normal_offsets = {};
  
  		// Build collision manifest
  		for ( i = 0; i < data[1]; i++ ) {
  			offset = 2 + i * COLLISIONREPORT_ITEMSIZE;
  			object = data[ offset ];
  			object2 = data[ offset + 1 ];
  
  			normal_offsets[ object + '-' + object2 ] = offset + 2;
  			normal_offsets[ object2 + '-' + object ] = -1 * ( offset + 2 );
  
  			// Register collisions for both the object colliding and the object being collided with
  			if ( !collisions[ object ] ) collisions[ object ] = [];
  			collisions[ object ].push( object2 );
  
  			if ( !collisions[ object2 ] ) collisions[ object2 ] = [];
  			collisions[ object2 ].push( object );
  		}
  
  		// Deal with collisions
  		for ( id1 in this._objects ) {
  			if ( !this._objects.hasOwnProperty( id1 ) ) continue;
  			object = this._objects[ id1 ];
  
  			// If object touches anything, ...
  			if ( collisions[ id1 ] ) {
  
  				// Clean up touches array
  				for ( j = 0; j < object._physijs.touches.length; j++ ) {
  					if ( collisions[ id1 ].indexOf( object._physijs.touches[j] ) === -1 ) {
  						object._physijs.touches.splice( j--, 1 );
  					}
  				}
  
  				// Handle each colliding object
  				for ( j = 0; j < collisions[ id1 ].length; j++ ) {
  					id2 = collisions[ id1 ][ j ];
  					object2 = this._objects[ id2 ];
  
  					if ( object2 ) {
  						// If object was not already touching object2, notify object
  						if ( object._physijs.touches.indexOf( id2 ) === -1 ) {
  							object._physijs.touches.push( id2 );
  
  							_temp_vector3_1.subVectors( object.getLinearVelocity(), object2.getLinearVelocity() );
  							_temp1 = _temp_vector3_1.clone();
  
  							_temp_vector3_1.subVectors( object.getAngularVelocity(), object2.getAngularVelocity() );
  							_temp2 = _temp_vector3_1.clone();
  
  							var normal_offset = normal_offsets[ object._physijs.id + '-' + object2._physijs.id ];
  							if ( normal_offset > 0 ) {
  								_temp_vector3_1.set(
  									-data[ normal_offset ],
  									-data[ normal_offset + 1 ],
  									-data[ normal_offset + 2 ]
  								);
  							} else {
  								normal_offset *= -1;
  								_temp_vector3_1.set(
  									data[ normal_offset ],
  									data[ normal_offset + 1 ],
  									data[ normal_offset + 2 ]
  								);
  							}
  
  							object.dispatchEvent( 'collision', object2, _temp1, _temp2, _temp_vector3_1 );
  						}
  					}
  				}
  
  			} else {
  
  				// not touching other objects
  				object._physijs.touches.length = 0;
  
  			}
  
  		}
  
  		this.collisions = collisions;
  
  		if ( SUPPORT_TRANSFERABLE ) {
  			// Give the typed array back to the worker
  			this._worker.transferableMessage( data.buffer, [data.buffer] );
  		}
  	};
  
  	Physijs.Scene.prototype.addConstraint = function ( constraint, show_marker ) {
  		this._constraints[ constraint.id ] = constraint;
  		this.execute( 'addConstraint', constraint.getDefinition() );
  
  		if ( show_marker ) {
  			var marker;
  
  			switch ( constraint.type ) {
  				case 'point':
  					marker = new THREE.Mesh(
  						new THREE.SphereGeometry( 1.5 ),
  						new THREE.MeshNormalMaterial
  					);
  					marker.position.copy( constraint.positiona );
  					this._objects[ constraint.objecta ].add( marker );
  					break;
  
  				case 'hinge':
  					marker = new THREE.Mesh(
  						new THREE.SphereGeometry( 1.5 ),
  						new THREE.MeshNormalMaterial
  					);
  					marker.position.copy( constraint.positiona );
  					this._objects[ constraint.objecta ].add( marker );
  					break;
  
  				case 'slider':
  					marker = new THREE.Mesh(
  						new THREE.CubeGeometry( 10, 1, 1 ),
  						new THREE.MeshNormalMaterial
  					);
  					marker.position.copy( constraint.positiona );
  					// This rotation isn't right if all three axis are non-0 values
  					// TODO: change marker's rotation order to ZYX
  					marker.rotation.set(
  						constraint.axis.y, // yes, y and
  						constraint.axis.x, // x axis are swapped
  						constraint.axis.z
  					);
  					this._objects[ constraint.objecta ].add( marker );
  					break;
  
  				case 'conetwist':
  					marker = new THREE.Mesh(
  						new THREE.SphereGeometry( 1.5 ),
  						new THREE.MeshNormalMaterial
  					);
  					marker.position.copy( constraint.positiona );
  					this._objects[ constraint.objecta ].add( marker );
  					break;
  
  				case 'dof':
  					marker = new THREE.Mesh(
  						new THREE.SphereGeometry( 1.5 ),
  						new THREE.MeshNormalMaterial
  					);
  					marker.position.copy( constraint.positiona );
  					this._objects[ constraint.objecta ].add( marker );
  					break;
  			}
  		}
  
  		return constraint;
  	};
  
  	Physijs.Scene.prototype.removeConstraint = function( constraint ) {
  		if ( this._constraints[constraint.id ] !== undefined ) {
  			this.execute( 'removeConstraint', { id: constraint.id } );
  			delete this._constraints[ constraint.id ];
  		}
  	};
  
  	Physijs.Scene.prototype.execute = function( cmd, params ) {
  		this._worker.postMessage({ cmd: cmd, params: params });
  	};
  
  	addObjectChildren = function( parent, object ) {
  		var i;
  
  		for ( i = 0; i < object.children.length; i++ ) {
  			if ( object.children[i]._physijs ) {
  				object.children[i].updateMatrix();
  				object.children[i].updateMatrixWorld();
  
  				_temp_vector3_1.getPositionFromMatrix( object.children[i].matrixWorld );
  				_quaternion_1.setFromRotationMatrix( object.children[i].matrixWorld );
  
  				object.children[i]._physijs.position_offset = {
  					x: _temp_vector3_1.x,
  					y: _temp_vector3_1.y,
  					z: _temp_vector3_1.z
  				};
  
  				object.children[i]._physijs.rotation = {
  					x: _quaternion_1.x,
  					y: _quaternion_1.y,
  					z: _quaternion_1.z,
  					w: _quaternion_1.w
  				};
  
  				parent._physijs.children.push( object.children[i]._physijs );
  			}
  
  			addObjectChildren( parent, object.children[i] );
  		}
  	};
  
  	Physijs.Scene.prototype.add = function( object ) {
  		THREE.Mesh.prototype.add.call( this, object );
  
  		if ( object._physijs ) {
  
  			object.world = this;
  
  			if ( object instanceof Physijs.Vehicle ) {
  
  				this.add( object.mesh );
  				this._vehicles[ object._physijs.id ] = object;
  				this.execute( 'addVehicle', object._physijs );
  
  			} else {
  
  				object.__dirtyPosition = false;
  				object.__dirtyRotation = false;
  				this._objects[object._physijs.id] = object;
  
  				if ( object.children.length ) {
  					object._physijs.children = [];
  					addObjectChildren( object, object );
  				}
  
  				if ( object.material._physijs ) {
  					if ( !this._materials_ref_counts.hasOwnProperty( object.material._physijs.id ) ) {
  						this.execute( 'registerMaterial', object.material._physijs );
  						object._physijs.materialId = object.material._physijs.id;
  						this._materials_ref_counts[object.material._physijs.id] = 1;
  					} else {
  						this._materials_ref_counts[object.material._physijs.id]++;
  					}
  				}
  
  				// Object starting position + rotation
  				object._physijs.position = { x: object.position.x, y: object.position.y, z: object.position.z };
  				object._physijs.rotation = { x: object.quaternion.x, y: object.quaternion.y, z: object.quaternion.z, w: object.quaternion.w };
  
  				// Check for scaling
  				var mass_scaling = new THREE.Vector3( 1, 1, 1 );
  				if ( object._physijs.width ) {
  					object._physijs.width *= object.scale.x;
  				}
  				if ( object._physijs.height ) {
  					object._physijs.height *= object.scale.y;
  				}
  				if ( object._physijs.depth ) {
  					object._physijs.depth *= object.scale.z;
  				}
  
  				this.execute( 'addObject', object._physijs );
  
  			}
  		}
  	};
  
  	Physijs.Scene.prototype.remove = function( object ) {
  		if ( object instanceof Physijs.Vehicle ) {
  			this.execute( 'removeVehicle', { id: object._physijs.id } );
  			while( object.wheels.length ) {
  				this.remove( object.wheels.pop() );
  			}
  			this.remove( object.mesh );
  			delete this._vehicles[ object._physijs.id ];
  		} else {
  			THREE.Mesh.prototype.remove.call( this, object );
  			if ( object._physijs ) {
  				delete this._objects[object._physijs.id];
  				this.execute( 'removeObject', { id: object._physijs.id } );
  			}
  		}
  		if ( object.material && object.material._physijs && this._materials_ref_counts.hasOwnProperty( object.material._physijs.id ) ) {
  			this._materials_ref_counts[object.material._physijs.id]--;
  			if(this._materials_ref_counts[object.material._physijs.id] == 0) {
  				this.execute( 'unRegisterMaterial', object.material._physijs );
  				delete this._materials_ref_counts[object.material._physijs.id];
  			}
  		}
  	};
  
  	Physijs.Scene.prototype.setFixedTimeStep = function( fixedTimeStep ) {
  		if ( fixedTimeStep ) {
  			this.execute( 'setFixedTimeStep', fixedTimeStep );
  		}
  	};
  
  	Physijs.Scene.prototype.setGravity = function( gravity ) {
  		if ( gravity ) {
  			this.execute( 'setGravity', gravity );
  		}
  	};
  
  	Physijs.Scene.prototype.simulate = function( timeStep, maxSubSteps ) {
  		var object_id, object, update;
  
  		if ( _is_simulating ) {
  			return false;
  		}
  
  		_is_simulating = true;
  
  		for ( object_id in this._objects ) {
  			if ( !this._objects.hasOwnProperty( object_id ) ) continue;
  
  			object = this._objects[object_id];
  
  			if ( object.__dirtyPosition || object.__dirtyRotation ) {
  				update = { id: object._physijs.id };
  
  				if ( object.__dirtyPosition ) {
  					update.pos = { x: object.position.x, y: object.position.y, z: object.position.z };
  					object.__dirtyPosition = false;
  				}
  
  				if ( object.__dirtyRotation ) {
  					update.quat = { x: object.quaternion.x, y: object.quaternion.y, z: object.quaternion.z, w: object.quaternion.w };
  					object.__dirtyRotation = false;
  				}
  
  				this.execute( 'updateTransform', update );
  			}
  		}
  
  		this.execute( 'simulate', { timeStep: timeStep, maxSubSteps: maxSubSteps } );
  
  		return true;
  	};
  
  
  	// Phsijs.Mesh
  	Physijs.Mesh = function ( geometry, material, mass ) {
  		var index;
  
  		if ( !geometry ) {
  			return;
  		}
  
  		Eventable.call( this );
  		THREE.Mesh.call( this, geometry, material );
  
  		if ( !geometry.boundingBox ) {
  			geometry.computeBoundingBox();
  		}
  
  		this._physijs = {
  			type: null,
  			id: getObjectId(),
  			mass: mass || 0,
  			touches: [],
  			linearVelocity: new THREE.Vector3,
  			angularVelocity: new THREE.Vector3
  		};
  	};
  	Physijs.Mesh.prototype = new THREE.Mesh;
  	Physijs.Mesh.prototype.constructor = Physijs.Mesh;
  	Eventable.make( Physijs.Mesh );
  
  	// Physijs.Mesh.mass
  	Physijs.Mesh.prototype.__defineGetter__('mass', function() {
  		return this._physijs.mass;
  	});
  	Physijs.Mesh.prototype.__defineSetter__('mass', function( mass ) {
  		this._physijs.mass = mass;
  		if ( this.world ) {
  			this.world.execute( 'updateMass', { id: this._physijs.id, mass: mass } );
  		}
  	});
  
  	// Physijs.Mesh.applyCentralImpulse
  	Physijs.Mesh.prototype.applyCentralImpulse = function ( force ) {
  		if ( this.world ) {
  			this.world.execute( 'applyCentralImpulse', { id: this._physijs.id, x: force.x, y: force.y, z: force.z } );
  		}
  	};
  
  	// Physijs.Mesh.applyImpulse
  	Physijs.Mesh.prototype.applyImpulse = function ( force, offset ) {
  		if ( this.world ) {
  			this.world.execute( 'applyImpulse', { id: this._physijs.id, impulse_x: force.x, impulse_y: force.y, impulse_z: force.z, x: offset.x, y: offset.y, z: offset.z } );
  		}
  	};
  
  	// Physijs.Mesh.applyCentralForce
  	Physijs.Mesh.prototype.applyCentralForce = function ( force ) {
  		if ( this.world ) {
  			this.world.execute( 'applyCentralForce', { id: this._physijs.id, x: force.x, y: force.y, z: force.z } );
  		}
  	};
  
  	// Physijs.Mesh.applyForce
  	Physijs.Mesh.prototype.applyForce = function ( force, offset ) {
  		if ( this.world ) {
  			this.world.execute( 'applyForce', { id: this._physijs.id, force_x: force.x, force_y : force.y, force_z : force.z, x: offset.x, y: offset.y, z: offset.z } );
  		}
  	};
  
  	// Physijs.Mesh.getAngularVelocity
  	Physijs.Mesh.prototype.getAngularVelocity = function () {
  		return this._physijs.angularVelocity;
  	};
  
  	// Physijs.Mesh.setAngularVelocity
  	Physijs.Mesh.prototype.setAngularVelocity = function ( velocity ) {
  		if ( this.world ) {
  			this.world.execute( 'setAngularVelocity', { id: this._physijs.id, x: velocity.x, y: velocity.y, z: velocity.z } );
  		}
  	};
  
  	// Physijs.Mesh.getLinearVelocity
  	Physijs.Mesh.prototype.getLinearVelocity = function () {
  		return this._physijs.linearVelocity;
  	};
  
  	// Physijs.Mesh.setLinearVelocity
  	Physijs.Mesh.prototype.setLinearVelocity = function ( velocity ) {
  		if ( this.world ) {
  			this.world.execute( 'setLinearVelocity', { id: this._physijs.id, x: velocity.x, y: velocity.y, z: velocity.z } );
  		}
  	};
  
  	// Physijs.Mesh.setAngularFactor
  	Physijs.Mesh.prototype.setAngularFactor = function ( factor ) {
  		if ( this.world ) {
  			this.world.execute( 'setAngularFactor', { id: this._physijs.id, x: factor.x, y: factor.y, z: factor.z } );
  		}
  	};
  
  	// Physijs.Mesh.setLinearFactor
  	Physijs.Mesh.prototype.setLinearFactor = function ( factor ) {
  		if ( this.world ) {
  			this.world.execute( 'setLinearFactor', { id: this._physijs.id, x: factor.x, y: factor.y, z: factor.z } );
  		}
  	};
  
  	// Physijs.Mesh.setDamping
  	Physijs.Mesh.prototype.setDamping = function ( linear, angular ) {
  		if ( this.world ) {
  			this.world.execute( 'setDamping', { id: this._physijs.id, linear: linear, angular: angular } );
  		}
  	};
  
  	// Physijs.Mesh.setCcdMotionThreshold
  	Physijs.Mesh.prototype.setCcdMotionThreshold = function ( threshold ) {
  		if ( this.world ) {
  			this.world.execute( 'setCcdMotionThreshold', { id: this._physijs.id, threshold: threshold } );
  		}
  	};
  
  	// Physijs.Mesh.setCcdSweptSphereRadius
  	Physijs.Mesh.prototype.setCcdSweptSphereRadius = function ( radius ) {
  		if ( this.world ) {
  			this.world.execute( 'setCcdSweptSphereRadius', { id: this._physijs.id, radius: radius } );
  		}
  	};
  
  
  	// Physijs.PlaneMesh
  	Physijs.PlaneMesh = function ( geometry, material, mass ) {
  		var width, height;
  
  		Physijs.Mesh.call( this, geometry, material, mass );
  
  		if ( !geometry.boundingBox ) {
  			geometry.computeBoundingBox();
  		}
  
  		width = geometry.boundingBox.max.x - geometry.boundingBox.min.x;
  		height = geometry.boundingBox.max.y - geometry.boundingBox.min.y;
  
  		this._physijs.type = 'plane';
  		this._physijs.normal = geometry.faces[0].normal.clone();
  		this._physijs.mass = (typeof mass === 'undefined') ? width * height : mass;
  	};
  	Physijs.PlaneMesh.prototype = new Physijs.Mesh;
  	Physijs.PlaneMesh.prototype.constructor = Physijs.PlaneMesh;
  
  	// Physijs.HeightfieldMesh
  	Physijs.HeightfieldMesh = function ( geometry, material, mass, xdiv, ydiv) {
  		Physijs.Mesh.call( this, geometry, material, mass );
  
  		this._physijs.type   = 'heightfield';
  		this._physijs.xsize  = geometry.boundingBox.max.x - geometry.boundingBox.min.x;
  		this._physijs.ysize  = geometry.boundingBox.max.y - geometry.boundingBox.min.y;
  		this._physijs.xpts = (typeof xdiv === 'undefined') ? Math.sqrt(geometry.vertices.length) : xdiv + 1;
  		this._physijs.ypts = (typeof ydiv === 'undefined') ? Math.sqrt(geometry.vertices.length) : ydiv + 1;
  		// note - this assumes our plane geometry is square, unless we pass in specific xdiv and ydiv
  		this._physijs.absMaxHeight = Math.max(geometry.boundingBox.max.z,Math.abs(geometry.boundingBox.min.z));
  
  		var points = [];
  
  		var a, b;
  		for ( var i = 0; i < geometry.vertices.length; i++ ) {
  
  			a = i % this._physijs.xpts;
  			b = Math.round( ( i / this._physijs.xpts ) - ( (i % this._physijs.xpts) / this._physijs.xpts ) );
  			points[i] = geometry.vertices[ a + ( ( this._physijs.ypts - b - 1 ) * this._physijs.ypts ) ].z;
  
  			//points[i] = geometry.vertices[i];
  		}
  
  		this._physijs.points = points;
  	};
  	Physijs.HeightfieldMesh.prototype = new Physijs.Mesh;
  	Physijs.HeightfieldMesh.prototype.constructor = Physijs.HeightfieldMesh;
  
  	// Physijs.BoxMesh
  	Physijs.BoxMesh = function( geometry, material, mass ) {
  		var width, height, depth;
  
  		Physijs.Mesh.call( this, geometry, material, mass );
  
  		if ( !geometry.boundingBox ) {
  			geometry.computeBoundingBox();
  		}
  
  		width = geometry.boundingBox.max.x - geometry.boundingBox.min.x;
  		height = geometry.boundingBox.max.y - geometry.boundingBox.min.y;
  		depth = geometry.boundingBox.max.z - geometry.boundingBox.min.z;
  
  		this._physijs.type = 'box';
  		this._physijs.width = width;
  		this._physijs.height = height;
  		this._physijs.depth = depth;
  		this._physijs.mass = (typeof mass === 'undefined') ? width * height * depth : mass;
  	};
  	Physijs.BoxMesh.prototype = new Physijs.Mesh;
  	Physijs.BoxMesh.prototype.constructor = Physijs.BoxMesh;
  
  
  	// Physijs.SphereMesh
  	Physijs.SphereMesh = function( geometry, material, mass ) {
  		Physijs.Mesh.call( this, geometry, material, mass );
  
  		if ( !geometry.boundingSphere ) {
  			geometry.computeBoundingSphere();
  		}
  
  		this._physijs.type = 'sphere';
  		this._physijs.radius = geometry.boundingSphere.radius;
  		this._physijs.mass = (typeof mass === 'undefined') ? (4/3) * Math.PI * Math.pow(this._physijs.radius, 3) : mass;
  	};
  	Physijs.SphereMesh.prototype = new Physijs.Mesh;
  	Physijs.SphereMesh.prototype.constructor = Physijs.SphereMesh;
  
  
  	// Physijs.CylinderMesh
  	Physijs.CylinderMesh = function( geometry, material, mass ) {
  		var width, height, depth;
  
  		Physijs.Mesh.call( this, geometry, material, mass );
  
  		if ( !geometry.boundingBox ) {
  			geometry.computeBoundingBox();
  		}
  
  		width = geometry.boundingBox.max.x - geometry.boundingBox.min.x;
  		height = geometry.boundingBox.max.y - geometry.boundingBox.min.y;
  		depth = geometry.boundingBox.max.z - geometry.boundingBox.min.z;
  
  		this._physijs.type = 'cylinder';
  		this._physijs.width = width;
  		this._physijs.height = height;
  		this._physijs.depth = depth;
  		this._physijs.mass = (typeof mass === 'undefined') ? width * height * depth : mass;
  	};
  	Physijs.CylinderMesh.prototype = new Physijs.Mesh;
  	Physijs.CylinderMesh.prototype.constructor = Physijs.CylinderMesh;
  
  
  	// Physijs.CapsuleMesh
  	Physijs.CapsuleMesh = function( geometry, material, mass ) {
  		var width, height, depth;
  
  		Physijs.Mesh.call( this, geometry, material, mass );
  
  		if ( !geometry.boundingBox ) {
  			geometry.computeBoundingBox();
  		}
  
  		width = geometry.boundingBox.max.x - geometry.boundingBox.min.x;
  		height = geometry.boundingBox.max.y - geometry.boundingBox.min.y;
  		depth = geometry.boundingBox.max.z - geometry.boundingBox.min.z;
  
  		this._physijs.type = 'capsule';
  		this._physijs.radius = Math.max(width / 2, depth / 2);
  		this._physijs.height = height;
  		this._physijs.mass = (typeof mass === 'undefined') ? width * height * depth : mass;
  	};
  	Physijs.CapsuleMesh.prototype = new Physijs.Mesh;
  	Physijs.CapsuleMesh.prototype.constructor = Physijs.CapsuleMesh;
  
  
  	// Physijs.ConeMesh
  	Physijs.ConeMesh = function( geometry, material, mass ) {
  		var width, height, depth;
  
  		Physijs.Mesh.call( this, geometry, material, mass );
  
  		if ( !geometry.boundingBox ) {
  			geometry.computeBoundingBox();
  		}
  
  		width = geometry.boundingBox.max.x - geometry.boundingBox.min.x;
  		height = geometry.boundingBox.max.y - geometry.boundingBox.min.y;
  
  		this._physijs.type = 'cone';
  		this._physijs.radius = width / 2;
  		this._physijs.height = height;
  		this._physijs.mass = (typeof mass === 'undefined') ? width * height : mass;
  	};
  	Physijs.ConeMesh.prototype = new Physijs.Mesh;
  	Physijs.ConeMesh.prototype.constructor = Physijs.ConeMesh;
  
  
  	// Physijs.ConcaveMesh
  	Physijs.ConcaveMesh = function( geometry, material, mass ) {
  		var i,
  			width, height, depth,
  			vertices, face, triangles = [];
  
  		Physijs.Mesh.call( this, geometry, material, mass );
  
  		if ( !geometry.boundingBox ) {
  			geometry.computeBoundingBox();
  		}
  
  		vertices = geometry.vertices;
  
  		for ( i = 0; i < geometry.faces.length; i++ ) {
  			face = geometry.faces[i];
  			if ( face instanceof THREE.Face3) {
  
  				triangles.push([
  					{ x: vertices[face.a].x, y: vertices[face.a].y, z: vertices[face.a].z },
  					{ x: vertices[face.b].x, y: vertices[face.b].y, z: vertices[face.b].z },
  					{ x: vertices[face.c].x, y: vertices[face.c].y, z: vertices[face.c].z }
  				]);
  
  			} else if ( face instanceof THREE.Face4 ) {
  
  				triangles.push([
  					{ x: vertices[face.a].x, y: vertices[face.a].y, z: vertices[face.a].z },
  					{ x: vertices[face.b].x, y: vertices[face.b].y, z: vertices[face.b].z },
  					{ x: vertices[face.d].x, y: vertices[face.d].y, z: vertices[face.d].z }
  				]);
  				triangles.push([
  					{ x: vertices[face.b].x, y: vertices[face.b].y, z: vertices[face.b].z },
  					{ x: vertices[face.c].x, y: vertices[face.c].y, z: vertices[face.c].z },
  					{ x: vertices[face.d].x, y: vertices[face.d].y, z: vertices[face.d].z }
  				]);
  
  			}
  		}
  
  		width = geometry.boundingBox.max.x - geometry.boundingBox.min.x;
  		height = geometry.boundingBox.max.y - geometry.boundingBox.min.y;
  		depth = geometry.boundingBox.max.z - geometry.boundingBox.min.z;
  
  		this._physijs.type = 'concave';
  		this._physijs.triangles = triangles;
  		this._physijs.mass = (typeof mass === 'undefined') ? width * height * depth : mass;
  	};
  	Physijs.ConcaveMesh.prototype = new Physijs.Mesh;
  	Physijs.ConcaveMesh.prototype.constructor = Physijs.ConcaveMesh;
  
  
  	// Physijs.ConvexMesh
  	Physijs.ConvexMesh = function( geometry, material, mass ) {
  		var i,
  			width, height, depth,
  			points = [];
  
  		Physijs.Mesh.call( this, geometry, material, mass );
  
  		if ( !geometry.boundingBox ) {
  			geometry.computeBoundingBox();
  		}
  
  		for ( i = 0; i < geometry.vertices.length; i++ ) {
  			points.push({
  				x: geometry.vertices[i].x,
  				y: geometry.vertices[i].y,
  				z: geometry.vertices[i].z
  			});
  		}
  
  
  		width = geometry.boundingBox.max.x - geometry.boundingBox.min.x;
  		height = geometry.boundingBox.max.y - geometry.boundingBox.min.y;
  		depth = geometry.boundingBox.max.z - geometry.boundingBox.min.z;
  
  		this._physijs.type = 'convex';
  		this._physijs.points = points;
  		this._physijs.mass = (typeof mass === 'undefined') ? width * height * depth : mass;
  	};
  	Physijs.ConvexMesh.prototype = new Physijs.Mesh;
  	Physijs.ConvexMesh.prototype.constructor = Physijs.ConvexMesh;
  
  
  	// Physijs.Vehicle
  	Physijs.Vehicle = function( mesh, tuning ) {
  		tuning = tuning || new Physijs.VehicleTuning;
  		this.mesh = mesh;
  		this.wheels = [];
  		this._physijs = {
  			id: getObjectId(),
  			rigidBody: mesh._physijs.id,
  			suspension_stiffness: tuning.suspension_stiffness,
  			suspension_compression: tuning.suspension_compression,
  			suspension_damping: tuning.suspension_damping,
  			max_suspension_travel: tuning.max_suspension_travel,
  			friction_slip: tuning.friction_slip,
  			max_suspension_force: tuning.max_suspension_force
  		};
  	};
  	Physijs.Vehicle.prototype.addWheel = function( wheel_geometry, wheel_material, connection_point, wheel_direction, wheel_axle, suspension_rest_length, wheel_radius, is_front_wheel, tuning ) {
  		var wheel = new THREE.Mesh( wheel_geometry, wheel_material );
  		wheel.castShadow = wheel.receiveShadow = true;
  		wheel.position.copy( wheel_direction ).multiplyScalar( suspension_rest_length / 100 ).add( connection_point );
  		this.world.add( wheel );
  		this.wheels.push( wheel );
  
  		this.world.execute( 'addWheel', {
  			id: this._physijs.id,
  			connection_point: { x: connection_point.x, y: connection_point.y, z: connection_point.z },
  			wheel_direction: { x: wheel_direction.x, y: wheel_direction.y, z: wheel_direction.z },
  			wheel_axle: { x: wheel_axle.x, y: wheel_axle.y, z: wheel_axle.z },
  			suspension_rest_length: suspension_rest_length,
  			wheel_radius: wheel_radius,
  			is_front_wheel: is_front_wheel,
  			tuning: tuning
  		});
  	};
  	Physijs.Vehicle.prototype.setSteering = function( amount, wheel ) {
  		if ( wheel !== undefined && this.wheels[ wheel ] !== undefined ) {
  			this.world.execute( 'setSteering', { id: this._physijs.id, wheel: wheel, steering: amount } );
  		} else if ( this.wheels.length > 0 ) {
  			for ( var i = 0; i < this.wheels.length; i++ ) {
  				this.world.execute( 'setSteering', { id: this._physijs.id, wheel: i, steering: amount } );
  			}
  		}
  	};
  	Physijs.Vehicle.prototype.setBrake = function( amount, wheel ) {
  		if ( wheel !== undefined && this.wheels[ wheel ] !== undefined ) {
  			this.world.execute( 'setBrake', { id: this._physijs.id, wheel: wheel, brake: amount } );
  		} else if ( this.wheels.length > 0 ) {
  			for ( var i = 0; i < this.wheels.length; i++ ) {
  				this.world.execute( 'setBrake', { id: this._physijs.id, wheel: i, brake: amount } );
  			}
  		}
  	};
  	Physijs.Vehicle.prototype.applyEngineForce = function( amount, wheel ) {
  		if ( wheel !== undefined && this.wheels[ wheel ] !== undefined ) {
  			this.world.execute( 'applyEngineForce', { id: this._physijs.id, wheel: wheel, force: amount } );
  		} else if ( this.wheels.length > 0 ) {
  			for ( var i = 0; i < this.wheels.length; i++ ) {
  				this.world.execute( 'applyEngineForce', { id: this._physijs.id, wheel: i, force: amount } );
  			}
  		}
  	};
  
  	// Physijs.VehicleTuning
  	Physijs.VehicleTuning = function( suspension_stiffness, suspension_compression, suspension_damping, max_suspension_travel, friction_slip, max_suspension_force ) {
  		this.suspension_stiffness = suspension_stiffness !== undefined ? suspension_stiffness : 5.88;
  		this.suspension_compression = suspension_compression !== undefined ? suspension_compression : 0.83;
  		this.suspension_damping = suspension_damping !== undefined ? suspension_damping : 0.88;
  		this.max_suspension_travel = max_suspension_travel !== undefined ? max_suspension_travel : 500;
  		this.friction_slip = friction_slip !== undefined ? friction_slip : 10.5;
  		this.max_suspension_force = max_suspension_force !== undefined ? max_suspension_force : 6000;
  	};
  
  	return Physijs;
  })();
  