Bullet Collision Detection & Physics Library
|
Go to the documentation of this file.
17 #ifndef _BT_SOFT_BODY_H
18 #define _BT_SOFT_BODY_H
36 #define btSoftBodyData btSoftBodyFloatData
37 #define btSoftBodyDataName "btSoftBodyFloatData"
39 static unsigned long seed = 243703;
534 static const btMatrix3x3 iwi(0, 0, 0, 0, 0, 0, 0, 0, 0);
894 const Node* node1)
const;
921 void appendLink(
int model = -1, Material* mat = 0);
925 bool bcheckexist =
false);
929 bool bcheckexist =
false);
931 void appendFace(
int model = -1, Material* mat = 0);
948 btRigidBody* body,
bool disableCollisionBetweenLinkedBodies =
false,
btScalar influence = 1);
988 bool fromfaces =
false);
1047 static void clusterAImpulse(Cluster* cluster,
const Impulse& impulse);
1065 bool cutLink(
const Node* node0,
const Node* node1,
btScalar position);
1209 #define SAFE_EPSILON SIMD_EPSILON * 100.0
1248 template <
class DBVTNODE>
1277 updateFace(node->childs[0], use_velocity, margin);
1278 updateFace(node->childs[1], use_velocity, margin);
1281 Merge(node->childs[0]->volume, node->childs[1]->volume, vol);
1293 template <
typename T>
1299 return (a * coord.
x() + b * coord.
y() + c * coord.
z());
1310 #define NEXTRAND (seed = (1664525L * seed + 1013904223L) & 0xffffffff)
1313 for (i = 0, ni = indices.
size(); i < ni; ++i)
1339 if (applySpringForce)
1342 I += 0.5 * mass * vn;
1343 int face_penetration = 0, node_penetration = node->
m_constrained;
1344 for (
int i = 0; i < 3; ++i)
1349 if (face_penetration > 0 || node_penetration > 0)
1353 if (face_penetration <= 0)
1355 for (
int j = 0; j < 3; ++j)
1356 face->
m_n[j]->
m_v += w[j] * n * I_tilde * node->
m_im;
1358 if (node_penetration <= 0)
1360 node->
m_v -= I_tilde * node->
m_im * n;
1370 I = 0.5 * mass * (vt_norm - vt_new);
1372 I_tilde = 2.0 * I / (1.0 + w.
length2());
1374 if (face_penetration > 0 || node_penetration > 0)
1376 if (face_penetration <= 0)
1378 for (
int j = 0; j < 3; ++j)
1379 face->
m_n[j]->
m_v += w[j] * vt * I_tilde * (face->
m_n[j])->m_im;
1381 if (node_penetration <= 0)
1383 node->
m_v -= I_tilde * node->
m_im * vt;
1394 #endif //_BT_SOFT_BODY_H
virtual int calculateSerializeBufferSize() const
void removeAnchor(int node)
btScalar m_restLengthScale
void applyVAImpulse(const btVector3 &impulse) const
btMultiBodyJacobianData jacobianData_t2
void updateDeactivation(btScalar timeStep)
void Solve(btScalar dt, btScalar sor)
void addVelocity(const btVector3 &velocity)
void transformTo(const btTransform &trs)
const btTransform & xform() const
btCollisionObject can be used to manage collision detection objects.
bool checkLink(int node0, int node1) const
virtual void Terminate(btScalar dt)=0
void updateFaceTree(bool use_velocity, bool margin)
@ Default
Enable debug draw.
btAlignedObjectArray< Anchor > tAnchorArray
static void PSolve_Links(btSoftBody *psb, btScalar kst, btScalar ti)
tVSolverArray m_vsequence
static void solveClusters(const btAlignedObjectArray< btSoftBody * > &bodies)
btVector3 angularVelocity(const btVector3 &rpos) const
The btRigidBody is the main class for rigid body objects.
@ VF_DD
Cluster soft body self collision.
void setDampingCoefficient(btScalar damping_coeff)
void(* vsolver_t)(btSoftBody *, btScalar)
void appendLink(int model=-1, Material *mat=0)
static btSoftBody * upcast(btCollisionObject *colObj)
void Terminate(btScalar dt)
btAlignedObjectArray< bool > m_clusterConnectivity
btAlignedObjectArray< Link > tLinkArray
void indicesToPointers(const int *map=0)
btAlignedObjectArray< Cluster * > tClusterArray
@ F_OneSided
Face normals are flipped to match velocity and lift and drag forces are applied.
ePSolver : positions solvers
const btCollisionObject * m_collisionObject
btAlignedObjectArray< ePSolver::_ > tPSolverArray
tRenderNodeArray m_renderNodes
The btQuaternion implements quaternion to perform linear algebra rotations in combination with btMatr...
@ VF_SS
Rigid versus soft mask.
void appendFace(int model=-1, Material *mat=0)
void(* psolver_t)(btSoftBody *, btScalar, btScalar)
btAlignedObjectArray< btVector3 > m_quads
const btVector3 & getAngularVelocity() const
btAlignedObjectArray< DeformableFaceNodeContact > m_faceNodeContacts
void Prepare(btScalar dt, int iterations)
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
void refine(ImplicitFn *ifn, btScalar accurary, bool cut)
BT_DECLARE_ALIGNED_ALLOCATOR()
void prepareClusters(int iterations)
btScalar m_sleepingThreshold
void defaultCollisionHandler(const btCollisionObjectWrapper *pcoWrap)
The btDispatcher interface class can be used in combination with broadphase to dispatch calculations ...
bool checkDeformableContact(const btCollisionObjectWrapper *colObjWrap, const btVector3 &x, btScalar margin, btSoftBody::sCti &cti, bool predict=false) const
virtual eType::_ Type() const =0
@ SDF_RD
Cluster vs convex rigid vs soft.
@ SContacts
Rigid contacts solver.
btVector3 getCenterOfMass() const
void appendNote(const char *text, const btVector3 &o, const btVector4 &c=btVector4(1, 0, 0, 0), Node *n0=0, Node *n1=0, Node *n2=0, Node *n3=0)
btDispatcher * m_dispatcher
const btVector3 & getWindVelocity()
Return the wind velocity for interaction with the air.
void Terminate(btScalar dt)
static const btSoftBody * upcast(const btCollisionObject *colObj)
@ SDF_RS
Rigid versus soft mask.
btMatrix3x3 m_effectiveMass
void appendAnchor(int node, btRigidBody *body, bool disableCollisionBetweenLinkedBodies=false, btScalar influence=1)
btScalar safeNorm() const
Return the norm (length) of the vector.
btScalar dot(const btVector3 &v) const
Return the dot product.
void staticSolve(int iterations)
void applyDAImpulse(const btVector3 &impulse) const
Material * appendMaterial()
bool rayFaceTest(const btVector3 &rayFrom, const btVector3 &rayTo, sRayCast &results)
btMatrix3x3 m_effectiveMass_inv
btVector3 btCross(const btVector3 &v1, const btVector3 &v2)
Return the cross product of two vectors.
void resetLinkRestLengths()
static btVector3 clusterCom(const Cluster *cluster)
void applyTorqueImpulse(const btVector3 &torque)
btAlignedObjectArray< Note > tNoteArray
void setVolumeDensity(btScalar density)
void setSelfCollision(bool useSelfCollision)
void setWindVelocity(const btVector3 &velocity)
Set a wind velocity for interaction with the air.
void setCacheBarycenter(bool cacheBarycenter)
btAlignedObjectArray< Tetra > tTetraArray
static btVector3 clusterVelocity(const Cluster *cluster, const btVector3 &rpos)
btVector3 velocity(const btVector3 &rpos) const
void addAeroForceToFace(const btVector3 &windVelocity, int faceIndex)
Body(const btCollisionObject *colObj)
btAlignedObjectArray< SContact > tSContactArray
void applyDImpulse(const btVector3 &impulse, const btVector3 &rpos) const
tVector3Array m_framerefs
const T & btMin(const T &a, const T &b)
bool checkFace(int node0, int node1, int node2) const
const btMatrix3x3 & invWorldInertia() const
void randomizeConstraints()
void applyImpulse(const Impulse &impulse, const btVector3 &rpos) const
tMaterialArray m_materials
void Solve(btScalar dt, btScalar sor)
const T & btMax(const T &a, const T &b)
btMultiBodyJacobianData jacobianData_t1
int generateClusters(int k, int maxiterations=8192)
generateClusters with k=0 will create a convex cluster for each tetrahedron or triangle otherwise an ...
@ F_TwoSidedLiftDrag
Face normals are flipped to match velocity.
btAlignedObjectArray< TetraScratch > m_tetraScratches
const btScalar & y() const
Return the y value.
btAlignedObjectArray< btVector4 > m_renderNodesInterpolationWeights
static void PSolve_RContacts(btSoftBody *psb, btScalar kst, btScalar ti)
static IControl * Default()
virtual void Prepare(AJoint *)
btScalar getVolume() const
@ END
Face normals are taken as it is.
btAlignedObjectArray< btAlignedObjectArray< const btSoftBody::Node * > > m_renderNodesParents
btTransform & getWorldTransform()
tSContactArray m_scontacts
btAlignedObjectArray< RContact > tRContactArray
btAlignedObjectArray< int > m_userIndexMapping
btAlignedObjectArray< Node * > m_nodes
The btCollisionShape class provides an interface for collision shapes that can be shared among btColl...
void updateNodeTree(bool use_velocity, bool margin)
btAlignedObjectArray< DeformableFaceRigidContact > m_faceRigidContacts
btScalar fraction
feature index
const btCollisionObject * m_colObj
btScalar m_element_measure
btSoftBodyWorldInfo * m_worldInfo
virtual const char * serialize(void *dataBuffer, class btSerializer *serializer) const
fills the dataBuffer and returns the struct name (and 0 on failure)
void Process(const btDbvtNode *leaf)
@ CL_SS
Vertex vs face soft vs soft handling.
btVector3 angularVelocity() const
btAlignedObjectArray< RenderFace > tRenderFaceArray
virtual btScalar Speed(AJoint *, btScalar current)
RayFromToCaster(const btVector3 &rayFrom, const btVector3 &rayTo, btScalar mxt)
btScalar m_repulsionStiffness
btMultiBodyJacobianData jacobianData_normal
The btDbvt class implements a fast dynamic bounding volume tree based on axis aligned bounding boxes ...
btAlignedObjectArray< btVector3 > tVector3Array
btMultiBodyJacobianData jacobianData_t2
void activate(bool forceActivation=false) const
static void PSolve_SContacts(btSoftBody *psb, btScalar, btScalar ti)
void Prepare(btScalar dt, int iterations)
void transform(const btTransform &trs)
btSoftBodyWorldInfo * getWorldInfo()
void resize(int newsize, const T &fillData=T())
btAlignedObjectArray< TetraScratch > m_tetraScratchesTn
void setLinearVelocity(const btVector3 &linVel)
void setAngularVelocity(const btVector3 &angVel)
void setSpringStiffness(btScalar k)
void addAeroForceToNode(const btVector3 &windVelocity, int nodeIndex)
void setSoftBodySolver(btSoftBodySolver *softBodySolver)
btAlignedObjectArray< Material * > tMaterialArray
tPSolverArray m_psequence
static void clusterAImpulse(Cluster *cluster, const Impulse &impulse)
btVector3 linearVelocity() const
static void clusterVAImpulse(Cluster *cluster, const btVector3 &impulse)
btScalar m_maxSpeedSquared
void appendNode(const btVector3 &x, btScalar m)
btAlignedObjectArray< Face > tFaceArray
The btMatrix3x3 class implements a 3x3 rotation matrix, to perform linear algebra in combination with...
void geometricCollisionHandler(btSoftBody *psb)
void updateNode(btDbvtNode *node, bool use_velocity, bool margin)
static void solveCommonConstraints(btSoftBody **bodies, int count, int iterations)
btScalar getInvMass() const
btScalar m_maxSelfCollisionImpulse
static psolver_t getSolver(ePSolver::_ solver)
btSoftBodySolver * getSoftBodySolver()
static const btScalar OVERLAP_REDUCTION_FACTOR
void predictMotion(btScalar dt)
void updateFace(DBVTNODE *node, bool use_velocity, bool margin)
void initializeFaceTree()
static void clusterDCImpulse(Cluster *cluster, const btVector3 &impulse)
btScalar m_maxDisplacement
void setPose(bool bvolume, bool bframe)
@ RContacts
Anchor solver.
btVector3 getLinearVelocity()
btVector3 can be used to represent 3D points and vectors.
void setMaxStress(btScalar maxStress)
static btScalar rayFromToTriangle(const btVector3 &rayFrom, const btVector3 &rayTo, const btVector3 &rayNormalizedDirection, const btVector3 &a, const btVector3 &b, const btVector3 &c, btScalar maxt=SIMD_INFINITY)
static T BaryEval(const T &a, const T &b, const T &c, const btVector3 &coord)
void setRestLengthScale(btScalar restLength)
@ END
Soft contacts solver.
btSoftBodySolver * m_softBodySolver
const btVector3 & getLinearVelocity() const
@ SVSmask
rigid vs deformable
void appendAngularJoint(const AJoint::Specs &specs, Cluster *body0, Body body1)
virtual void getAabb(btVector3 &aabbMin, btVector3 &aabbMax) const
btAlignedObjectArray< btScalar > m_z
@ SDF_RDF
Rigid versus deformable face mask.
btScalar getMass(int node) const
#define ATTRIBUTE_ALIGNED16(a)
btAlignedObjectArray< RenderNode > tRenderNodeArray
void appendLinearJoint(const LJoint::Specs &specs, Cluster *body0, Body body1)
void scale(const btVector3 &scl)
btSoftBodySolver * getSoftBodySolver() const
btAlignedObjectArray< eVSolver::_ > tVSolverArray
virtual btScalar Eval(const btVector3 &x)=0
btAlignedObjectArray< Joint * > tJointArray
tRContactArray m_rcontacts
btVector3 evaluateCom() const
btSoftBody(btSoftBodyWorldInfo *worldInfo, int node_count, const btVector3 *x, const btScalar *m)
btScalar getRestLengthScale()
btScalar m_selfCollisionImpulseFactor
static btDbvtAabbMm FromCR(const btVector3 &c, btScalar r)
DBVT_INLINE void Merge(const btDbvtAabbMm &a, const btDbvtAabbMm &b, btDbvtAabbMm &r)
void setTotalMass(btScalar mass, bool fromfaces=false)
void initializeClusters()
static btDbvtAabbMm FromPoints(const btVector3 *pts, int n)
bool rayTest(const btVector3 &rayFrom, const btVector3 &rayTo, sRayCast &results)
Ray casting using rayFrom and rayTo in worldspace, (not direction!)
void applyAImpulse(const Impulse &impulse) const
tPSolverArray m_dsequence
void rotate(const btQuaternion &rot)
btScalar btDot(const btVector3 &v1, const btVector3 &v2)
Return the dot product between two vectors.
void updateLinkConstants()
@ V_TwoSided
Vertex normals are oriented toward velocity.
const btScalar & x() const
Return the x value.
The btSoftBody is an class to simulate cloth and volumetric soft bodies.
virtual void Solve(btScalar dt, btScalar sor)=0
btAlignedObjectArray< btVector3 > m_X
void setTotalDensity(btScalar density)
void applyCentralImpulse(const btVector3 &impulse)
void applyVImpulse(const btVector3 &impulse, const btVector3 &rpos) const
@ CL_RS
SDF based rigid vs soft.
The btBroadphaseInterface class provides an interface to detect aabb-overlapping object pairs.
void Prepare(btScalar dt, int iterations)
void appendDeformableAnchor(int node, btRigidBody *body)
bool checkContact(const btCollisionObjectWrapper *colObjWrap, const btVector3 &x, btScalar margin, btSoftBody::sCti &cti) const
btAlignedObjectArray< DeformableNodeRigidContact > m_nodeRigidContacts
virtual void setCollisionShape(btCollisionShape *collisionShape)
int getInternalType() const
reserved for Bullet internal usage
void appendTetra(int model, Material *mat)
void releaseCluster(int index)
RayFromToCaster takes a ray from, ray to (instead of direction!)
@ V_TwoSidedLiftDrag
Vertex normals are flipped to match velocity.
const btMatrix3x3 & getInvInertiaTensorWorld() const
virtual void Prepare(btScalar dt, int iterations)
void setVolumeMass(btScalar mass)
static unsigned long seed
@ V_OneSided
Vertex normals are flipped to match velocity and lift and drag forces are applied.
static void clusterDImpulse(Cluster *cluster, const btVector3 &rpos, const btVector3 &impulse)
void setSolver(eSolverPresets::_ preset)
DBVT_INLINE bool isleaf() const
void setCollisionQuadrature(int N)
void updateArea(bool averageArea=true)
btAlignedObjectArray< DeformableNodeRigidAnchor > m_deformableAnchors
void applyClusters(bool drift)
btMultiBodyJacobianData jacobianData_t1
@ SDF_MDF
GJK based Rigid vs. deformable face.
void applyRepulsionForce(btScalar timeStep, bool applySpringForce)
bool cutLink(int node0, int node1, btScalar position)
bool checkDeformableFaceContact(const btCollisionObjectWrapper *colObjWrap, Face &f, btVector3 &contact_point, btVector3 &bary, btScalar margin, btSoftBody::sCti &cti, bool predict=false) const
@ SDF_RDN
GJK based Multibody vs. deformable face.
Impulse operator-() const
void setMass(int node, btScalar mass)
@ RVDFmask
Vertex vs face soft vs soft handling.
btAlignedObjectArray< const class btCollisionObject * > m_collisionDisabledObjects
static void PSolve_Anchors(btSoftBody *psb, btScalar kst, btScalar ti)
void applyImpulse(const btVector3 &impulse, const btVector3 &rel_pos)
@ CL_SELF
Cluster vs cluster soft vs soft handling.
btBroadphaseInterface * m_broadphase
int generateBendingConstraints(int distance, Material *mat=0)
void interpolateRenderMesh()
eFeature::_ feature
soft body
btSparseSdf< 3 > m_sparsesdf
static void VSolve_Links(btSoftBody *psb, btScalar kst)
void setGravityFactor(btScalar gravFactor)
void Solve(btScalar dt, btScalar sor)
tRenderFaceArray m_renderFaces
btAlignedObjectArray< Node > tNodeArray
btAlignedObjectArray< btSoftBody * > tSoftBodyArray
void advanceDeformation()
static void clusterImpulse(Cluster *cluster, const btVector3 &rpos, const Impulse &impulse)
@ Default
SDF based Rigid vs. deformable node.
eVSolver : velocities solvers
void addForce(const btVector3 &force)
@ F_TwoSided
Vertex normals are taken as it is.
btVector3 & safeNormalize()
void translate(const btVector3 &trs)
static void clusterVImpulse(Cluster *cluster, const btVector3 &rpos, const btVector3 &impulse)
btAlignedObjectArray< btScalar > tScalarArray
btMultiBodyJacobianData jacobianData_normal
static const btRigidBody * upcast(const btCollisionObject *colObj)
to keep collision detection and dynamics separate we don't store a rigidbody pointer but a rigidbody ...
void initializeDmInverse()
btScalar getTotalMass() const
static void clusterDAImpulse(Cluster *cluster, const btVector3 &impulse)
Impulse operator*(btScalar x) const
const btScalar & z() const
Return the z value.
btVector3 m_rayNormalizedDirection
int size() const
return the number of elements in the array
void setVelocity(const btVector3 &velocity)
btScalar length2() const
Return the length of the vector squared.
btScalar m_dampingCoefficient
void Terminate(btScalar dt)
btTransform getRigidTransform()
void applyDCImpulse(const btVector3 &impulse) const
btAlignedObjectArray< btDbvtNode * > tLeafArray