Box2D: b2Body.h Source File

| Box2D 2.3.0 A 2D Physics Engine for Games

b2Body.h
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>
23 #include <Box2D/Collision/Shapes/b2Shape.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
39 enum b2BodyType
40 {
41 b2_staticBody = 0,
42 b2_kinematicBody,
43 b2_dynamicBody
44
45 // TODO_ERIN
46 //b2_bulletBody,
47 };
48
51 struct b2BodyDef
52 {
54 b2BodyDef()
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;
67 type = b2_staticBody;
68 active = true;
69 gravityScale = 1.0f;
70 }
71
74 b2BodyType type;
75
78 b2Vec2 position;
79
81 float32 angle;
82
84 b2Vec2 linearVelocity;
85
87 float32 angularVelocity;
88
92 float32 linearDamping;
93
97 float32 angularDamping;
98
101 bool allowSleep;
102
104 bool awake;
105
107 bool fixedRotation;
108
113 bool bullet;
114
116 bool active;
117
119 void* userData;
120
122 float32 gravityScale;
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
430 b2BodyType m_type;
431
432 uint16 m_flags;
433
434 int32 m_islandIndex;
435
436 b2Transform m_xf; // the body origin transform
437 b2Sweep m_sweep; // the swept motion for CCD
438
439 b2Vec2 m_linearVelocity;
440 float32 m_angularVelocity;
441
442 b2Vec2 m_force;
443 float32 m_torque;
444
445 b2World* m_world;
446 b2Body* m_prev;
447 b2Body* m_next;
448
449 b2Fixture* m_fixtureList;
450 int32 m_fixtureCount;
451
452 b2JointEdge* m_jointList;
453 b2ContactEdge* m_contactList;
454
455 float32 m_mass, m_invMass;
456
457 // Rotational inertia about the center of mass.
458 float32 m_I, m_invI;
459
460 float32 m_linearDamping;
461 float32 m_angularDamping;
462 float32 m_gravityScale;
463
464 float32 m_sleepTime;
465
466 void* m_userData;
467 };
468
469 inline b2BodyType b2Body::GetType() const
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
519 inline void b2Body::SetAngularVelocity(float32 w)
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
534 inline float32 b2Body::GetAngularVelocity() const
535 {
536 return m_angularVelocity;
537 }
538
539 inline float32 b2Body::GetMass() const
540 {
541 return m_mass;
542 }
543
544 inline float32 b2Body::GetInertia() const
545 {
546 return m_I + m_mass * b2Dot(m_sweep.localCenter, m_sweep.localCenter);
547 }
548
549 inline void b2Body::GetMassData(b2MassData* data) const
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
576 inline b2Vec2 b2Body::GetLinearVelocityFromWorldPoint(const b2Vec2& worldPoint) const
577 {
578 return m_linearVelocity + b2Cross(m_angularVelocity, worldPoint - m_sweep.c);
579 }
580
581 inline b2Vec2 b2Body::GetLinearVelocityFromLocalPoint(const b2Vec2& localPoint) const
582 {
583 return GetLinearVelocityFromWorldPoint(GetWorldPoint(localPoint));
584 }
585
586 inline float32 b2Body::GetLinearDamping() const
587 {
588 return m_linearDamping;
589 }
590
591 inline void b2Body::SetLinearDamping(float32 linearDamping)
592 {
593 m_linearDamping = linearDamping;
594 }
595
596 inline float32 b2Body::GetAngularDamping() const
597 {
598 return m_angularDamping;
599 }
600
601 inline void b2Body::SetAngularDamping(float32 angularDamping)
602 {
603 m_angularDamping = angularDamping;
604 }
605
606 inline float32 b2Body::GetGravityScale() const
607 {
608 return m_gravityScale;
609 }
610
611 inline void b2Body::SetGravityScale(float32 scale)
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
687 inline b2Fixture* b2Body::GetFixtureList()
688 {
689 return m_fixtureList;
690 }
691
692 inline const b2Fixture* b2Body::GetFixtureList() const
693 {
694 return m_fixtureList;
695 }
696
697 inline b2JointEdge* b2Body::GetJointList()
698 {
699 return m_jointList;
700 }
701
702 inline const b2JointEdge* b2Body::GetJointList() const
703 {
704 return m_jointList;
705 }
706
707 inline b2ContactEdge* b2Body::GetContactList()
708 {
709 return m_contactList;
710 }
711
712 inline const b2ContactEdge* b2Body::GetContactList() const
713 {
714 return m_contactList;
715 }
716
717 inline b2Body* b2Body::GetNext()
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
834 inline void b2Body::SynchronizeTransform()
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
840 inline void b2Body::Advance(float32 alpha)
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
850 inline b2World* b2Body::GetWorld()
851 {
852 return m_world;
853 }
854
855 inline const b2World* b2Body::GetWorld() const
856 {
857 return m_world;
858 }
859
860 #endif
b2Vec2
A 2D column vector.
Definition: b2Math.h:53
b2FrictionJoint
Definition: b2FrictionJoint.h:55
b2Body::IsAwake
bool IsAwake() const
Definition: b2Body.h:654
b2Body
A rigid body. These are created via b2World::CreateBody.
Definition: b2Body.h:126
b2Body::GetMassData
void GetMassData(b2MassData *data) const
Definition: b2Body.h:549
b2Body::SetBullet
void SetBullet(bool flag)
Should this body be treated like a bullet for continuous collision detection?
Definition: b2Body.h:616
b2ContactManager
Definition: b2ContactManager.h:30
b2Body::GetFixtureList
b2Fixture * GetFixtureList()
Get the list of all fixtures attached to this body.
Definition: b2Body.h:687
b2DistanceJoint
Definition: b2DistanceJoint.h:67
b2Vec2::Set
void Set(float32 x_, float32 y_)
Set this vector to some specified coordinates.
Definition: b2Math.h:65
b2Body::GetLocalPoint
b2Vec2 GetLocalPoint(const b2Vec2 &worldPoint) const
Definition: b2Body.h:566
b2Body::GetTransform
const b2Transform & GetTransform() const
Definition: b2Body.h:474
b2Body::GetJointList
b2JointEdge * GetJointList()
Get the list of all joints attached to this body.
Definition: b2Body.h:697
b2Transform
Definition: b2Math.h:350
b2Body::GetType
b2BodyType GetType() const
Get the type of this body.
Definition: b2Body.h:469
b2Body::GetWorldPoint
b2Vec2 GetWorldPoint(const b2Vec2 &localPoint) const
Definition: b2Body.h:556
b2Body::GetNext
b2Body * GetNext()
Get the next body in the world's body list.
Definition: b2Body.h:717
b2Sweep
Definition: b2Math.h:380
b2Body::GetAngularVelocity
float32 GetAngularVelocity() const
Definition: b2Body.h:534
b2Body::GetLinearVelocityFromWorldPoint
b2Vec2 GetLinearVelocityFromWorldPoint(const b2Vec2 &worldPoint) const
Definition: b2Body.h:576
b2PrismaticJoint
Definition: b2PrismaticJoint.h:86
b2BodyDef::fixedRotation
bool fixedRotation
Should this body be prevented from rotating? Useful for characters.
Definition: b2Body.h:107
b2BodyDef::angularVelocity
float32 angularVelocity
The angular velocity of the body.
Definition: b2Body.h:87
b2BodyDef::b2BodyDef
b2BodyDef()
This constructor sets the body definition default values.
Definition: b2Body.h:54
b2Body::GetLinearVelocity
const b2Vec2 & GetLinearVelocity() const
Definition: b2Body.h:514
b2Body::SetType
void SetType(b2BodyType type)
Set the type of this body. This may alter the mass and velocity.
Definition: b2Body.cpp:113
b2Body::GetLocalVector
b2Vec2 GetLocalVector(const b2Vec2 &worldVector) const
Definition: b2Body.h:571
b2Sweep::c
b2Vec2 c
center world positions
Definition: b2Math.h:394
b2BodyDef::userData
void * userData
Use this to store application specific body data.
Definition: b2Body.h:119
b2WheelJoint
Definition: b2WheelJoint.h:79
b2Body::SetSleepingAllowed
void SetSleepingAllowed(bool flag)
Definition: b2Body.h:669
b2Body::GetAngularDamping
float32 GetAngularDamping() const
Get the angular damping of the body.
Definition: b2Body.h:596
b2BodyDef::angularDamping
float32 angularDamping
Definition: b2Body.h:97
b2Body::IsBullet
bool IsBullet() const
Is this body treated like a bullet for continuous collision detection?
Definition: b2Body.h:628
b2ContactSolver
Definition: b2ContactSolver.h:69
b2Body::IsSleepingAllowed
bool IsSleepingAllowed() const
Is this body allowed to sleep.
Definition: b2Body.h:682
b2Body::GetUserData
void * GetUserData() const
Get the user data pointer that was provided in the body definition.
Definition: b2Body.h:732
b2Body::SetGravityScale
void SetGravityScale(float32 scale)
Set the gravity scale of the body.
Definition: b2Body.h:611
b2FixtureDef
Definition: b2Fixture.h:56
b2WeldJoint
Definition: b2WeldJoint.h:62
b2Body::SetLinearVelocity
void SetLinearVelocity(const b2Vec2 &v)
Definition: b2Body.h:499
b2Body::GetWorldVector
b2Vec2 GetWorldVector(const b2Vec2 &localVector) const
Definition: b2Body.h:561
b2Rot::Set
void Set(float32 angle)
Set using an angle in radians.
Definition: b2Math.h:312
b2Body::Dump
void Dump()
Dump this body to a log file.
Definition: b2Body.cpp:521
b2Body::SetUserData
void SetUserData(void *data)
Set the user data. Use this to store your application specific data.
Definition: b2Body.h:727
b2BodyDef::type
b2BodyType type
Definition: b2Body.h:74
b2Body::GetWorld
b2World * GetWorld()
Get the parent world of this body.
Definition: b2Body.h:850
b2Fixture
Definition: b2Fixture.h:107
b2BodyDef::linearVelocity
b2Vec2 linearVelocity
The linear velocity of the body's origin in world co-ordinates.
Definition: b2Body.h:84
b2BodyDef::bullet
bool bullet
Definition: b2Body.h:113
b2Body::SetLinearDamping
void SetLinearDamping(float32 linearDamping)
Set the linear damping of the body.
Definition: b2Body.h:591
b2Body::GetInertia
float32 GetInertia() const
Definition: b2Body.h:544
b2MassData::mass
float32 mass
The mass of the shape, usually in kilograms.
Definition: b2Shape.h:30
b2Body::SetActive
void SetActive(bool flag)
Definition: b2Body.cpp:454
b2RevoluteJoint
Definition: b2RevoluteJoint.h:90
b2Body::GetWorldCenter
const b2Vec2 & GetWorldCenter() const
Get the world position of the center of mass.
Definition: b2Body.h:489
b2BodyDef::awake
bool awake
Is this body initially awake or sleeping?
Definition: b2Body.h:104
b2BodyDef::allowSleep
bool allowSleep
Definition: b2Body.h:101
b2Body::SetAngularVelocity
void SetAngularVelocity(float32 omega)
Definition: b2Body.h:519
b2BodyDef
Definition: b2Body.h:51
b2Body::GetMass
float32 GetMass() const
Definition: b2Body.h:539
b2Body::ApplyAngularImpulse
void ApplyAngularImpulse(float32 impulse, bool wake)
Definition: b2Body.h:815
b2Body::GetLinearVelocityFromLocalPoint
b2Vec2 GetLinearVelocityFromLocalPoint(const b2Vec2 &localPoint) const
Definition: b2Body.h:581
b2Body::GetGravityScale
float32 GetGravityScale() const
Get the gravity scale of the body.
Definition: b2Body.h:606
b2Contact
Definition: b2Contact.h:77
b2Body::GetContactList
b2ContactEdge * GetContactList()
Definition: b2Body.h:707
b2JointEdge
Definition: b2Joint.h:65
b2MotorJoint
Definition: b2MotorJoint.h:59
b2Sweep::Advance
void Advance(float32 alpha)
Definition: b2Math.h:702
b2Body::SetTransform
void SetTransform(const b2Vec2 &position, float32 angle)
Definition: b2Body.cpp:417
b2Body::SetAngularDamping
void SetAngularDamping(float32 angularDamping)
Set the angular damping of the body.
Definition: b2Body.h:601
b2Body::DestroyFixture
void DestroyFixture(b2Fixture *fixture)
Definition: b2Body.cpp:214
b2Body::ApplyTorque
void ApplyTorque(float32 torque, bool wake)
Definition: b2Body.h:776
b2Body::CreateFixture
b2Fixture * CreateFixture(const b2FixtureDef *def)
Definition: b2Body.cpp:166
b2BodyDef::linearDamping
float32 linearDamping
Definition: b2Body.h:92
b2World
Definition: b2World.h:41
b2Body::GetAngle
float32 GetAngle() const
Definition: b2Body.h:484
b2Body::IsFixedRotation
bool IsFixedRotation() const
Does this body have fixed rotation?
Definition: b2Body.h:664
b2MassData::I
float32 I
The rotational inertia of the shape about the local origin.
Definition: b2Shape.h:36
b2Body::ApplyLinearImpulse
void ApplyLinearImpulse(const b2Vec2 &impulse, const b2Vec2 &point, bool wake)
Definition: b2Body.h:795
b2GearJoint
Definition: b2GearJoint.h:56
b2Body::IsActive
bool IsActive() const
Get the active state of the body.
Definition: b2Body.h:659
b2Shape
Definition: b2Shape.h:42
b2RopeJoint
Definition: b2RopeJoint.h:58
b2BodyDef::angle
float32 angle
The world angle of the body in radians.
Definition: b2Body.h:81
b2MassData
This holds the mass data computed for a shape.
Definition: b2Shape.h:27
b2MassData::center
b2Vec2 center
The position of the shape's centroid relative to the shape's origin.
Definition: b2Shape.h:33
b2Body::SetAwake
void SetAwake(bool flag)
Definition: b2Body.h:633
b2Vec2::SetZero
void SetZero()
Set this vector to all zeros.
Definition: b2Math.h:62
b2Body::SetMassData
void SetMassData(const b2MassData *data)
Definition: b2Body.cpp:353
b2MouseJoint
Definition: b2MouseJoint.h:60
b2Body::SetFixedRotation
void SetFixedRotation(bool flag)
Definition: b2Body.cpp:499
b2Joint
Definition: b2Joint.h:103
b2Body::GetLocalCenter
const b2Vec2 & GetLocalCenter() const
Get the local position of the center of mass.
Definition: b2Body.h:494
b2Sweep::localCenter
b2Vec2 localCenter
local center of mass position
Definition: b2Math.h:393
b2BodyDef::active
bool active
Does this body start out active?
Definition: b2Body.h:116
b2Sweep::a
float32 a
world angles
Definition: b2Math.h:395
b2Body::ResetMassData
void ResetMassData()
Definition: b2Body.cpp:281
b2Body::GetPosition
const b2Vec2 & GetPosition() const
Definition: b2Body.h:479
b2Island
This is an internal class.
Definition: b2Island.h:34
b2ContactEdge
Definition: b2Contact.h:66
b2Body::GetLinearDamping
float32 GetLinearDamping() const
Get the linear damping of the body.
Definition: b2Body.h:586
b2Body::ApplyForce
void ApplyForce(const b2Vec2 &force, const b2Vec2 &point, bool wake)
Definition: b2Body.h:737
b2PulleyJoint
Definition: b2PulleyJoint.h:79
b2BodyDef::position
b2Vec2 position
Definition: b2Body.h:78
b2BodyDef::gravityScale
float32 gravityScale
Scale the gravity applied to this body.
Definition: b2Body.h:122
b2Body::ApplyForceToCenter
void ApplyForceToCenter(const b2Vec2 &force, bool wake)
Definition: b2Body.h:757