forked from bartvdbraak/blender
248 lines
5.8 KiB
C++
248 lines
5.8 KiB
C++
/*
|
|
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
|