Class RigidBody

RigidBody a body in the physics simulation
Defined in: rigid_body.js.

Class Summary
Constructor Attributes	Constructor Name and Description
	RigidBody(_skin)

Field Summary
Field Attributes	Field Name and Description
	collisions a collection of CollisionInfo objects
	idCounter
	isActive

Method Summary
Method Attributes	Method Name and Description
	addBodyForce(f, p)
	addBodyTorque(t)
	addConstraint(constraint)
	addExternalForces(dt)
	addGravity()
	addMovementActivation(pos, otherBody)
	addWorldForce(f, p)
	addWorldTorque(t)
	applyBodyWorldImpulse(impulse, delta)
	applyBodyWorldImpulseAux(impulse, delta)
	applyWorldImpulse(impulse, pos)
	applyWorldImpulseAux(impulse, pos)
	clearForces()
	clearVelChanged()
	copyCurrentStateToOld()
	createRotationMatrix()
	dampForDeactivation()
	degreesToRadians(deg)
	disableCollisions(body)
	doMovementActivations()
	enableCollisions(body)
	findConstraint(constraint)
	findNonCollidablesBody(body)
	get_boundingBox()
	get_boundingSphere()
	get_currentState()
	get_doShockProcessing()
	get_force()
	get_friction()
	get_id()
	get_invMass()
	get_linVelocityDamping()
	get_mass()
	get_material()
	get_maxLinVelocities()
	get_maxRotVelocities()
	get_movable()
	get_nonCollidables()
	get_oldState()
	get_position()
	get_restitution()
	get_rotationX()
	get_rotationY()
	get_rotationZ()
	get_rotVelocityDamping()
	get_skin()
	get_type()
	get_worldInertia()
	get_worldInvInertia()
	get_x()
	get_y()
	get_z()
	getInertiaProperties(m)
	getShouldBeActive()
	getShouldBeActiveAux()
	getTransform()
	getVelChanged()
	getVelocity(relPos)
	getVelocityAux(relPos)
	hitTestObject3D(obj3D)
	internalRestoreImmovable()
	internalSetImmovable()
	limitAngVel()
	limitVel()
	moveTo(pos)
	pitch(rot)
	postPhysics(dt)
	radiansToDegrees(rad)
	removeAllConstraints()
	removeConstraint(constraint)
	restoreState()
	roll(rot)
	segmentIntersect(out, seg, state)
	set_doShockProcessing(doShock)
	set_friction(restitution)
	set_linVelocityDamping(vel)
	set_mass(m)
	set_maxLinVelocities(vel)
	set_maxRotVelocities(vel)
	set_movable(mov)
	set_restitution(restitution)
	set_rotationX(px)
	set_rotationY(py)
	set_rotationZ(pz)
	set_rotVelocityDamping(vel)
	set_x(px)
	set_y(py)
	set_z(pz)
	setActive(activityFactor)
	setAngVel(angVel)
	setAngVelAux(angVel)
	setConstraintsAndCollisionsUnsatisfied()
	setInactive()
	setInertia(matrix3D)
	setOrientation(orient)
	setRotation(vect)
	setVelocity(vel)
	setVelocityAux(vel)
	storeState()
	tryToFreeze(dt)
	updateBoundingBox()
	updateInertia()
	updateObject3D()
	updatePositionWithAux(dt)
	updateState()
	updateVelocity(dt)
	yaw(rot)

Class Detail

RigidBody(_skin)

Parameters:
{ISkin3D} _skin

Requires:: Vector3DUtil; JConfig; Matrix3D; JMatrix3D; JNumber3D; MaterialProperties; PhysicsState; PhysicsSystem; JAABox

Field Detail

{array} collisions

a collection of CollisionInfo objects

{number} idCounter

{boolean} isActive

Method Detail

{void} addBodyForce(f, p)

Parameters:
{array} f: force expressed as a 3D vector
{array} p: position of origin of the force expressed as a 3D vector

{void} addBodyTorque(t)

Parameters:
{array} t: torque expressed as a 3D vector

{void} addConstraint(constraint)

Parameters:
{JConstraint} constraint: the constraint

{void} addExternalForces(dt)

Parameters:
{number} dt: a UNIX timestamp

{void} addGravity()

{void} addMovementActivation(pos, otherBody)

Parameters:
{array} pos: position expressed as a 3D vector
{RigidBody} otherBody: the other body

{void} addWorldForce(f, p)

Parameters:
{array} f: force expressed as a 3D vector
{array} p: position of origin of the force expressed as a 3D vector

{void} addWorldTorque(t)

Parameters:
{array} t: torque expressed as a 3D vector

{void} applyBodyWorldImpulse(impulse, delta)

Parameters:
{array} impulse: impulse expressed as a 3D vector
{array} delta: impulse delta expressed as a 3D vector

{void} applyBodyWorldImpulseAux(impulse, delta)

Parameters:
{array} impulse: impulse expressed as a 3D vector
{array} delta: impulse delta expressed as a 3D vector

{void} applyWorldImpulse(impulse, pos)

Parameters:
{array} impulse: impulse expressed as a 3D vector
{array} pos: position of origin of the impulse expressed as a 3D vector

{void} applyWorldImpulseAux(impulse, pos)

Parameters:
{array} impulse: impulse expressed as a 3D vector
{array} pos: position of origin of the impulse expressed as a 3D vector

{void} clearForces()

{void} clearVelChanged()

{void} copyCurrentStateToOld()

{Matrix3D} createRotationMatrix()

{void} dampForDeactivation()

{number} degreesToRadians(deg)

Parameters:
{number} deg

{void} disableCollisions(body)

Parameters:
{RigidBody} body

{void} doMovementActivations()

{void} enableCollisions(body)

Parameters:
{RigidBody} body

{void} findConstraint(constraint)

Parameters:
{JConstraint} constraint: the constraint

{boolean} findNonCollidablesBody(body)

Parameters:
{RigidBody} body

{JAABox} get_boundingBox()

{number} get_boundingSphere()

{PhysicsState} get_currentState()

{boolean} get_doShockProcessing()

{array} get_force()

{number} get_friction()

{number} get_id()

{number} get_invMass()

{array} get_linVelocityDamping()

{number} get_mass()

{MaterialProperties} get_material()

{number} get_maxLinVelocities()

{number} get_maxRotVelocities()

{boolean} get_movable()

{array} get_nonCollidables()

Returns:: a collection of RigidBody objects

{PhysicsState} get_oldState()

{array} get_position()

Returns:: a 3D vector

{number} get_restitution()

{number} get_rotationX()

{number} get_rotationY()

{number} get_rotationZ()

{array} get_rotVelocityDamping()

{ISkin3D} get_skin()

{string} get_type()

{Matrix3D} get_worldInertia()

{Matrix3D} get_worldInvInertia()

{number} get_x()

{number} get_y()

{number} get_z()

{Matrix3D} getInertiaProperties(m)

Parameters:
{number} m

{boolean} getShouldBeActive()

{boolean} getShouldBeActiveAux()

{Matrix3D} getTransform()

{boolean} getVelChanged()

{array} getVelocity(relPos)

Parameters:
{array} relPos: the body-relative position expressed as a 3D vector

{array} getVelocityAux(relPos)

Parameters:
{array} relPos: the body-relative position expressed as a 3D vector

{boolean} hitTestObject3D(obj3D)

Parameters:
{RigidBody} obj3D

{void} internalRestoreImmovable()

{void} internalSetImmovable()

{void} limitAngVel()

{void} limitVel()

{void} moveTo(pos)

Parameters:
{array} pos: a 3D vector

{void} pitch(rot)

Parameters:
{number} rot

{void} postPhysics(dt)

Parameters:
{number} dt: a UNIX timestamp

{number} radiansToDegrees(rad)

Parameters:
{number} rad

{void} removeAllConstraints()

{void} removeConstraint(constraint)

Parameters:
{JConstraint} constraint: the constraint

{void} restoreState()

{void} roll(rot)

Parameters:
{number} rot

{boolean} segmentIntersect(out, seg, state)

Parameters:
{object} out
{JSegment} seg
{PhysicsState} state

{void} set_doShockProcessing(doShock)

Parameters:
{boolean} doShock

{void} set_friction(restitution)

Parameters:
{number} restitution

{void} set_linVelocityDamping(vel)

Parameters:
{array} vel: a 3D vector

{void} set_mass(m)

Parameters:
{number} m: the mass

{void} set_maxLinVelocities(vel)

Parameters:
{number} vel

{void} set_maxRotVelocities(vel)

Parameters:
{number} vel

{void} set_movable(mov)

Parameters:
{boolean} mov

{void} set_restitution(restitution)

Parameters:
{number} restitution

{void} set_rotationX(px)

Parameters:
{number} px

{void} set_rotationY(py)

Parameters:
{number} py

{void} set_rotationZ(pz)

Parameters:
{number} pz

{void} set_rotVelocityDamping(vel)

Parameters:
{array} vel: a 3D vector

{void} set_x(px)

Parameters:
{number} px

{void} set_y(py)

Parameters:
{number} py

{void} set_z(pz)

Parameters:
{number} pz

{void} setActive(activityFactor)

Parameters:
{number} activityFactor

{void} setAngVel(angVel)

Parameters:
{array} angVel: a 3D vector

{void} setAngVelAux(angVel)

Parameters:
{array} angVel: a 3D vector

{void} setConstraintsAndCollisionsUnsatisfied()

{void} setInactive()

{void} setInertia(matrix3D)

Parameters:
{Matrix3D} matrix3D: the inertia expressed as a 3D matrix

{void} setOrientation(orient)

Parameters:
orient: Matrix3D

{void} setRotation(vect)

Parameters:
{array} vect: [x,y,z] rotation

{void} setVelocity(vel)

Parameters:
{array} vel: velocity in each axis expressed as a 3D vector

{void} setVelocityAux(vel)

Parameters:
{array} vel: a 3D vector

{void} storeState()

{void} tryToFreeze(dt)

Parameters:
{number} dt: a UNIX timestamp

{void} updateBoundingBox()

{void} updateInertia()

{void} updateObject3D()

{void} updatePositionWithAux(dt)

Parameters:
{number} dt: a UNIX timestamp

{void} updateState()

{void} updateVelocity(dt)

Parameters:
{number} dt: a UNIX timestamp

{void} yaw(rot)

Parameters:
{number} rot

Classes

Class RigidBody