Bullet Collision Detection & Physics Library
btDeformableBodySolver.h
Go to the documentation of this file.
1/*
2 Written by Xuchen Han <xuchenhan2015@u.northwestern.edu>
3
4 Bullet Continuous Collision Detection and Physics Library
5 Copyright (c) 2019 Google Inc. http://bulletphysics.org
6 This software is provided 'as-is', without any express or implied warranty.
7 In no event will the authors be held liable for any damages arising from the use of this software.
8 Permission is granted to anyone to use this software for any purpose,
9 including commercial applications, and to alter it and redistribute it freely,
10 subject to the following restrictions:
11 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.
12 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
13 3. This notice may not be removed or altered from any source distribution.
14 */
15
16#ifndef BT_DEFORMABLE_BODY_SOLVERS_H
17#define BT_DEFORMABLE_BODY_SOLVERS_H
18
19
20#include "btSoftBodySolvers.h"
25
29
31{
33protected:
34 int m_numNodes; // total number of deformable body nodes
35 TVStack m_dv; // v_{n+1} - v_n
36 TVStack m_backup_dv; // backed up dv
37 TVStack m_ddv; // incremental dv
38 TVStack m_residual; // rhs of the linear solve
40 TVStack m_backupVelocity; // backed up v, equals v_n for implicit, equals v_{n+1}^* for explicit
43 bool m_implicit; // use implicit scheme if true, explicit scheme if false
44 int m_maxNewtonIterations; // max number of newton iterations
45 btScalar m_newtonTolerance; // stop newton iterations if f(x) < m_newtonTolerance
46 bool m_lineSearch; // If true, use newton's method with line search under implicit scheme
47
48public:
49 // handles data related to objective function
51
53
55
56 virtual SolverTypes getSolverType() const
57 {
58 return DEFORMABLE_SOLVER;
59 }
60
61 // update soft body normals
62 virtual void updateSoftBodies();
63
64 // solve the momentum equation
65 virtual void solveDeformableConstraints(btScalar solverdt);
66
67 // solve the contact between deformable and rigid as well as among deformables
68 btScalar solveContactConstraints(btCollisionObject** deformableBodies,int numDeformableBodies);
69
70 // solve the position error between deformable and rigid as well as among deformables;
72
73 // set up the position error in split impulse
74 void splitImpulseSetup(const btContactSolverInfo& infoGlobal);
75
76 // resize/clear data structures
78
79 // set up contact constraints
80 void setConstraints();
81
82 // add in elastic forces and gravity to obtain v_{n+1}^* and calls predictDeformableMotion
83 virtual void predictMotion(btScalar solverdt);
84
85 // move to temporary position x_{n+1}^* = x_n + dt * v_{n+1}^*
86 // x_{n+1}^* is stored in m_q
88
89 // save the current velocity to m_backupVelocity
90 void backupVelocity();
91
92 // set m_dv and m_backupVelocity to desired value to prepare for momentum solve
93 void setupDeformableSolve(bool implicit);
94
95 // set the current velocity to that backed up in m_backupVelocity
96 void revertVelocity();
97
98 // set velocity to m_dv + m_backupVelocity
99 void updateVelocity();
100
101 // update the node count
102 bool updateNodes();
103
104 // calculate the change in dv resulting from the momentum solve
105 void computeStep(TVStack& ddv, const TVStack& residual);
106
107 // calculate the change in dv resulting from the momentum solve when line search is turned on
108 btScalar computeDescentStep(TVStack& ddv, const TVStack& residual, bool verbose=false);
109
110 virtual void copySoftBodyToVertexBuffer(const btSoftBody *const softBody, btVertexBufferDescriptor *vertexBuffer) {}
111
112 // process collision between deformable and rigid
113 virtual void processCollision(btSoftBody * softBody, const btCollisionObjectWrapper * collisionObjectWrap)
114 {
115 softBody->defaultCollisionHandler(collisionObjectWrap);
116 }
117
118 // process collision between deformable and deformable
119 virtual void processCollision(btSoftBody * softBody, btSoftBody * otherSoftBody) {
120 softBody->defaultCollisionHandler(otherSoftBody);
121 }
122
123 // If true, implicit time stepping scheme is used.
124 // Otherwise, explicit time stepping scheme is used
125 void setImplicit(bool implicit);
126
127 // If true, newton's method with line search is used when implicit time stepping scheme is turned on
128 void setLineSearch(bool lineSearch);
129
130 // set temporary position x^* = x_n + dt * v
131 // update the deformation gradient at position x^*
132 void updateState();
133
134 // set dv = dv + scale * ddv
135 void updateDv(btScalar scale = 1);
136
137 // set temporary position x^* = x_n + dt * v^*
138 void updateTempPosition();
139
140 // save the current dv to m_backup_dv;
141 void backupDv();
142
143 // set dv to the backed-up value
144 void revertDv();
145
146 // set dv = dv + scale * ddv
147 // set v^* = v_n + dv
148 // set temporary position x^* = x_n + dt * v^*
149 // update the deformation gradient at position x^*
150 void updateEnergy(btScalar scale);
151
152 // calculates the appropriately scaled kinetic energy in the system, which is
153 // 1/2 * dv^T * M * dv
154 // used in line search
156
157 // unused functions
158 virtual void optimize(btAlignedObjectArray<btSoftBody *> &softBodies, bool forceUpdate = false){}
159 virtual void solveConstraints(btScalar dt){}
160 virtual bool checkInitialized(){return true;}
161 virtual void copyBackToSoftBodies(bool bMove = true) {}
162};
163
164#endif /* btDeformableBodySolver_h */
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition: btScalar.h:314
btCollisionObject can be used to manage collision detection objects.
virtual void processCollision(btSoftBody *softBody, btSoftBody *otherSoftBody)
Process a collision between two soft bodies.
virtual void updateSoftBodies()
Perform necessary per-step updates of soft bodies such as recomputing normals and bounding boxes.
virtual void solveDeformableConstraints(btScalar solverdt)
void updateEnergy(btScalar scale)
virtual SolverTypes getSolverType() const
Return the type of the solver.
virtual bool checkInitialized()
Ensure that this solver is initialized.
virtual void processCollision(btSoftBody *softBody, const btCollisionObjectWrapper *collisionObjectWrap)
btDeformableBackwardEulerObjective * m_objective
btAlignedObjectArray< btSoftBody * > m_softBodies
void splitImpulseSetup(const btContactSolverInfo &infoGlobal)
btScalar computeDescentStep(TVStack &ddv, const TVStack &residual, bool verbose=false)
virtual void copyBackToSoftBodies(bool bMove=true)
Copy necessary data back to the original soft body source objects.
virtual void copySoftBodyToVertexBuffer(const btSoftBody *const softBody, btVertexBufferDescriptor *vertexBuffer)
void predictDeformableMotion(btSoftBody *psb, btScalar dt)
virtual void optimize(btAlignedObjectArray< btSoftBody * > &softBodies, bool forceUpdate=false)
Optimize soft bodies in this solver.
btConjugateGradient< btDeformableBackwardEulerObjective > m_cg
btScalar solveContactConstraints(btCollisionObject **deformableBodies, int numDeformableBodies)
void reinitialize(const btAlignedObjectArray< btSoftBody * > &softBodies, btScalar dt)
void setupDeformableSolve(bool implicit)
void setLineSearch(bool lineSearch)
virtual void solveConstraints(btScalar dt)
Solve constraints for a set of soft bodies.
btAlignedObjectArray< btVector3 > TVStack
virtual void predictMotion(btScalar solverdt)
Predict motion of soft bodies into next timestep.
void computeStep(TVStack &ddv, const TVStack &residual)
btScalar solveSplitImpulse(const btContactSolverInfo &infoGlobal)
void updateDv(btScalar scale=1)
The btSoftBody is an class to simulate cloth and volumetric soft bodies.
Definition: btSoftBody.h:73
void defaultCollisionHandler(const btCollisionObjectWrapper *pcoWrap)