# 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.

## Definition

* **Type:** Struct
* **Namespace:** [Unity.U2D.Physics](/engine/6000.5/script-reference/unity/u2d/physics.md)
* **Assembly:** UnityEngine.PhysicsCore2DModule
* **Implements:** [IEquatable\<PhysicsBody>](https://learn.microsoft.com/dotnet/api/system.iequatable-1)

```csharp
public readonly struct PhysicsBody : IEquatable<PhysicsBody>
```

## Constructors

| Constructor                                                                                                           | Description                          |
| --------------------------------------------------------------------------------------------------------------------- | ------------------------------------ |
| [PhysicsBody(Unity.U2D.Physics.PhysicsHandle)](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/ctor.md) | Create a body from a physics handle. |

## Properties

| Property                                                                                                            | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| ------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| [angularDamping](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/angulardamping.md)                   | The angular damping of the body. This will reduce the angular velocity over time. See [\_angularVelocity](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/angularvelocity.md).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| [angularVelocity](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/angularvelocity.md)                 | The angular velocity of the body, in degrees per second.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| [awake](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/awake.md)                                     | The awake state of the body.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| [callbackTarget](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/callbacktarget.md)                   | Get/Set the [Object](/engine/6000.5/script-reference/unityengine/object.md) that event callbacks for this body will be sent to. Care should be taken with any [Object](/engine/6000.5/script-reference/unityengine/object.md) assigned as a callback target that isn't a [Object](/engine/6000.5/script-reference/unityengine/object.md) 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](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/collisionthreshold.md)           | 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](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/constraints.md)                         | Get/Set the degrees of freedom constraints (locks) for the body of Linear X, Linear Y and Rotation Z.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| [contactRecyclingAllowed](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/contactrecyclingallowed.md) | 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](/engine/6000.5/script-reference/unity/u2d/physics/physicsbodydefinition/contactrecyclingallowed.md).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| [definition](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/definition.md)                           | 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.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| [enabled](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/enabled.md)                                 | The enabled state of the body. If false, the body and anything attached to it will not participate in the simulation.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| [fastCollisionsAllowed](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/fastcollisionsallowed.md)     | 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. They are not a solution for general dynamic-versus-dynamic continuous collision.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| [fastRotationAllowed](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/fastrotationallowed.md)         | This allows this body to bypass rotational speed limits. This should only be used for circular objects, such as wheels, balls etc.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| [gravityScale](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/gravityscale.md)                       | 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](/engine/6000.5/script-reference/unity/u2d/physics/physicsworld/gravity.md).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| [isOwned](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/isowned.md)                                 | Get if the body is owned. See [PhysicsBody.SetOwner](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/setowner.md).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| [isValid](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/isvalid.md)                                 | Checks if a body is valid.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| [jointCount](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/jointcount.md)                           | Get the number of joints attached to this body. Use [PhysicsBody.GetJoints](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/getjoints.md) to retrieve the joints.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| [linearDamping](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/lineardamping.md)                     | The linear damping of the body. This will reduce the linear velocity over time. See [\_linearVelocity](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/linearvelocity.md).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| [linearVelocity](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/linearvelocity.md)                   | The linear velocity of the body.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| [localCenterOfMass](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/localcenterofmass.md)             | The center of mass position of the body in local space. This can be accessed as a union of [\_mass](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/mass.md), [\_rotationalInertia](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/rotationalinertia.md) and [\_localCenterOfMass](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/localcenterofmass.md) using \_massConfiguration.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| [mass](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/mass.md)                                       | The calculated mass of the body, usually in kilograms. This can be accessed as a union of [\_mass](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/mass.md), [\_rotationalInertia](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/rotationalinertia.md) and [\_localCenterOfMass](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/localcenterofmass.md) using \_massConfiguration.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| [massConfiguration](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/massconfiguration-1.md)           | The body mass configuration comprised of the [\_mass](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/mass.md), [\_rotationalInertia](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/rotationalinertia.md) and [\_localCenterOfMass](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/localcenterofmass.md). Normally this is computed automatically as each [PhysicsShape](/engine/6000.5/script-reference/unity/u2d/physics/physicsshape.md) 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](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/mass.md), [\_rotationalInertia](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/rotationalinertia.md) and [\_localCenterOfMass](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/localcenterofmass.md). The [PhysicsBody.MassConfiguration](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/massconfiguration.md) will be overwritten when setting this property or if [PhysicsBody.ApplyMassFromShapes](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/applymassfromshapes.md) is called or when adding, removing or changing [PhysicsShape](/engine/6000.5/script-reference/unity/u2d/physics/physicsshape.md) with [\_startMassUpdate](/engine/6000.5/script-reference/unity/u2d/physics/physicsshapedefinition/startmassupdate.md) enabled. |
| [ownerUserData](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/owneruserdata.md)                     | Get [PhysicsUserData](/engine/6000.5/script-reference/unity/u2d/physics/physicsuserdata.md) that can be used for any purpose, typically by the owner only.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| [physicsHandle](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/physicshandle.md)                     | Get the physics handle.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| [position](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/position.md)                               | The position of the body in the world.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| [rotation](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/rotation.md)                               | The rotation of the body.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| [rotationalInertia](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/rotationalinertia.md)             | The rotational inertia of the body, usually in kg\*m^2. This can be accessed as a union of [\_mass](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/mass.md), [\_rotationalInertia](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/rotationalinertia.md) and [\_localCenterOfMass](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/localcenterofmass.md) using \_massConfiguration.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| [shapeCount](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/shapecount.md)                           | Get the number of shapes attached to this body. Use [PhysicsBody.GetShapes](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/getshapes.md) to retrieve the shapes.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| [sleepingAllowed](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/sleepingallowed.md)                 | The sleeping ability of the body. If false, the body will never sleep and will be woken up. See [\_awake](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/awake.md).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| [sleepThreshold](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/sleepthreshold.md)                   | The threshold below which the body will sleep, in meters/sec.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| [totalForce](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/totalforce.md)                           | 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](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/totaltorque.md)                         | 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](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/transform.md)                             | The full transform of the body composed of position and rotation.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| [transformObject](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/transformobject.md)                 | 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](/engine/6000.5/script-reference/unity/u2d/physics/physicsworld.md) drawing. See \_transformWriteMode.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| [transformWriteMode](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/transformwritemode-1.md)         | Get/Set how the [\_transformObject](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/transformobject.md) should be written to after the simulation has completed. Transform write will only occur if it is enabled on the world using \_transformWriteMode.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| [type](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/type.md)                                       | 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](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/userdata.md)                               | Get/Set [PhysicsUserData](/engine/6000.5/script-reference/unity/u2d/physics/physicsuserdata.md) that can be used for any purpose. The physics system doesn't use this data, it is entirely for custom use.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| [world](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/world.md)                                     | Get the world the body is attached to.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| [worldCenterOfMass](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/worldcenterofmass.md)             | Get the center of mass position of the body in world space. This changes as the body moves i.e. as the [\_transform](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/transform.md) is changed.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| [worldDrawing](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/worlddrawing.md)                       | Controls whether this body is automatically drawn when the world is drawn.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |

## Methods

| Method                                                                                                                    | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| ------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [ApplyAngularImpulse](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/applyangularimpulse.md)               | 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.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| [ApplyForce](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/applyforce.md)                                 | 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](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/applyforcetocenter.md)                 | Apply a force to the center of mass.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| [ApplyLinearImpulse](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/applylinearimpulse.md)                 | 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](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/applylinearimpulsetocenter.md) | 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](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/applymassfromshapes.md)               | Typically a body will automatically calculate the [PhysicsBody.MassConfiguration](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/massconfiguration.md) using all the attached shapes. The [PhysicsBody.MassConfiguration](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/massconfiguration.md) is automatically updated whenever a [PhysicsShape](/engine/6000.5/script-reference/unity/u2d/physics/physicsshape.md) 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](/engine/6000.5/script-reference/unity/u2d/physics/physicsshapedefinition/startmassupdate.md) for each shape being added to the body. This call will result in the [PhysicsBody.MassConfiguration](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/massconfiguration.md) being calculated using the currently added [PhysicsShape](/engine/6000.5/script-reference/unity/u2d/physics/physicsshape.md) so is typically called after many shapes are added if they have [\_startMassUpdate](/engine/6000.5/script-reference/unity/u2d/physics/physicsshapedefinition/startmassupdate.md) disabled. Alternately, if you wish to assign your own [PhysicsBody.MassConfiguration](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/massconfiguration.md) 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](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody.md) will exhibit unstable collision behaviour. The [PhysicsBody.MassConfiguration](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/massconfiguration.md) will be overwritten when calling [PhysicsBody.ApplyMassFromShapes](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/applymassfromshapes.md), if \_massConfiguration is set or when adding, removing or changing [PhysicsShape](/engine/6000.5/script-reference/unity/u2d/physics/physicsshape.md) with [\_startMassUpdate](/engine/6000.5/script-reference/unity/u2d/physics/physicsshapedefinition/startmassupdate.md) enabled. |
| [ApplyTorque](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/applytorque.md)                               | Apply a torque. This affects the angular velocity without affecting the linear velocity.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| [ClearForces](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/clearforces.md)                               | 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](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/createchain.md)                               | Create a Chain of multiple shapes attached to this body.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| [CreateShape](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/createshape.md)                               | Create a Capsule shape, using its default definition, attached to this body.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| [CreateShapeBatch](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/createshapebatch.md)                     | Create a batch of Capsule shapes attached to this body.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| [Destroy](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/destroy.md)                                       | Destroy a body, destroying all attached [PhysicsShape](/engine/6000.5/script-reference/unity/u2d/physics/physicsshape.md) and [PhysicsJoint](/engine/6000.5/script-reference/unity/u2d/physics/physicsjoint.md). If the object is owned with [PhysicsBody.SetOwner](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/setowner.md) 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](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/distance.md)                                     | Get the minimum distance between all the shapes attached to this body and the specified shape.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| [Draw](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/draw.md)                                             | Draw a body that visually represents its current state in the world.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| [GetAABB](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/getaabb.md)                                       | 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](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/getcontacts.md)                               | 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](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/getjoints.md)                                   | Get the joints attached to this body.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| [GetLocalPoint](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/getlocalpoint.md)                           | Gets a local point relative to the body given a world point.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| [GetLocalPointVelocity](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/getlocalpointvelocity.md)           | Get the linear velocity of a local point attached to a body. Usually in meters per second.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| [GetLocalVector](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/getlocalvector.md)                         | Gets a local vector on a body given a world vector.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| [GetOwner](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/getowner.md)                                     | Get the owner object associated with this body as specified using [PhysicsBody.SetOwner](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/setowner.md).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| [GetShapes](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/getshapes.md)                                   | Get the shapes attached to this body.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| [GetWorldPoint](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/getworldpoint.md)                           | Gets a world point transformed from a local point relative to the body.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| [GetWorldPointVelocity](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/getworldpointvelocity.md)           | Get the linear velocity of a world point attached to a body. Usually in meters per second.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| [GetWorldVector](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/getworldvector.md)                         | Gets a world vector transformed from a local vector relative to the body.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| [ReadPose](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/readpose.md)                                     | Read the full 3D position and rotation of the body given the specified [Transform](/engine/6000.5/script-reference/unityengine/transform.md).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| [SetContactEvents](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/setcontactevents.md)                     | Enable/disable contact events on all shapes attached to the body. See [\_contactEvents](/engine/6000.5/script-reference/unity/u2d/physics/physicsshape/contactevents.md).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| [SetHitEvents](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/sethitevents.md)                             | Enable/disable hit events on all shapes attached to the body. See [\_hitEvents](/engine/6000.5/script-reference/unity/u2d/physics/physicsshape/hitevents.md).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| [SetOwner](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/setowner.md)                                     | 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](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/setowneruserdata.md)                     | Set [PhysicsUserData](/engine/6000.5/script-reference/unity/u2d/physics/physicsuserdata.md) that can be used for any purpose, typically by the owner only.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| [SetTransformTarget](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/settransformtarget.md)                 | Set the [\_linearVelocity](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/linearvelocity.md) and [\_angularVelocity](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/angularvelocity.md) 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](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/linearvelocity.md) and [\_angularVelocity](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/angularvelocity.md) would be below the [\_sleepThreshold](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/sleepthreshold.md). This will automatically wake the body if it is asleep.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| [WakeTouching](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/waketouching.md)                             | Wake any bodies that are touching this body via their shapes. This also works for Static bodies.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| [WritePose](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/writepose.md)                                   | Write the full 3D position and rotation of the body to the currently set [\_transformObject](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/transformobject.md). If no [\_transformObject](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/transformobject.md) is assigned, this method will do nothing and false will be returned.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |

## Static Methods

| Method                                                                                                  | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| ------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Create](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/create.md)                       | Create a body using [\_defaultDefinition](/engine/6000.5/script-reference/unity/u2d/physics/physicsbodydefinition/defaultdefinition.md) in the specified world.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| [CreateBatch](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/createbatch.md)             | Create a batch of bodies in the specified world.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| [DestroyBatch](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/destroybatch.md)           | Destroy a batch of bodies, destroying all attached [PhysicsShape](/engine/6000.5/script-reference/unity/u2d/physics/physicsshape.md) and [PhysicsJoint](/engine/6000.5/script-reference/unity/u2d/physics/physicsjoint.md). Any invalid bodies will be ignored. Owned bodies will produce a warning and will not be destroyed (See [PhysicsBody.SetOwner](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/setowner.md)).                                                                                                                                                                                                                                                                                                                                                             |
| [GetBatchTransform](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/getbatchtransform.md) | Get the transform for a batch of [PhysicsBody](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody.md).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| [GetBatchVelocity](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/getbatchvelocity.md)   | Get the velocity for a batch of [PhysicsBody](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody.md).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| [SetBatchForce](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/setbatchforce.md)         | Apply a force for a batch of [PhysicsBody](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody.md) using a span of [PhysicsBody.BatchForce](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/batchforce.md). 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](/engine/6000.5/script-reference/unity/u2d/physics/physicsworld.md). If the bodies in the batch are not contained in the same [PhysicsWorld](/engine/6000.5/script-reference/unity/u2d/physics/physicsworld.md), the batch should be sorted by the [PhysicsWorld](/engine/6000.5/script-reference/unity/u2d/physics/physicsworld.md) the bodies are contained within.             |
| [SetBatchImpulse](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/setbatchimpulse.md)     | Apply an impulse for a batch of [PhysicsBody](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody.md) using a span of [PhysicsBody.BatchImpulse](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/batchimpulse.md). 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](/engine/6000.5/script-reference/unity/u2d/physics/physicsworld.md). If the bodies in the batch are not contained in the same [PhysicsWorld](/engine/6000.5/script-reference/unity/u2d/physics/physicsworld.md), the batch should be sorted by the [PhysicsWorld](/engine/6000.5/script-reference/unity/u2d/physics/physicsworld.md) the bodies are contained within.      |
| [SetBatchTransform](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/setbatchtransform.md) | Set the transform for a batch of [PhysicsBody](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody.md) using a span of [PhysicsBody.BatchTransform](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/batchtransform.md). 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](/engine/6000.5/script-reference/unity/u2d/physics/physicsworld.md). If the bodies in the batch are not contained in the same [PhysicsWorld](/engine/6000.5/script-reference/unity/u2d/physics/physicsworld.md), the batch should be sorted by the [PhysicsWorld](/engine/6000.5/script-reference/unity/u2d/physics/physicsworld.md) the bodies are contained within. |
| [SetBatchVelocity](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/setbatchvelocity.md)   | Set the velocity for a batch of [PhysicsBody](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody.md) using a span of [PhysicsBody.BatchVelocity](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/batchvelocity.md). 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](/engine/6000.5/script-reference/unity/u2d/physics/physicsworld.md). If the bodies in the batch are not contained in the same [PhysicsWorld](/engine/6000.5/script-reference/unity/u2d/physics/physicsworld.md), the batch should be sorted by the [PhysicsWorld](/engine/6000.5/script-reference/unity/u2d/physics/physicsworld.md) the bodies are contained within.    |
| [SetOwner](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/setowner.md)                   | 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.                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |

## Structs

| Struct                                                                                                                  | Description                                                                                                                 |
| ----------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------- |
| [PhysicsBody.BatchForce](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/batchforce.md)                   | A batch item used to apply a force to a [PhysicsBody](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody.md).    |
| [PhysicsBody.BatchImpulse](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/batchimpulse.md)               | A batch item used to apply an impulse to a [PhysicsBody](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody.md). |
| [PhysicsBody.BatchTransform](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/batchtransform.md)           | A batch item used to get/set the pose of a [PhysicsBody](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody.md). |
| [PhysicsBody.BatchVelocity](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/batchvelocity.md)             | A batch item used to set the velocity of a [PhysicsBody](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody.md). |
| [PhysicsBody.MassConfiguration](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/massconfiguration.md)     | This holds the mass configuration computed for a PhysicsBody.                                                               |
| [PhysicsBody.TransformWriteTween](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/transformwritetween.md) | Used to define a Transform write "tween" for a body.                                                                        |

## Enums

| Enum                                                                                                                  | Description                                                                                                                             |
| --------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------- |
| [PhysicsBody.BodyConstraints](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/bodyconstraints.md)       | Body constrains constrain the degrees of freedom a body when solving the simulation.                                                    |
| [PhysicsBody.BodyType](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/bodytype.md)                     | 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.TransformWriteMode](/engine/6000.5/script-reference/unity/u2d/physics/physicsbody/transformwritemode.md) | The method used to Write the body pose to the Transform. See \_transformWriteMode.                                                      |
