Blender  V3.3
frameacc.inl
Go to the documentation of this file.
1 /*****************************************************************************
2  * \file
3  * provides inline functions of rrframes.h
4  *
5  * Erwin Aertbelien, Div. PMA, Dep. of Mech. Eng., K.U.Leuven
6  *
7  * \version
8  * ORO_Geometry V0.2
9  *
10  * \par History
11  * - $log$
12  *
13  * \par Release
14  * $Name: $
15  ****************************************************************************/
16 
17 
18 
19 
21 
22 VectorAcc operator + (const VectorAcc& r1,const VectorAcc& r2) {
23  return VectorAcc(r1.p+r2.p,r1.v+r2.v,r1.dv+r2.dv);
24 }
25 
26 VectorAcc operator - (const VectorAcc& r1,const VectorAcc& r2) {
27  return VectorAcc(r1.p-r2.p, r1.v-r2.v, r1.dv-r2.dv);
28 }
29 VectorAcc operator + (const Vector& r1,const VectorAcc& r2) {
30  return VectorAcc(r1+r2.p,r2.v,r2.dv);
31 }
32 
33 VectorAcc operator - (const Vector& r1,const VectorAcc& r2) {
34  return VectorAcc(r1-r2.p, -r2.v, -r2.dv);
35 }
36 VectorAcc operator + (const VectorAcc& r1,const Vector& r2) {
37  return VectorAcc(r1.p+r2,r1.v,r1.dv);
38 }
39 
40 VectorAcc operator - (const VectorAcc& r1,const Vector& r2) {
41  return VectorAcc(r1.p-r2, r1.v, r1.dv);
42 }
43 
44 // unary -
45 VectorAcc operator - (const VectorAcc& r) {
46  return VectorAcc(-r.p,-r.v,-r.dv);
47 }
48 
49 // cross prod.
50 VectorAcc operator * (const VectorAcc& r1,const VectorAcc& r2) {
51  return VectorAcc(r1.p*r2.p,
52  r1.p*r2.v+r1.v*r2.p,
53  r1.dv*r2.p+2*r1.v*r2.v+r1.p*r2.dv
54  );
55 }
56 
57 VectorAcc operator * (const VectorAcc& r1,const Vector& r2) {
58  return VectorAcc(r1.p*r2, r1.v*r2, r1.dv*r2 );
59 }
60 
61 VectorAcc operator * (const Vector& r1,const VectorAcc& r2) {
62  return VectorAcc(r1*r2.p, r1*r2.v, r1*r2.dv );
63 }
64 
65 
66 
67 // scalar mult.
68 VectorAcc operator * (double r1,const VectorAcc& r2) {
69  return VectorAcc(r1*r2.p, r1*r2.v, r1*r2.dv );
70 }
71 
72 VectorAcc operator * (const VectorAcc& r1,double r2) {
73  return VectorAcc(r1.p*r2, r1.v*r2, r1.dv*r2 );
74 }
75 
76 VectorAcc operator * (const doubleAcc& r1,const VectorAcc& r2) {
77  return VectorAcc(r1.t*r2.p,
78  r1.t*r2.v + r1.d*r2.p,
79  r1.t*r2.dv + 2*r1.d*r2.v + r1.dd*r2.p
80  );
81 }
82 
83 VectorAcc operator * (const VectorAcc& r2,const doubleAcc& r1) {
84  return VectorAcc(r1.t*r2.p,
85  r1.t*r2.v + r1.d*r2.p,
86  r1.t*r2.dv + 2*r1.d*r2.v + r1.dd*r2.p
87  );
88 }
89 
91  p=arg.p;
92  v=arg.v;
93  dv=arg.dv;
94  return *this;
95 }
96 
98  p=arg;
99  v=Vector::Zero();
100  dv=Vector::Zero();
101  return *this;
102 }
103 
105  p+=arg.p;
106  v+=arg.v;
107  dv+= arg.dv;
108  return *this;
109 }
111  p-=arg.p;
112  v-=arg.v;
113  dv-=arg.dv;
114  return *this;
115 }
116 
117 VectorAcc VectorAcc::Zero() {
118  return VectorAcc(Vector::Zero(),Vector::Zero(),Vector::Zero());
119 }
120 
121 void VectorAcc::ReverseSign() {
122  p.ReverseSign();
123  v.ReverseSign();
124  dv.ReverseSign();
125 }
126 
128  doubleAcc res;
129  res.t = p.Norm();
130  res.d = dot(p,v)/res.t;
131  res.dd = (dot(p,dv)+dot(v,v)-res.d*res.d)/res.t;
132  return res;
133 }
134 
135 doubleAcc dot(const VectorAcc& lhs,const VectorAcc& rhs) {
136  return doubleAcc( dot(lhs.p,rhs.p),
137  dot(lhs.p,rhs.v)+dot(lhs.v,rhs.p),
138  dot(lhs.p,rhs.dv)+2*dot(lhs.v,rhs.v)+dot(lhs.dv,rhs.p)
139  );
140 }
141 
142 doubleAcc dot(const VectorAcc& lhs,const Vector& rhs) {
143  return doubleAcc( dot(lhs.p,rhs),
144  dot(lhs.v,rhs),
145  dot(lhs.dv,rhs)
146  );
147 }
148 
149 doubleAcc dot(const Vector& lhs,const VectorAcc& rhs) {
150  return doubleAcc( dot(lhs,rhs.p),
151  dot(lhs,rhs.v),
152  dot(lhs,rhs.dv)
153  );
154 }
155 
156 
157 bool Equal(const VectorAcc& r1,const VectorAcc& r2,double eps) {
158  return (Equal(r1.p,r2.p,eps)
159  && Equal(r1.v,r2.v,eps)
160  && Equal(r1.dv,r2.dv,eps)
161  );
162 }
163 
164 bool Equal(const Vector& r1,const VectorAcc& r2,double eps) {
165  return (Equal(r1,r2.p,eps)
166  && Equal(Vector::Zero(),r2.v,eps)
167  && Equal(Vector::Zero(),r2.dv,eps)
168  );
169 }
170 
171 bool Equal(const VectorAcc& r1,const Vector& r2,double eps) {
172  return (Equal(r1.p,r2,eps)
173  && Equal(r1.v,Vector::Zero(),eps)
174  && Equal(r1.dv,Vector::Zero(),eps)
175  );
176 }
177 
178 VectorAcc operator / (const VectorAcc& r1,double r2) {
179  return r1*(1.0/r2);
180 }
181 
182 VectorAcc operator / (const VectorAcc& r2,const doubleAcc& r1) {
183  return r2*(1.0/r1);
184 }
185 
186 
187 
189 
190 RotationAcc operator* (const RotationAcc& r1,const RotationAcc& r2) {
191  return RotationAcc( r1.R * r2.R,
192  r1.w + r1.R*r2.w,
193  r1.dw + r1.w*(r1.R*r2.w) + r1.R*r2.dw
194  );
195 }
196 
197 RotationAcc operator* (const Rotation& r1,const RotationAcc& r2) {
198  return RotationAcc( r1*r2.R, r1*r2.w, r1*r2.dw);
199 }
200 
201 RotationAcc operator* (const RotationAcc& r1,const Rotation& r2) {
202  return RotationAcc( r1.R*r2, r1.w, r1.dw );
203 }
204 
206  R=arg.R;
207  w=arg.w;
208  dw=arg.dw;
209  return *this;
210 }
212  R = arg;
213  w = Vector::Zero();
214  dw = Vector::Zero();
215  return *this;
216 }
217 
218 RotationAcc RotationAcc::Identity() {
219  return RotationAcc(Rotation::Identity(),Vector::Zero(),Vector::Zero());
220 }
221 
222 RotationAcc RotationAcc::Inverse() const {
223  return RotationAcc(R.Inverse(),-R.Inverse(w),-R.Inverse(dw));
224 }
225 
226 VectorAcc RotationAcc::Inverse(const VectorAcc& arg) const {
227  VectorAcc tmp;
228  tmp.p = R.Inverse(arg.p);
229  tmp.v = R.Inverse(arg.v - w * arg.p);
230  tmp.dv = R.Inverse(arg.dv - dw*arg.p - w*(arg.v+R*tmp.v));
231  return tmp;
232 }
233 
234 VectorAcc RotationAcc::Inverse(const Vector& arg) const {
235  VectorAcc tmp;
236  tmp.p = R.Inverse(arg);
237  tmp.v = R.Inverse(-w*arg);
238  tmp.dv = R.Inverse(-dw*arg - w*(R*tmp.v));
239  return tmp;
240 }
241 
242 
244  VectorAcc tmp;
245  tmp.p = R*arg.p;
246  tmp.dv = R*arg.v;
247  tmp.v = w*tmp.p + tmp.dv;
248  tmp.dv = dw*tmp.p + w*(tmp.v + tmp.dv) + R*arg.dv;
249  return tmp;
250 }
251 
252 VectorAcc operator*(const Rotation& R,const VectorAcc& x) {
253  return VectorAcc(R*x.p,R*x.v,R*x.dv);
254 }
255 
257  VectorAcc tmp;
258  tmp.p = R*arg;
259  tmp.v = w*tmp.p;
260  tmp.dv = dw*tmp.p + w*tmp.v;
261  return tmp;
262 }
263 
264 /*
265  // = Rotations
266  // The Rot... static functions give the value of the appropriate rotation matrix back.
267  // The DoRot... functions apply a rotation R to *this,such that *this = *this * R.
268 
269  void RRotation::DoRotX(const RDouble& angle) {
270  w+=R*Vector(angle.grad,0,0);
271  R.DoRotX(angle.t);
272  }
273 RotationAcc RotationAcc::RotX(const doubleAcc& angle) {
274  return RotationAcc(Rotation::RotX(angle.t),
275  Vector(angle.d,0,0),
276  Vector(angle.dd,0,0)
277  );
278 }
279 
280  void RRotation::DoRotY(const RDouble& angle) {
281  w+=R*Vector(0,angle.grad,0);
282  R.DoRotY(angle.t);
283  }
284 RotationAcc RotationAcc::RotY(const doubleAcc& angle) {
285  return RotationAcc(
286  Rotation::RotX(angle.t),
287  Vector(0,angle.d,0),
288  Vector(0,angle.dd,0)
289  );
290 }
291 
292  void RRotation::DoRotZ(const RDouble& angle) {
293  w+=R*Vector(0,0,angle.grad);
294  R.DoRotZ(angle.t);
295  }
296 RotationAcc RotationAcc::RotZ(const doubleAcc& angle) {
297  return RotationAcc(
298  Rotation::RotZ(angle.t),
299  Vector(0,0,angle.d),
300  Vector(0,0,angle.dd)
301  );
302 }
303 
304 
305  RRotation RRotation::Rot(const Vector& rotvec,const RDouble& angle)
306  // rotvec has arbitrary norm
307  // rotation around a constant vector !
308  {
309  Vector v = rotvec.Normalize();
310  return RRotation(Rotation::Rot2(v,angle.t),v*angle.grad);
311  }
312 
313  RRotation RRotation::Rot2(const Vector& rotvec,const RDouble& angle)
314  // rotvec is normalized.
315  {
316  return RRotation(Rotation::Rot2(rotvec,angle.t),rotvec*angle.grad);
317  }
318 
319 */
320 
321 bool Equal(const RotationAcc& r1,const RotationAcc& r2,double eps) {
322  return (Equal(r1.w,r2.w,eps) && Equal(r1.R,r2.R,eps) && Equal(r1.dw,r2.dw,eps) );
323 }
324 bool Equal(const Rotation& r1,const RotationAcc& r2,double eps) {
325  return (Equal(Vector::Zero(),r2.w,eps) && Equal(r1,r2.R,eps) &&
326  Equal(Vector::Zero(),r2.dw,eps) );
327 }
328 bool Equal(const RotationAcc& r1,const Rotation& r2,double eps) {
329  return (Equal(r1.w,Vector::Zero(),eps) && Equal(r1.R,r2,eps) &&
330  Equal(r1.dw,Vector::Zero(),eps) );
331 }
332 
333 
334 // Methods and operators related to FrameAcc
335 // They all delegate most of the work to RotationAcc and VectorAcc
337  M=arg.M;
338  p=arg.p;
339  return *this;
340 }
341 
342 FrameAcc FrameAcc::Identity() {
343  return FrameAcc(RotationAcc::Identity(),VectorAcc::Zero());
344 }
345 
346 
347 FrameAcc operator *(const FrameAcc& lhs,const FrameAcc& rhs)
348 {
349  return FrameAcc(lhs.M*rhs.M,lhs.M*rhs.p+lhs.p);
350 }
351 FrameAcc operator *(const FrameAcc& lhs,const Frame& rhs)
352 {
353  return FrameAcc(lhs.M*rhs.M,lhs.M*rhs.p+lhs.p);
354 }
355 FrameAcc operator *(const Frame& lhs,const FrameAcc& rhs)
356 {
357  return FrameAcc(lhs.M*rhs.M,lhs.M*rhs.p+lhs.p);
358 }
359 
361 {
362  return M*arg+p;
363 }
365 {
366  return M*arg+p;
367 }
368 
369 VectorAcc FrameAcc::Inverse(const VectorAcc& arg) const
370 {
371  return M.Inverse(arg-p);
372 }
373 
374 VectorAcc FrameAcc::Inverse(const Vector& arg) const
375 {
376  return M.Inverse(arg-p);
377 }
378 
379 FrameAcc FrameAcc::Inverse() const
380 {
381  return FrameAcc(M.Inverse(),-M.Inverse(p));
382 }
383 
385 {
386  M = arg.M;
387  p = arg.p;
388  return *this;
389 }
390 
391 bool Equal(const FrameAcc& r1,const FrameAcc& r2,double eps) {
392  return (Equal(r1.M,r2.M,eps) && Equal(r1.p,r2.p,eps));
393 }
394 bool Equal(const Frame& r1,const FrameAcc& r2,double eps) {
395  return (Equal(r1.M,r2.M,eps) && Equal(r1.p,r2.p,eps));
396 }
397 bool Equal(const FrameAcc& r1,const Frame& r2,double eps) {
398  return (Equal(r1.M,r2.M,eps) && Equal(r1.p,r2.p,eps));
399 }
400 
401 
402 Frame FrameAcc::GetFrame() const {
403  return Frame(M.R,p.p);
404 }
405 
406 
407 Twist FrameAcc::GetTwist() const {
408  return Twist(p.v,M.w);
409 }
410 
411 
412 Twist FrameAcc::GetAccTwist() const {
413  return Twist(p.dv,M.dw);
414 }
415 
416 
417 
418 
419 
420 
421 
422 
423 
424 
425 
426 
427 
428 
429 
430 
431 
432 TwistAcc TwistAcc::Zero()
433 {
434  return TwistAcc(VectorAcc::Zero(),VectorAcc::Zero());
435 }
436 
437 
438 void TwistAcc::ReverseSign()
439 {
440  vel.ReverseSign();
441  rot.ReverseSign();
442 }
443 
444 TwistAcc TwistAcc::RefPoint(const VectorAcc& v_base_AB)
445  // Changes the reference point of the TwistAcc.
446  // The RVector v_base_AB is expressed in the same base as the TwistAcc
447  // The RVector v_base_AB is a RVector from the old point to
448  // the new point.
449  // Complexity : 6M+6A
450 {
451  return TwistAcc(this->vel+this->rot*v_base_AB,this->rot);
452 }
453 
455 {
456  vel-=arg.vel;
457  rot -=arg.rot;
458  return *this;
459 }
460 
462 {
463  vel+=arg.vel;
464  rot +=arg.rot;
465  return *this;
466 }
467 
468 
469 TwistAcc operator*(const TwistAcc& lhs,double rhs)
470 {
471  return TwistAcc(lhs.vel*rhs,lhs.rot*rhs);
472 }
473 
474 TwistAcc operator*(double lhs,const TwistAcc& rhs)
475 {
476  return TwistAcc(lhs*rhs.vel,lhs*rhs.rot);
477 }
478 
479 TwistAcc operator/(const TwistAcc& lhs,double rhs)
480 {
481  return TwistAcc(lhs.vel/rhs,lhs.rot/rhs);
482 }
483 
484 
485 TwistAcc operator*(const TwistAcc& lhs,const doubleAcc& rhs)
486 {
487  return TwistAcc(lhs.vel*rhs,lhs.rot*rhs);
488 }
489 
490 TwistAcc operator*(const doubleAcc& lhs,const TwistAcc& rhs)
491 {
492  return TwistAcc(lhs*rhs.vel,lhs*rhs.rot);
493 }
494 
495 TwistAcc operator/(const TwistAcc& lhs,const doubleAcc& rhs)
496 {
497  return TwistAcc(lhs.vel/rhs,lhs.rot/rhs);
498 }
499 
500 
501 
502 // addition of TwistAcc's
503 TwistAcc operator+(const TwistAcc& lhs,const TwistAcc& rhs)
504 {
505  return TwistAcc(lhs.vel+rhs.vel,lhs.rot+rhs.rot);
506 }
507 
508 TwistAcc operator-(const TwistAcc& lhs,const TwistAcc& rhs)
509 {
510  return TwistAcc(lhs.vel-rhs.vel,lhs.rot-rhs.rot);
511 }
512 
513 // unary -
514 TwistAcc operator-(const TwistAcc& arg)
515 {
516  return TwistAcc(-arg.vel,-arg.rot);
517 }
518 
519 
520 
521 
522 
523 TwistAcc RotationAcc::Inverse(const TwistAcc& arg) const
524 {
525  return TwistAcc(Inverse(arg.vel),Inverse(arg.rot));
526 }
527 
529 {
530  return TwistAcc((*this)*arg.vel,(*this)*arg.rot);
531 }
532 
533 TwistAcc RotationAcc::Inverse(const Twist& arg) const
534 {
535  return TwistAcc(Inverse(arg.vel),Inverse(arg.rot));
536 }
537 
539 {
540  return TwistAcc((*this)*arg.vel,(*this)*arg.rot);
541 }
542 
543 
545 {
546  TwistAcc tmp;
547  tmp.rot = M*arg.rot;
548  tmp.vel = M*arg.vel+p*tmp.rot;
549  return tmp;
550 }
551 
553 {
554  TwistAcc tmp;
555  tmp.rot = M*arg.rot;
556  tmp.vel = M*arg.vel+p*tmp.rot;
557  return tmp;
558 }
559 
560 TwistAcc FrameAcc::Inverse(const TwistAcc& arg) const
561 {
562  TwistAcc tmp;
563  tmp.rot = M.Inverse(arg.rot);
564  tmp.vel = M.Inverse(arg.vel-p*arg.rot);
565  return tmp;
566 }
567 
568 TwistAcc FrameAcc::Inverse(const Twist& arg) const
569 {
570  TwistAcc tmp;
571  tmp.rot = M.Inverse(arg.rot);
572  tmp.vel = M.Inverse(arg.vel-p*arg.rot);
573  return tmp;
574 }
575 
576 Twist TwistAcc::GetTwist() const {
577  return Twist(vel.p,rot.p);
578 }
579 
580 Twist TwistAcc::GetTwistDot() const {
581  return Twist(vel.v,rot.v);
582 }
583 
584 bool Equal(const TwistAcc& a,const TwistAcc& b,double eps) {
585  return (Equal(a.rot,b.rot,eps)&&
586  Equal(a.vel,b.vel,eps) );
587 }
588 bool Equal(const Twist& a,const TwistAcc& b,double eps) {
589  return (Equal(a.rot,b.rot,eps)&&
590  Equal(a.vel,b.vel,eps) );
591 }
592 bool Equal(const TwistAcc& a,const Twist& b,double eps) {
593  return (Equal(a.rot,b.rot,eps)&&
594  Equal(a.vel,b.vel,eps) );
595 }
596 
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum const void *lists _GL_VOID_RET _GL_VOID const GLdouble *equation _GL_VOID_RET _GL_VOID GLdouble GLdouble blue _GL_VOID_RET _GL_VOID GLfloat GLfloat blue _GL_VOID_RET _GL_VOID GLint GLint blue _GL_VOID_RET _GL_VOID GLshort GLshort blue _GL_VOID_RET _GL_VOID GLubyte GLubyte blue _GL_VOID_RET _GL_VOID GLuint GLuint blue _GL_VOID_RET _GL_VOID GLushort GLushort blue _GL_VOID_RET _GL_VOID GLbyte GLbyte GLbyte alpha _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble alpha _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat alpha _GL_VOID_RET _GL_VOID GLint GLint GLint alpha _GL_VOID_RET _GL_VOID GLshort GLshort GLshort alpha _GL_VOID_RET _GL_VOID GLubyte GLubyte GLubyte alpha _GL_VOID_RET _GL_VOID GLuint GLuint GLuint alpha _GL_VOID_RET _GL_VOID GLushort GLushort GLushort alpha _GL_VOID_RET _GL_VOID GLenum mode _GL_VOID_RET _GL_VOID GLint GLsizei GLsizei GLenum type _GL_VOID_RET _GL_VOID GLsizei GLenum GLenum const void *pixels _GL_VOID_RET _GL_VOID const void *pointer _GL_VOID_RET _GL_VOID GLdouble v _GL_VOID_RET _GL_VOID GLfloat v _GL_VOID_RET _GL_VOID GLint GLint i2 _GL_VOID_RET _GL_VOID GLint j _GL_VOID_RET _GL_VOID GLfloat param _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble GLdouble GLdouble zFar _GL_VOID_RET _GL_UINT GLdouble *equation _GL_VOID_RET _GL_VOID GLenum GLint *params _GL_VOID_RET _GL_VOID GLenum GLfloat *v _GL_VOID_RET _GL_VOID GLenum GLfloat *params _GL_VOID_RET _GL_VOID GLfloat *values _GL_VOID_RET _GL_VOID GLushort *values _GL_VOID_RET _GL_VOID GLenum GLfloat *params _GL_VOID_RET _GL_VOID GLenum GLdouble *params _GL_VOID_RET _GL_VOID GLenum GLint *params _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_BOOL GLfloat param _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID GLenum GLfloat param _GL_VOID_RET _GL_VOID GLenum GLint param _GL_VOID_RET _GL_VOID GLushort pattern _GL_VOID_RET _GL_VOID GLdouble GLdouble GLint GLint const GLdouble *points _GL_VOID_RET _GL_VOID GLdouble GLdouble GLint GLint GLdouble GLdouble GLint GLint const GLdouble *points _GL_VOID_RET _GL_VOID GLdouble GLdouble u2 _GL_VOID_RET _GL_VOID GLdouble GLdouble GLint GLdouble GLdouble v2 _GL_VOID_RET _GL_VOID GLenum GLfloat param _GL_VOID_RET _GL_VOID GLenum GLint param _GL_VOID_RET _GL_VOID GLenum mode _GL_VOID_RET _GL_VOID GLdouble GLdouble nz _GL_VOID_RET _GL_VOID GLfloat GLfloat nz _GL_VOID_RET _GL_VOID GLint GLint nz _GL_VOID_RET _GL_VOID GLshort GLshort nz _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_VOID GLsizei const GLfloat *values _GL_VOID_RET _GL_VOID GLsizei const GLushort *values _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID const GLuint const GLclampf *priorities _GL_VOID_RET _GL_VOID GLdouble y _GL_VOID_RET _GL_VOID GLfloat y _GL_VOID_RET _GL_VOID GLint y _GL_VOID_RET _GL_VOID GLshort y _GL_VOID_RET _GL_VOID GLdouble GLdouble z _GL_VOID_RET _GL_VOID GLfloat GLfloat z _GL_VOID_RET _GL_VOID GLint GLint z _GL_VOID_RET _GL_VOID GLshort GLshort z _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble w _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat w _GL_VOID_RET _GL_VOID GLint GLint GLint w _GL_VOID_RET _GL_VOID GLshort GLshort GLshort w _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble y2 _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat y2 _GL_VOID_RET _GL_VOID GLint GLint GLint y2 _GL_VOID_RET _GL_VOID GLshort GLshort GLshort y2 _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble z _GL_VOID_RET _GL_VOID GLdouble GLdouble z _GL_VOID_RET _GL_VOID GLuint *buffer _GL_VOID_RET _GL_VOID GLdouble t _GL_VOID_RET _GL_VOID GLfloat t _GL_VOID_RET _GL_VOID GLint t _GL_VOID_RET _GL_VOID GLshort t _GL_VOID_RET _GL_VOID GLdouble GLdouble r _GL_VOID_RET _GL_VOID GLfloat GLfloat r _GL_VOID_RET _GL_VOID GLint GLint r _GL_VOID_RET _GL_VOID GLshort GLshort r _GL_VOID_RET _GL_VOID GLdouble GLdouble r
struct Frame Frame
Definition: frames.hpp:261
__forceinline avxi & operator-=(avxi &a, const avxi &b)
Definition: avxi.h:394
__forceinline avxi & operator+=(avxi &a, const avxi &b)
Assignment Operators.
Definition: avxi.h:385
ATTR_WARN_UNUSED_RESULT const BMVert * v
btGeneric6DofConstraint & operator=(btGeneric6DofConstraint &other)
SIMD_FORCE_INLINE const btScalar & w() const
Return the w value.
Definition: btQuadWord.h:119
RotationAcc M
Rotation,angular velocity, and angular acceleration of frame.
Definition: frameacc.hpp:149
VectorAcc p
Translation, velocity and acceleration of origin.
Definition: frameacc.hpp:150
represents a frame transformation in 3D space (rotation + translation)
Definition: frames.hpp:526
Rotation M
Orientation of the Frame.
Definition: frames.hpp:529
Vector p
origine of the Frame
Definition: frames.hpp:528
V d
1st derivative
Definition: rall2d.h:56
V dd
2nd derivative
Definition: rall2d.h:57
T t
value
Definition: rall2d.h:55
Vector dw
angular acceration vector
Definition: frameacc.hpp:96
Vector w
angular velocity vector
Definition: frameacc.hpp:95
Rotation R
rotation matrix
Definition: frameacc.hpp:94
represents rotations in 3 dimensional space.
Definition: frames.hpp:299
VectorAcc rot
rotational velocity and its 1st and 2nd derivative
Definition: frameacc.hpp:194
VectorAcc vel
translational velocity and its 1st and 2nd derivative
Definition: frameacc.hpp:193
represents both translational and rotational velocities.
Definition: frames.hpp:679
Vector rot
The rotational velocity of that point.
Definition: frames.hpp:682
Vector vel
The velocity of that point.
Definition: frames.hpp:681
Vector p
position vector
Definition: frameacc.hpp:45
Vector dv
acceleration vector
Definition: frameacc.hpp:47
Vector v
velocity vector
Definition: frameacc.hpp:46
A concrete implementation of a 3 dimensional vector class.
Definition: frames.hpp:143
#define rot(x, k)
bool Equal(const VectorAcc &r1, const VectorAcc &r2, double eps)
Definition: frameacc.inl:157
VectorAcc operator*(const VectorAcc &r1, const VectorAcc &r2)
Definition: frameacc.inl:50
VectorAcc operator-(const VectorAcc &r1, const VectorAcc &r2)
Definition: frameacc.inl:26
VectorAcc operator/(const VectorAcc &r1, double r2)
Definition: frameacc.inl:178
doubleAcc dot(const VectorAcc &lhs, const VectorAcc &rhs)
Definition: frameacc.inl:135
VectorAcc operator+(const VectorAcc &r1, const VectorAcc &r2)
Definition: frameacc.inl:22
#define M
#define R
static unsigned a[3]
Definition: RandGen.cpp:78
INLINE S Norm(const Rall1d< T, V, S > &value)
Definition: rall1d.h:416
Rall2d< double, double, double > doubleAcc
Definition: frameacc.hpp:38
static const pxr::TfToken b("b", pxr::TfToken::Immortal)
const btScalar eps
Definition: poly34.cpp:11