/**

* from OimoPhysics DEV 1.1.0a AS3

* @author Saharan / http://el-ement.com/

*

* to Oimo.js 2015 JAVASCRIPT

* @author LoTh / http://lo-th.github.io/labs/

*/

var OIMO = {

REVISION: "1.2",

// Global identification of next shape.

// This will be incremented every time a shape is created.

nextID: 0,

proxyID: 0,

// BroadPhase

BR_NULL: 0,

BR_BRUTE_FORCE: 1,

BR_SWEEP_AND_PRUNE: 2,

BR_BOUNDING_VOLUME_TREE: 3,

// body type

BODY_NULL: 0,

BODY_DYNAMIC: 1,

BODY_STATIC: 2,

// shape type

SHAPE_NULL: 0,

SHAPE_SPHERE: 1,

SHAPE_BOX: 2,

SHAPE_CYLINDER: 3,

SHAPE_TETRA: 4,

// joint type

JOINT_NULL: 0,

JOINT_DISTANCE: 1,

JOINT_BALL_AND_SOCKET: 2,

JOINT_HINGE: 3,

JOINT_WHEEL: 4,

JOINT_SLIDER: 5,

JOINT_PRISMATIC: 6,

// this world scale defaut is 0.1 to 10 meters max for dynamique body

// scale all by 100 so object is between 10 to 10000 three unit.

WORLD_SCALE: 100,

INV_SCALE: 0.01,

// AABB aproximation

AABB_PROX: 0.005,

// Math function

sqrt: Math.sqrt,

abs: Math.abs,

floor: Math.floor,

cos: Math.cos,

sin: Math.sin,

acos: Math.acos,

asin: Math.asin,

atan2: Math.atan2,

round: Math.round,

pow: Math.pow,

max: Math.max,

min: Math.min,

random: Math.random,

lerp: function (a, b, percent) { return a + (b - a) * percent; },

rand: function (a, b) { return OIMO.lerp(a, b, OIMO.random()); },

randInt: function (a, b, n) { return OIMO.lerp(a, b, OIMO.random()).toFixed(n || 0) * 1; },

int: function (x) { return ~~x; },

fix: function (x, n) { return x.toFixed(n || 3, 10); },

clamp: function (value, min, max) { return OIMO.max(min, OIMO.min(max, value)); },

degtorad: 0.0174532925199432957,

radtodeg: 57.295779513082320876,

PI: 3.141592653589793,

TwoPI: 6.283185307179586,

PI90: 1.570796326794896,

PI270: 4.712388980384689,

CustomError: null,

Error: function (Class, Msg) {

if (OIMO.CustomError == null) console.error(Class, Msg);

else OIMO.CustomError.innerHTML += Class + " - " + Msg + '<br>';

}

};

var OIMO_ARRAY_TYPE;

if (!OIMO_ARRAY_TYPE) { OIMO_ARRAY_TYPE = typeof Float32Array !== 'undefined' ? Float32Array : Array; }

try {

(function (w) {

var perfNow;

var perfNowNames = ['now', 'webkitNow', 'msNow', 'mozNow'];

if (!!w['performance']) for (var i = 0; i < perfNowNames.length; ++i) {

var n = perfNowNames[i];

if (!!w['performance'][n]) {

perfNow = function () { return w['performance'][n]() };

break;

}

}

if (!perfNow) perfNow = Date.now;

//w.perfNow = perfNow;

OIMO.now = perfNow;

})(window);

} catch (e) { OIMO.now = function () { return 0; }; }

/**

* The class of physical computing world.

* You must be added to the world physical all computing objects

* @author saharan

* @author lo-th

*/

OIMO.World = function (TimeStep, BroadPhaseType, Iterations, NoStat) {

// The time between each step

this.timeStep = TimeStep || 0.01666; // 1/60;

// The number of iterations for constraint solvers.

this.numIterations = Iterations || 8;

// It is a wide-area collision judgment that is used in order to reduce as much as possible a detailed collision judgment.

switch (BroadPhaseType || 2) {

case 1: this.broadPhase = new OIMO.BruteForceBroadPhase(); break;

case 2: default: this.broadPhase = new OIMO.SAPBroadPhase(); break;

case 3: this.broadPhase = new OIMO.DBVTBroadPhase(); break;

}

// This is the detailed information of the performance.

this.performance = null;

this.isNoStat = NoStat || false;

if (!this.isNoStat) this.performance = new OIMO.Performance(this);

// Whether the constraints randomizer is enabled or not.

this.enableRandomizer = true;

// The rigid body list

this.rigidBodies = null;

// number of rigid body

this.numRigidBodies = 0;

// The contact list

this.contacts = null;

this.unusedContacts = null;

// The number of contact

this.numContacts = 0;

// The number of contact points

this.numContactPoints = 0;

// The joint list

this.joints = null;

// The number of joints.

this.numJoints = 0;

// The number of simulation islands.

this.numIslands = 0;

// The gravity in the world.

this.gravity = new OIMO.Vec3(0, -9.80665, 0);

var numShapeTypes = 5;//4;//3;

this.detectors = [];

this.detectors.length = numShapeTypes;

var i = numShapeTypes;

while (i--) {

this.detectors[i] = [];

this.detectors[i].length = numShapeTypes;

}

this.detectors[OIMO.SHAPE_SPHERE][OIMO.SHAPE_SPHERE] = new OIMO.SphereSphereCollisionDetector();

this.detectors[OIMO.SHAPE_SPHERE][OIMO.SHAPE_BOX] = new OIMO.SphereBoxCollisionDetector(false);

this.detectors[OIMO.SHAPE_BOX][OIMO.SHAPE_SPHERE] = new OIMO.SphereBoxCollisionDetector(true);

this.detectors[OIMO.SHAPE_BOX][OIMO.SHAPE_BOX] = new OIMO.BoxBoxCollisionDetector();

// CYLINDER add

this.detectors[OIMO.SHAPE_CYLINDER][OIMO.SHAPE_CYLINDER] = new OIMO.CylinderCylinderCollisionDetector();

this.detectors[OIMO.SHAPE_CYLINDER][OIMO.SHAPE_BOX] = new OIMO.BoxCylinderCollisionDetector(true);

this.detectors[OIMO.SHAPE_BOX][OIMO.SHAPE_CYLINDER] = new OIMO.BoxCylinderCollisionDetector(false);

this.detectors[OIMO.SHAPE_CYLINDER][OIMO.SHAPE_SPHERE] = new OIMO.SphereCylinderCollisionDetector(true);

this.detectors[OIMO.SHAPE_SPHERE][OIMO.SHAPE_CYLINDER] = new OIMO.SphereCylinderCollisionDetector(false);

// TETRA add

this.detectors[OIMO.SHAPE_TETRA][OIMO.SHAPE_TETRA] = new OIMO.TetraTetraCollisionDetector();

this.randX = 65535;

this.randA = 98765;

this.randB = 123456789;

//this.maxIslandRigidBodies = 64;

this.islandRigidBodies = [];

//this.islandRigidBodies.length = this.maxIslandRigidBodies;

this.islandStack = [];

//this.islandStack.length = this.maxIslandRigidBodies;

//this.maxIslandConstraints = 128;

this.islandConstraints = [];

//this.islandConstraints.length = this.maxIslandConstraints;

};

OIMO.World.prototype = {

constructor: OIMO.World,

/**

* Reset the randomizer and remove all rigid bodies, shapes, joints and any object from the world.

*/

clear: function () {

this.randX = 65535;

while (this.joints !== null) {

this.removeJoint(this.joints);

}

while (this.contacts !== null) {

this.removeContact(this.contacts);

}

while (this.rigidBodies !== null) {

this.removeRigidBody(this.rigidBodies);

}

OIMO.nextID = 0;

OIMO.proxyID = 0;

},

/**

* I'll add a rigid body to the world.

* Rigid body that has been added will be the operands of each step.

* @param rigidBody Rigid body that you want to add

*/

addRigidBody: function (rigidBody) {

if (rigidBody.parent) {

OIMO.Error("World", "It is not possible to be added to more than one world one of the rigid body");

}

rigidBody.parent = this;

rigidBody.awake();

for (var shape = rigidBody.shapes; shape !== null; shape = shape.next) {

this.addShape(shape);

}

if (this.rigidBodies !== null) (this.rigidBodies.prev = rigidBody).next = this.rigidBodies;

this.rigidBodies = rigidBody;

this.numRigidBodies++;

},

/**

* I will remove the rigid body from the world.

* Rigid body that has been deleted is excluded from the calculation on a step-by-step basis.

* @param rigidBody Rigid body to be removed

*/

removeRigidBody: function (rigidBody) {

var remove = rigidBody;

if (remove.parent !== this) return;

remove.awake();

var js = remove.jointLink;

while (js != null) {

var joint = js.joint;

js = js.next;

this.removeJoint(joint);

}

for (var shape = rigidBody.shapes; shape !== null; shape = shape.next) {

this.removeShape(shape);

}

var prev = remove.prev;

var next = remove.next;

if (prev !== null) prev.next = next;

if (next !== null) next.prev = prev;

if (this.rigidBodies == remove) this.rigidBodies = next;

remove.prev = null;

remove.next = null;

remove.parent = null;

this.numRigidBodies--;

},

getByName: function (name) {

var result = null;

var body = this.rigidBodies;

while (body !== null) {

if (body.name !== " " && body.name === name) result = body;

body = body.next;

}

var joint = this.joints;

while (joint !== null) {

if (joint.name !== "" && joint.name === name) result = joint;

joint = joint.next;

}

return result;

},

/**

* I'll add a shape to the world..

* Add to the rigid world, and if you add a shape to a rigid body that has been added to the world,

* Shape will be added to the world automatically, please do not call from outside this method.

* @param shape Shape you want to add

*/

addShape: function (shape) {

if (!shape.parent || !shape.parent.parent) {

OIMO.Error("World", "It is not possible to be added alone to shape world");

}

shape.proxy = this.broadPhase.createProxy(shape);

shape.updateProxy();

this.broadPhase.addProxy(shape.proxy);

},

/**

* I will remove the shape from the world.

* Add to the rigid world, and if you add a shape to a rigid body that has been added to the world,

* Shape will be added to the world automatically, please do not call from outside this method.

* @param shape Shape you want to delete

*/

removeShape: function (shape) {

this.broadPhase.removeProxy(shape.proxy);

shape.proxy = null;

},

/**

* I'll add a joint to the world.

* Joint that has been added will be the operands of each step.

* @param shape Joint to be added

*/

addJoint: function (joint) {

if (joint.parent) {

OIMO.Error("World", "It is not possible to be added to more than one world one of the joint");

}

if (this.joints != null) (this.joints.prev = joint).next = this.joints;

this.joints = joint;

joint.parent = this;

this.numJoints++;

joint.awake();

joint.attach();

},

/**

* I will remove the joint from the world.

* Joint that has been added will be the operands of each step.

* @param shape Joint to be deleted

*/

removeJoint: function (joint) {

var remove = joint;

var prev = remove.prev;

var next = remove.next;

if (prev !== null) prev.next = next;

if (next !== null) next.prev = prev;

if (this.joints == remove) this.joints = next;

remove.prev = null;

remove.next = null;

this.numJoints--;

remove.awake();

remove.detach();

remove.parent = null;

},

worldscale: function (scale) {

OIMO.WORLD_SCALE = scale || 100;

OIMO.INV_SCALE = 1 / OIMO.WORLD_SCALE;

},

addContact: function (s1, s2) {

var newContact;

if (this.unusedContacts !== null) {

newContact = this.unusedContacts;

this.unusedContacts = this.unusedContacts.next;

} else {

newContact = new OIMO.Contact();

}

newContact.attach(s1, s2);

newContact.detector = this.detectors[s1.type][s2.type];

if (this.contacts) (this.contacts.prev = newContact).next = this.contacts;

this.contacts = newContact;

this.numContacts++;

},

removeContact: function (contact) {

var prev = contact.prev;

var next = contact.next;

if (next) next.prev = prev;

if (prev) prev.next = next;

if (this.contacts == contact) this.contacts = next;

contact.prev = null;

contact.next = null;

contact.detach();

contact.next = this.unusedContacts;

this.unusedContacts = contact;

this.numContacts--;

},

checkContact: function (name1, name2) {

var n1, n2;

var contact = this.contacts;

while (contact !== null) {

n1 = contact.body1.name || ' ';

n2 = contact.body2.name || ' ';

if ((n1 == name1 && n2 == name2) || (n2 == name1 && n1 == name2)) { if (contact.touching) return true; else return false; }

else contact = contact.next;

}

return false;

},

callSleep: function (body) {

if (!body.allowSleep) return false;

if (body.linearVelocity.lengthSq() > 0.04) return false;

if (body.angularVelocity.lengthSq() > 0.25) return false;

return true;

},

/**

* I will proceed only time step seconds time of World.

*/

step: function () {

var time0, time1, time2, time3;

var stat = !this.isNoStat ? true : false;

if (stat) time0 = OIMO.now();

var body = this.rigidBodies;

while (body !== null) {

body.addedToIsland = false;

if (body.sleeping) {

if (

body.linearVelocity.testZero() ||

body.angularVelocity.testZero() ||

body.position.testDiff(body.sleepPosition) ||

body.orientation.testDiff(body.sleepOrientation)

) body.awake(); // awake the body

}

body = body.next;

}

//------------------------------------------------------

// UPDATE CONTACT

//------------------------------------------------------

// broad phase

if (stat) time1 = OIMO.now();

this.broadPhase.detectPairs();

var pairs = this.broadPhase.pairs;

var i = this.broadPhase.numPairs;

//do{

while (i--) {

//for(var i=0, l=numPairs; i<l; i++){

var pair = pairs[i];

var s1;

var s2;

if (pair.shape1.id < pair.shape2.id) {

s1 = pair.shape1;

s2 = pair.shape2;

} else {

s1 = pair.shape2;

s2 = pair.shape1;

}

var link;

if (s1.numContacts < s2.numContacts) link = s1.contactLink;

else link = s2.contactLink;

var exists = false;

while (link) {

var contact = link.contact;

if (contact.shape1 == s1 && contact.shape2 == s2) {

contact.persisting = true;

exists = true;// contact already exists

break;

}

link = link.next;

}

if (!exists) {

this.addContact(s1, s2);

}

}// while(i-- >0);

if (stat) {

time2 = OIMO.now();

this.performance.broadPhaseTime = time2 - time1;

}

// update & narrow phase

this.numContactPoints = 0;

contact = this.contacts;

while (contact !== null) {

if (!contact.persisting) {

if (contact.shape1.aabb.intersectTest(contact.shape2.aabb)) {

/*var aabb1=contact.shape1.aabb;

var aabb2=contact.shape2.aabb;

if(

aabb1.minX>aabb2.maxX || aabb1.maxX<aabb2.minX ||

aabb1.minY>aabb2.maxY || aabb1.maxY<aabb2.minY ||

aabb1.minZ>aabb2.maxZ || aabb1.maxZ<aabb2.minZ

){*/

var next = contact.next;

this.removeContact(contact);

contact = next;

continue;

}

}

var b1 = contact.body1;

var b2 = contact.body2;

if (b1.isDynamic && !b1.sleeping || b2.isDynamic && !b2.sleeping) {

contact.updateManifold();

}

this.numContactPoints += contact.manifold.numPoints;

contact.persisting = false;

contact.constraint.addedToIsland = false;

contact = contact.next;

}

if (stat) {

time3 = OIMO.now();

this.performance.narrowPhaseTime = time3 - time2;

}

//------------------------------------------------------

// SOLVE ISLANDS

//------------------------------------------------------

var invTimeStep = 1 / this.timeStep;

//var body;

var joint;

var constraint;

//var num;

for (joint = this.joints; joint !== null; joint = joint.next) {

joint.addedToIsland = false;

}

// clear old island array

this.islandRigidBodies = [];

this.islandConstraints = [];

this.islandStack = [];

// expand island buffers

/*if(this.maxIslandRigidBodies<this.numRigidBodies){

this.maxIslandRigidBodies=this.numRigidBodies<<1;

//this.maxIslandRigidBodies=this.numRigidBodies*2;

this.islandRigidBodies=[];

this.islandStack=[];

this.islandRigidBodies.length = this.maxIslandRigidBodies;

this.islandStack.length = this.maxIslandRigidBodies;

}

var numConstraints=this.numJoints+this.numContacts;

if(this.maxIslandConstraints<numConstraints){

this.maxIslandConstraints=numConstraints<<1;

//this.maxIslandConstraints=numConstraints*2;

this.islandConstraints=[];

this.islandConstraints.length = this.maxIslandConstraints;

}*/

time1 = OIMO.now();

this.numIslands = 0;

// build and solve simulation islands

for (var base = this.rigidBodies; base !== null; base = base.next) {

if (base.addedToIsland || base.isStatic || base.sleeping) continue;// ignore

if (base.isLonely()) {// update single body

if (base.isDynamic) {

base.linearVelocity.addTime(this.gravity, this.timeStep);

/*base.linearVelocity.x+=this.gravity.x*this.timeStep;

base.linearVelocity.y+=this.gravity.y*this.timeStep;

base.linearVelocity.z+=this.gravity.z*this.timeStep;*/

}

if (this.callSleep(base)) {

base.sleepTime += this.timeStep;

if (base.sleepTime > 0.5) base.sleep();

else base.updatePosition(this.timeStep);

} else {

base.sleepTime = 0;

base.updatePosition(this.timeStep);

}

this.numIslands++;

continue;

}

var islandNumRigidBodies = 0;

var islandNumConstraints = 0;

var stackCount = 1;

// add rigid body to stack

this.islandStack[0] = base;

base.addedToIsland = true;

// build an island

do {

// get rigid body from stack

body = this.islandStack[--stackCount];

this.islandStack[stackCount] = null;

body.sleeping = false;

// add rigid body to the island

this.islandRigidBodies[islandNumRigidBodies++] = body;

if (body.isStatic) continue;

// search connections

for (var cs = body.contactLink; cs !== null; cs = cs.next) {

var contact = cs.contact;

constraint = contact.constraint;

if (constraint.addedToIsland || !contact.touching) continue;// ignore

// add constraint to the island

this.islandConstraints[islandNumConstraints++] = constraint;

constraint.addedToIsland = true;

var next = cs.body;

if (next.addedToIsland) continue;

// add rigid body to stack

this.islandStack[stackCount++] = next;

next.addedToIsland = true;

}

for (var js = body.jointLink; js !== null; js = js.next) {

constraint = js.joint;

if (constraint.addedToIsland) continue;// ignore

// add constraint to the island

this.islandConstraints[islandNumConstraints++] = constraint;

constraint.addedToIsland = true;

next = js.body;

if (next.addedToIsland || !next.isDynamic) continue;

// add rigid body to stack

this.islandStack[stackCount++] = next;

next.addedToIsland = true;

}

} while (stackCount != 0);

// update velocities

var gVel = new OIMO.Vec3().addTime(this.gravity, this.timeStep);

/*var gx=this.gravity.x*this.timeStep;

var gy=this.gravity.y*this.timeStep;

var gz=this.gravity.z*this.timeStep;*/

var j = islandNumRigidBodies;

while (j--) {

//or(var j=0, l=islandNumRigidBodies; j<l; j++){

body = this.islandRigidBodies[j];

if (body.isDynamic) {

body.linearVelocity.addEqual(gVel);

/*body.linearVelocity.x+=gx;

body.linearVelocity.y+=gy;

body.linearVelocity.z+=gz;*/

}

}

// randomizing order

if (this.enableRandomizer) {

//for(var j=1, l=islandNumConstraints; j<l; j++){

j = islandNumConstraints;

while (j--) {

if (j !== 0) {

var swap = (this.randX = (this.randX * this.randA + this.randB & 0x7fffffff)) / 2147483648.0 * j | 0;

constraint = this.islandConstraints[j];

this.islandConstraints[j] = this.islandConstraints[swap];

this.islandConstraints[swap] = constraint;

}

}

}

// solve contraints

j = islandNumConstraints;

while (j--) {

//for(j=0, l=islandNumConstraints; j<l; j++){

this.islandConstraints[j].preSolve(this.timeStep, invTimeStep);// pre-solve

}

var k = this.numIterations;

while (k--) {

//for(var k=0, l=this.numIterations; k<l; k++){

j = islandNumConstraints;

while (j--) {

//for(j=0, m=islandNumConstraints; j<m; j++){

this.islandConstraints[j].solve();// main-solve

}

}

j = islandNumConstraints;

while (j--) {

//for(j=0, l=islandNumConstraints; j<l; j++){

this.islandConstraints[j].postSolve();// post-solve

this.islandConstraints[j] = null;// gc

}

// sleeping check

var sleepTime = 10;

j = islandNumRigidBodies;

while (j--) {

//for(j=0, l=islandNumRigidBodies;j<l;j++){

body = this.islandRigidBodies[j];

if (this.callSleep(body)) {

body.sleepTime += this.timeStep;

if (body.sleepTime < sleepTime) sleepTime = body.sleepTime;

} else {

body.sleepTime = 0;

sleepTime = 0;

continue;

}

}

if (sleepTime > 0.5) {

// sleep the island

j = islandNumRigidBodies;

while (j--) {

//for(j=0, l=islandNumRigidBodies;j<l;j++){

this.islandRigidBodies[j].sleep();

this.islandRigidBodies[j] = null;// gc

}

} else {

// update positions

j = islandNumRigidBodies;

while (j--) {

//for(j=0, l=islandNumRigidBodies;j<l;j++){

this.islandRigidBodies[j].updatePosition(this.timeStep);

this.islandRigidBodies[j] = null;// gc

}

}

this.numIslands++;

}

if (stat) {

time2 = OIMO.now();

this.performance.solvingTime = time2 - time1;

//------------------------------------------------------

// END SIMULATION

//------------------------------------------------------

time2 = OIMO.now();

// fps update

this.performance.upfps();

this.performance.totalTime = time2 - time0;

}

}

}

/**

* The class of rigid body.

* Rigid body has the shape of a single or multiple collision processing,

* I can set the parameters individually.

* @author saharan

*/

OIMO.RigidBody = function (x, y, z, rad, ax, ay, az) {

this.name = " ";

// The maximum number of shapes that can be added to a one rigid.

this.MAX_SHAPES = 64;//64;

this.prev = null;

this.next = null;

// I represent the kind of rigid body.

// Please do not change from the outside this variable.

// If you want to change the type of rigid body, always

// Please specify the type you want to set the arguments of setupMass method.

this.type = OIMO.BODY_NULL;

this.massInfo = new OIMO.MassInfo();

// It is the world coordinate of the center of gravity.

this.position = new OIMO.Vec3(x, y, z);

this.orientation = this.rotationAxisToQuad(rad || 0, ax || 0, ay || 0, az || 0);

this.newPosition = new OIMO.Vec3();

this.controlPos = false;

this.newOrientation = new OIMO.Quat();

this.newRotation = new OIMO.Vec3();

this.currentRotation = new OIMO.Vec3();

this.controlRot = false;

this.controlRotInTime = false;

// Is the translational velocity.

this.linearVelocity = new OIMO.Vec3();

// Is the angular velocity.

this.angularVelocity = new OIMO.Vec3();

// return matrix for three.js

this.matrix = new OIMO.Mat44();

//--------------------------------------------

// Please do not change from the outside this variables.

//--------------------------------------------

// It is a world that rigid body has been added.

this.parent = null;

this.contactLink = null;

this.numContacts = 0;

// An array of shapes that are included in the rigid body.

this.shapes = null;

// The number of shapes that are included in the rigid body.

this.numShapes = 0;

// It is the link array of joint that is connected to the rigid body.

this.jointLink = null;

// The number of joints that are connected to the rigid body.

this.numJoints = 0;

// It is the world coordinate of the center of gravity in the sleep just before.

this.sleepPosition = new OIMO.Vec3();

// It is a quaternion that represents the attitude of sleep just before.

this.sleepOrientation = new OIMO.Quat();

// I will show this rigid body to determine whether it is a rigid body static.

this.isStatic = false;

// I indicates that this rigid body to determine whether it is a rigid body dynamic.

this.isDynamic = false;

// It is a rotation matrix representing the orientation.

this.rotation = new OIMO.Mat33();

//--------------------------------------------

// It will be recalculated automatically from the shape, which is included.

//--------------------------------------------

// This is the weight.

this.mass = NaN;

// It is the reciprocal of the mass.

this.inverseMass = NaN;

// It is the inverse of the inertia tensor in the world system.

this.inverseInertia = new OIMO.Mat33();

// It is the inertia tensor in the initial state.

this.localInertia = new OIMO.Mat33();

// It is the inverse of the inertia tensor in the initial state.

this.inverseLocalInertia = new OIMO.Mat33();

// I indicates rigid body whether it has been added to the simulation Island.

this.addedToIsland = false;

// It shows how to sleep rigid body.

this.allowSleep = true;

// This is the time from when the rigid body at rest.

this.sleepTime = 0;

// I shows rigid body to determine whether it is a sleep state.

this.sleeping = false;

};

OIMO.RigidBody.prototype = {

constructor: OIMO.RigidBody,

/**

* I'll add a shape to rigid body.

* If you add a shape, please call the setupMass method to step up to the start of the next.

* @param shape shape to Add

*/

addShape: function (shape) {

if (shape.parent) OIMO.Error("RigidBody", "It is not possible that you add to the multi-rigid body the shape of one");

if (this.shapes != null) (this.shapes.prev = shape).next = this.shapes;

this.shapes = shape;

shape.parent = this;

if (this.parent) this.parent.addShape(shape);

this.numShapes++;

},

/**

* I will delete the shape from the rigid body.

* If you delete a shape, please call the setupMass method to step up to the start of the next.

* @param shape shape to Delete

*/

removeShape: function (shape) {

var remove = shape;

if (remove.parent != this) return;

var prev = remove.prev;

var next = remove.next;

if (prev != null) prev.next = next;

if (next != null) next.prev = prev;

if (this.shapes == remove) this.shapes = next;

remove.prev = null;

remove.next = null;

remove.parent = null;

if (this.parent) this.parent.removeShape(remove);

this.numShapes--;

},

remove: function () {

this.dispose();

},

dispose: function () {

this.parent.removeRigidBody(this);

},

checkContact: function (name) {

this.parent.checkContact(this.name, name);

},

/**

* Calulates mass datas(center of gravity, mass, moment inertia, etc...).

* If the parameter type is set to BODY_STATIC, the rigid body will be fixed to the space.

* If the parameter adjustPosition is set to true, the shapes' relative positions and

* the rigid body's position will be adjusted to the center of gravity.

* @param type

* @param adjustPosition

*/

setupMass: function (type, AdjustPosition) {

var adjustPosition = (AdjustPosition !== undefined) ? AdjustPosition : true;

this.type = type || OIMO.BODY_DYNAMIC;

this.isDynamic = this.type == OIMO.BODY_DYNAMIC;

this.isStatic = this.type == OIMO.BODY_STATIC;

this.mass = 0;

this.localInertia.set(0, 0, 0, 0, 0, 0, 0, 0, 0);

var te = this.localInertia.elements;

//

var tmpM = new OIMO.Mat33();

var tmpV = new OIMO.Vec3();

for (var shape = this.shapes; shape != null; shape = shape.next) {

shape.calculateMassInfo(this.massInfo);

var shapeMass = this.massInfo.mass;

var relX = shape.relativePosition.x;

var relY = shape.relativePosition.y;

var relZ = shape.relativePosition.z;

/*tmpV.x+=relX*shapeMass;

tmpV.y+=relY*shapeMass;

tmpV.z+=relZ*shapeMass;*/

tmpV.addScale(shape.relativePosition, shapeMass);

this.mass += shapeMass;

this.rotateInertia(shape.relativeRotation, this.massInfo.inertia, tmpM);

this.localInertia.addEqual(tmpM);

// add offset inertia

te[0] += shapeMass * (relY * relY + relZ * relZ);

te[4] += shapeMass * (relX * relX + relZ * relZ);

te[8] += shapeMass * (relX * relX + relY * relY);

var xy = shapeMass * relX * relY;

var yz = shapeMass * relY * relZ;

var zx = shapeMass * relZ * relX;

te[1] -= xy;

te[3] -= xy;

te[2] -= yz;

te[6] -= yz;

te[5] -= zx;

te[7] -= zx;

}

this.inverseMass = 1 / this.mass;

tmpV.scaleEqual(this.inverseMass);

if (adjustPosition) {

this.position.addEqual(tmpV);

for (shape = this.shapes; shape != null; shape = shape.next) {

shape.relativePosition.subEqual(tmpV);

}

// subtract offset inertia

relX = tmpV.x;

relY = tmpV.y;

relZ = tmpV.z;

//var te = this.localInertia.elements;

te[0] -= this.mass * (relY * relY + relZ * relZ);

te[4] -= this.mass * (relX * relX + relZ * relZ);

te[8] -= this.mass * (relX * relX + relY * relY);

xy = this.mass * relX * relY;

yz = this.mass * relY * relZ;

zx = this.mass * relZ * relX;

te[1] += xy;

te[3] += xy;

te[2] += yz;

te[6] += yz;

te[5] += zx;

te[7] += zx;

}

this.inverseLocalInertia.invert(this.localInertia);

if (this.type == OIMO.BODY_STATIC) {

this.inverseMass = 0;

this.inverseLocalInertia.set(0, 0, 0, 0, 0, 0, 0, 0, 0);

}

this.syncShapes();

this.awake();

},