Scripting API

Physics2D

static class in UnityEngine · UnityEngine.Physics2DModule

60 of 70 of Unity's membersUnity's documentation

In Tassix

2D physics settings, queries and the simulation step (Box2D, see tassix_physics2d). The player loop steps 2D physics after 3D physics in each fixed step, then sends OnTrigger*2D and OnCollision*2D messages. Settings default to Unity's Physics2D.

Fields 3

const int AllLayers

const int DefaultRaycastLayers

const int IgnoreRaycastLayer

Properties 21

static float angularSleepTolerance { get; set; }

static bool autoSyncTransforms { get; set; }

static float baumgarteScale { get; set; }

static float baumgarteTOIScale { get; set; }

static float bounceThreshold { get; set; }

Unity's older name for velocityThreshold.

static bool callbacksOnDisable { get; set; }

static float defaultContactOffset { get; set; }

static Vector2 gravity { get; set; }

static float linearSleepTolerance { get; set; }

static float maxAngularCorrection { get; set; }

static float maxLinearCorrection { get; set; }

static float maxRotationSpeed { get; set; }

static float maxTranslationSpeed { get; set; }

static int positionIterations { get; set; }

static bool queriesHitTriggers { get; set; }

static bool queriesStartInColliders { get; set; }

static bool reuseCollisionCallbacks { get; set; }

static SimulationMode2D simulationMode { get; set; }

static float timeToSleep { get; set; }

static int velocityIterations { get; set; }

static float velocityThreshold { get; set; }

Methods 45

static RaycastHit2D BoxCast(Vector2 origin, Vector2 size, float angle, Vector2 direction, float distance = float.PositiveInfinity, int layerMask = DefaultRaycastLayers, float minDepth = float.NegativeInfinity, float maxDepth = float.PositiveInfinity)

static RaycastHit2D BoxCast(Vector2 origin, Vector2 size, float angle, Vector2 direction)

static RaycastHit2D BoxCast(Vector2 origin, Vector2 size, float angle, Vector2 direction, float distance)

static RaycastHit2D BoxCast(Vector2 origin, Vector2 size, float angle, Vector2 direction, float distance, int layerMask)

static RaycastHit2D BoxCast(Vector2 origin, Vector2 size, float angle, Vector2 direction, float distance, int layerMask, float minDepth)

static int BoxCast(Vector2 origin, Vector2 size, float angle, Vector2 direction, ContactFilter2D contactFilter, RaycastHit2D[] results, float distance = float.PositiveInfinity)

static int BoxCast(Vector2 origin, Vector2 size, float angle, Vector2 direction, ContactFilter2D contactFilter, RaycastHit2D[] results)

static RaycastHit2D[] BoxCastAll(Vector2 origin, Vector2 size, float angle, Vector2 direction, float distance = float.PositiveInfinity, int layerMask = DefaultRaycastLayers, float minDepth = float.NegativeInfinity, float maxDepth = float.PositiveInfinity)

static RaycastHit2D[] BoxCastAll(Vector2 origin, Vector2 size, float angle, Vector2 direction)

static RaycastHit2D[] BoxCastAll(Vector2 origin, Vector2 size, float angle, Vector2 direction, float distance)

static RaycastHit2D[] BoxCastAll(Vector2 origin, Vector2 size, float angle, Vector2 direction, float distance, int layerMask)

static RaycastHit2D[] BoxCastAll(Vector2 origin, Vector2 size, float angle, Vector2 direction, float distance, int layerMask, float minDepth)

static int BoxCastNonAlloc(Vector2 origin, Vector2 size, float angle, Vector2 direction, RaycastHit2D[] results, float distance = float.PositiveInfinity, int layerMask = DefaultRaycastLayers, float minDepth = float.NegativeInfinity, float maxDepth = float.PositiveInfinity)

static RaycastHit2D CapsuleCast(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, float distance = float.PositiveInfinity, int layerMask = DefaultRaycastLayers, float minDepth = float.NegativeInfinity, float maxDepth = float.PositiveInfinity)

static RaycastHit2D CapsuleCast(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction)

static RaycastHit2D CapsuleCast(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, float distance)

static RaycastHit2D CapsuleCast(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, float distance, int layerMask)

static RaycastHit2D CapsuleCast(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, float distance, int layerMask, float minDepth)

static RaycastHit2D[] CapsuleCastAll(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, float distance = float.PositiveInfinity, int layerMask = DefaultRaycastLayers, float minDepth = float.NegativeInfinity, float maxDepth = float.PositiveInfinity)

static RaycastHit2D[] CapsuleCastAll(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction)

static RaycastHit2D[] CapsuleCastAll(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, float distance)

static RaycastHit2D[] CapsuleCastAll(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, float distance, int layerMask)

static RaycastHit2D[] CapsuleCastAll(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, float distance, int layerMask, float minDepth)

static RaycastHit2D CircleCast(Vector2 origin, float radius, Vector2 direction, float distance = float.PositiveInfinity, int layerMask = DefaultRaycastLayers, float minDepth = float.NegativeInfinity, float maxDepth = float.PositiveInfinity)

static RaycastHit2D CircleCast(Vector2 origin, float radius, Vector2 direction)

static RaycastHit2D CircleCast(Vector2 origin, float radius, Vector2 direction, float distance)

static RaycastHit2D CircleCast(Vector2 origin, float radius, Vector2 direction, float distance, int layerMask)

static RaycastHit2D CircleCast(Vector2 origin, float radius, Vector2 direction, float distance, int layerMask, float minDepth)

static int CircleCast(Vector2 origin, float radius, Vector2 direction, ContactFilter2D contactFilter, RaycastHit2D[] results, float distance = float.PositiveInfinity)

static int CircleCast(Vector2 origin, float radius, Vector2 direction, ContactFilter2D contactFilter, RaycastHit2D[] results)

static RaycastHit2D[] CircleCastAll(Vector2 origin, float radius, Vector2 direction, float distance = float.PositiveInfinity, int layerMask = DefaultRaycastLayers, float minDepth = float.NegativeInfinity, float maxDepth = float.PositiveInfinity)

static RaycastHit2D[] CircleCastAll(Vector2 origin, float radius, Vector2 direction)

static RaycastHit2D[] CircleCastAll(Vector2 origin, float radius, Vector2 direction, float distance)

static RaycastHit2D[] CircleCastAll(Vector2 origin, float radius, Vector2 direction, float distance, int layerMask)

static RaycastHit2D[] CircleCastAll(Vector2 origin, float radius, Vector2 direction, float distance, int layerMask, float minDepth)

static int CircleCastNonAlloc(Vector2 origin, float radius, Vector2 direction, RaycastHit2D[] results, float distance = float.PositiveInfinity, int layerMask = DefaultRaycastLayers, float minDepth = float.NegativeInfinity, float maxDepth = float.PositiveInfinity)

static Vector2 ClosestPoint(Vector2 position, Collider2D collider)

static Vector2 ClosestPoint(Vector2 position, Rigidbody2D rigidbody)

static ColliderDistance2D Distance(Collider2D colliderA, Collider2D colliderB)

static int GetContacts(Collider2D collider, ContactPoint2D[] contacts)

static int GetContacts(Collider2D collider, List<ContactPoint2D> contacts)

static int GetContacts(Collider2D collider, ContactFilter2D contactFilter, ContactPoint2D[] contacts)

static int GetContacts(Collider2D collider, ContactFilter2D contactFilter, List<ContactPoint2D> contacts)

static int GetContacts(Collider2D collider, Collider2D[] colliders)

static int GetContacts(Collider2D collider, List<Collider2D> colliders)

static int GetContacts(Collider2D collider, ContactFilter2D contactFilter, Collider2D[] colliders)

static int GetContacts(Collider2D collider, ContactFilter2D contactFilter, List<Collider2D> colliders)

static int GetContacts(Rigidbody2D rigidbody, ContactPoint2D[] contacts)

static int GetContacts(Rigidbody2D rigidbody, List<ContactPoint2D> contacts)

static int GetContacts(Rigidbody2D rigidbody, ContactFilter2D contactFilter, ContactPoint2D[] contacts)

static int GetContacts(Rigidbody2D rigidbody, ContactFilter2D contactFilter, List<ContactPoint2D> contacts)

static int GetContacts(Rigidbody2D rigidbody, Collider2D[] colliders)

static int GetContacts(Rigidbody2D rigidbody, List<Collider2D> colliders)

static bool GetIgnoreCollision(Collider2D collider1, Collider2D collider2)

static bool GetIgnoreLayerCollision(int layer1, int layer2)

static int GetLayerCollisionMask(int layer)

static RaycastHit2D GetRayIntersection(Ray ray, float distance = float.PositiveInfinity, int layerMask = DefaultRaycastLayers)

static RaycastHit2D GetRayIntersection(Ray ray)

static RaycastHit2D GetRayIntersection(Ray ray, float distance)

static RaycastHit2D[] GetRayIntersectionAll(Ray ray, float distance = float.PositiveInfinity, int layerMask = DefaultRaycastLayers)

static RaycastHit2D[] GetRayIntersectionAll(Ray ray)

static RaycastHit2D[] GetRayIntersectionAll(Ray ray, float distance)

2D colliders a 3D ray passes through: those containing the point where it crosses each collider's z plane, nearest first.

static int GetRayIntersectionNonAlloc(Ray ray, RaycastHit2D[] results, float distance = float.PositiveInfinity, int layerMask = DefaultRaycastLayers)

static void IgnoreCollision(Collider2D collider1, Collider2D collider2, bool ignore = true)

static void IgnoreCollision(Collider2D collider1, Collider2D collider2)

static void IgnoreLayerCollision(int layer1, int layer2, bool ignore = true)

static void IgnoreLayerCollision(int layer1, int layer2)

static bool IsTouching(Collider2D collider1, Collider2D collider2)

static bool IsTouchingLayers(Collider2D collider, int layerMask = AllLayers)

static bool IsTouchingLayers(Collider2D collider)

static RaycastHit2D Linecast(Vector2 start, Vector2 end, int layerMask = DefaultRaycastLayers, float minDepth = float.NegativeInfinity, float maxDepth = float.PositiveInfinity)

static RaycastHit2D Linecast(Vector2 start, Vector2 end)

static RaycastHit2D Linecast(Vector2 start, Vector2 end, int layerMask)

static RaycastHit2D Linecast(Vector2 start, Vector2 end, int layerMask, float minDepth)

static int Linecast(Vector2 start, Vector2 end, ContactFilter2D contactFilter, RaycastHit2D[] results)

static RaycastHit2D[] LinecastAll(Vector2 start, Vector2 end, int layerMask = DefaultRaycastLayers, float minDepth = float.NegativeInfinity, float maxDepth = float.PositiveInfinity)

static RaycastHit2D[] LinecastAll(Vector2 start, Vector2 end)

static RaycastHit2D[] LinecastAll(Vector2 start, Vector2 end, int layerMask)

static RaycastHit2D[] LinecastAll(Vector2 start, Vector2 end, int layerMask, float minDepth)

static int LinecastNonAlloc(Vector2 start, Vector2 end, RaycastHit2D[] results, int layerMask = DefaultRaycastLayers, float minDepth = float.NegativeInfinity, float maxDepth = float.PositiveInfinity)

static Collider2D? OverlapArea(Vector2 pointA, Vector2 pointB, int layerMask = DefaultRaycastLayers, float minDepth = float.NegativeInfinity, float maxDepth = float.PositiveInfinity)

static Collider2D? OverlapArea(Vector2 pointA, Vector2 pointB)

static Collider2D? OverlapArea(Vector2 pointA, Vector2 pointB, int layerMask)

static Collider2D? OverlapArea(Vector2 pointA, Vector2 pointB, int layerMask, float minDepth)

The axis-aligned rectangle between two corners.

static Collider2D[] OverlapAreaAll(Vector2 pointA, Vector2 pointB, int layerMask = DefaultRaycastLayers, float minDepth = float.NegativeInfinity, float maxDepth = float.PositiveInfinity)

static Collider2D[] OverlapAreaAll(Vector2 pointA, Vector2 pointB)

static Collider2D[] OverlapAreaAll(Vector2 pointA, Vector2 pointB, int layerMask)

static Collider2D[] OverlapAreaAll(Vector2 pointA, Vector2 pointB, int layerMask, float minDepth)

static int OverlapAreaNonAlloc(Vector2 pointA, Vector2 pointB, Collider2D[] results, int layerMask = DefaultRaycastLayers, float minDepth = float.NegativeInfinity, float maxDepth = float.PositiveInfinity)

static Collider2D? OverlapBox(Vector2 point, Vector2 size, float angle, int layerMask = DefaultRaycastLayers, float minDepth = float.NegativeInfinity, float maxDepth = float.PositiveInfinity)

static Collider2D? OverlapBox(Vector2 point, Vector2 size, float angle)

static Collider2D? OverlapBox(Vector2 point, Vector2 size, float angle, int layerMask)

static Collider2D? OverlapBox(Vector2 point, Vector2 size, float angle, int layerMask, float minDepth)

static int OverlapBox(Vector2 point, Vector2 size, float angle, ContactFilter2D contactFilter, Collider2D[] results)

static int OverlapBox(Vector2 point, Vector2 size, float angle, ContactFilter2D contactFilter, List<Collider2D> results)

static Collider2D[] OverlapBoxAll(Vector2 point, Vector2 size, float angle, int layerMask = DefaultRaycastLayers, float minDepth = float.NegativeInfinity, float maxDepth = float.PositiveInfinity)

static Collider2D[] OverlapBoxAll(Vector2 point, Vector2 size, float angle)

static Collider2D[] OverlapBoxAll(Vector2 point, Vector2 size, float angle, int layerMask)

static Collider2D[] OverlapBoxAll(Vector2 point, Vector2 size, float angle, int layerMask, float minDepth)

static int OverlapBoxNonAlloc(Vector2 point, Vector2 size, float angle, Collider2D[] results, int layerMask = DefaultRaycastLayers, float minDepth = float.NegativeInfinity, float maxDepth = float.PositiveInfinity)

static Collider2D? OverlapCapsule(Vector2 point, Vector2 size, CapsuleDirection2D direction, float angle, int layerMask = DefaultRaycastLayers, float minDepth = float.NegativeInfinity, float maxDepth = float.PositiveInfinity)

static Collider2D? OverlapCapsule(Vector2 point, Vector2 size, CapsuleDirection2D direction, float angle)

static Collider2D? OverlapCapsule(Vector2 point, Vector2 size, CapsuleDirection2D direction, float angle, int layerMask)

static Collider2D? OverlapCapsule(Vector2 point, Vector2 size, CapsuleDirection2D direction, float angle, int layerMask, float minDepth)

static Collider2D[] OverlapCapsuleAll(Vector2 point, Vector2 size, CapsuleDirection2D direction, float angle, int layerMask = DefaultRaycastLayers, float minDepth = float.NegativeInfinity, float maxDepth = float.PositiveInfinity)

static Collider2D[] OverlapCapsuleAll(Vector2 point, Vector2 size, CapsuleDirection2D direction, float angle)

static Collider2D[] OverlapCapsuleAll(Vector2 point, Vector2 size, CapsuleDirection2D direction, float angle, int layerMask)

static Collider2D[] OverlapCapsuleAll(Vector2 point, Vector2 size, CapsuleDirection2D direction, float angle, int layerMask, float minDepth)

static Collider2D? OverlapCircle(Vector2 point, float radius, int layerMask = DefaultRaycastLayers, float minDepth = float.NegativeInfinity, float maxDepth = float.PositiveInfinity)

static Collider2D? OverlapCircle(Vector2 point, float radius)

static Collider2D? OverlapCircle(Vector2 point, float radius, int layerMask)

static Collider2D? OverlapCircle(Vector2 point, float radius, int layerMask, float minDepth)

static int OverlapCircle(Vector2 point, float radius, ContactFilter2D contactFilter, Collider2D[] results)

static int OverlapCircle(Vector2 point, float radius, ContactFilter2D contactFilter, List<Collider2D> results)

static Collider2D[] OverlapCircleAll(Vector2 point, float radius, int layerMask = DefaultRaycastLayers, float minDepth = float.NegativeInfinity, float maxDepth = float.PositiveInfinity)

static Collider2D[] OverlapCircleAll(Vector2 point, float radius)

static Collider2D[] OverlapCircleAll(Vector2 point, float radius, int layerMask)

static Collider2D[] OverlapCircleAll(Vector2 point, float radius, int layerMask, float minDepth)

static int OverlapCircleNonAlloc(Vector2 point, float radius, Collider2D[] results, int layerMask = DefaultRaycastLayers, float minDepth = float.NegativeInfinity, float maxDepth = float.PositiveInfinity)

static int OverlapCollider(Collider2D collider, ContactFilter2D contactFilter, Collider2D[] results)

static int OverlapCollider(Collider2D collider, ContactFilter2D contactFilter, List<Collider2D> results)

static int OverlapCollider(Collider2D collider, List<Collider2D> results)

static Collider2D? OverlapPoint(Vector2 point, int layerMask = DefaultRaycastLayers, float minDepth = float.NegativeInfinity, float maxDepth = float.PositiveInfinity)

static Collider2D? OverlapPoint(Vector2 point)

static Collider2D? OverlapPoint(Vector2 point, int layerMask)

static Collider2D? OverlapPoint(Vector2 point, int layerMask, float minDepth)

static int OverlapPoint(Vector2 point, ContactFilter2D contactFilter, Collider2D[] results)

static int OverlapPoint(Vector2 point, ContactFilter2D contactFilter, List<Collider2D> results)

static Collider2D[] OverlapPointAll(Vector2 point, int layerMask = DefaultRaycastLayers, float minDepth = float.NegativeInfinity, float maxDepth = float.PositiveInfinity)

static Collider2D[] OverlapPointAll(Vector2 point)

static Collider2D[] OverlapPointAll(Vector2 point, int layerMask)

static Collider2D[] OverlapPointAll(Vector2 point, int layerMask, float minDepth)

static int OverlapPointNonAlloc(Vector2 point, Collider2D[] results, int layerMask = DefaultRaycastLayers, float minDepth = float.NegativeInfinity, float maxDepth = float.PositiveInfinity)

static RaycastHit2D Raycast(Vector2 origin, Vector2 direction, float distance = float.PositiveInfinity, int layerMask = DefaultRaycastLayers, float minDepth = float.NegativeInfinity, float maxDepth = float.PositiveInfinity)

static RaycastHit2D Raycast(Vector2 origin, Vector2 direction)

static RaycastHit2D Raycast(Vector2 origin, Vector2 direction, float distance)

static RaycastHit2D Raycast(Vector2 origin, Vector2 direction, float distance, int layerMask)

static RaycastHit2D Raycast(Vector2 origin, Vector2 direction, float distance, int layerMask, float minDepth)

static int Raycast(Vector2 origin, Vector2 direction, ContactFilter2D contactFilter, RaycastHit2D[] results, float distance = float.PositiveInfinity)

static int Raycast(Vector2 origin, Vector2 direction, ContactFilter2D contactFilter, RaycastHit2D[] results)

static int Raycast(Vector2 origin, Vector2 direction, ContactFilter2D contactFilter, List<RaycastHit2D> results, float distance = float.PositiveInfinity)

static RaycastHit2D[] RaycastAll(Vector2 origin, Vector2 direction, float distance = float.PositiveInfinity, int layerMask = DefaultRaycastLayers, float minDepth = float.NegativeInfinity, float maxDepth = float.PositiveInfinity)

static RaycastHit2D[] RaycastAll(Vector2 origin, Vector2 direction)

static RaycastHit2D[] RaycastAll(Vector2 origin, Vector2 direction, float distance)

static RaycastHit2D[] RaycastAll(Vector2 origin, Vector2 direction, float distance, int layerMask)

static RaycastHit2D[] RaycastAll(Vector2 origin, Vector2 direction, float distance, int layerMask, float minDepth)

static int RaycastNonAlloc(Vector2 origin, Vector2 direction, RaycastHit2D[] results, float distance = float.PositiveInfinity, int layerMask = DefaultRaycastLayers, float minDepth = float.NegativeInfinity, float maxDepth = float.PositiveInfinity)

static int RaycastNonAlloc(Vector2 origin, Vector2 direction, RaycastHit2D[] results, float distance, int layerMask)

static void SetLayerCollisionMask(int layer, int layerMask)

static bool Simulate(float deltaTime)

Steps the simulation (for SimulationMode2D.Script) and sends the messages.

static void SyncTransforms()

Transforms always reach the simulation before stepping and queries.

Not in Tassix yet 10

(constructor) MaxPolygonShapeVertices contactThreshold defaultPhysicsScene jobOptions maxSubStepCount minSubStepFPS simulationLayers useSubStepContacts useSubStepping

Checked against Unity

Conformance scenarios that exercise it, recorded in Unity and compared event by event.

physics2d_queries