blender/extern/bullet/BulletDynamics/Dynamics/RigidBody.h

/*
Bullet Continuous Collision Detection and Physics Library
Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/

This software is provided 'as-is', without any express or implied warranty.
In no event will the authors be held liable for any damages arising from the use of this software.
Permission is granted to anyone to use this software for any purpose, 
including commercial applications, and to alter it and redistribute it freely, 
subject to the following restrictions:

1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/

#ifndef RIGIDBODY_H
#define RIGIDBODY_H

#include <vector>
#include <SimdPoint3.h>
#include <SimdTransform.h>
#include "BroadphaseCollision/BroadphaseProxy.h"


#include "CollisionDispatch/CollisionObject.h"

class CollisionShape;
struct MassProps;
typedef SimdScalar dMatrix3[4*3];

extern float gLinearAirDamping;
extern bool gUseEpa;

#define MAX_RIGIDBODIES 8192


/// RigidBody class for RigidBody Dynamics
/// 
class RigidBody  : public CollisionObject
{
public:

	RigidBody(const MassProps& massProps,SimdScalar linearDamping,SimdScalar angularDamping,SimdScalar friction,SimdScalar restitution);

	void			proceedToTransform(const SimdTransform& newTrans); 
	
	
	/// continuous collision detection needs prediction
	void			predictIntegratedTransform(SimdScalar step, SimdTransform& predictedTransform) const;
	
	void			applyForces(SimdScalar step);
	
	void			setGravity(const SimdVector3& acceleration);  
	
	void			setDamping(SimdScalar lin_damping, SimdScalar ang_damping);
	
	inline const CollisionShape*	GetCollisionShape() const {
		return m_collisionShape;
	}

	inline CollisionShape*	GetCollisionShape() {
			return m_collisionShape;
	}
	
	void			setMassProps(SimdScalar mass, const SimdVector3& inertia);
	
	SimdScalar		getInvMass() const { return m_inverseMass; }
	const SimdMatrix3x3& getInvInertiaTensorWorld() const { return m_invInertiaTensorWorld; }
		
	void			integrateVelocities(SimdScalar step);

	void			setCenterOfMassTransform(const SimdTransform& xform);

	void			applyCentralForce(const SimdVector3& force)
	{
		m_totalForce += force;
	}
    
	const SimdVector3& getInvInertiaDiagLocal()
	{
		return m_invInertiaLocal;
	};

	void	setInvInertiaDiagLocal(const SimdVector3& diagInvInertia)
	{
		m_invInertiaLocal = diagInvInertia;
	}

	void	applyTorque(const SimdVector3& torque)
	{
		m_totalTorque += torque;
	}
	
	void	applyForce(const SimdVector3& force, const SimdVector3& rel_pos) 
	{
		applyCentralForce(force);
		applyTorque(rel_pos.cross(force));
	}
	
	void applyCentralImpulse(const SimdVector3& impulse)
	{
		m_linearVelocity += impulse * m_inverseMass;
	}
	
  	void applyTorqueImpulse(const SimdVector3& torque)
	{
		m_angularVelocity += m_invInertiaTensorWorld * torque;

	}
	
	void applyImpulse(const SimdVector3& impulse, const SimdVector3& rel_pos) 
	{
		if (m_inverseMass != 0.f)
		{
			applyCentralImpulse(impulse);
			applyTorqueImpulse(rel_pos.cross(impulse));
		}
	}
	
	void clearForces() 
	{
		m_totalForce.setValue(0.0f, 0.0f, 0.0f);
		m_totalTorque.setValue(0.0f, 0.0f, 0.0f);
	}
	
	void updateInertiaTensor();    
	
	const SimdPoint3&     getCenterOfMassPosition() const { return m_worldTransform.getOrigin(); }
	SimdQuaternion getOrientation() const;
	
	const SimdTransform&  getCenterOfMassTransform() const { return m_worldTransform; }
	const SimdVector3&   getLinearVelocity() const { return m_linearVelocity; }
	const SimdVector3&    getAngularVelocity() const { return m_angularVelocity; }
	

	void setLinearVelocity(const SimdVector3& lin_vel);
	void setAngularVelocity(const SimdVector3& ang_vel) { m_angularVelocity = ang_vel; }

	SimdVector3 getVelocityInLocalPoint(const SimdVector3& rel_pos) const
	{
		return m_linearVelocity + m_angularVelocity.cross(rel_pos);
	}

	void translate(const SimdVector3& v) 
	{
		m_worldTransform.getOrigin() += v; 
	}

	
	void	getAabb(SimdVector3& aabbMin,SimdVector3& aabbMax) const;


	void	setRestitution(float rest)
	{
		m_restitution = rest;
	}
	float	getRestitution() const
	{
		return m_restitution;
	}
	void	setFriction(float frict)
	{
		m_friction = frict;
	}
	float	getFriction() const
	{
		return m_friction;
	}

	
	inline float ComputeImpulseDenominator(const SimdPoint3& pos, const SimdVector3& normal) const
	{
		SimdVector3 r0 = pos - getCenterOfMassPosition();

		SimdVector3 c0 = (r0).cross(normal);

		SimdVector3 vec = (c0 * getInvInertiaTensorWorld()).cross(r0);

		return m_inverseMass + normal.dot(vec);

	}

	inline float ComputeAngularImpulseDenominator(const SimdVector3& axis) const
	{
		SimdVector3 vec = axis * getInvInertiaTensorWorld();
		return axis.dot(vec);
	}



private:
	
	SimdMatrix3x3	m_invInertiaTensorWorld;
	SimdVector3		m_gravity;	
	SimdVector3		m_invInertiaLocal;
	SimdVector3		m_totalForce;
	SimdVector3		m_totalTorque;
//	SimdQuaternion	m_orn1;
	
	SimdVector3		m_linearVelocity;
	
	SimdVector3		m_angularVelocity;
	
	SimdScalar		m_linearDamping;
	SimdScalar		m_angularDamping;
	SimdScalar		m_inverseMass;

	SimdScalar		m_friction;
	SimdScalar		m_restitution;

	BroadphaseProxy*	m_broadphaseProxy;



	
public:
	const BroadphaseProxy*	GetBroadphaseProxy() const
	{
		return m_broadphaseProxy;
	}
	BroadphaseProxy*	GetBroadphaseProxy() 
	{
		return m_broadphaseProxy;
	}
	void	SetBroadphaseProxy(BroadphaseProxy* broadphaseProxy)
	{
		m_broadphaseProxy = broadphaseProxy;
	}
	

	/// for ode solver-binding
	dMatrix3		m_R;//temp
	dMatrix3		m_I;
	dMatrix3		m_invI;

	int				m_odeTag;
	float		m_padding[1024];
	SimdVector3		m_tacc;//temp
	SimdVector3		m_facc;
	

	int	m_debugBodyId;
};



#endif