b2Body.h
Go to the documentation of this file.
1 /*
2 * Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
3 *
4 * This software is provided 'as-is', without any express or implied
5 * warranty. In no event will the authors be held liable for any damages
6 * arising from the use of this software.
7 * Permission is granted to anyone to use this software for any purpose,
8 * including commercial applications, and to alter it and redistribute it
9 * freely, subject to the following restrictions:
10 * 1. The origin of this software must not be misrepresented; you must not
11 * claim that you wrote the original software. If you use this software
12 * in a product, an acknowledgment in the product documentation would be
13 * appreciated but is not required.
14 * 2. Altered source versions must be plainly marked as such, and must not be
15 * misrepresented as being the original software.
16 * 3. This notice may not be removed or altered from any source distribution.
17 */
18 
19 #ifndef B2_BODY_H
20 #define B2_BODY_H
21 
22 #include <Box2D/Common/b2Math.h>
24 #include <memory>
25 
26 class b2Fixture;
27 class b2Joint;
28 class b2Contact;
29 class b2Controller;
30 class b2World;
31 struct b2FixtureDef;
32 struct b2JointEdge;
33 struct b2ContactEdge;
34 
40 {
44 
45  // TODO_ERIN
46  //b2_bulletBody,
47 };
48 
51 struct b2BodyDef
52 {
55  {
56  userData = NULL;
57  position.Set(0.0f, 0.0f);
58  angle = 0.0f;
59  linearVelocity.Set(0.0f, 0.0f);
60  angularVelocity = 0.0f;
61  linearDamping = 0.0f;
62  angularDamping = 0.0f;
63  allowSleep = true;
64  awake = true;
65  fixedRotation = false;
66  bullet = false;
68  active = true;
69  gravityScale = 1.0f;
70  }
71 
75 
79 
82 
85 
88 
93 
98 
102 
104  bool awake;
105 
108 
113  bool bullet;
114 
116  bool active;
117 
119  void* userData;
120 
123 };
124 
126 class b2Body
127 {
128 public:
136  b2Fixture* CreateFixture(const b2FixtureDef* def);
137 
145  b2Fixture* CreateFixture(const b2Shape* shape, float32 density);
146 
154  void DestroyFixture(b2Fixture* fixture);
155 
161  void SetTransform(const b2Vec2& position, float32 angle);
162 
165  const b2Transform& GetTransform() const;
166 
169  const b2Vec2& GetPosition() const;
170 
173  float32 GetAngle() const;
174 
176  const b2Vec2& GetWorldCenter() const;
177 
179  const b2Vec2& GetLocalCenter() const;
180 
183  void SetLinearVelocity(const b2Vec2& v);
184 
187  const b2Vec2& GetLinearVelocity() const;
188 
191  void SetAngularVelocity(float32 omega);
192 
195  float32 GetAngularVelocity() const;
196 
203  void ApplyForce(const b2Vec2& force, const b2Vec2& point, bool wake);
204 
208  void ApplyForceToCenter(const b2Vec2& force, bool wake);
209 
215  void ApplyTorque(float32 torque, bool wake);
216 
223  void ApplyLinearImpulse(const b2Vec2& impulse, const b2Vec2& point, bool wake);
224 
228  void ApplyAngularImpulse(float32 impulse, bool wake);
229 
232  float32 GetMass() const;
233 
236  float32 GetInertia() const;
237 
240  void GetMassData(b2MassData* data) const;
241 
247  void SetMassData(const b2MassData* data);
248 
252  void ResetMassData();
253 
257  b2Vec2 GetWorldPoint(const b2Vec2& localPoint) const;
258 
262  b2Vec2 GetWorldVector(const b2Vec2& localVector) const;
263 
267  b2Vec2 GetLocalPoint(const b2Vec2& worldPoint) const;
268 
272  b2Vec2 GetLocalVector(const b2Vec2& worldVector) const;
273 
277  b2Vec2 GetLinearVelocityFromWorldPoint(const b2Vec2& worldPoint) const;
278 
282  b2Vec2 GetLinearVelocityFromLocalPoint(const b2Vec2& localPoint) const;
283 
285  float32 GetLinearDamping() const;
286 
288  void SetLinearDamping(float32 linearDamping);
289 
291  float32 GetAngularDamping() const;
292 
294  void SetAngularDamping(float32 angularDamping);
295 
297  float32 GetGravityScale() const;
298 
300  void SetGravityScale(float32 scale);
301 
303  void SetType(b2BodyType type);
304 
306  b2BodyType GetType() const;
307 
309  void SetBullet(bool flag);
310 
312  bool IsBullet() const;
313 
316  void SetSleepingAllowed(bool flag);
317 
319  bool IsSleepingAllowed() const;
320 
324  void SetAwake(bool flag);
325 
328  bool IsAwake() const;
329 
343  void SetActive(bool flag);
344 
346  bool IsActive() const;
347 
350  void SetFixedRotation(bool flag);
351 
353  bool IsFixedRotation() const;
354 
356  b2Fixture* GetFixtureList();
357  const b2Fixture* GetFixtureList() const;
358 
360  b2JointEdge* GetJointList();
361  const b2JointEdge* GetJointList() const;
362 
366  b2ContactEdge* GetContactList();
367  const b2ContactEdge* GetContactList() const;
368 
370  b2Body* GetNext();
371  const b2Body* GetNext() const;
372 
374  void* GetUserData() const;
375 
377  void SetUserData(void* data);
378 
380  b2World* GetWorld();
381  const b2World* GetWorld() const;
382 
384  void Dump();
385 
386 private:
387 
388  friend class b2World;
389  friend class b2Island;
390  friend class b2ContactManager;
391  friend class b2ContactSolver;
392  friend class b2Contact;
393 
394  friend class b2DistanceJoint;
395  friend class b2FrictionJoint;
396  friend class b2GearJoint;
397  friend class b2MotorJoint;
398  friend class b2MouseJoint;
399  friend class b2PrismaticJoint;
400  friend class b2PulleyJoint;
401  friend class b2RevoluteJoint;
402  friend class b2RopeJoint;
403  friend class b2WeldJoint;
404  friend class b2WheelJoint;
405 
406  // m_flags
407  enum
408  {
409  e_islandFlag = 0x0001,
410  e_awakeFlag = 0x0002,
411  e_autoSleepFlag = 0x0004,
412  e_bulletFlag = 0x0008,
413  e_fixedRotationFlag = 0x0010,
414  e_activeFlag = 0x0020,
415  e_toiFlag = 0x0040
416  };
417 
418  b2Body(const b2BodyDef* bd, b2World* world);
419  ~b2Body();
420 
421  void SynchronizeFixtures();
422  void SynchronizeTransform();
423 
424  // This is used to prevent connected bodies from colliding.
425  // It may lie, depending on the collideConnected flag.
426  bool ShouldCollide(const b2Body* other) const;
427 
428  void Advance(float32 t);
429 
431 
433 
435 
436  b2Transform m_xf; // the body origin transform
437  b2Sweep m_sweep; // the swept motion for CCD
438 
441 
444 
448 
451 
454 
455  float32 m_mass, m_invMass;
456 
457  // Rotational inertia about the center of mass.
459 
463 
465 
466  void* m_userData;
467 };
468 
470 {
471  return m_type;
472 }
473 
474 inline const b2Transform& b2Body::GetTransform() const
475 {
476  return m_xf;
477 }
478 
479 inline const b2Vec2& b2Body::GetPosition() const
480 {
481  return m_xf.p;
482 }
483 
484 inline float32 b2Body::GetAngle() const
485 {
486  return m_sweep.a;
487 }
488 
489 inline const b2Vec2& b2Body::GetWorldCenter() const
490 {
491  return m_sweep.c;
492 }
493 
494 inline const b2Vec2& b2Body::GetLocalCenter() const
495 {
496  return m_sweep.localCenter;
497 }
498 
499 inline void b2Body::SetLinearVelocity(const b2Vec2& v)
500 {
501  if (m_type == b2_staticBody)
502  {
503  return;
504  }
505 
506  if (b2Dot(v,v) > 0.0f)
507  {
508  SetAwake(true);
509  }
510 
511  m_linearVelocity = v;
512 }
513 
514 inline const b2Vec2& b2Body::GetLinearVelocity() const
515 {
516  return m_linearVelocity;
517 }
518 
520 {
521  if (m_type == b2_staticBody)
522  {
523  return;
524  }
525 
526  if (w * w > 0.0f)
527  {
528  SetAwake(true);
529  }
530 
531  m_angularVelocity = w;
532 }
533 
535 {
536  return m_angularVelocity;
537 }
538 
539 inline float32 b2Body::GetMass() const
540 {
541  return m_mass;
542 }
543 
545 {
546  return m_I + m_mass * b2Dot(m_sweep.localCenter, m_sweep.localCenter);
547 }
548 
550 {
551  data->mass = m_mass;
552  data->I = m_I + m_mass * b2Dot(m_sweep.localCenter, m_sweep.localCenter);
553  data->center = m_sweep.localCenter;
554 }
555 
556 inline b2Vec2 b2Body::GetWorldPoint(const b2Vec2& localPoint) const
557 {
558  return b2Mul(m_xf, localPoint);
559 }
560 
561 inline b2Vec2 b2Body::GetWorldVector(const b2Vec2& localVector) const
562 {
563  return b2Mul(m_xf.q, localVector);
564 }
565 
566 inline b2Vec2 b2Body::GetLocalPoint(const b2Vec2& worldPoint) const
567 {
568  return b2MulT(m_xf, worldPoint);
569 }
570 
571 inline b2Vec2 b2Body::GetLocalVector(const b2Vec2& worldVector) const
572 {
573  return b2MulT(m_xf.q, worldVector);
574 }
575 
577 {
578  return m_linearVelocity + b2Cross(m_angularVelocity, worldPoint - m_sweep.c);
579 }
580 
582 {
583  return GetLinearVelocityFromWorldPoint(GetWorldPoint(localPoint));
584 }
585 
587 {
588  return m_linearDamping;
589 }
590 
592 {
593  m_linearDamping = linearDamping;
594 }
595 
597 {
598  return m_angularDamping;
599 }
600 
602 {
603  m_angularDamping = angularDamping;
604 }
605 
607 {
608  return m_gravityScale;
609 }
610 
612 {
613  m_gravityScale = scale;
614 }
615 
616 inline void b2Body::SetBullet(bool flag)
617 {
618  if (flag)
619  {
620  m_flags |= e_bulletFlag;
621  }
622  else
623  {
624  m_flags &= ~e_bulletFlag;
625  }
626 }
627 
628 inline bool b2Body::IsBullet() const
629 {
630  return (m_flags & e_bulletFlag) == e_bulletFlag;
631 }
632 
633 inline void b2Body::SetAwake(bool flag)
634 {
635  if (flag)
636  {
637  if ((m_flags & e_awakeFlag) == 0)
638  {
639  m_flags |= e_awakeFlag;
640  m_sleepTime = 0.0f;
641  }
642  }
643  else
644  {
645  m_flags &= ~e_awakeFlag;
646  m_sleepTime = 0.0f;
647  m_linearVelocity.SetZero();
648  m_angularVelocity = 0.0f;
649  m_force.SetZero();
650  m_torque = 0.0f;
651  }
652 }
653 
654 inline bool b2Body::IsAwake() const
655 {
656  return (m_flags & e_awakeFlag) == e_awakeFlag;
657 }
658 
659 inline bool b2Body::IsActive() const
660 {
661  return (m_flags & e_activeFlag) == e_activeFlag;
662 }
663 
664 inline bool b2Body::IsFixedRotation() const
665 {
666  return (m_flags & e_fixedRotationFlag) == e_fixedRotationFlag;
667 }
668 
669 inline void b2Body::SetSleepingAllowed(bool flag)
670 {
671  if (flag)
672  {
673  m_flags |= e_autoSleepFlag;
674  }
675  else
676  {
677  m_flags &= ~e_autoSleepFlag;
678  SetAwake(true);
679  }
680 }
681 
682 inline bool b2Body::IsSleepingAllowed() const
683 {
684  return (m_flags & e_autoSleepFlag) == e_autoSleepFlag;
685 }
686 
688 {
689  return m_fixtureList;
690 }
691 
692 inline const b2Fixture* b2Body::GetFixtureList() const
693 {
694  return m_fixtureList;
695 }
696 
698 {
699  return m_jointList;
700 }
701 
702 inline const b2JointEdge* b2Body::GetJointList() const
703 {
704  return m_jointList;
705 }
706 
708 {
709  return m_contactList;
710 }
711 
713 {
714  return m_contactList;
715 }
716 
718 {
719  return m_next;
720 }
721 
722 inline const b2Body* b2Body::GetNext() const
723 {
724  return m_next;
725 }
726 
727 inline void b2Body::SetUserData(void* data)
728 {
729  m_userData = data;
730 }
731 
732 inline void* b2Body::GetUserData() const
733 {
734  return m_userData;
735 }
736 
737 inline void b2Body::ApplyForce(const b2Vec2& force, const b2Vec2& point, bool wake)
738 {
739  if (m_type != b2_dynamicBody)
740  {
741  return;
742  }
743 
744  if (wake && (m_flags & e_awakeFlag) == 0)
745  {
746  SetAwake(true);
747  }
748 
749  // Don't accumulate a force if the body is sleeping.
750  if (m_flags & e_awakeFlag)
751  {
752  m_force += force;
753  m_torque += b2Cross(point - m_sweep.c, force);
754  }
755 }
756 
757 inline void b2Body::ApplyForceToCenter(const b2Vec2& force, bool wake)
758 {
759  if (m_type != b2_dynamicBody)
760  {
761  return;
762  }
763 
764  if (wake && (m_flags & e_awakeFlag) == 0)
765  {
766  SetAwake(true);
767  }
768 
769  // Don't accumulate a force if the body is sleeping
770  if (m_flags & e_awakeFlag)
771  {
772  m_force += force;
773  }
774 }
775 
776 inline void b2Body::ApplyTorque(float32 torque, bool wake)
777 {
778  if (m_type != b2_dynamicBody)
779  {
780  return;
781  }
782 
783  if (wake && (m_flags & e_awakeFlag) == 0)
784  {
785  SetAwake(true);
786  }
787 
788  // Don't accumulate a force if the body is sleeping
789  if (m_flags & e_awakeFlag)
790  {
791  m_torque += torque;
792  }
793 }
794 
795 inline void b2Body::ApplyLinearImpulse(const b2Vec2& impulse, const b2Vec2& point, bool wake)
796 {
797  if (m_type != b2_dynamicBody)
798  {
799  return;
800  }
801 
802  if (wake && (m_flags & e_awakeFlag) == 0)
803  {
804  SetAwake(true);
805  }
806 
807  // Don't accumulate velocity if the body is sleeping
808  if (m_flags & e_awakeFlag)
809  {
810  m_linearVelocity += m_invMass * impulse;
811  m_angularVelocity += m_invI * b2Cross(point - m_sweep.c, impulse);
812  }
813 }
814 
815 inline void b2Body::ApplyAngularImpulse(float32 impulse, bool wake)
816 {
817  if (m_type != b2_dynamicBody)
818  {
819  return;
820  }
821 
822  if (wake && (m_flags & e_awakeFlag) == 0)
823  {
824  SetAwake(true);
825  }
826 
827  // Don't accumulate velocity if the body is sleeping
828  if (m_flags & e_awakeFlag)
829  {
830  m_angularVelocity += m_invI * impulse;
831  }
832 }
833 
835 {
836  m_xf.q.Set(m_sweep.a);
837  m_xf.p = m_sweep.c - b2Mul(m_xf.q, m_sweep.localCenter);
838 }
839 
841 {
842  // Advance to the new safe time. This doesn't sync the broad-phase.
843  m_sweep.Advance(alpha);
844  m_sweep.c = m_sweep.c0;
845  m_sweep.a = m_sweep.a0;
846  m_xf.q.Set(m_sweep.a);
847  m_xf.p = m_sweep.c - b2Mul(m_xf.q, m_sweep.localCenter);
848 }
849 
851 {
852  return m_world;
853 }
854 
855 inline const b2World* b2Body::GetWorld() const
856 {
857  return m_world;
858 }
859 
860 #endif
b2BodyDef()
This constructor sets the body definition default values.
Definition: b2Body.h:54
const GLdouble * v
This is an internal class.
Definition: b2Island.h:34
float32 b2Dot(const b2Vec2 &a, const b2Vec2 &b)
Perform the dot product on two vectors.
Definition: b2Math.h:405
int32 m_islandIndex
Definition: b2Body.h:434
b2Vec2 b2Mul(const b2Mat22 &A, const b2Vec2 &v)
Definition: b2Math.h:432
float32 m_gravityScale
Definition: b2Body.h:462
float32 linearDamping
Definition: b2Body.h:92
float32 angularVelocity
The angular velocity of the body.
Definition: b2Body.h:87
bool fixedRotation
Should this body be prevented from rotating? Useful for characters.
Definition: b2Body.h:107
bool IsBullet() const
Is this body treated like a bullet for continuous collision detection?
Definition: b2Body.h:628
GLenum GLenum GLenum GLenum GLenum scale
unsigned short uint16
Definition: b2Settings.h:33
void SetUserData(void *data)
Set the user data. Use this to store your application specific data.
Definition: b2Body.h:727
void ApplyForceToCenter(const b2Vec2 &force, bool wake)
Definition: b2Body.h:757
GLclampf GLclampf GLclampf alpha
void SetAngularVelocity(float32 omega)
Definition: b2Body.h:519
b2Vec2 m_linearVelocity
Definition: b2Body.h:439
float32 I
The rotational inertia of the shape about the local origin.
Definition: b2Shape.h:36
GLubyte GLubyte GLubyte GLubyte w
void SetAngularDamping(float32 angularDamping)
Set the angular damping of the body.
Definition: b2Body.h:601
b2Vec2 m_force
Definition: b2Body.h:442
GLdouble GLdouble t
void ApplyForce(const b2Vec2 &force, const b2Vec2 &point, bool wake)
Definition: b2Body.h:737
b2ContactEdge * GetContactList()
Definition: b2Body.h:707
b2ContactEdge * m_contactList
Definition: b2Body.h:453
float32 angularDamping
Definition: b2Body.h:97
bool IsAwake() const
Definition: b2Body.h:654
float32 GetInertia() const
Definition: b2Body.h:544
void ApplyTorque(float32 torque, bool wake)
Definition: b2Body.h:776
float32 GetGravityScale() const
Get the gravity scale of the body.
Definition: b2Body.h:606
float32 GetAngularDamping() const
Get the angular damping of the body.
Definition: b2Body.h:596
void SetSleepingAllowed(bool flag)
Definition: b2Body.h:669
b2Vec2 GetWorldPoint(const b2Vec2 &localPoint) const
Definition: b2Body.h:556
void SetLinearDamping(float32 linearDamping)
Set the linear damping of the body.
Definition: b2Body.h:591
bool bullet
Definition: b2Body.h:113
b2Vec2 center
The position of the shape&#39;s centroid relative to the shape&#39;s origin.
Definition: b2Shape.h:33
float32 GetAngle() const
Definition: b2Body.h:484
A 2D column vector.
Definition: b2Math.h:52
float32 m_angularDamping
Definition: b2Body.h:461
b2JointEdge * GetJointList()
Get the list of all joints attached to this body.
Definition: b2Body.h:697
float32 GetAngularVelocity() const
Definition: b2Body.h:534
signed int int32
Definition: b2Settings.h:31
float32 b2Cross(const b2Vec2 &a, const b2Vec2 &b)
Perform the cross product on two vectors. In 2D this produces a scalar.
Definition: b2Math.h:411
b2Vec2 linearVelocity
The linear velocity of the body&#39;s origin in world co-ordinates.
Definition: b2Body.h:84
b2JointEdge * m_jointList
Definition: b2Body.h:452
void SetBullet(bool flag)
Should this body be treated like a bullet for continuous collision detection?
Definition: b2Body.h:616
b2BodyType type
Definition: b2Body.h:74
float32 angle
The world angle of the body in radians.
Definition: b2Body.h:81
bool active
Does this body start out active?
Definition: b2Body.h:116
float32 m_linearDamping
Definition: b2Body.h:460
A rigid body. These are created via b2World::CreateBody.
Definition: b2Body.h:126
b2Body * m_prev
Definition: b2Body.h:446
float32 GetLinearDamping() const
Get the linear damping of the body.
Definition: b2Body.h:586
float32 mass
The mass of the shape, usually in kilograms.
Definition: b2Shape.h:30
void SetLinearVelocity(const b2Vec2 &v)
Definition: b2Body.h:499
b2Joint * m_next
Definition: b2Joint.h:172
b2World * m_world
Definition: b2Body.h:445
b2Vec2 GetWorldVector(const b2Vec2 &localVector) const
Definition: b2Body.h:561
float32 m_mass
Definition: b2Body.h:455
float32 m_invI
Definition: b2Body.h:458
int32 m_fixtureCount
Definition: b2Body.h:450
float32 gravityScale
Scale the gravity applied to this body.
Definition: b2Body.h:122
GLint GLenum GLsizei GLint GLsizei const GLvoid * data
b2Body * GetNext()
Get the next body in the world&#39;s body list.
Definition: b2Body.h:717
b2Vec2 GetLinearVelocityFromWorldPoint(const b2Vec2 &worldPoint) const
Definition: b2Body.h:576
bool awake
Is this body initially awake or sleeping?
Definition: b2Body.h:104
b2JointType m_type
Definition: b2Joint.h:170
void * m_userData
Definition: b2Joint.h:183
void SynchronizeTransform()
Definition: b2Body.h:834
bool IsActive() const
Get the active state of the body.
Definition: b2Body.h:659
b2Vec2 b2MulT(const b2Mat22 &A, const b2Vec2 &v)
Definition: b2Math.h:439
const b2Vec2 & GetLocalCenter() const
Get the local position of the center of mass.
Definition: b2Body.h:494
void SetGravityScale(float32 scale)
Set the gravity scale of the body.
Definition: b2Body.h:611
void GetMassData(b2MassData *data) const
Definition: b2Body.h:549
b2Vec2 GetLinearVelocityFromLocalPoint(const b2Vec2 &localPoint) const
Definition: b2Body.h:581
b2Vec2 GetLocalPoint(const b2Vec2 &worldPoint) const
Definition: b2Body.h:566
bool IsFixedRotation() const
Does this body have fixed rotation?
Definition: b2Body.h:664
float32 m_torque
Definition: b2Body.h:443
b2Vec2 position
Definition: b2Body.h:78
b2Vec2 GetLocalVector(const b2Vec2 &worldVector) const
Definition: b2Body.h:571
b2BodyType GetType() const
Get the type of this body.
Definition: b2Body.h:469
float32 GetMass() const
Definition: b2Body.h:539
const b2Vec2 & GetLinearVelocity() const
Definition: b2Body.h:514
float32 m_sleepTime
Definition: b2Body.h:464
float32 m_mass
Definition: b2WheelJoint.h:172
const b2Vec2 & GetWorldCenter() const
Get the world position of the center of mass.
Definition: b2Body.h:489
uint16 m_flags
Definition: b2Body.h:432
const b2Vec2 & GetPosition() const
Definition: b2Body.h:479
b2Transform m_xf
Definition: b2Body.h:436
void * m_userData
Definition: b2Body.h:466
float32 m_angularVelocity
Definition: b2Body.h:440
void Advance(float32 t)
Definition: b2Body.h:840
b2Fixture * GetFixtureList()
Get the list of all fixtures attached to this body.
Definition: b2Body.h:687
GLdouble angle
bool allowSleep
Definition: b2Body.h:101
void * GetUserData() const
Get the user data pointer that was provided in the body definition.
Definition: b2Body.h:732
void ApplyLinearImpulse(const b2Vec2 &impulse, const b2Vec2 &point, bool wake)
Definition: b2Body.h:795
const b2Transform & GetTransform() const
Definition: b2Body.h:474
GLuint GLuint GLsizei GLenum type
b2BodyType m_type
Definition: b2Body.h:430
void Set(float32 x_, float32 y_)
Set this vector to some specified coordinates.
Definition: b2Math.h:64
This holds the mass data computed for a shape.
Definition: b2Shape.h:27
friend class b2Body
Definition: b2Joint.h:154
void ApplyAngularImpulse(float32 impulse, bool wake)
Definition: b2Body.h:815
bool IsSleepingAllowed() const
Is this body allowed to sleep.
Definition: b2Body.h:682
void SetAwake(bool flag)
Definition: b2Body.h:633
void * userData
Use this to store application specific body data.
Definition: b2Body.h:119
b2BodyType
Definition: b2Body.h:39
b2Sweep m_sweep
Definition: b2Body.h:437
float float32
Definition: b2Settings.h:35
b2World * GetWorld()
Get the parent world of this body.
Definition: b2Body.h:850
b2Fixture * m_fixtureList
Definition: b2Body.h:449
GLdouble GLdouble GLdouble GLdouble GLdouble GLdouble f
b2Body * m_next
Definition: b2Body.h:447


mvsim
Author(s):
autogenerated on Fri May 7 2021 03:05:51