1 |
tim |
1254 |
#ifndef _ROLL_H_ |
2 |
|
|
#define _ROLL_H_ |
3 |
|
|
#include "Rattle.hpp" |
4 |
|
|
#include "Vector3d.hpp" |
5 |
|
|
//////////////////////////////////////////////////////////////////////////////// |
6 |
|
|
//Declaration of DCRollAFunctor |
7 |
|
|
//////////////////////////////////////////////////////////////////////////////// |
8 |
|
|
class DCRollAFunctor : public DCRattleAFunctor{ |
9 |
|
|
public: |
10 |
|
|
DCRollAFunctor(SimInfo* info) : DCRattleAFunctor(info) {} |
11 |
tim |
1268 |
virtual int operator()(ConstraintAtom* consAtom1, ConstraintAtom* consAtom2); |
12 |
tim |
1254 |
//virtual int operator()(ConstraintAtom* consAtom,ConstraintRigidBody* consRB); |
13 |
|
|
virtual int operator()(ConstraintRigidBody* consRB1, ConstraintRigidBody* consRB2); |
14 |
|
|
private: |
15 |
tim |
1268 |
|
16 |
|
|
void calcZeta(ConstraintAtom* consAtom, const Vector3d& bondDir, Vector3d&zeta); |
17 |
|
|
void integrate(ConstraintAtom* consAtom, const Vector3d& force); |
18 |
|
|
|
19 |
|
|
void calcZeta(ConstraintRigidBody* consRB, const Vector3d& bondDir, Vector3d& zeta); |
20 |
tim |
1254 |
void integrate(ConstraintRigidBody* consRB, const Vector3d& force); |
21 |
|
|
void rotationPropagation(StuntDouble* sd, double ji[3]); |
22 |
|
|
void rotate(int axes1, int axes2, double angle, double ji[3], double A[3][3]); |
23 |
|
|
}; |
24 |
|
|
|
25 |
|
|
//////////////////////////////////////////////////////////////////////////////// |
26 |
|
|
//Declaration of JCRollAFunctor |
27 |
|
|
//////////////////////////////////////////////////////////////////////////////// |
28 |
|
|
class JCRollAFunctor : public JCRattleAFunctor{ |
29 |
|
|
public: |
30 |
|
|
JCRollAFunctor(SimInfo* info) : JCRattleAFunctor(info) {} |
31 |
|
|
//virtual int operator()(ConstraintAtom* consAtom1, ConstraintAtom* consAtom2); |
32 |
|
|
//virtual int operator()(ConstraintAtom* consAtom,ConstraintRigidBody* consRB); |
33 |
|
|
//virtual int operator()(ConstraintRigidBody* consRB1, ConstraintRigidBody* consRB2); |
34 |
|
|
}; |
35 |
|
|
|
36 |
|
|
//////////////////////////////////////////////////////////////////////////////// |
37 |
|
|
//Declaration of RollA |
38 |
|
|
//////////////////////////////////////////////////////////////////////////////// |
39 |
|
|
class RollA : public ConstraintAlgorithm{ |
40 |
|
|
public: |
41 |
|
|
RollA(SimInfo* rhs) : ConstraintAlgorithm(rhs){ |
42 |
|
|
registerCallback(typeid(DistanceConstraintPair), new DCRollAFunctor(rhs)); |
43 |
|
|
registerCallback(typeid(JointConstraintPair), new JCRollAFunctor(rhs)); |
44 |
|
|
} |
45 |
|
|
}; |
46 |
|
|
|
47 |
|
|
//////////////////////////////////////////////////////////////////////////////// |
48 |
|
|
//Declaration of DCRollBFunctor |
49 |
|
|
//////////////////////////////////////////////////////////////////////////////// |
50 |
|
|
class DCRollBFunctor : public DCRattleBFunctor{ |
51 |
|
|
public: |
52 |
|
|
DCRollBFunctor(SimInfo* info) : DCRattleBFunctor(info) {} |
53 |
|
|
//virtual int operator()(ConstraintAtom* consAtom1, ConstraintAtom* consAtom2); |
54 |
|
|
//virtual int operator()(ConstraintAtom* consAtom,ConstraintRigidBody* consRB); |
55 |
|
|
virtual int operator()(ConstraintRigidBody* consRB1, ConstraintRigidBody* consRB2); |
56 |
|
|
private: |
57 |
|
|
void getEffInvMassVec(ConstraintRigidBody* consRB, const Vector3d& bondDir, Vector3d& invMassVec); |
58 |
|
|
void integrate(ConstraintRigidBody* consRB, const Vector3d& force); |
59 |
|
|
}; |
60 |
|
|
|
61 |
|
|
//////////////////////////////////////////////////////////////////////////////// |
62 |
|
|
//Declaration of JCRollBFunctor |
63 |
|
|
//////////////////////////////////////////////////////////////////////////////// |
64 |
|
|
class JCRollBFunctor : public JCRattleBFunctor{ |
65 |
|
|
public: |
66 |
|
|
JCRollBFunctor(SimInfo* info) : JCRattleBFunctor(info) {} |
67 |
|
|
//virtual int operator()(ConstraintAtom* consAtom1, ConstraintAtom* consAtom2); |
68 |
|
|
//virtual int operator()(ConstraintAtom* consAtom,ConstraintRigidBody* consRB); |
69 |
|
|
//virtual int operator()(ConstraintRigidBody* consRB1, ConstraintRigidBody* consRB2); |
70 |
|
|
}; |
71 |
|
|
|
72 |
|
|
//////////////////////////////////////////////////////////////////////////////// |
73 |
|
|
//Declaration of RollB |
74 |
|
|
//////////////////////////////////////////////////////////////////////////////// |
75 |
|
|
class RollB : public ConstraintAlgorithm{ |
76 |
|
|
public: |
77 |
|
|
RollB(SimInfo* rhs) : ConstraintAlgorithm(rhs){ |
78 |
|
|
registerCallback(typeid(DistanceConstraintPair), new DCRollBFunctor(rhs)); |
79 |
|
|
registerCallback(typeid(JointConstraintPair), new JCRollBFunctor(rhs)); |
80 |
|
|
} |
81 |
|
|
}; |
82 |
|
|
|
83 |
|
|
//////////////////////////////////////////////////////////////////////////////// |
84 |
|
|
//Declaration of RollFramework |
85 |
|
|
//////////////////////////////////////////////////////////////////////////////// |
86 |
|
|
//class RattleAlgorithm will encapsulate preConstraint, RattleA and RattleB |
87 |
|
|
//actually, we could use factory pattern to seperate the creation process |
88 |
tim |
1268 |
class RollFramework : public VelVerletConsFramework{ |
89 |
tim |
1254 |
public: |
90 |
tim |
1268 |
RollFramework(SimInfo* rhs) : VelVerletConsFramework(rhs){ |
91 |
tim |
1254 |
raAlgo = new RollA(rhs); |
92 |
|
|
rbAlgo = new RollB(rhs); |
93 |
|
|
} |
94 |
|
|
|
95 |
|
|
~RollFramework(){ |
96 |
|
|
delete raAlgo; |
97 |
|
|
delete rbAlgo; |
98 |
|
|
} |
99 |
|
|
|
100 |
tim |
1268 |
virtual int doConstrainA(){ |
101 |
tim |
1254 |
raAlgo->doConstrain(); |
102 |
|
|
return raAlgo->haveError()? -1 : 1; |
103 |
|
|
|
104 |
|
|
} |
105 |
|
|
|
106 |
tim |
1268 |
virtual int doConstrainB(){ |
107 |
tim |
1254 |
rbAlgo->doConstrain(); |
108 |
|
|
return rbAlgo->haveError()? -1 : 1; |
109 |
|
|
|
110 |
|
|
} |
111 |
|
|
private: |
112 |
|
|
RollA* raAlgo; |
113 |
|
|
RollB* rbAlgo; |
114 |
|
|
}; |
115 |
|
|
#endif //end ifndef _ROLL_H_ |