|
|
@@ -4,1220 +4,1404 @@
|
|
|
* Dependencies
|
|
|
* - Ammo.js https://github.com/kripken/ammo.js
|
|
|
*
|
|
|
- * MMD specific Physics class.
|
|
|
- *
|
|
|
- * See THREE.MMDLoader for the passed parameter list of RigidBody/Constraint.
|
|
|
- *
|
|
|
- * Requirement:
|
|
|
- * - don't change object's scale from (1,1,1) after setting physics to object
|
|
|
+ * MMDPhysics calculates physics with Ammo(Bullet based JavaScript Physics engine)
|
|
|
+ * for MMD model loaded by THREE.MMDLoader.
|
|
|
*
|
|
|
* TODO
|
|
|
- * - optimize for the performance
|
|
|
- * - use Physijs http://chandlerprall.github.io/Physijs/
|
|
|
- * and improve the performance by making use of Web worker.
|
|
|
- * - if possible, make this class being non-MMD specific.
|
|
|
- * - object scale change support
|
|
|
+ * - Physics in Worker
|
|
|
*/
|
|
|
|
|
|
-THREE.MMDPhysics = function ( mesh, params ) {
|
|
|
+THREE.MMDPhysics = ( function () {
|
|
|
|
|
|
- if ( typeof Ammo === 'undefined' ) {
|
|
|
+ /**
|
|
|
+ * @param {THREE.SkinnedMesh} mesh
|
|
|
+ * @param {Array<Object>} rigidBodyParams
|
|
|
+ * @param {Array<Object>} (optional) constraintParams
|
|
|
+ * @param {Object} params - (optional)
|
|
|
+ * @param {Number} params.unitStep - Default is 1 / 65.
|
|
|
+ * @param {Integer} params.maxStepNum - Default is 3.
|
|
|
+ * @param {THREE.Vector3} params.gravity - Default is ( 0, - 9.8 * 10, 0 )
|
|
|
+ */
|
|
|
+ function MMDPhysics( mesh, rigidBodyParams, constraintParams, params ) {
|
|
|
|
|
|
- throw new Error( 'THREE.MMDPhysics: Import ammo.js https://github.com/kripken/ammo.js' );
|
|
|
+ if ( typeof Ammo === 'undefined' ) {
|
|
|
|
|
|
- }
|
|
|
+ throw new Error( 'THREE.MMDPhysics: Import ammo.js https://github.com/kripken/ammo.js' );
|
|
|
|
|
|
- if ( params === undefined ) params = {};
|
|
|
+ }
|
|
|
|
|
|
- this.mesh = mesh;
|
|
|
- this.helper = new THREE.MMDPhysics.ResourceHelper();
|
|
|
+ constraintParams = constraintParams || [];
|
|
|
+ params = params || {};
|
|
|
|
|
|
- /*
|
|
|
- * I don't know why but 1/60 unitStep easily breaks models
|
|
|
- * so I set it 1/65 so far.
|
|
|
- * Don't set too small unitStep because
|
|
|
- * the smaller unitStep can make the performance worse.
|
|
|
- */
|
|
|
- this.unitStep = ( params.unitStep !== undefined ) ? params.unitStep : 1 / 65;
|
|
|
- this.maxStepNum = ( params.maxStepNum !== undefined ) ? params.maxStepNum : 3;
|
|
|
+ this.manager = new ResourceManager();
|
|
|
|
|
|
- this.world = params.world !== undefined ? params.world : null;
|
|
|
- this.bodies = [];
|
|
|
- this.constraints = [];
|
|
|
+ this.mesh = mesh;
|
|
|
|
|
|
- this.init( mesh );
|
|
|
+ /*
|
|
|
+ * I don't know why but 1/60 unitStep easily breaks models
|
|
|
+ * so I set it 1/65 so far.
|
|
|
+ * Don't set too small unitStep because
|
|
|
+ * the smaller unitStep can make the performance worse.
|
|
|
+ */
|
|
|
+ this.unitStep = ( params.unitStep !== undefined ) ? params.unitStep : 1 / 65;
|
|
|
+ this.maxStepNum = ( params.maxStepNum !== undefined ) ? params.maxStepNum : 3;
|
|
|
+ this.gravity = new THREE.Vector3( 0, - 9.8 * 10, 0 );
|
|
|
|
|
|
-};
|
|
|
+ if ( params.gravity !== undefined ) this.gravity.copy( gravity );
|
|
|
|
|
|
-THREE.MMDPhysics.prototype = {
|
|
|
+ this.world = params.world !== undefined ? params.world : null; // experimental
|
|
|
|
|
|
- constructor: THREE.MMDPhysics,
|
|
|
+ this.bodies = [];
|
|
|
+ this.constraints = [];
|
|
|
|
|
|
- init: function ( mesh ) {
|
|
|
+ this._init( mesh, rigidBodyParams, constraintParams );
|
|
|
|
|
|
- var parent = mesh.parent;
|
|
|
+ }
|
|
|
|
|
|
- if ( parent !== null ) {
|
|
|
+ MMDPhysics.prototype = {
|
|
|
|
|
|
- parent.remove( mesh );
|
|
|
+ constructor: MMDPhysics,
|
|
|
|
|
|
- }
|
|
|
+ /**
|
|
|
+ * Advances Physics calculation and updates bones.
|
|
|
+ *
|
|
|
+ * @param {Number} delta - time in second
|
|
|
+ * @return {THREE.MMDPhysics}
|
|
|
+ */
|
|
|
+ update: function ( delta ) {
|
|
|
|
|
|
- var helper = this.helper;
|
|
|
- var currentPosition = helper.allocThreeVector3();
|
|
|
- var currentRotation = helper.allocThreeEuler();
|
|
|
- var currentScale = helper.allocThreeVector3();
|
|
|
+ var manager = this.manager;
|
|
|
+ var mesh = this.mesh;
|
|
|
|
|
|
- currentPosition.copy( mesh.position );
|
|
|
- currentRotation.copy( mesh.rotation );
|
|
|
- currentScale.copy( mesh.scale );
|
|
|
+ // rigid bodies and constrains are for
|
|
|
+ // mesh's world scale (1, 1, 1).
|
|
|
+ // Convert to (1, 1, 1) if it isn't.
|
|
|
|
|
|
- mesh.position.set( 0, 0, 0 );
|
|
|
- mesh.rotation.set( 0, 0, 0 );
|
|
|
- mesh.scale.set( 1, 1, 1 );
|
|
|
+ var isNonDefaultScale = false;
|
|
|
|
|
|
- mesh.updateMatrixWorld( true );
|
|
|
+ var position = manager.allocThreeVector3();
|
|
|
+ var quaternion = manager.allocThreeQuaternion();
|
|
|
+ var scale = manager.allocThreeVector3();
|
|
|
|
|
|
- if ( this.world === null ) this.initWorld();
|
|
|
- this.initRigidBodies();
|
|
|
- this.initConstraints();
|
|
|
+ mesh.matrixWorld.decompose( position, quaternion, scale );
|
|
|
|
|
|
- if ( parent !== null ) {
|
|
|
+ if ( scale.x !== 1 || scale.y !== 1 || scale.z !== 1 ) {
|
|
|
|
|
|
- parent.add( mesh );
|
|
|
+ isNonDefaultScale = true;
|
|
|
|
|
|
- }
|
|
|
+ }
|
|
|
|
|
|
- mesh.position.copy( currentPosition );
|
|
|
- mesh.rotation.copy( currentRotation );
|
|
|
- mesh.scale.copy( currentScale );
|
|
|
+ var parent;
|
|
|
|
|
|
- mesh.updateMatrixWorld( true );
|
|
|
+ if ( isNonDefaultScale ) {
|
|
|
|
|
|
- this.reset();
|
|
|
+ parent = mesh.parent;
|
|
|
|
|
|
- helper.freeThreeVector3( currentPosition );
|
|
|
- helper.freeThreeEuler( currentRotation );
|
|
|
- helper.freeThreeVector3( currentScale );
|
|
|
+ if ( parent !== null ) mesh.parent = null;
|
|
|
|
|
|
- },
|
|
|
+ scale.copy( this.mesh.scale );
|
|
|
|
|
|
- initWorld: function () {
|
|
|
+ mesh.scale.set( 1, 1, 1 );
|
|
|
+ mesh.updateMatrixWorld( true );
|
|
|
|
|
|
- var config = new Ammo.btDefaultCollisionConfiguration();
|
|
|
- var dispatcher = new Ammo.btCollisionDispatcher( config );
|
|
|
- var cache = new Ammo.btDbvtBroadphase();
|
|
|
- var solver = new Ammo.btSequentialImpulseConstraintSolver();
|
|
|
- var world = new Ammo.btDiscreteDynamicsWorld( dispatcher, cache, solver, config );
|
|
|
- world.setGravity( new Ammo.btVector3( 0, -9.8 * 10, 0 ) );
|
|
|
- this.world = world;
|
|
|
+ }
|
|
|
|
|
|
- },
|
|
|
+ // calculate physics and update bones
|
|
|
|
|
|
- initRigidBodies: function () {
|
|
|
+ this._updateRigidBodies();
|
|
|
+ this._stepSimulation( delta );
|
|
|
+ this._updateBones();
|
|
|
|
|
|
- var bodies = this.mesh.geometry.rigidBodies;
|
|
|
+ // restore mesh if converted above
|
|
|
|
|
|
- for ( var i = 0; i < bodies.length; i++ ) {
|
|
|
+ if ( isNonDefaultScale ) {
|
|
|
|
|
|
- var b = new THREE.MMDPhysics.RigidBody( this.mesh, this.world, bodies[ i ], this.helper );
|
|
|
- this.bodies.push( b );
|
|
|
+ if ( parent !== null ) parent.parent = parent;
|
|
|
|
|
|
- }
|
|
|
+ mesh.scale.copy( scale );
|
|
|
|
|
|
- },
|
|
|
+ }
|
|
|
|
|
|
- initConstraints: function () {
|
|
|
+ manager.freeThreeVector3( scale );
|
|
|
+ manager.freeThreeQuaternion( quaternion );
|
|
|
+ manager.freeThreeVector3( position );
|
|
|
|
|
|
- var constraints = this.mesh.geometry.constraints;
|
|
|
+ return this;
|
|
|
|
|
|
- for ( var i = 0; i < constraints.length; i++ ) {
|
|
|
+ },
|
|
|
|
|
|
- var params = constraints[ i ];
|
|
|
- var bodyA = this.bodies[ params.rigidBodyIndex1 ];
|
|
|
- var bodyB = this.bodies[ params.rigidBodyIndex2 ];
|
|
|
- var c = new THREE.MMDPhysics.Constraint( this.mesh, this.world, bodyA, bodyB, params, this.helper );
|
|
|
- this.constraints.push( c );
|
|
|
+ /**
|
|
|
+ * Resets rigid bodies transorm to current bone's.
|
|
|
+ *
|
|
|
+ * @return {THREE.MMDPhysics}
|
|
|
+ */
|
|
|
+ reset: function () {
|
|
|
|
|
|
- }
|
|
|
+ for ( var i = 0, il = this.bodies.length; i < il; i++ ) {
|
|
|
|
|
|
+ this.bodies[ i ].reset();
|
|
|
|
|
|
- },
|
|
|
+ }
|
|
|
|
|
|
- update: function ( delta ) {
|
|
|
+ return this;
|
|
|
|
|
|
- this.updateRigidBodies();
|
|
|
- this.stepSimulation( delta );
|
|
|
- this.updateBones();
|
|
|
+ },
|
|
|
|
|
|
- },
|
|
|
+ /**
|
|
|
+ * Warm ups Rigid bodies. Calculates cycles steps.
|
|
|
+ *
|
|
|
+ * @param {Integer} cycles
|
|
|
+ * @return {THREE.MMDPhysics}
|
|
|
+ */
|
|
|
+ warmup: function ( cycles ) {
|
|
|
|
|
|
- stepSimulation: function ( delta ) {
|
|
|
+ for ( var i = 0; i < cycles; i++ ) {
|
|
|
|
|
|
- var unitStep = this.unitStep;
|
|
|
- var stepTime = delta;
|
|
|
- var maxStepNum = ( ( delta / unitStep ) | 0 ) + 1;
|
|
|
+ this.update( 1 / 60 );
|
|
|
|
|
|
- if ( stepTime < unitStep ) {
|
|
|
+ }
|
|
|
|
|
|
- stepTime = unitStep;
|
|
|
- maxStepNum = 1;
|
|
|
+ return this;
|
|
|
|
|
|
- }
|
|
|
+ },
|
|
|
|
|
|
- if ( maxStepNum > this.maxStepNum ) {
|
|
|
+ /**
|
|
|
+ * Sets gravity.
|
|
|
+ *
|
|
|
+ * @param {THREE.Vector3} gravity
|
|
|
+ * @return {MMDPhysicsHelper}
|
|
|
+ */
|
|
|
+ setGravity: function ( gravity ) {
|
|
|
|
|
|
- maxStepNum = this.maxStepNum;
|
|
|
+ this.world.setGravity( new Ammo.btVector3( gravity.x, gravity.y, gravity.z ) );
|
|
|
+ this.gravity.copy( gravity );
|
|
|
|
|
|
- }
|
|
|
+ return this;
|
|
|
|
|
|
- this.world.stepSimulation( stepTime, maxStepNum, unitStep );
|
|
|
+ },
|
|
|
|
|
|
- },
|
|
|
+ /**
|
|
|
+ * Creates MMDPhysicsHelper
|
|
|
+ *
|
|
|
+ * @return {MMDPhysicsHelper}
|
|
|
+ */
|
|
|
+ createHelper: function () {
|
|
|
|
|
|
- updateRigidBodies: function () {
|
|
|
+ return new MMDPhysicsHelper( this.mesh, this );
|
|
|
|
|
|
- for ( var i = 0; i < this.bodies.length; i++ ) {
|
|
|
+ },
|
|
|
|
|
|
- this.bodies[ i ].updateFromBone();
|
|
|
+ // private methods
|
|
|
|
|
|
- }
|
|
|
+ _init: function ( mesh, rigidBodyParams, constraintParams ) {
|
|
|
|
|
|
- },
|
|
|
+ var manager = this.manager;
|
|
|
|
|
|
- updateBones: function () {
|
|
|
+ // rigid body/constraint parameters are for
|
|
|
+ // mesh's default world transform as position(0, 0, 0),
|
|
|
+ // quaternion(0, 0, 0, 1) and scale(0, 0, 0)
|
|
|
|
|
|
- for ( var i = 0; i < this.bodies.length; i++ ) {
|
|
|
+ var parent = mesh.parent;
|
|
|
|
|
|
- this.bodies[ i ].updateBone();
|
|
|
+ if ( parent !== null ) parent = null;
|
|
|
|
|
|
- }
|
|
|
+ var currentPosition = manager.allocThreeVector3();
|
|
|
+ var currentQuaternion = manager.allocThreeQuaternion();
|
|
|
+ var currentScale = manager.allocThreeVector3();
|
|
|
|
|
|
- },
|
|
|
+ currentPosition.copy( mesh.position );
|
|
|
+ currentQuaternion.copy( mesh.quaternion );
|
|
|
+ currentScale.copy( mesh.scale );
|
|
|
|
|
|
- reset: function () {
|
|
|
+ mesh.position.set( 0, 0, 0 );
|
|
|
+ mesh.quaternion.set( 0, 0, 0, 1 );
|
|
|
+ mesh.scale.set( 1, 1, 1 );
|
|
|
|
|
|
- for ( var i = 0; i < this.bodies.length; i++ ) {
|
|
|
+ mesh.updateMatrixWorld( true );
|
|
|
|
|
|
- this.bodies[ i ].reset();
|
|
|
+ if ( this.world === null ) {
|
|
|
|
|
|
- }
|
|
|
+ this.world = this._createWorld();
|
|
|
+ this.setGravity( this.gravity );
|
|
|
|
|
|
- },
|
|
|
+ }
|
|
|
|
|
|
- warmup: function ( cycles ) {
|
|
|
+ this._initRigidBodies( rigidBodyParams );
|
|
|
+ this._initConstraints( constraintParams );
|
|
|
|
|
|
- for ( var i = 0; i < cycles; i++ ) {
|
|
|
+ if ( parent !== null ) mesh.parent = parent;
|
|
|
|
|
|
- this.update( 1 / 60 );
|
|
|
+ mesh.position.copy( currentPosition );
|
|
|
+ mesh.quaternion.copy( currentQuaternion );
|
|
|
+ mesh.scale.copy( currentScale );
|
|
|
|
|
|
- }
|
|
|
+ mesh.updateMatrixWorld( true );
|
|
|
|
|
|
- }
|
|
|
+ this.reset();
|
|
|
|
|
|
-};
|
|
|
+ manager.freeThreeVector3( currentPosition );
|
|
|
+ manager.freeThreeQuaternion( currentQuaternion );
|
|
|
+ manager.freeThreeVector3( currentScale );
|
|
|
|
|
|
-/**
|
|
|
- * This helper class responsibilies are
|
|
|
- *
|
|
|
- * 1. manage Ammo.js and Three.js object resources and
|
|
|
- * improve the performance and the memory consumption by
|
|
|
- * reusing objects.
|
|
|
- *
|
|
|
- * 2. provide simple Ammo object operations.
|
|
|
- */
|
|
|
-THREE.MMDPhysics.ResourceHelper = function () {
|
|
|
+ },
|
|
|
|
|
|
- // for Three.js
|
|
|
- this.threeVector3s = [];
|
|
|
- this.threeMatrix4s = [];
|
|
|
- this.threeQuaternions = [];
|
|
|
- this.threeEulers = [];
|
|
|
+ _createWorld: function () {
|
|
|
|
|
|
- // for Ammo.js
|
|
|
- this.transforms = [];
|
|
|
- this.quaternions = [];
|
|
|
- this.vector3s = [];
|
|
|
+ var config = new Ammo.btDefaultCollisionConfiguration();
|
|
|
+ var dispatcher = new Ammo.btCollisionDispatcher( config );
|
|
|
+ var cache = new Ammo.btDbvtBroadphase();
|
|
|
+ var solver = new Ammo.btSequentialImpulseConstraintSolver();
|
|
|
+ var world = new Ammo.btDiscreteDynamicsWorld( dispatcher, cache, solver, config );
|
|
|
+ return world;
|
|
|
|
|
|
-};
|
|
|
+ },
|
|
|
|
|
|
-THREE.MMDPhysics.ResourceHelper.prototype = {
|
|
|
+ _initRigidBodies: function ( rigidBodies ) {
|
|
|
|
|
|
- allocThreeVector3: function () {
|
|
|
+ for ( var i = 0, il = rigidBodies.length; i < il; i++ ) {
|
|
|
|
|
|
- return ( this.threeVector3s.length > 0 ) ? this.threeVector3s.pop() : new THREE.Vector3();
|
|
|
+ this.bodies.push( new RigidBody(
|
|
|
+ this.mesh, this.world, rigidBodies[ i ], this.manager ) );
|
|
|
|
|
|
- },
|
|
|
+ }
|
|
|
|
|
|
- freeThreeVector3: function ( v ) {
|
|
|
+ },
|
|
|
|
|
|
- this.threeVector3s.push( v );
|
|
|
+ _initConstraints: function ( constraints ) {
|
|
|
|
|
|
- },
|
|
|
+ for ( var i = 0, il = constraints.length; i < il; i++ ) {
|
|
|
|
|
|
- allocThreeMatrix4: function () {
|
|
|
+ var params = constraints[ i ];
|
|
|
+ var bodyA = this.bodies[ params.rigidBodyIndex1 ];
|
|
|
+ var bodyB = this.bodies[ params.rigidBodyIndex2 ];
|
|
|
+ this.constraints.push( new Constraint(
|
|
|
+ this.mesh, this.world, bodyA, bodyB, params, this.manager ) );
|
|
|
|
|
|
- return ( this.threeMatrix4s.length > 0 ) ? this.threeMatrix4s.pop() : new THREE.Matrix4();
|
|
|
+ }
|
|
|
|
|
|
- },
|
|
|
|
|
|
- freeThreeMatrix4: function ( m ) {
|
|
|
+ },
|
|
|
|
|
|
- this.threeMatrix4s.push( m );
|
|
|
+ _stepSimulation: function ( delta ) {
|
|
|
|
|
|
- },
|
|
|
+ var unitStep = this.unitStep;
|
|
|
+ var stepTime = delta;
|
|
|
+ var maxStepNum = ( ( delta / unitStep ) | 0 ) + 1;
|
|
|
|
|
|
- allocThreeQuaternion: function () {
|
|
|
+ if ( stepTime < unitStep ) {
|
|
|
|
|
|
- return ( this.threeQuaternions.length > 0 ) ? this.threeQuaternions.pop() : new THREE.Quaternion();
|
|
|
+ stepTime = unitStep;
|
|
|
+ maxStepNum = 1;
|
|
|
|
|
|
- },
|
|
|
+ }
|
|
|
|
|
|
- freeThreeQuaternion: function ( q ) {
|
|
|
+ if ( maxStepNum > this.maxStepNum ) {
|
|
|
|
|
|
- this.threeQuaternions.push( q );
|
|
|
+ maxStepNum = this.maxStepNum;
|
|
|
|
|
|
- },
|
|
|
+ }
|
|
|
|
|
|
- allocThreeEuler: function () {
|
|
|
+ this.world.stepSimulation( stepTime, maxStepNum, unitStep );
|
|
|
|
|
|
- return ( this.threeEulers.length > 0 ) ? this.threeEulers.pop() : new THREE.Euler();
|
|
|
+ },
|
|
|
|
|
|
- },
|
|
|
+ _updateRigidBodies: function () {
|
|
|
|
|
|
- freeThreeEuler: function ( e ) {
|
|
|
+ for ( var i = 0, il = this.bodies.length; i < il; i++ ) {
|
|
|
|
|
|
- this.threeEulers.push( e );
|
|
|
+ this.bodies[ i ].updateFromBone();
|
|
|
|
|
|
- },
|
|
|
+ }
|
|
|
|
|
|
- allocTransform: function () {
|
|
|
+ },
|
|
|
|
|
|
- return ( this.transforms.length > 0 ) ? this.transforms.pop() : new Ammo.btTransform();
|
|
|
+ _updateBones: function () {
|
|
|
|
|
|
- },
|
|
|
+ for ( var i = 0, il = this.bodies.length; i < il; i++ ) {
|
|
|
|
|
|
- freeTransform: function ( t ) {
|
|
|
+ this.bodies[ i ].updateBone();
|
|
|
|
|
|
- this.transforms.push( t );
|
|
|
+ }
|
|
|
|
|
|
- },
|
|
|
+ }
|
|
|
|
|
|
- allocQuaternion: function () {
|
|
|
+ };
|
|
|
|
|
|
- return ( this.quaternions.length > 0 ) ? this.quaternions.pop() : new Ammo.btQuaternion();
|
|
|
+ /**
|
|
|
+ * This manager's responsibilies are
|
|
|
+ *
|
|
|
+ * 1. manage Ammo.js and Three.js object resources and
|
|
|
+ * improve the performance and the memory consumption by
|
|
|
+ * reusing objects.
|
|
|
+ *
|
|
|
+ * 2. provide simple Ammo object operations.
|
|
|
+ */
|
|
|
+ function ResourceManager() {
|
|
|
|
|
|
- },
|
|
|
+ // for Three.js
|
|
|
+ this.threeVector3s = [];
|
|
|
+ this.threeMatrix4s = [];
|
|
|
+ this.threeQuaternions = [];
|
|
|
+ this.threeEulers = [];
|
|
|
|
|
|
- freeQuaternion: function ( q ) {
|
|
|
+ // for Ammo.js
|
|
|
+ this.transforms = [];
|
|
|
+ this.quaternions = [];
|
|
|
+ this.vector3s = [];
|
|
|
|
|
|
- this.quaternions.push( q );
|
|
|
+ }
|
|
|
|
|
|
- },
|
|
|
+ ResourceManager.prototype = {
|
|
|
|
|
|
- allocVector3: function () {
|
|
|
+ constructor: ResourceManager,
|
|
|
|
|
|
- return ( this.vector3s.length > 0 ) ? this.vector3s.pop() : new Ammo.btVector3();
|
|
|
+ allocThreeVector3: function () {
|
|
|
|
|
|
- },
|
|
|
+ return ( this.threeVector3s.length > 0 )
|
|
|
+ ? this.threeVector3s.pop()
|
|
|
+ : new THREE.Vector3();
|
|
|
|
|
|
- freeVector3: function ( v ) {
|
|
|
+ },
|
|
|
|
|
|
- this.vector3s.push( v );
|
|
|
+ freeThreeVector3: function ( v ) {
|
|
|
|
|
|
- },
|
|
|
+ this.threeVector3s.push( v );
|
|
|
|
|
|
- setIdentity: function ( t ) {
|
|
|
+ },
|
|
|
|
|
|
- t.setIdentity();
|
|
|
+ allocThreeMatrix4: function () {
|
|
|
|
|
|
- },
|
|
|
+ return ( this.threeMatrix4s.length > 0 )
|
|
|
+ ? this.threeMatrix4s.pop()
|
|
|
+ : new THREE.Matrix4();
|
|
|
|
|
|
- getBasis: function ( t ) {
|
|
|
+ },
|
|
|
|
|
|
- var q = this.allocQuaternion();
|
|
|
- t.getBasis().getRotation( q );
|
|
|
- return q;
|
|
|
+ freeThreeMatrix4: function ( m ) {
|
|
|
|
|
|
- },
|
|
|
+ this.threeMatrix4s.push( m );
|
|
|
|
|
|
- getBasisAsMatrix3: function ( t ) {
|
|
|
+ },
|
|
|
|
|
|
- var q = this.getBasis( t );
|
|
|
- var m = this.quaternionToMatrix3( q );
|
|
|
- this.freeQuaternion( q );
|
|
|
- return m;
|
|
|
+ allocThreeQuaternion: function () {
|
|
|
|
|
|
- },
|
|
|
+ return ( this.threeQuaternions.length > 0 )
|
|
|
+ ? this.threeQuaternions.pop()
|
|
|
+ : new THREE.Quaternion();
|
|
|
|
|
|
- getOrigin: function( t ) {
|
|
|
+ },
|
|
|
|
|
|
- return t.getOrigin();
|
|
|
+ freeThreeQuaternion: function ( q ) {
|
|
|
|
|
|
- },
|
|
|
+ this.threeQuaternions.push( q );
|
|
|
|
|
|
- setOrigin: function( t, v ) {
|
|
|
+ },
|
|
|
|
|
|
- t.getOrigin().setValue( v.x(), v.y(), v.z() );
|
|
|
+ allocThreeEuler: function () {
|
|
|
|
|
|
- },
|
|
|
+ return ( this.threeEulers.length > 0 )
|
|
|
+ ? this.threeEulers.pop()
|
|
|
+ : new THREE.Euler();
|
|
|
|
|
|
- copyOrigin: function( t1, t2 ) {
|
|
|
+ },
|
|
|
|
|
|
- var o = t2.getOrigin();
|
|
|
- this.setOrigin( t1, o );
|
|
|
+ freeThreeEuler: function ( e ) {
|
|
|
|
|
|
- },
|
|
|
+ this.threeEulers.push( e );
|
|
|
|
|
|
- setBasis: function( t, q ) {
|
|
|
+ },
|
|
|
|
|
|
- t.setRotation( q );
|
|
|
+ allocTransform: function () {
|
|
|
|
|
|
- },
|
|
|
+ return ( this.transforms.length > 0 )
|
|
|
+ ? this.transforms.pop()
|
|
|
+ : new Ammo.btTransform();
|
|
|
|
|
|
- setBasisFromMatrix3: function( t, m ) {
|
|
|
+ },
|
|
|
|
|
|
- var q = this.matrix3ToQuaternion( m );
|
|
|
- this.setBasis( t, q );
|
|
|
- this.freeQuaternion( q );
|
|
|
+ freeTransform: function ( t ) {
|
|
|
|
|
|
- },
|
|
|
+ this.transforms.push( t );
|
|
|
|
|
|
- setOriginFromArray3: function ( t, a ) {
|
|
|
+ },
|
|
|
|
|
|
- t.getOrigin().setValue( a[ 0 ], a[ 1 ], a[ 2 ] );
|
|
|
+ allocQuaternion: function () {
|
|
|
|
|
|
- },
|
|
|
+ return ( this.quaternions.length > 0 )
|
|
|
+ ? this.quaternions.pop()
|
|
|
+ : new Ammo.btQuaternion();
|
|
|
|
|
|
- setOriginFromThreeVector3: function ( t, v ) {
|
|
|
+ },
|
|
|
|
|
|
- t.getOrigin().setValue( v.x, v.y, v.z );
|
|
|
+ freeQuaternion: function ( q ) {
|
|
|
|
|
|
- },
|
|
|
+ this.quaternions.push( q );
|
|
|
|
|
|
- setBasisFromArray3: function ( t, a ) {
|
|
|
+ },
|
|
|
|
|
|
- var thQ = this.allocThreeQuaternion();
|
|
|
- var thE = this.allocThreeEuler();
|
|
|
- thE.set( a[ 0 ], a[ 1 ], a[ 2 ] );
|
|
|
- this.setBasisFromThreeQuaternion( t, thQ.setFromEuler( thE ) );
|
|
|
+ allocVector3: function () {
|
|
|
|
|
|
- this.freeThreeEuler( thE );
|
|
|
- this.freeThreeQuaternion( thQ );
|
|
|
+ return ( this.vector3s.length > 0 )
|
|
|
+ ? this.vector3s.pop()
|
|
|
+ : new Ammo.btVector3();
|
|
|
|
|
|
- },
|
|
|
+ },
|
|
|
|
|
|
- setBasisFromThreeQuaternion: function ( t, a ) {
|
|
|
+ freeVector3: function ( v ) {
|
|
|
|
|
|
- var q = this.allocQuaternion();
|
|
|
+ this.vector3s.push( v );
|
|
|
|
|
|
- q.setX( a.x );
|
|
|
- q.setY( a.y );
|
|
|
- q.setZ( a.z );
|
|
|
- q.setW( a.w );
|
|
|
- this.setBasis( t, q );
|
|
|
+ },
|
|
|
|
|
|
- this.freeQuaternion( q );
|
|
|
+ setIdentity: function ( t ) {
|
|
|
|
|
|
- },
|
|
|
+ t.setIdentity();
|
|
|
|
|
|
- multiplyTransforms: function ( t1, t2 ) {
|
|
|
+ },
|
|
|
|
|
|
- var t = this.allocTransform();
|
|
|
- this.setIdentity( t );
|
|
|
+ getBasis: function ( t ) {
|
|
|
|
|
|
- var m1 = this.getBasisAsMatrix3( t1 );
|
|
|
- var m2 = this.getBasisAsMatrix3( t2 );
|
|
|
+ var q = this.allocQuaternion();
|
|
|
+ t.getBasis().getRotation( q );
|
|
|
+ return q;
|
|
|
|
|
|
- var o1 = this.getOrigin( t1 );
|
|
|
- var o2 = this.getOrigin( t2 );
|
|
|
+ },
|
|
|
|
|
|
- var v1 = this.multiplyMatrix3ByVector3( m1, o2 );
|
|
|
- var v2 = this.addVector3( v1, o1 );
|
|
|
- this.setOrigin( t, v2 );
|
|
|
+ getBasisAsMatrix3: function ( t ) {
|
|
|
|
|
|
- var m3 = this.multiplyMatrices3( m1, m2 );
|
|
|
- this.setBasisFromMatrix3( t, m3 );
|
|
|
+ var q = this.getBasis( t );
|
|
|
+ var m = this.quaternionToMatrix3( q );
|
|
|
+ this.freeQuaternion( q );
|
|
|
+ return m;
|
|
|
|
|
|
- this.freeVector3( v1 );
|
|
|
- this.freeVector3( v2 );
|
|
|
+ },
|
|
|
|
|
|
- return t;
|
|
|
+ getOrigin: function( t ) {
|
|
|
|
|
|
- },
|
|
|
+ return t.getOrigin();
|
|
|
|
|
|
- inverseTransform: function ( t ) {
|
|
|
+ },
|
|
|
|
|
|
- var t2 = this.allocTransform();
|
|
|
+ setOrigin: function( t, v ) {
|
|
|
|
|
|
- var m1 = this.getBasisAsMatrix3( t );
|
|
|
- var o = this.getOrigin( t );
|
|
|
+ t.getOrigin().setValue( v.x(), v.y(), v.z() );
|
|
|
|
|
|
- var m2 = this.transposeMatrix3( m1 );
|
|
|
- var v1 = this.negativeVector3( o );
|
|
|
- var v2 = this.multiplyMatrix3ByVector3( m2, v1 );
|
|
|
+ },
|
|
|
|
|
|
- this.setOrigin( t2, v2 );
|
|
|
- this.setBasisFromMatrix3( t2, m2 );
|
|
|
+ copyOrigin: function( t1, t2 ) {
|
|
|
|
|
|
- this.freeVector3( v1 );
|
|
|
- this.freeVector3( v2 );
|
|
|
+ var o = t2.getOrigin();
|
|
|
+ this.setOrigin( t1, o );
|
|
|
|
|
|
- return t2;
|
|
|
+ },
|
|
|
|
|
|
- },
|
|
|
+ setBasis: function( t, q ) {
|
|
|
|
|
|
- multiplyMatrices3: function ( m1, m2 ) {
|
|
|
+ t.setRotation( q );
|
|
|
|
|
|
- var m3 = [];
|
|
|
+ },
|
|
|
|
|
|
- var v10 = this.rowOfMatrix3( m1, 0 );
|
|
|
- var v11 = this.rowOfMatrix3( m1, 1 );
|
|
|
- var v12 = this.rowOfMatrix3( m1, 2 );
|
|
|
+ setBasisFromMatrix3: function( t, m ) {
|
|
|
|
|
|
- var v20 = this.columnOfMatrix3( m2, 0 );
|
|
|
- var v21 = this.columnOfMatrix3( m2, 1 );
|
|
|
- var v22 = this.columnOfMatrix3( m2, 2 );
|
|
|
+ var q = this.matrix3ToQuaternion( m );
|
|
|
+ this.setBasis( t, q );
|
|
|
+ this.freeQuaternion( q );
|
|
|
|
|
|
- m3[ 0 ] = this.dotVectors3( v10, v20 );
|
|
|
- m3[ 1 ] = this.dotVectors3( v10, v21 );
|
|
|
- m3[ 2 ] = this.dotVectors3( v10, v22 );
|
|
|
- m3[ 3 ] = this.dotVectors3( v11, v20 );
|
|
|
- m3[ 4 ] = this.dotVectors3( v11, v21 );
|
|
|
- m3[ 5 ] = this.dotVectors3( v11, v22 );
|
|
|
- m3[ 6 ] = this.dotVectors3( v12, v20 );
|
|
|
- m3[ 7 ] = this.dotVectors3( v12, v21 );
|
|
|
- m3[ 8 ] = this.dotVectors3( v12, v22 );
|
|
|
+ },
|
|
|
|
|
|
- this.freeVector3( v10 );
|
|
|
- this.freeVector3( v11 );
|
|
|
- this.freeVector3( v12 );
|
|
|
- this.freeVector3( v20 );
|
|
|
- this.freeVector3( v21 );
|
|
|
- this.freeVector3( v22 );
|
|
|
+ setOriginFromArray3: function ( t, a ) {
|
|
|
|
|
|
- return m3;
|
|
|
+ t.getOrigin().setValue( a[ 0 ], a[ 1 ], a[ 2 ] );
|
|
|
|
|
|
- },
|
|
|
+ },
|
|
|
|
|
|
- addVector3: function( v1, v2 ) {
|
|
|
+ setOriginFromThreeVector3: function ( t, v ) {
|
|
|
|
|
|
- var v = this.allocVector3();
|
|
|
- v.setValue( v1.x() + v2.x(), v1.y() + v2.y(), v1.z() + v2.z() );
|
|
|
- return v;
|
|
|
+ t.getOrigin().setValue( v.x, v.y, v.z );
|
|
|
|
|
|
- },
|
|
|
+ },
|
|
|
|
|
|
- dotVectors3: function( v1, v2 ) {
|
|
|
+ setBasisFromArray3: function ( t, a ) {
|
|
|
|
|
|
- return v1.x() * v2.x() + v1.y() * v2.y() + v1.z() * v2.z();
|
|
|
+ var thQ = this.allocThreeQuaternion();
|
|
|
+ var thE = this.allocThreeEuler();
|
|
|
+ thE.set( a[ 0 ], a[ 1 ], a[ 2 ] );
|
|
|
+ this.setBasisFromThreeQuaternion( t, thQ.setFromEuler( thE ) );
|
|
|
|
|
|
- },
|
|
|
+ this.freeThreeEuler( thE );
|
|
|
+ this.freeThreeQuaternion( thQ );
|
|
|
|
|
|
- rowOfMatrix3: function( m, i ) {
|
|
|
+ },
|
|
|
|
|
|
- var v = this.allocVector3();
|
|
|
- v.setValue( m[ i * 3 + 0 ], m[ i * 3 + 1 ], m[ i * 3 + 2 ] );
|
|
|
- return v;
|
|
|
+ setBasisFromThreeQuaternion: function ( t, a ) {
|
|
|
|
|
|
- },
|
|
|
+ var q = this.allocQuaternion();
|
|
|
|
|
|
- columnOfMatrix3: function( m, i ) {
|
|
|
+ q.setX( a.x );
|
|
|
+ q.setY( a.y );
|
|
|
+ q.setZ( a.z );
|
|
|
+ q.setW( a.w );
|
|
|
+ this.setBasis( t, q );
|
|
|
|
|
|
- var v = this.allocVector3();
|
|
|
- v.setValue( m[ i + 0 ], m[ i + 3 ], m[ i + 6 ] );
|
|
|
- return v;
|
|
|
+ this.freeQuaternion( q );
|
|
|
|
|
|
- },
|
|
|
+ },
|
|
|
|
|
|
- negativeVector3: function( v ) {
|
|
|
+ multiplyTransforms: function ( t1, t2 ) {
|
|
|
|
|
|
- var v2 = this.allocVector3();
|
|
|
- v2.setValue( -v.x(), -v.y(), -v.z() );
|
|
|
- return v2;
|
|
|
+ var t = this.allocTransform();
|
|
|
+ this.setIdentity( t );
|
|
|
|
|
|
- },
|
|
|
+ var m1 = this.getBasisAsMatrix3( t1 );
|
|
|
+ var m2 = this.getBasisAsMatrix3( t2 );
|
|
|
|
|
|
- multiplyMatrix3ByVector3: function ( m, v ) {
|
|
|
+ var o1 = this.getOrigin( t1 );
|
|
|
+ var o2 = this.getOrigin( t2 );
|
|
|
|
|
|
- var v4 = this.allocVector3();
|
|
|
+ var v1 = this.multiplyMatrix3ByVector3( m1, o2 );
|
|
|
+ var v2 = this.addVector3( v1, o1 );
|
|
|
+ this.setOrigin( t, v2 );
|
|
|
|
|
|
- var v0 = this.rowOfMatrix3( m, 0 );
|
|
|
- var v1 = this.rowOfMatrix3( m, 1 );
|
|
|
- var v2 = this.rowOfMatrix3( m, 2 );
|
|
|
- var x = this.dotVectors3( v0, v );
|
|
|
- var y = this.dotVectors3( v1, v );
|
|
|
- var z = this.dotVectors3( v2, v );
|
|
|
+ var m3 = this.multiplyMatrices3( m1, m2 );
|
|
|
+ this.setBasisFromMatrix3( t, m3 );
|
|
|
|
|
|
- v4.setValue( x, y, z );
|
|
|
+ this.freeVector3( v1 );
|
|
|
+ this.freeVector3( v2 );
|
|
|
|
|
|
- this.freeVector3( v0 );
|
|
|
- this.freeVector3( v1 );
|
|
|
- this.freeVector3( v2 );
|
|
|
+ return t;
|
|
|
|
|
|
- return v4;
|
|
|
+ },
|
|
|
|
|
|
- },
|
|
|
+ inverseTransform: function ( t ) {
|
|
|
|
|
|
- transposeMatrix3: function( m ) {
|
|
|
+ var t2 = this.allocTransform();
|
|
|
|
|
|
- var m2 = [];
|
|
|
- m2[ 0 ] = m[ 0 ];
|
|
|
- m2[ 1 ] = m[ 3 ];
|
|
|
- m2[ 2 ] = m[ 6 ];
|
|
|
- m2[ 3 ] = m[ 1 ];
|
|
|
- m2[ 4 ] = m[ 4 ];
|
|
|
- m2[ 5 ] = m[ 7 ];
|
|
|
- m2[ 6 ] = m[ 2 ];
|
|
|
- m2[ 7 ] = m[ 5 ];
|
|
|
- m2[ 8 ] = m[ 8 ];
|
|
|
- return m2;
|
|
|
+ var m1 = this.getBasisAsMatrix3( t );
|
|
|
+ var o = this.getOrigin( t );
|
|
|
|
|
|
- },
|
|
|
+ var m2 = this.transposeMatrix3( m1 );
|
|
|
+ var v1 = this.negativeVector3( o );
|
|
|
+ var v2 = this.multiplyMatrix3ByVector3( m2, v1 );
|
|
|
|
|
|
- quaternionToMatrix3: function ( q ) {
|
|
|
+ this.setOrigin( t2, v2 );
|
|
|
+ this.setBasisFromMatrix3( t2, m2 );
|
|
|
|
|
|
- var m = [];
|
|
|
+ this.freeVector3( v1 );
|
|
|
+ this.freeVector3( v2 );
|
|
|
|
|
|
- var x = q.x();
|
|
|
- var y = q.y();
|
|
|
- var z = q.z();
|
|
|
- var w = q.w();
|
|
|
+ return t2;
|
|
|
|
|
|
- var xx = x * x;
|
|
|
- var yy = y * y;
|
|
|
- var zz = z * z;
|
|
|
+ },
|
|
|
|
|
|
- var xy = x * y;
|
|
|
- var yz = y * z;
|
|
|
- var zx = z * x;
|
|
|
+ multiplyMatrices3: function ( m1, m2 ) {
|
|
|
|
|
|
- var xw = x * w;
|
|
|
- var yw = y * w;
|
|
|
- var zw = z * w;
|
|
|
+ var m3 = [];
|
|
|
|
|
|
- m[ 0 ] = 1 - 2 * ( yy + zz );
|
|
|
- m[ 1 ] = 2 * ( xy - zw );
|
|
|
- m[ 2 ] = 2 * ( zx + yw );
|
|
|
- m[ 3 ] = 2 * ( xy + zw );
|
|
|
- m[ 4 ] = 1 - 2 * ( zz + xx );
|
|
|
- m[ 5 ] = 2 * ( yz - xw );
|
|
|
- m[ 6 ] = 2 * ( zx - yw );
|
|
|
- m[ 7 ] = 2 * ( yz + xw );
|
|
|
- m[ 8 ] = 1 - 2 * ( xx + yy );
|
|
|
+ var v10 = this.rowOfMatrix3( m1, 0 );
|
|
|
+ var v11 = this.rowOfMatrix3( m1, 1 );
|
|
|
+ var v12 = this.rowOfMatrix3( m1, 2 );
|
|
|
|
|
|
- return m;
|
|
|
+ var v20 = this.columnOfMatrix3( m2, 0 );
|
|
|
+ var v21 = this.columnOfMatrix3( m2, 1 );
|
|
|
+ var v22 = this.columnOfMatrix3( m2, 2 );
|
|
|
|
|
|
- },
|
|
|
+ m3[ 0 ] = this.dotVectors3( v10, v20 );
|
|
|
+ m3[ 1 ] = this.dotVectors3( v10, v21 );
|
|
|
+ m3[ 2 ] = this.dotVectors3( v10, v22 );
|
|
|
+ m3[ 3 ] = this.dotVectors3( v11, v20 );
|
|
|
+ m3[ 4 ] = this.dotVectors3( v11, v21 );
|
|
|
+ m3[ 5 ] = this.dotVectors3( v11, v22 );
|
|
|
+ m3[ 6 ] = this.dotVectors3( v12, v20 );
|
|
|
+ m3[ 7 ] = this.dotVectors3( v12, v21 );
|
|
|
+ m3[ 8 ] = this.dotVectors3( v12, v22 );
|
|
|
|
|
|
- matrix3ToQuaternion: function( m ) {
|
|
|
+ this.freeVector3( v10 );
|
|
|
+ this.freeVector3( v11 );
|
|
|
+ this.freeVector3( v12 );
|
|
|
+ this.freeVector3( v20 );
|
|
|
+ this.freeVector3( v21 );
|
|
|
+ this.freeVector3( v22 );
|
|
|
|
|
|
- var t = m[ 0 ] + m[ 4 ] + m[ 8 ];
|
|
|
- var s, x, y, z, w;
|
|
|
+ return m3;
|
|
|
|
|
|
- if( t > 0 ) {
|
|
|
+ },
|
|
|
|
|
|
- s = Math.sqrt( t + 1.0 ) * 2;
|
|
|
- w = 0.25 * s;
|
|
|
- x = ( m[ 7 ] - m[ 5 ] ) / s;
|
|
|
- y = ( m[ 2 ] - m[ 6 ] ) / s;
|
|
|
- z = ( m[ 3 ] - m[ 1 ] ) / s;
|
|
|
+ addVector3: function( v1, v2 ) {
|
|
|
|
|
|
- } else if( ( m[ 0 ] > m[ 4 ] ) && ( m[ 0 ] > m[ 8 ] ) ) {
|
|
|
+ var v = this.allocVector3();
|
|
|
+ v.setValue( v1.x() + v2.x(), v1.y() + v2.y(), v1.z() + v2.z() );
|
|
|
+ return v;
|
|
|
|
|
|
- s = Math.sqrt( 1.0 + m[ 0 ] - m[ 4 ] - m[ 8 ] ) * 2;
|
|
|
- w = ( m[ 7 ] - m[ 5 ] ) / s;
|
|
|
- x = 0.25 * s;
|
|
|
- y = ( m[ 1 ] + m[ 3 ] ) / s;
|
|
|
- z = ( m[ 2 ] + m[ 6 ] ) / s;
|
|
|
+ },
|
|
|
|
|
|
- } else if( m[ 4 ] > m[ 8 ] ) {
|
|
|
+ dotVectors3: function( v1, v2 ) {
|
|
|
|
|
|
- s = Math.sqrt( 1.0 + m[ 4 ] - m[ 0 ] - m[ 8 ] ) * 2;
|
|
|
- w = ( m[ 2 ] - m[ 6 ] ) / s;
|
|
|
- x = ( m[ 1 ] + m[ 3 ] ) / s;
|
|
|
- y = 0.25 * s;
|
|
|
- z = ( m[ 5 ] + m[ 7 ] ) / s;
|
|
|
+ return v1.x() * v2.x() + v1.y() * v2.y() + v1.z() * v2.z();
|
|
|
|
|
|
- } else {
|
|
|
+ },
|
|
|
|
|
|
- s = Math.sqrt( 1.0 + m[ 8 ] - m[ 0 ] - m[ 4 ] ) * 2;
|
|
|
- w = ( m[ 3 ] - m[ 1 ] ) / s;
|
|
|
- x = ( m[ 2 ] + m[ 6 ] ) / s;
|
|
|
- y = ( m[ 5 ] + m[ 7 ] ) / s;
|
|
|
- z = 0.25 * s;
|
|
|
+ rowOfMatrix3: function( m, i ) {
|
|
|
|
|
|
- }
|
|
|
+ var v = this.allocVector3();
|
|
|
+ v.setValue( m[ i * 3 + 0 ], m[ i * 3 + 1 ], m[ i * 3 + 2 ] );
|
|
|
+ return v;
|
|
|
|
|
|
- var q = this.allocQuaternion();
|
|
|
- q.setX( x );
|
|
|
- q.setY( y );
|
|
|
- q.setZ( z );
|
|
|
- q.setW( w );
|
|
|
- return q;
|
|
|
+ },
|
|
|
|
|
|
- }
|
|
|
+ columnOfMatrix3: function( m, i ) {
|
|
|
|
|
|
-};
|
|
|
+ var v = this.allocVector3();
|
|
|
+ v.setValue( m[ i + 0 ], m[ i + 3 ], m[ i + 6 ] );
|
|
|
+ return v;
|
|
|
|
|
|
-THREE.MMDPhysics.RigidBody = function ( mesh, world, params, helper ) {
|
|
|
+ },
|
|
|
|
|
|
- this.mesh = mesh;
|
|
|
- this.world = world;
|
|
|
- this.params = params;
|
|
|
- this.helper = helper;
|
|
|
+ negativeVector3: function( v ) {
|
|
|
|
|
|
- this.body = null;
|
|
|
- this.bone = null;
|
|
|
- this.boneOffsetForm = null;
|
|
|
- this.boneOffsetFormInverse = null;
|
|
|
+ var v2 = this.allocVector3();
|
|
|
+ v2.setValue( -v.x(), -v.y(), -v.z() );
|
|
|
+ return v2;
|
|
|
|
|
|
- this.init();
|
|
|
+ },
|
|
|
|
|
|
-};
|
|
|
+ multiplyMatrix3ByVector3: function ( m, v ) {
|
|
|
|
|
|
-THREE.MMDPhysics.RigidBody.prototype = {
|
|
|
+ var v4 = this.allocVector3();
|
|
|
|
|
|
- constructor: THREE.MMDPhysics.RigidBody,
|
|
|
+ var v0 = this.rowOfMatrix3( m, 0 );
|
|
|
+ var v1 = this.rowOfMatrix3( m, 1 );
|
|
|
+ var v2 = this.rowOfMatrix3( m, 2 );
|
|
|
+ var x = this.dotVectors3( v0, v );
|
|
|
+ var y = this.dotVectors3( v1, v );
|
|
|
+ var z = this.dotVectors3( v2, v );
|
|
|
|
|
|
- init: function () {
|
|
|
+ v4.setValue( x, y, z );
|
|
|
|
|
|
- function generateShape( p ) {
|
|
|
+ this.freeVector3( v0 );
|
|
|
+ this.freeVector3( v1 );
|
|
|
+ this.freeVector3( v2 );
|
|
|
|
|
|
- switch( p.shapeType ) {
|
|
|
+ return v4;
|
|
|
|
|
|
- case 0:
|
|
|
- return new Ammo.btSphereShape( p.width );
|
|
|
+ },
|
|
|
|
|
|
- case 1:
|
|
|
- return new Ammo.btBoxShape( new Ammo.btVector3( p.width, p.height, p.depth ) );
|
|
|
+ transposeMatrix3: function( m ) {
|
|
|
|
|
|
- case 2:
|
|
|
- return new Ammo.btCapsuleShape( p.width, p.height );
|
|
|
+ var m2 = [];
|
|
|
+ m2[ 0 ] = m[ 0 ];
|
|
|
+ m2[ 1 ] = m[ 3 ];
|
|
|
+ m2[ 2 ] = m[ 6 ];
|
|
|
+ m2[ 3 ] = m[ 1 ];
|
|
|
+ m2[ 4 ] = m[ 4 ];
|
|
|
+ m2[ 5 ] = m[ 7 ];
|
|
|
+ m2[ 6 ] = m[ 2 ];
|
|
|
+ m2[ 7 ] = m[ 5 ];
|
|
|
+ m2[ 8 ] = m[ 8 ];
|
|
|
+ return m2;
|
|
|
|
|
|
- default:
|
|
|
- throw 'unknown shape type ' + p.shapeType;
|
|
|
+ },
|
|
|
|
|
|
- }
|
|
|
+ quaternionToMatrix3: function ( q ) {
|
|
|
|
|
|
- }
|
|
|
+ var m = [];
|
|
|
|
|
|
- var helper = this.helper;
|
|
|
- var params = this.params;
|
|
|
- var bones = this.mesh.skeleton.bones;
|
|
|
- var bone = ( params.boneIndex === -1 ) ? new THREE.Bone() : bones[ params.boneIndex ];
|
|
|
+ var x = q.x();
|
|
|
+ var y = q.y();
|
|
|
+ var z = q.z();
|
|
|
+ var w = q.w();
|
|
|
|
|
|
- var shape = generateShape( params );
|
|
|
- var weight = ( params.type === 0 ) ? 0 : params.weight;
|
|
|
- var localInertia = helper.allocVector3();
|
|
|
- localInertia.setValue( 0, 0, 0 );
|
|
|
+ var xx = x * x;
|
|
|
+ var yy = y * y;
|
|
|
+ var zz = z * z;
|
|
|
|
|
|
- if( weight !== 0 ) {
|
|
|
+ var xy = x * y;
|
|
|
+ var yz = y * z;
|
|
|
+ var zx = z * x;
|
|
|
|
|
|
- shape.calculateLocalInertia( weight, localInertia );
|
|
|
+ var xw = x * w;
|
|
|
+ var yw = y * w;
|
|
|
+ var zw = z * w;
|
|
|
|
|
|
- }
|
|
|
+ m[ 0 ] = 1 - 2 * ( yy + zz );
|
|
|
+ m[ 1 ] = 2 * ( xy - zw );
|
|
|
+ m[ 2 ] = 2 * ( zx + yw );
|
|
|
+ m[ 3 ] = 2 * ( xy + zw );
|
|
|
+ m[ 4 ] = 1 - 2 * ( zz + xx );
|
|
|
+ m[ 5 ] = 2 * ( yz - xw );
|
|
|
+ m[ 6 ] = 2 * ( zx - yw );
|
|
|
+ m[ 7 ] = 2 * ( yz + xw );
|
|
|
+ m[ 8 ] = 1 - 2 * ( xx + yy );
|
|
|
|
|
|
- var boneOffsetForm = helper.allocTransform();
|
|
|
- helper.setIdentity( boneOffsetForm );
|
|
|
- helper.setOriginFromArray3( boneOffsetForm, params.position );
|
|
|
- helper.setBasisFromArray3( boneOffsetForm, params.rotation );
|
|
|
+ return m;
|
|
|
|
|
|
- var vector = helper.allocThreeVector3();
|
|
|
- var boneForm = helper.allocTransform();
|
|
|
- helper.setIdentity( boneForm );
|
|
|
- helper.setOriginFromThreeVector3( boneForm, bone.getWorldPosition( vector ) );
|
|
|
+ },
|
|
|
|
|
|
- var form = helper.multiplyTransforms( boneForm, boneOffsetForm );
|
|
|
- var state = new Ammo.btDefaultMotionState( form );
|
|
|
+ matrix3ToQuaternion: function( m ) {
|
|
|
|
|
|
- var info = new Ammo.btRigidBodyConstructionInfo( weight, state, shape, localInertia );
|
|
|
- info.set_m_friction( params.friction );
|
|
|
- info.set_m_restitution( params.restitution );
|
|
|
+ var t = m[ 0 ] + m[ 4 ] + m[ 8 ];
|
|
|
+ var s, x, y, z, w;
|
|
|
|
|
|
- var body = new Ammo.btRigidBody( info );
|
|
|
+ if( t > 0 ) {
|
|
|
|
|
|
- if ( params.type === 0 ) {
|
|
|
+ s = Math.sqrt( t + 1.0 ) * 2;
|
|
|
+ w = 0.25 * s;
|
|
|
+ x = ( m[ 7 ] - m[ 5 ] ) / s;
|
|
|
+ y = ( m[ 2 ] - m[ 6 ] ) / s;
|
|
|
+ z = ( m[ 3 ] - m[ 1 ] ) / s;
|
|
|
|
|
|
- body.setCollisionFlags( body.getCollisionFlags() | 2 );
|
|
|
+ } else if( ( m[ 0 ] > m[ 4 ] ) && ( m[ 0 ] > m[ 8 ] ) ) {
|
|
|
|
|
|
- /*
|
|
|
- * It'd be better to comment out this line though in general I should call this method
|
|
|
- * because I'm not sure why but physics will be more like MMD's
|
|
|
- * if I comment out.
|
|
|
- */
|
|
|
- body.setActivationState( 4 );
|
|
|
+ s = Math.sqrt( 1.0 + m[ 0 ] - m[ 4 ] - m[ 8 ] ) * 2;
|
|
|
+ w = ( m[ 7 ] - m[ 5 ] ) / s;
|
|
|
+ x = 0.25 * s;
|
|
|
+ y = ( m[ 1 ] + m[ 3 ] ) / s;
|
|
|
+ z = ( m[ 2 ] + m[ 6 ] ) / s;
|
|
|
|
|
|
- }
|
|
|
+ } else if( m[ 4 ] > m[ 8 ] ) {
|
|
|
|
|
|
- body.setDamping( params.positionDamping, params.rotationDamping );
|
|
|
- body.setSleepingThresholds( 0, 0 );
|
|
|
+ s = Math.sqrt( 1.0 + m[ 4 ] - m[ 0 ] - m[ 8 ] ) * 2;
|
|
|
+ w = ( m[ 2 ] - m[ 6 ] ) / s;
|
|
|
+ x = ( m[ 1 ] + m[ 3 ] ) / s;
|
|
|
+ y = 0.25 * s;
|
|
|
+ z = ( m[ 5 ] + m[ 7 ] ) / s;
|
|
|
|
|
|
- this.world.addRigidBody( body, 1 << params.groupIndex, params.groupTarget );
|
|
|
+ } else {
|
|
|
|
|
|
- this.body = body;
|
|
|
- this.bone = bone;
|
|
|
- this.boneOffsetForm = boneOffsetForm;
|
|
|
- this.boneOffsetFormInverse = helper.inverseTransform( boneOffsetForm );
|
|
|
+ s = Math.sqrt( 1.0 + m[ 8 ] - m[ 0 ] - m[ 4 ] ) * 2;
|
|
|
+ w = ( m[ 3 ] - m[ 1 ] ) / s;
|
|
|
+ x = ( m[ 2 ] + m[ 6 ] ) / s;
|
|
|
+ y = ( m[ 5 ] + m[ 7 ] ) / s;
|
|
|
+ z = 0.25 * s;
|
|
|
|
|
|
- helper.freeVector3( localInertia );
|
|
|
- helper.freeTransform( form );
|
|
|
- helper.freeTransform( boneForm );
|
|
|
- helper.freeThreeVector3( vector );
|
|
|
+ }
|
|
|
|
|
|
- },
|
|
|
+ var q = this.allocQuaternion();
|
|
|
+ q.setX( x );
|
|
|
+ q.setY( y );
|
|
|
+ q.setZ( z );
|
|
|
+ q.setW( w );
|
|
|
+ return q;
|
|
|
|
|
|
- reset: function () {
|
|
|
+ }
|
|
|
|
|
|
- this.setTransformFromBone();
|
|
|
+ };
|
|
|
|
|
|
- },
|
|
|
+ /**
|
|
|
+ * @param {THREE.SkinnedMesh} mesh
|
|
|
+ * @param {Ammo.btDiscreteDynamicsWorld} world
|
|
|
+ * @param {Object} params
|
|
|
+ * @param {ResourceManager} manager
|
|
|
+ */
|
|
|
+ function RigidBody( mesh, world, params, manager ) {
|
|
|
|
|
|
- updateFromBone: function () {
|
|
|
+ this.mesh = mesh;
|
|
|
+ this.world = world;
|
|
|
+ this.params = params;
|
|
|
+ this.manager = manager;
|
|
|
|
|
|
- if ( this.params.boneIndex === -1 ) {
|
|
|
+ this.body = null;
|
|
|
+ this.bone = null;
|
|
|
+ this.boneOffsetForm = null;
|
|
|
+ this.boneOffsetFormInverse = null;
|
|
|
|
|
|
- return;
|
|
|
+ this._init();
|
|
|
|
|
|
- }
|
|
|
+ }
|
|
|
|
|
|
- if ( this.params.type === 0 ) {
|
|
|
+ RigidBody.prototype = {
|
|
|
|
|
|
- this.setTransformFromBone();
|
|
|
+ constructor: MMDPhysics.RigidBody,
|
|
|
|
|
|
- }
|
|
|
+ /**
|
|
|
+ * Resets rigid body transform to the current bone's.
|
|
|
+ *
|
|
|
+ * @return {RigidBody}
|
|
|
+ */
|
|
|
+ reset: function () {
|
|
|
|
|
|
- },
|
|
|
+ this._setTransformFromBone();
|
|
|
+ return this;
|
|
|
|
|
|
- updateBone: function () {
|
|
|
+ },
|
|
|
|
|
|
- if ( this.params.type === 0 || this.params.boneIndex === -1 ) {
|
|
|
+ /**
|
|
|
+ * Updates rigid body's transform from the current bone.
|
|
|
+ *
|
|
|
+ * @return {RidigBody}
|
|
|
+ */
|
|
|
+ updateFromBone: function () {
|
|
|
|
|
|
- return;
|
|
|
+ if ( this.params.boneIndex !== - 1 &&
|
|
|
+ this.params.type === 0 ) {
|
|
|
|
|
|
- }
|
|
|
+ this._setTransformFromBone();
|
|
|
|
|
|
- this.updateBoneRotation();
|
|
|
+ }
|
|
|
|
|
|
- if ( this.params.type === 1 ) {
|
|
|
+ return this;
|
|
|
|
|
|
- this.updateBonePosition();
|
|
|
+ },
|
|
|
|
|
|
- }
|
|
|
+ /**
|
|
|
+ * Updates bone from the current ridid body's transform.
|
|
|
+ *
|
|
|
+ * @return {RidigBody}
|
|
|
+ */
|
|
|
+ updateBone: function () {
|
|
|
|
|
|
- this.bone.updateMatrixWorld( true );
|
|
|
+ if ( this.params.type === 0 ||
|
|
|
+ this.params.boneIndex === - 1 ) {
|
|
|
|
|
|
- if ( this.params.type === 2 ) {
|
|
|
+ return this;
|
|
|
|
|
|
- this.setPositionFromBone();
|
|
|
+ }
|
|
|
|
|
|
- }
|
|
|
+ this._updateBoneRotation();
|
|
|
|
|
|
- },
|
|
|
+ if ( this.params.type === 1 ) {
|
|
|
|
|
|
- getBoneTransform: function () {
|
|
|
+ this._updateBonePosition();
|
|
|
|
|
|
- var helper = this.helper;
|
|
|
- var p = helper.allocThreeVector3();
|
|
|
- var q = helper.allocThreeQuaternion();
|
|
|
- var s = helper.allocThreeVector3();
|
|
|
+ }
|
|
|
|
|
|
- this.bone.matrixWorld.decompose( p, q, s );
|
|
|
+ this.bone.updateMatrixWorld( true );
|
|
|
|
|
|
- var tr = helper.allocTransform();
|
|
|
- helper.setOriginFromThreeVector3( tr, p );
|
|
|
- helper.setBasisFromThreeQuaternion( tr, q );
|
|
|
+ if ( this.params.type === 2 ) {
|
|
|
|
|
|
- var form = helper.multiplyTransforms( tr, this.boneOffsetForm );
|
|
|
+ this._setPositionFromBone();
|
|
|
|
|
|
- helper.freeTransform( tr );
|
|
|
- helper.freeThreeVector3( s );
|
|
|
- helper.freeThreeQuaternion( q );
|
|
|
- helper.freeThreeVector3( p );
|
|
|
+ }
|
|
|
|
|
|
- return form;
|
|
|
+ return this;
|
|
|
|
|
|
- },
|
|
|
+ },
|
|
|
|
|
|
- getWorldTransformForBone: function () {
|
|
|
+ // private methods
|
|
|
|
|
|
- var helper = this.helper;
|
|
|
+ _init: function () {
|
|
|
|
|
|
- var tr = helper.allocTransform();
|
|
|
- this.body.getMotionState().getWorldTransform( tr );
|
|
|
- var tr2 = helper.multiplyTransforms( tr, this.boneOffsetFormInverse );
|
|
|
+ function generateShape( p ) {
|
|
|
|
|
|
- helper.freeTransform( tr );
|
|
|
+ switch( p.shapeType ) {
|
|
|
|
|
|
- return tr2;
|
|
|
+ case 0:
|
|
|
+ return new Ammo.btSphereShape( p.width );
|
|
|
|
|
|
- },
|
|
|
+ case 1:
|
|
|
+ return new Ammo.btBoxShape( new Ammo.btVector3( p.width, p.height, p.depth ) );
|
|
|
|
|
|
- setTransformFromBone: function () {
|
|
|
+ case 2:
|
|
|
+ return new Ammo.btCapsuleShape( p.width, p.height );
|
|
|
|
|
|
- var helper = this.helper;
|
|
|
- var form = this.getBoneTransform();
|
|
|
+ default:
|
|
|
+ throw 'unknown shape type ' + p.shapeType;
|
|
|
|
|
|
- // TODO: check the most appropriate way to set
|
|
|
- //this.body.setWorldTransform( form );
|
|
|
- this.body.setCenterOfMassTransform( form );
|
|
|
- this.body.getMotionState().setWorldTransform( form );
|
|
|
+ }
|
|
|
|
|
|
- helper.freeTransform( form );
|
|
|
+ }
|
|
|
|
|
|
- },
|
|
|
+ var manager = this.manager;
|
|
|
+ var params = this.params;
|
|
|
+ var bones = this.mesh.skeleton.bones;
|
|
|
+ var bone = ( params.boneIndex === - 1 )
|
|
|
+ ? new THREE.Bone()
|
|
|
+ : bones[ params.boneIndex ];
|
|
|
|
|
|
- setPositionFromBone: function () {
|
|
|
+ var shape = generateShape( params );
|
|
|
+ var weight = ( params.type === 0 ) ? 0 : params.weight;
|
|
|
+ var localInertia = manager.allocVector3();
|
|
|
+ localInertia.setValue( 0, 0, 0 );
|
|
|
|
|
|
- var helper = this.helper;
|
|
|
- var form = this.getBoneTransform();
|
|
|
+ if( weight !== 0 ) {
|
|
|
|
|
|
- var tr = helper.allocTransform();
|
|
|
- this.body.getMotionState().getWorldTransform( tr );
|
|
|
- helper.copyOrigin( tr, form );
|
|
|
+ shape.calculateLocalInertia( weight, localInertia );
|
|
|
|
|
|
- // TODO: check the most appropriate way to set
|
|
|
- //this.body.setWorldTransform( tr );
|
|
|
- this.body.setCenterOfMassTransform( tr );
|
|
|
- this.body.getMotionState().setWorldTransform( tr );
|
|
|
+ }
|
|
|
|
|
|
- helper.freeTransform( tr );
|
|
|
- helper.freeTransform( form );
|
|
|
+ var boneOffsetForm = manager.allocTransform();
|
|
|
+ manager.setIdentity( boneOffsetForm );
|
|
|
+ manager.setOriginFromArray3( boneOffsetForm, params.position );
|
|
|
+ manager.setBasisFromArray3( boneOffsetForm, params.rotation );
|
|
|
|
|
|
- },
|
|
|
+ var vector = manager.allocThreeVector3();
|
|
|
+ var boneForm = manager.allocTransform();
|
|
|
+ manager.setIdentity( boneForm );
|
|
|
+ manager.setOriginFromThreeVector3( boneForm, bone.getWorldPosition( vector ) );
|
|
|
|
|
|
- updateBoneRotation: function () {
|
|
|
+ var form = manager.multiplyTransforms( boneForm, boneOffsetForm );
|
|
|
+ var state = new Ammo.btDefaultMotionState( form );
|
|
|
|
|
|
- var helper = this.helper;
|
|
|
+ var info = new Ammo.btRigidBodyConstructionInfo( weight, state, shape, localInertia );
|
|
|
+ info.set_m_friction( params.friction );
|
|
|
+ info.set_m_restitution( params.restitution );
|
|
|
|
|
|
- var tr = this.getWorldTransformForBone();
|
|
|
- var q = helper.getBasis( tr );
|
|
|
+ var body = new Ammo.btRigidBody( info );
|
|
|
|
|
|
- var thQ = helper.allocThreeQuaternion();
|
|
|
- var thQ2 = helper.allocThreeQuaternion();
|
|
|
- var thQ3 = helper.allocThreeQuaternion();
|
|
|
+ if ( params.type === 0 ) {
|
|
|
|
|
|
- thQ.set( q.x(), q.y(), q.z(), q.w() );
|
|
|
- thQ2.setFromRotationMatrix( this.bone.matrixWorld );
|
|
|
- thQ2.conjugate();
|
|
|
- thQ2.multiply( thQ );
|
|
|
+ body.setCollisionFlags( body.getCollisionFlags() | 2 );
|
|
|
|
|
|
- //this.bone.quaternion.multiply( thQ2 );
|
|
|
+ /*
|
|
|
+ * It'd be better to comment out this line though in general I should call this method
|
|
|
+ * because I'm not sure why but physics will be more like MMD's
|
|
|
+ * if I comment out.
|
|
|
+ */
|
|
|
+ body.setActivationState( 4 );
|
|
|
|
|
|
- thQ3.setFromRotationMatrix( this.bone.matrix );
|
|
|
- this.bone.quaternion.copy( thQ2.multiply( thQ3 ) );
|
|
|
+ }
|
|
|
|
|
|
- helper.freeThreeQuaternion( thQ );
|
|
|
- helper.freeThreeQuaternion( thQ2 );
|
|
|
- helper.freeThreeQuaternion( thQ3 );
|
|
|
+ body.setDamping( params.positionDamping, params.rotationDamping );
|
|
|
+ body.setSleepingThresholds( 0, 0 );
|
|
|
|
|
|
- helper.freeQuaternion( q );
|
|
|
- helper.freeTransform( tr );
|
|
|
+ this.world.addRigidBody( body, 1 << params.groupIndex, params.groupTarget );
|
|
|
|
|
|
- },
|
|
|
+ this.body = body;
|
|
|
+ this.bone = bone;
|
|
|
+ this.boneOffsetForm = boneOffsetForm;
|
|
|
+ this.boneOffsetFormInverse = manager.inverseTransform( boneOffsetForm );
|
|
|
|
|
|
- updateBonePosition: function () {
|
|
|
+ manager.freeVector3( localInertia );
|
|
|
+ manager.freeTransform( form );
|
|
|
+ manager.freeTransform( boneForm );
|
|
|
+ manager.freeThreeVector3( vector );
|
|
|
|
|
|
- var helper = this.helper;
|
|
|
+ },
|
|
|
|
|
|
- var tr = this.getWorldTransformForBone();
|
|
|
+ _getBoneTransform: function () {
|
|
|
|
|
|
- var thV = helper.allocThreeVector3();
|
|
|
+ var manager = this.manager;
|
|
|
+ var p = manager.allocThreeVector3();
|
|
|
+ var q = manager.allocThreeQuaternion();
|
|
|
+ var s = manager.allocThreeVector3();
|
|
|
|
|
|
- var o = helper.getOrigin( tr );
|
|
|
- thV.set( o.x(), o.y(), o.z() );
|
|
|
+ this.bone.matrixWorld.decompose( p, q, s );
|
|
|
|
|
|
- var v = this.bone.worldToLocal( thV );
|
|
|
- this.bone.position.add( v );
|
|
|
+ var tr = manager.allocTransform();
|
|
|
+ manager.setOriginFromThreeVector3( tr, p );
|
|
|
+ manager.setBasisFromThreeQuaternion( tr, q );
|
|
|
|
|
|
- helper.freeThreeVector3( thV );
|
|
|
+ var form = manager.multiplyTransforms( tr, this.boneOffsetForm );
|
|
|
|
|
|
- helper.freeTransform( tr );
|
|
|
+ manager.freeTransform( tr );
|
|
|
+ manager.freeThreeVector3( s );
|
|
|
+ manager.freeThreeQuaternion( q );
|
|
|
+ manager.freeThreeVector3( p );
|
|
|
|
|
|
- }
|
|
|
+ return form;
|
|
|
|
|
|
-};
|
|
|
+ },
|
|
|
|
|
|
-THREE.MMDPhysics.Constraint = function ( mesh, world, bodyA, bodyB, params, helper ) {
|
|
|
+ _getWorldTransformForBone: function () {
|
|
|
|
|
|
- this.mesh = mesh;
|
|
|
- this.world = world;
|
|
|
- this.bodyA = bodyA;
|
|
|
- this.bodyB = bodyB;
|
|
|
- this.params = params;
|
|
|
- this.helper = helper;
|
|
|
+ var manager = this.manager;
|
|
|
|
|
|
- this.constraint = null;
|
|
|
+ var tr = manager.allocTransform();
|
|
|
+ this.body.getMotionState().getWorldTransform( tr );
|
|
|
+ var tr2 = manager.multiplyTransforms( tr, this.boneOffsetFormInverse );
|
|
|
|
|
|
- this.init();
|
|
|
+ manager.freeTransform( tr );
|
|
|
|
|
|
-};
|
|
|
+ return tr2;
|
|
|
|
|
|
-THREE.MMDPhysics.Constraint.prototype = {
|
|
|
+ },
|
|
|
|
|
|
- constructor: THREE.MMDPhysics.Constraint,
|
|
|
+ _setTransformFromBone: function () {
|
|
|
|
|
|
- init: function () {
|
|
|
+ var manager = this.manager;
|
|
|
+ var form = this._getBoneTransform();
|
|
|
|
|
|
- var helper = this.helper;
|
|
|
- var params = this.params;
|
|
|
- var bodyA = this.bodyA;
|
|
|
- var bodyB = this.bodyB;
|
|
|
+ // TODO: check the most appropriate way to set
|
|
|
+ //this.body.setWorldTransform( form );
|
|
|
+ this.body.setCenterOfMassTransform( form );
|
|
|
+ this.body.getMotionState().setWorldTransform( form );
|
|
|
|
|
|
- var form = helper.allocTransform();
|
|
|
- helper.setIdentity( form );
|
|
|
- helper.setOriginFromArray3( form, params.position );
|
|
|
- helper.setBasisFromArray3( form, params.rotation );
|
|
|
+ manager.freeTransform( form );
|
|
|
|
|
|
- var formA = helper.allocTransform();
|
|
|
- var formB = helper.allocTransform();
|
|
|
+ },
|
|
|
|
|
|
- bodyA.body.getMotionState().getWorldTransform( formA );
|
|
|
- bodyB.body.getMotionState().getWorldTransform( formB );
|
|
|
+ _setPositionFromBone: function () {
|
|
|
|
|
|
- var formInverseA = helper.inverseTransform( formA );
|
|
|
- var formInverseB = helper.inverseTransform( formB );
|
|
|
+ var manager = this.manager;
|
|
|
+ var form = this._getBoneTransform();
|
|
|
|
|
|
- var formA2 = helper.multiplyTransforms( formInverseA, form );
|
|
|
- var formB2 = helper.multiplyTransforms( formInverseB, form );
|
|
|
+ var tr = manager.allocTransform();
|
|
|
+ this.body.getMotionState().getWorldTransform( tr );
|
|
|
+ manager.copyOrigin( tr, form );
|
|
|
|
|
|
- var constraint = new Ammo.btGeneric6DofSpringConstraint( bodyA.body, bodyB.body, formA2, formB2, true );
|
|
|
+ // TODO: check the most appropriate way to set
|
|
|
+ //this.body.setWorldTransform( tr );
|
|
|
+ this.body.setCenterOfMassTransform( tr );
|
|
|
+ this.body.getMotionState().setWorldTransform( tr );
|
|
|
|
|
|
- var lll = helper.allocVector3();
|
|
|
- var lul = helper.allocVector3();
|
|
|
- var all = helper.allocVector3();
|
|
|
- var aul = helper.allocVector3();
|
|
|
+ manager.freeTransform( tr );
|
|
|
+ manager.freeTransform( form );
|
|
|
|
|
|
- lll.setValue( params.translationLimitation1[ 0 ],
|
|
|
- params.translationLimitation1[ 1 ],
|
|
|
- params.translationLimitation1[ 2 ] );
|
|
|
- lul.setValue( params.translationLimitation2[ 0 ],
|
|
|
- params.translationLimitation2[ 1 ],
|
|
|
- params.translationLimitation2[ 2 ] );
|
|
|
- all.setValue( params.rotationLimitation1[ 0 ],
|
|
|
- params.rotationLimitation1[ 1 ],
|
|
|
- params.rotationLimitation1[ 2 ] );
|
|
|
- aul.setValue( params.rotationLimitation2[ 0 ],
|
|
|
- params.rotationLimitation2[ 1 ],
|
|
|
- params.rotationLimitation2[ 2 ] );
|
|
|
+ },
|
|
|
|
|
|
- constraint.setLinearLowerLimit( lll );
|
|
|
- constraint.setLinearUpperLimit( lul );
|
|
|
- constraint.setAngularLowerLimit( all );
|
|
|
- constraint.setAngularUpperLimit( aul );
|
|
|
+ _updateBoneRotation: function () {
|
|
|
|
|
|
- for ( var i = 0; i < 3; i++ ) {
|
|
|
+ var manager = this.manager;
|
|
|
|
|
|
- if( params.springPosition[ i ] !== 0 ) {
|
|
|
+ var tr = this._getWorldTransformForBone();
|
|
|
+ var q = manager.getBasis( tr );
|
|
|
|
|
|
- constraint.enableSpring( i, true );
|
|
|
- constraint.setStiffness( i, params.springPosition[ i ] );
|
|
|
+ var thQ = manager.allocThreeQuaternion();
|
|
|
+ var thQ2 = manager.allocThreeQuaternion();
|
|
|
+ var thQ3 = manager.allocThreeQuaternion();
|
|
|
|
|
|
- }
|
|
|
+ thQ.set( q.x(), q.y(), q.z(), q.w() );
|
|
|
+ thQ2.setFromRotationMatrix( this.bone.matrixWorld );
|
|
|
+ thQ2.conjugate();
|
|
|
+ thQ2.multiply( thQ );
|
|
|
|
|
|
- }
|
|
|
+ //this.bone.quaternion.multiply( thQ2 );
|
|
|
|
|
|
- for ( var i = 0; i < 3; i++ ) {
|
|
|
+ thQ3.setFromRotationMatrix( this.bone.matrix );
|
|
|
+ this.bone.quaternion.copy( thQ2.multiply( thQ3 ) );
|
|
|
|
|
|
- if( params.springRotation[ i ] !== 0 ) {
|
|
|
+ manager.freeThreeQuaternion( thQ );
|
|
|
+ manager.freeThreeQuaternion( thQ2 );
|
|
|
+ manager.freeThreeQuaternion( thQ3 );
|
|
|
|
|
|
- constraint.enableSpring( i + 3, true );
|
|
|
- constraint.setStiffness( i + 3, params.springRotation[ i ] );
|
|
|
+ manager.freeQuaternion( q );
|
|
|
+ manager.freeTransform( tr );
|
|
|
|
|
|
- }
|
|
|
+ },
|
|
|
|
|
|
- }
|
|
|
+ _updateBonePosition: function () {
|
|
|
|
|
|
- /*
|
|
|
- * Currently(10/31/2016) official ammo.js doesn't support
|
|
|
- * btGeneric6DofSpringConstraint.setParam method.
|
|
|
- * You need custom ammo.js (add the method into idl) if you wanna use.
|
|
|
- * By setting this parameter, physics will be more like MMD's
|
|
|
- */
|
|
|
- if ( constraint.setParam !== undefined ) {
|
|
|
+ var manager = this.manager;
|
|
|
|
|
|
- for ( var i = 0; i < 6; i ++ ) {
|
|
|
+ var tr = this._getWorldTransformForBone();
|
|
|
|
|
|
- // this parameter is from http://www20.atpages.jp/katwat/three.js_r58/examples/mytest37/mmd.three.js
|
|
|
- constraint.setParam( 2, 0.475, i );
|
|
|
+ var thV = manager.allocThreeVector3();
|
|
|
|
|
|
- }
|
|
|
+ var o = manager.getOrigin( tr );
|
|
|
+ thV.set( o.x(), o.y(), o.z() );
|
|
|
+
|
|
|
+ var v = this.bone.worldToLocal( thV );
|
|
|
+ this.bone.position.add( v );
|
|
|
+
|
|
|
+ manager.freeThreeVector3( thV );
|
|
|
+
|
|
|
+ manager.freeTransform( tr );
|
|
|
|
|
|
}
|
|
|
|
|
|
- this.world.addConstraint( constraint, true );
|
|
|
- this.constraint = constraint;
|
|
|
-
|
|
|
- helper.freeTransform( form );
|
|
|
- helper.freeTransform( formA );
|
|
|
- helper.freeTransform( formB );
|
|
|
- helper.freeTransform( formInverseA );
|
|
|
- helper.freeTransform( formInverseB );
|
|
|
- helper.freeTransform( formA2 );
|
|
|
- helper.freeTransform( formB2 );
|
|
|
- helper.freeVector3( lll );
|
|
|
- helper.freeVector3( lul );
|
|
|
- helper.freeVector3( all );
|
|
|
- helper.freeVector3( aul );
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @param {THREE.SkinnedMesh} mesh
|
|
|
+ * @param {Ammo.btDiscreteDynamicsWorld} world
|
|
|
+ * @param {RigidBody} bodyA
|
|
|
+ * @param {RigidBody} bodyB
|
|
|
+ * @param {Object} params
|
|
|
+ * @param {ResourceManager} manager
|
|
|
+ */
|
|
|
+ function Constraint( mesh, world, bodyA, bodyB, params, manager ) {
|
|
|
+
|
|
|
+ this.mesh = mesh;
|
|
|
+ this.world = world;
|
|
|
+ this.bodyA = bodyA;
|
|
|
+ this.bodyB = bodyB;
|
|
|
+ this.params = params;
|
|
|
+ this.manager = manager;
|
|
|
+
|
|
|
+ this.constraint = null;
|
|
|
+
|
|
|
+ this._init();
|
|
|
|
|
|
}
|
|
|
|
|
|
-};
|
|
|
+ Constraint.prototype = {
|
|
|
|
|
|
+ constructor: Constraint,
|
|
|
|
|
|
-THREE.MMDPhysicsHelper = function ( mesh, physics ) {
|
|
|
+ // private method
|
|
|
|
|
|
- if ( mesh.geometry.rigidBodies === undefined ) {
|
|
|
+ _init: function () {
|
|
|
|
|
|
- throw new Error( 'THREE.MMDPhysicsHelper requires rigidBodies in mesh.geometry.' );
|
|
|
+ var manager = this.manager;
|
|
|
+ var params = this.params;
|
|
|
+ var bodyA = this.bodyA;
|
|
|
+ var bodyB = this.bodyB;
|
|
|
|
|
|
- }
|
|
|
+ var form = manager.allocTransform();
|
|
|
+ manager.setIdentity( form );
|
|
|
+ manager.setOriginFromArray3( form, params.position );
|
|
|
+ manager.setBasisFromArray3( form, params.rotation );
|
|
|
|
|
|
- THREE.Object3D.call( this );
|
|
|
+ var formA = manager.allocTransform();
|
|
|
+ var formB = manager.allocTransform();
|
|
|
|
|
|
- this.root = mesh;
|
|
|
- this.physics = physics;
|
|
|
+ bodyA.body.getMotionState().getWorldTransform( formA );
|
|
|
+ bodyB.body.getMotionState().getWorldTransform( formB );
|
|
|
|
|
|
- this.matrix = mesh.matrixWorld;
|
|
|
- this.matrixAutoUpdate = false;
|
|
|
+ var formInverseA = manager.inverseTransform( formA );
|
|
|
+ var formInverseB = manager.inverseTransform( formB );
|
|
|
|
|
|
- this.materials = [];
|
|
|
+ var formA2 = manager.multiplyTransforms( formInverseA, form );
|
|
|
+ var formB2 = manager.multiplyTransforms( formInverseB, form );
|
|
|
|
|
|
- this.materials.push(
|
|
|
- new THREE.MeshBasicMaterial( {
|
|
|
- color: new THREE.Color( 0xff8888 ),
|
|
|
- wireframe: true,
|
|
|
- depthTest: false,
|
|
|
- depthWrite: false,
|
|
|
- opacity: 0.25,
|
|
|
- transparent: true
|
|
|
- } )
|
|
|
- );
|
|
|
+ var constraint = new Ammo.btGeneric6DofSpringConstraint( bodyA.body, bodyB.body, formA2, formB2, true );
|
|
|
|
|
|
- this.materials.push(
|
|
|
- new THREE.MeshBasicMaterial( {
|
|
|
- color: new THREE.Color( 0x88ff88 ),
|
|
|
- wireframe: true,
|
|
|
- depthTest: false,
|
|
|
- depthWrite: false,
|
|
|
- opacity: 0.25,
|
|
|
- transparent: true
|
|
|
- } )
|
|
|
- );
|
|
|
+ var lll = manager.allocVector3();
|
|
|
+ var lul = manager.allocVector3();
|
|
|
+ var all = manager.allocVector3();
|
|
|
+ var aul = manager.allocVector3();
|
|
|
|
|
|
- this.materials.push(
|
|
|
- new THREE.MeshBasicMaterial( {
|
|
|
- color: new THREE.Color( 0x8888ff ),
|
|
|
- wireframe: true,
|
|
|
- depthTest: false,
|
|
|
- depthWrite: false,
|
|
|
- opacity: 0.25,
|
|
|
- transparent: true
|
|
|
- } )
|
|
|
- );
|
|
|
+ lll.setValue( params.translationLimitation1[ 0 ],
|
|
|
+ params.translationLimitation1[ 1 ],
|
|
|
+ params.translationLimitation1[ 2 ] );
|
|
|
+ lul.setValue( params.translationLimitation2[ 0 ],
|
|
|
+ params.translationLimitation2[ 1 ],
|
|
|
+ params.translationLimitation2[ 2 ] );
|
|
|
+ all.setValue( params.rotationLimitation1[ 0 ],
|
|
|
+ params.rotationLimitation1[ 1 ],
|
|
|
+ params.rotationLimitation1[ 2 ] );
|
|
|
+ aul.setValue( params.rotationLimitation2[ 0 ],
|
|
|
+ params.rotationLimitation2[ 1 ],
|
|
|
+ params.rotationLimitation2[ 2 ] );
|
|
|
|
|
|
- this._init();
|
|
|
- this.update();
|
|
|
+ constraint.setLinearLowerLimit( lll );
|
|
|
+ constraint.setLinearUpperLimit( lul );
|
|
|
+ constraint.setAngularLowerLimit( all );
|
|
|
+ constraint.setAngularUpperLimit( aul );
|
|
|
|
|
|
-};
|
|
|
+ for ( var i = 0; i < 3; i++ ) {
|
|
|
|
|
|
-THREE.MMDPhysicsHelper.prototype = Object.create( THREE.Object3D.prototype );
|
|
|
-THREE.MMDPhysicsHelper.prototype.constructor = THREE.MMDPhysicsHelper;
|
|
|
+ if( params.springPosition[ i ] !== 0 ) {
|
|
|
|
|
|
-THREE.MMDPhysicsHelper.prototype._init = function () {
|
|
|
+ constraint.enableSpring( i, true );
|
|
|
+ constraint.setStiffness( i, params.springPosition[ i ] );
|
|
|
|
|
|
- var mesh = this.root;
|
|
|
- var rigidBodies = mesh.geometry.rigidBodies;
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ for ( var i = 0; i < 3; i++ ) {
|
|
|
+
|
|
|
+ if( params.springRotation[ i ] !== 0 ) {
|
|
|
+
|
|
|
+ constraint.enableSpring( i + 3, true );
|
|
|
+ constraint.setStiffness( i + 3, params.springRotation[ i ] );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
|
|
|
- function createGeometry( param ) {
|
|
|
+ /*
|
|
|
+ * Currently(10/31/2016) official ammo.js doesn't support
|
|
|
+ * btGeneric6DofSpringConstraint.setParam method.
|
|
|
+ * You need custom ammo.js (add the method into idl) if you wanna use.
|
|
|
+ * By setting this parameter, physics will be more like MMD's
|
|
|
+ */
|
|
|
+ if ( constraint.setParam !== undefined ) {
|
|
|
|
|
|
- switch ( param.shapeType ) {
|
|
|
+ for ( var i = 0; i < 6; i ++ ) {
|
|
|
|
|
|
- case 0:
|
|
|
- return new THREE.SphereBufferGeometry( param.width, 16, 8 );
|
|
|
+ // this parameter is from http://www20.atpages.jp/katwat/three.js_r58/examples/mytest37/mmd.three.js
|
|
|
+ constraint.setParam( 2, 0.475, i );
|
|
|
|
|
|
- case 1:
|
|
|
- return new THREE.BoxBufferGeometry( param.width * 2, param.height * 2, param.depth * 2, 8, 8, 8 );
|
|
|
+ }
|
|
|
|
|
|
- case 2:
|
|
|
- return new createCapsuleGeometry( param.width, param.height, 16, 8 );
|
|
|
+ }
|
|
|
|
|
|
- default:
|
|
|
- return null;
|
|
|
+ this.world.addConstraint( constraint, true );
|
|
|
+ this.constraint = constraint;
|
|
|
+
|
|
|
+ manager.freeTransform( form );
|
|
|
+ manager.freeTransform( formA );
|
|
|
+ manager.freeTransform( formB );
|
|
|
+ manager.freeTransform( formInverseA );
|
|
|
+ manager.freeTransform( formInverseB );
|
|
|
+ manager.freeTransform( formA2 );
|
|
|
+ manager.freeTransform( formB2 );
|
|
|
+ manager.freeVector3( lll );
|
|
|
+ manager.freeVector3( lul );
|
|
|
+ manager.freeVector3( all );
|
|
|
+ manager.freeVector3( aul );
|
|
|
|
|
|
}
|
|
|
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Visualize Rigid bodies
|
|
|
+ *
|
|
|
+ * @param {THREE.SkinnedMesh} mesh
|
|
|
+ * @param {THREE.Physics} physics
|
|
|
+ */
|
|
|
+ function MMDPhysicsHelper( mesh, physics ) {
|
|
|
+
|
|
|
+ THREE.Object3D.call( this );
|
|
|
+
|
|
|
+ this.root = mesh;
|
|
|
+ this.physics = physics;
|
|
|
+
|
|
|
+ this.matrix.copy( mesh.matrixWorld );
|
|
|
+ this.matrixAutoUpdate = false;
|
|
|
+
|
|
|
+ this.materials = [];
|
|
|
+
|
|
|
+ this.materials.push(
|
|
|
+ new THREE.MeshBasicMaterial( {
|
|
|
+ color: new THREE.Color( 0xff8888 ),
|
|
|
+ wireframe: true,
|
|
|
+ depthTest: false,
|
|
|
+ depthWrite: false,
|
|
|
+ opacity: 0.25,
|
|
|
+ transparent: true
|
|
|
+ } )
|
|
|
+ );
|
|
|
+
|
|
|
+ this.materials.push(
|
|
|
+ new THREE.MeshBasicMaterial( {
|
|
|
+ color: new THREE.Color( 0x88ff88 ),
|
|
|
+ wireframe: true,
|
|
|
+ depthTest: false,
|
|
|
+ depthWrite: false,
|
|
|
+ opacity: 0.25,
|
|
|
+ transparent: true
|
|
|
+ } )
|
|
|
+ );
|
|
|
+
|
|
|
+ this.materials.push(
|
|
|
+ new THREE.MeshBasicMaterial( {
|
|
|
+ color: new THREE.Color( 0x8888ff ),
|
|
|
+ wireframe: true,
|
|
|
+ depthTest: false,
|
|
|
+ depthWrite: false,
|
|
|
+ opacity: 0.25,
|
|
|
+ transparent: true
|
|
|
+ } )
|
|
|
+ );
|
|
|
+
|
|
|
+ this._init();
|
|
|
+
|
|
|
}
|
|
|
|
|
|
- // copy from http://www20.atpages.jp/katwat/three.js_r58/examples/mytest37/mytest37.js?ver=20160815
|
|
|
- function createCapsuleGeometry( radius, cylinderHeight, segmentsRadius, segmentsHeight ) {
|
|
|
+ MMDPhysicsHelper.prototype = Object.assign( Object.create( THREE.Object3D.prototype ), {
|
|
|
|
|
|
- var geometry = new THREE.CylinderBufferGeometry( radius, radius, cylinderHeight, segmentsRadius, segmentsHeight, true );
|
|
|
- var upperSphere = new THREE.Mesh( new THREE.SphereBufferGeometry( radius, segmentsRadius, segmentsHeight, 0, Math.PI * 2, 0, Math.PI / 2 ) );
|
|
|
- var lowerSphere = new THREE.Mesh( new THREE.SphereBufferGeometry( radius, segmentsRadius, segmentsHeight, 0, Math.PI * 2, Math.PI / 2, Math.PI / 2 ) );
|
|
|
+ constructor: MMDPhysicsHelper,
|
|
|
|
|
|
- upperSphere.position.set( 0, cylinderHeight / 2, 0 );
|
|
|
- lowerSphere.position.set( 0, -cylinderHeight / 2, 0 );
|
|
|
+ /**
|
|
|
+ * Updates Rigid Bodies visualization.
|
|
|
+ */
|
|
|
+ updateMatrixWorld: function () {
|
|
|
|
|
|
- upperSphere.updateMatrix();
|
|
|
- lowerSphere.updateMatrix();
|
|
|
+ var position = new THREE.Vector3();
|
|
|
+ var quaternion = new THREE.Quaternion();
|
|
|
+ var scale = new THREE.Vector3();
|
|
|
+ var matrixWorldInv = new THREE.Matrix4();
|
|
|
|
|
|
- geometry.merge( upperSphere.geometry, upperSphere.matrix );
|
|
|
- geometry.merge( lowerSphere.geometry, lowerSphere.matrix );
|
|
|
+ return function updateMatrixWorld( force ) {
|
|
|
|
|
|
- return geometry;
|
|
|
+ var mesh = this.root;
|
|
|
|
|
|
- }
|
|
|
+ if ( this.visible ) {
|
|
|
|
|
|
- for ( var i = 0, il = rigidBodies.length; i < il; i ++ ) {
|
|
|
+ var bodies = this.physics.bodies;
|
|
|
|
|
|
- var param = rigidBodies[ i ];
|
|
|
- this.add( new THREE.Mesh( createGeometry( param ), this.materials[ param.type ] ) );
|
|
|
+ matrixWorldInv
|
|
|
+ .copy( mesh.matrixWorld )
|
|
|
+ .decompose( position, quaternion, scale )
|
|
|
+ .compose( position, quaternion, scale.set( 1, 1, 1 ) )
|
|
|
+ .getInverse( matrixWorldInv );
|
|
|
|
|
|
- }
|
|
|
+ for ( var i = 0, il = bodies.length; i < il; i ++ ) {
|
|
|
|
|
|
-};
|
|
|
+ var body = bodies[ i ].body;
|
|
|
+ var child = this.children[ i ];
|
|
|
|
|
|
-THREE.MMDPhysicsHelper.prototype.update = function () {
|
|
|
+ var tr = body.getCenterOfMassTransform();
|
|
|
+ var origin = tr.getOrigin();
|
|
|
+ var rotation = tr.getRotation();
|
|
|
|
|
|
- var mesh = this.root;
|
|
|
- var rigidBodies = mesh.geometry.rigidBodies;
|
|
|
- var bodies = this.physics.bodies;
|
|
|
+ child.position
|
|
|
+ .set( origin.x(), origin.y(), origin.z() )
|
|
|
+ .applyMatrix4( matrixWorldInv );
|
|
|
|
|
|
- var matrixWorldInv = new THREE.Matrix4().getInverse( mesh.matrixWorld );
|
|
|
- var vector = new THREE.Vector3();
|
|
|
- var quaternion = new THREE.Quaternion();
|
|
|
- var quaternion2 = new THREE.Quaternion();
|
|
|
+ child.quaternion
|
|
|
+ .setFromRotationMatrix( matrixWorldInv )
|
|
|
+ .multiply(
|
|
|
+ quaternion.set(
|
|
|
+ rotation.x(), rotation.y(), rotation.z(), rotation.w() )
|
|
|
+ );
|
|
|
|
|
|
- function getPosition( origin ) {
|
|
|
+ }
|
|
|
|
|
|
- vector.set( origin.x(), origin.y(), origin.z() );
|
|
|
- vector.applyMatrix4( matrixWorldInv );
|
|
|
+ }
|
|
|
|
|
|
- return vector;
|
|
|
+ this.matrix
|
|
|
+ .copy( mesh.matrixWorld )
|
|
|
+ .decompose( position, quaternion, scale )
|
|
|
+ .compose( position, quaternion, scale.set( 1, 1, 1 ) );
|
|
|
|
|
|
- }
|
|
|
+ THREE.Object3D.prototype.updateMatrixWorld.call( this, force );
|
|
|
|
|
|
- function getQuaternion( rotation ) {
|
|
|
+ };
|
|
|
|
|
|
- quaternion.set( rotation.x(), rotation.y(), rotation.z(), rotation.w() );
|
|
|
- quaternion2.setFromRotationMatrix( matrixWorldInv );
|
|
|
- quaternion2.multiply( quaternion );
|
|
|
+ }(),
|
|
|
|
|
|
- return quaternion2;
|
|
|
+ // private method
|
|
|
|
|
|
- }
|
|
|
+ _init: function () {
|
|
|
|
|
|
- for ( var i = 0, il = rigidBodies.length; i < il; i ++ ) {
|
|
|
+ var mesh = this.root;
|
|
|
+ var bodies = this.physics.bodies;
|
|
|
|
|
|
- var body = bodies[ i ].body;
|
|
|
- var mesh = this.children[ i ];
|
|
|
+ function createGeometry( param ) {
|
|
|
|
|
|
- var tr = body.getCenterOfMassTransform();
|
|
|
+ switch ( param.shapeType ) {
|
|
|
|
|
|
- mesh.position.copy( getPosition( tr.getOrigin() ) );
|
|
|
- mesh.quaternion.copy( getQuaternion( tr.getRotation() ) );
|
|
|
+ case 0:
|
|
|
+ return new THREE.SphereBufferGeometry( param.width, 16, 8 );
|
|
|
|
|
|
- }
|
|
|
+ case 1:
|
|
|
+ return new THREE.BoxBufferGeometry( param.width * 2, param.height * 2, param.depth * 2, 8, 8, 8 );
|
|
|
+
|
|
|
+ case 2:
|
|
|
+ return new createCapsuleGeometry( param.width, param.height, 16, 8 );
|
|
|
+
|
|
|
+ default:
|
|
|
+ return null;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ // copy from http://www20.atpages.jp/katwat/three.js_r58/examples/mytest37/mytest37.js?ver=20160815
|
|
|
+ function createCapsuleGeometry( radius, cylinderHeight, segmentsRadius, segmentsHeight ) {
|
|
|
+
|
|
|
+ var geometry = new THREE.CylinderBufferGeometry( radius, radius, cylinderHeight, segmentsRadius, segmentsHeight, true );
|
|
|
+ var upperSphere = new THREE.Mesh( new THREE.SphereBufferGeometry( radius, segmentsRadius, segmentsHeight, 0, Math.PI * 2, 0, Math.PI / 2 ) );
|
|
|
+ var lowerSphere = new THREE.Mesh( new THREE.SphereBufferGeometry( radius, segmentsRadius, segmentsHeight, 0, Math.PI * 2, Math.PI / 2, Math.PI / 2 ) );
|
|
|
+
|
|
|
+ upperSphere.position.set( 0, cylinderHeight / 2, 0 );
|
|
|
+ lowerSphere.position.set( 0, - cylinderHeight / 2, 0 );
|
|
|
+
|
|
|
+ upperSphere.updateMatrix();
|
|
|
+ lowerSphere.updateMatrix();
|
|
|
+
|
|
|
+ geometry.merge( upperSphere.geometry, upperSphere.matrix );
|
|
|
+ geometry.merge( lowerSphere.geometry, lowerSphere.matrix );
|
|
|
+
|
|
|
+ return geometry;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ for ( var i = 0, il = bodies.length; i < il; i ++ ) {
|
|
|
+
|
|
|
+ var param = bodies[ i ].params;
|
|
|
+ this.add( new THREE.Mesh( createGeometry( param ), this.materials[ param.type ] ) );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ } );
|
|
|
+
|
|
|
+ return MMDPhysics;
|
|
|
|
|
|
-};
|
|
|
+} )();
|
Mr.doob