PhysicsBody
A body is contained within a world and has 3 degrees-of-freedom, two for position and one for rotation. A body can have forces, torques and impulses applied to it. A body has three distinct types: Static: This type of body does not move under simulation and behaves as if it has infinite mass, essentially an immovable object. Static bodies never interact with other Static or Kinematic bodies. Dynamic: This type of body is fully simulated and moves according to forces and torques applied to its linear/angular velocities. It can interact with all other body types. It always has finite, non-zero mass. Kinematic: This type of body moves under simulation and moves according to its linear/angular velocities and never uses forces or torques. It only interacts with Dynamic body types. It behaves as if it has infinite mass. A body is automatically destroyed when the world it is in is destroyed. A body cannot exist outside a world.
Read time 18 minutesLast updated 10 days ago
Definition
- Type: Struct
- Namespace: Unity.U2D.Physics
- Assembly: UnityEngine.PhysicsCore2DModule
- Implements: IEquatable<PhysicsBody>
public readonly struct PhysicsBody : IEquatable<PhysicsBody>
Remarks
Create a body with PhysicsWorld.CreateBody, then attach a shape with PhysicsBody.CreateShape. After you create a shape from a geometry object, the shape doesn't change if you later change the geometry object. Unity draws shapes as a debug visualization in the Scene view and Game view, with a line indicating the shape's rotation direction.
Additional Resources: PhysicsShape, PhysicsWorld
Examples
// Create a body, then attach a circle shape to it.using UnityEngine;using Unity.U2D.Physics;public class CreateWorldAndObjects : MonoBehaviour{ // Declare definitions that contain default properties for the body and shape. public PhysicsBodyDefinition bodyDefinition = PhysicsBodyDefinition.defaultDefinition; public PhysicsShapeDefinition shapeDefinition = PhysicsShapeDefinition.defaultDefinition; void Start() { // Get the default world. PhysicsWorld world = PhysicsWorld.defaultWorld; // Create the physics body with the body definition. PhysicsBody myObject = world.CreateBody(bodyDefinition); // Create the circle geometry. CircleGeometry circleGeometry = new CircleGeometry { radius = 1.5f }; // Create the shape with both the geometry and the shape definition. myObject.CreateShape(circleGeometry, shapeDefinition); }}
Constructors
Constructor | Description |
|---|---|
| PhysicsBody(Unity.U2D.Physics.PhysicsHandle) | Create a body from a physics handle. |
Properties
Property | Description |
|---|---|
| angularDamping | The angular damping of the body. This will reduce the angular velocity over time. See _angularVelocity. |
| angularVelocity | The angular velocity of the body, in degrees per second. |
| awake | The awake state of the body. |
| callbackTarget | Get/Set the Object that event callbacks for this body will be sent to. Care should be taken with any Object assigned as a callback target that isn't a Object as this assignment will not in itself keep the object alive and can be garbage collected. To avoid this, you should have at least a single reference to the object in your code. To remove the object assigned here, set the callback target to NULL. |
| collisionThreshold | A threshold used to control when continuous collision detection is used when a body moves. The value is used to compare the body linear velocity movement against the extents of all the shapes added to the body scaled by this threshold. If the movement exceeds the extents scaled by the threshold then continuous collision detection is used to stop tunneling. Lower values reduce the distance the body must move before continuous collision detection is used and can have a considerable impact on performance! Higher values increase the distance the body must move before continuous collision detection is used. Too low a threshold will result in continuous collision detection being used more often therefore affecting performance so this should be limited to specific bodies only. The default threshold is 0.5 which equates to half the total shape extents. The threshold is clamped to a range of 0.0 to 1.0 with 0.0 meaning continuous collision detection will always be used. |
| constraints | Get/Set the degrees of freedom constraints (locks) for the body of Linear X, Linear Y and Rotation Z. |
| contactRecyclingAllowed | Controls contact recycling for this body. Enabled by default. Contact recycling reuses contact manifolds when bodies move only slightly, improving performance. Disabling it can avoid ghost collisions, at the cost of higher simulation time. Both bodies in a contact must have recycling enabled for that contact to be recycled. Existing contacts retain their prior setting; only contacts created after a change will be recycled. See _contactRecyclingAllowed. |
| definition | Get/Set a body definition by accessing all of its current properties. This is provided as convenience only and should not be used when performance is important as all the properties defined in the definition are accessed sequentially. You should try to only use the specific properties you need rather than using this feature. |
| drawTarget | Controls which Unity editor views this body is drawn into. |
| enabled | The enabled state of the body. If false, the body and anything attached to it will not participate in the simulation. |
| fastCollisionsAllowed | Treat this body as high speed object that performs continuous collision detection against dynamic and kinematic bodies, but not other high speed bodies. Fast collision bodies should be used sparingly, not because they are slow but because everything using fast collisions does not work well. They are not a solution for general dynamic-versus-dynamic continuous collision. They also may interfere with joint constraints. |
| fastRotationAllowed | This allows this body to bypass rotational speed limits. This should only be used for circular objects, such as wheels, balls etc. |
| gravityScale | Scales the world gravity that is applied to this body. Setting the gravity scale to zero stops any gravity being applied. Likewise, a negative value inverts gravity. See _gravity. |
| isOwned | Get if the body is owned. See PhysicsBody.SetOwner. |
| isValid | Checks if a body is valid. |
| jointCount | Get the number of joints attached to this body. Use PhysicsBody.GetJoints to retrieve the joints. |
| linearDamping | The linear damping of the body. This will reduce the linear velocity over time. See _linearVelocity. |
| linearVelocity | The linear velocity of the body. |
| localCenterOfMass | The center of mass position of the body in local space. This can be accessed as a union of _mass, _rotationalInertia and _localCenterOfMass using _massConfiguration. When this value is overridden with _massOverride, setting it authors the override value, which persists across mass recalculations. |
| mass | The calculated mass of the body, usually in kilograms. This can be accessed as a union of _mass, _rotationalInertia and _localCenterOfMass using _massConfiguration. When this value is overridden with _massOverride, setting it authors the override value, which persists across mass recalculations. |
| massConfiguration | The body mass configuration comprised of the _mass, _rotationalInertia and _localCenterOfMass. Normally this is computed automatically as each PhysicsShape is added, removed or changed on a body. This will automatically change if the body type changes, for instance, a Static or Kinematic body always have zero mass and rotational inertia. The individual properties of the _massConfiguration and be accessed using _mass, _rotationalInertia and _localCenterOfMass. The PhysicsBody.MassConfiguration will be overwritten when setting this property or if PhysicsBody.ApplyMassFromShapes is called or when adding, removing or changing PhysicsShape with _startMassUpdate enabled. To make a value persist across those recalculations, override it with _massOverride; with anything overridden, setting this property authors the override values instead of writing the body directly, so overridden values persist and the rest are rederived from the attached shapes. |
| massOverride | Selects which of the mass, rotational inertia and center of mass are overridden with authored values instead of being computed from the attached shapes. |
| owner | The owner object associated with this body, or NULL if no owner has been specified. This is a convenience property that returns the same value as PhysicsBody.GetOwner. |
| ownerUserData | Get PhysicsUserData that can be used for any purpose, typically by the owner only. |
| physicsHandle | Get the physics handle. |
| position | The position of the body in the world. |
| rotation | The rotation of the body. |
| rotationalInertia | The rotational inertia of the body, usually in kg*m^2. This can be accessed as a union of _mass, _rotationalInertia and _localCenterOfMass using _massConfiguration. When this value is overridden with _massOverride, setting it authors the override value, which persists across mass recalculations. |
| selectedDrawing | Controls whether this body is drawn individually when the world is drawn. |
| shapeCount | Get the number of shapes attached to this body. Use PhysicsBody.GetShapes to retrieve the shapes. |
| sleepingAllowed | The sleeping ability of the body. If false, the body will never sleep and will be woken up. See _awake. |
| sleepThreshold | The threshold below which the body will sleep, in meters/sec. |
| totalForce | The total user force that has been applied to this body since the last simulation step. Setting this value overrides any force that was previously requested. |
| totalTorque | The total users torque that has been applied to this body since the last simulation step. Setting this value overrides any torque that was previously requested. |
| transform | The full transform of the body composed of position and rotation. |
| transformObject | Get/Set the transform object associated with the body. This can be used as a write transform and/or as a depth-hint for PhysicsWorld drawing. See _transformWriteMode. |
| transformWriteMode | Get/Set how the _transformObject should be written to after the simulation has completed. Transform write will only occur if it is enabled on the world using _transformWriteMode. |
| type | A body is one of these three body types, Dynamic, Kinematic or Static, each of which determines how the body behaves in the simulation. |
| userData | Get/Set PhysicsUserData that can be used for any purpose. The physics system doesn't use this data, it is entirely for custom use. |
| world | Get the world the body is attached to. |
| worldCenterOfMass | Get the center of mass position of the body in world space. This changes as the body moves i.e. as the _transform is changed. |
| worldDrawing | Controls whether this body is automatically drawn when the world is drawn. |
Methods
Method | Description |
|---|---|
| ApplyAngularImpulse | Apply an angular impulse. This should be used for one-shot impulses. If you need a steady torque, use a torque instead, which will work better with the sub-stepping solver. |
| ApplyBuoyancy | Apply buoyancy, flow and damping forces to the body based on how its attached shapes are submerged in a fluid plane. Forces and torques are continuous (not impulses), so this is expected to be called every simulation step. The body must be PhysicsBody.BodyType.Dynamic; otherwise a warning is logged and the call is a no-op. |
| ApplyForce | Apply a force at a world point. If the force is not applied at the center of mass, it will generate a torque and affect the angular velocity. |
| ApplyForceToCenter | Apply a force to the center of mass. |
| ApplyLinearImpulse | Apply an impulse at a point. This immediately modifies the velocity and also modifies the angular velocity if the point of application is not at the center of mass. This should be used for one-shot impulses. If you need a steady force, use a force instead, which will work better with the sub-stepping solver. |
| ApplyLinearImpulseToCenter | Apply an impulse to the center of mass. This immediately modifies the velocity. This should be used for one-shot impulses. If you need a steady force, use a force instead, which will work better with the sub-stepping solver. |
| ApplyMassFromShapes | Typically a body will automatically calculate the PhysicsBody.MassConfiguration using all the attached shapes. The PhysicsBody.MassConfiguration is automatically updated whenever a PhysicsShape is added, removed or modified. When adding many shapes to a body, you can choose to stop this automatic calculation, therefore improving performance, by disabling _startMassUpdate for each shape being added to the body. This call will result in the PhysicsBody.MassConfiguration being calculated using the currently added PhysicsShape so is typically called after many shapes are added if they have _startMassUpdate disabled. Alternately, if you wish to assign your own PhysicsBody.MassConfiguration then disabling the automatic calculation also makes sense. In either case, you must call this method or set _massConfiguration before any simulation step occurs otherwise the PhysicsBody will exhibit unstable collision behaviour. The PhysicsBody.MassConfiguration will be overwritten when calling PhysicsBody.ApplyMassFromShapes, if _massConfiguration is set or when adding, removing or changing PhysicsShape with _startMassUpdate enabled. Values overridden with _massOverride keep their authored values through this call; it refreshes the values that are computed from the attached shapes. |
| ApplyTorque | Apply a torque. This affects the angular velocity without affecting the linear velocity. |
| ApplyWind | Apply wind forces to this body's attached shapes. Forces are continuous (not impulses) and are computed per shape by Box2D using the drag/lift coefficients in |
| ClearForces | Clear any user forces that have been applied to this body. Forces on a body are automatically cleared when a simulation step completes, however under some circumstances it may be desirable to clear the forces explicitly. |
| CreateChain | Create a Chain of multiple shapes attached to this body. |
| CreateShape | Create a Capsule shape, using its default definition, attached to this body. |
| CreateShapeBatch | Create a batch of Capsule shapes attached to this body. |
| Destroy | Destroy a body, destroying all attached PhysicsShape and PhysicsJoint. If the object is owned with PhysicsBody.SetOwner then you must provide the owner key it returned. Failing to do so will return a warning and the body will not be destroyed. |
| Distance | Get the minimum distance between all the shapes attached to this body and the specified shape. |
| Draw | Draw this body's current state once, as custom drawing. |
| GetAABB | Get the world AABB that bounds all the shapes attached to this body. If there are no shapes attached to the body then the returned AABB is empty and centered on the body origin. |
| GetContacts | Get all the touching contacts this body is currently participating in. Speculative collision is used so some contact points may be separated, a property available in the provided contact manifold. |
| GetJoints | Get the joints attached to this body. |
| GetLocalPoint | Gets a local point relative to the body given a world point. |
| GetLocalPointVelocity | Get the linear velocity of a local point attached to a body. Usually in meters per second. |
| GetLocalVector | Gets a local vector on a body given a world vector. |
| GetOwner | Get the owner object associated with this body as specified using PhysicsBody.SetOwner. |
| GetShapes | Get the shapes attached to this body. |
| GetWorldPoint | Gets a world point transformed from a local point relative to the body. |
| GetWorldPointVelocity | Get the linear velocity of a world point attached to a body. Usually in meters per second. |
| GetWorldVector | Gets a world vector transformed from a local vector relative to the body. |
| ReadPose | Read the full 3D position and rotation of the body given the specified Transform. |
| SetContactEvents | Enable/disable contact events on all shapes attached to the body. See _contactEvents. |
| SetHitEvents | Enable/disable hit events on all shapes attached to the body. See _hitEvents. |
| SetOwner | Set the owner object using the specified owner key. You can only set the owner once, multiple attempts will produce a warning. This call does not bind the lifetime of the specified owner object, it is simply a reference. It is also valid to not specify an owner object (NULL) to simply gain an owner key however it can be useful, if simply for debugging purposes and discovery, to know which object is the owner. |
| SetOwnerUserData | Set PhysicsUserData that can be used for any purpose, typically by the owner only. |
| SetTransformTarget | Set the _linearVelocity and _angularVelocity to reach the specified transform in the specified time. The resultant transform will be closed by may not be exact. This is designed ideally for Kinematic bodies but will work with Dynamic bodies if nothing changes the assigned velocities. This will be ignored if the calculated _linearVelocity and _angularVelocity would be below the _sleepThreshold. This will automatically wake the body if it is asleep. |
| WakeTouching | Wake any bodies that are touching this body via their shapes. This also works for Static bodies. |
| WritePose | Write the full 3D position and rotation of the body to the currently set _transformObject. If no _transformObject is assigned, this method will do nothing and false will be returned. |
Static Methods
Method | Description |
|---|---|
| ApplyBuoyancy | Apply buoyancy, flow and damping forces to every body in |
| ApplyWind | Apply wind forces to every body in |
| Create | Create a body using _defaultDefinition in the specified world. |
| CreateBatch | Create a batch of bodies in the specified world. |
| DestroyBatch | Destroy a batch of bodies, destroying all attached PhysicsShape and PhysicsJoint. Any invalid bodies will be ignored. Owned bodies will produce a warning and will not be destroyed (See PhysicsBody.SetOwner). |
| GetBatchTransform | Get the transform for a batch of PhysicsBody. |
| GetBatchVelocity | Get the velocity for a batch of PhysicsBody. |
| SetBatchForce | Apply a force for a batch of PhysicsBody using a span of PhysicsBody.BatchForce. If invalid values are passed to the batch, they will simply be ignored. For best performance, the bodies contained in the batch should all be part of the same PhysicsWorld. If the bodies in the batch are not contained in the same PhysicsWorld, the batch should be sorted by the PhysicsWorld the bodies are contained within. |
| SetBatchImpulse | Apply an impulse for a batch of PhysicsBody using a span of PhysicsBody.BatchImpulse. If invalid values are passed to the batch, they will simply be ignored. For best performance, the bodies contained in the batch should all be part of the same PhysicsWorld. If the bodies in the batch are not contained in the same PhysicsWorld, the batch should be sorted by the PhysicsWorld the bodies are contained within. |
| SetBatchTransform | Set the transform for a batch of PhysicsBody using a span of PhysicsBody.BatchTransform. If invalid values are passed to the batch, they will simply be ignored. For best performance, the bodies contained in the batch should all be part of the same PhysicsWorld. If the bodies in the batch are not contained in the same PhysicsWorld, the batch should be sorted by the PhysicsWorld the bodies are contained within. |
| SetBatchVelocity | Set the velocity for a batch of PhysicsBody using a span of PhysicsBody.BatchVelocity. If invalid values are passed to the batch, they will simply be ignored. For best performance, the bodies contained in the batch should all be part of the same PhysicsWorld. If the bodies in the batch are not contained in the same PhysicsWorld, the batch should be sorted by the PhysicsWorld the bodies are contained within. |
| SetOwner | Set the owner object using the specified owner key. You can only set the owner once, multiple attempts will produce a warning. This call does not bind the lifetime of the specified owner object, it is simply a reference. Whilst it is valid to not specify an owner object (NULL), it is recommended for debugging purposes. |
| SetOwnerUserData | Set PhysicsUserData on a batch of bodies that can be used for any purpose, typically by the owner only. The bodies and userDatas spans must be the same length; bodies[n] receives userDatas[n]. |
| SetSelectedDrawing | Set the selected drawing state on a batch of bodies. |
| SetUserData | Set PhysicsUserData on a batch of bodies that can be used for any purpose. The bodies and userDatas spans must be the same length; bodies[n] receives userDatas[n]. |
Structs
Struct | Description |
|---|---|
| PhysicsBody.BatchForce | A batch item used to apply a force to a PhysicsBody. |
| PhysicsBody.BatchImpulse | A batch item used to apply an impulse to a PhysicsBody. |
| PhysicsBody.BatchTransform | A batch item used to get/set the pose of a PhysicsBody. |
| PhysicsBody.BatchVelocity | A batch item used to set the velocity of a PhysicsBody. |
| PhysicsBody.BuoyancyInput | Input to PhysicsBody.ApplyBuoyancy describing the fluid surface, density, flow and damping used to compute buoyancy, flow and damping forces for the body. |
| PhysicsBody.MassConfiguration | This holds the mass configuration computed for a PhysicsBody. |
| PhysicsBody.TransformWriteTween | Used to define a Transform write "tween" for a body. |
| PhysicsBody.WindInput | Input to PhysicsBody.ApplyWind describing the wind velocity, drag and lift coefficients and the shape filter used to compute aerodynamic forces per attached shape. |
Enums
Enum | Description |
|---|---|
| PhysicsBody.BodyConstraints | Body constrains constrain the degrees of freedom a body when solving the simulation. |
| PhysicsBody.BodyType | A body is one of these three body types, Dynamic, Kinematic or Static, each of which determines how the body behaves in the simulation. |
| PhysicsBody.MassOverride | Selects which of the mass, rotational inertia and center of mass are overridden with authored values instead of being computed from the attached shapes. |
| PhysicsBody.TransformWriteMode | The method used to Write the body pose to the Transform. See _transformWriteMode. |