public static RaycastHit2D CapsuleCast(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, float distance)
{
float positiveInfinity = float.PositiveInfinity;
float negativeInfinity = float.NegativeInfinity;
int layerMask = -5;
return CapsuleCast(origin, size, capsuleDirection, angle, direction, distance, layerMask, negativeInfinity, positiveInfinity);
}
public static void DrawCapsuleCast2DHits(RaycastHit2D[] hits,
Vector2 origin,
Vector2 size,
CapsuleDirection2D capsuleDirection,
float angle,
Vector2 direction,
Color color,
int maxCount = -1)
{
if (maxCount < 0)
{
maxCount = hits.Length;
}
if (maxCount == 0)
{
return;
}
direction.EnsureNormalized();
DrawCapsuleStructure2D capsuleStructure2D = new DrawCapsuleStructure2D(size, capsuleDirection, angle);
for (int i = 0; i < maxCount; i++)
{
DrawCapsule2DFast(origin + direction * hits[i].distance, capsuleStructure2D, DrawLine);
}
void DrawLine(Vector3 a, Vector3 b, float v) => lineDelegate(a, b, color);
}
public static void DrawCapsule(Vector2 position, Vector2 size, CapsuleDirection2D direction, float angle, Color color, bool debug, float duration)
{
Quaternion rotation = Quaternion.Euler(0, 0, angle);
Vector2 colliderDirectionVector = rotation * (direction == CapsuleDirection2D.Vertical ? Vector2.up : Vector2.right);
Vector2 colliderDirectionPerpendicularVector = rotation * (direction == CapsuleDirection2D.Vertical ? Vector2.right : Vector2.up);
float radius = (direction == CapsuleDirection2D.Vertical ? size.x : size.y) / 2.0f;
float boxHeight = 2 * Mathf.Max(0.0f, direction == CapsuleDirection2D.Vertical ? (size.y / 2.0f - radius) : (size.x / 2.0f - radius));
Vector2 colliderCircleA = colliderDirectionVector * boxHeight / 2.0f + position;
Vector2 colliderCircleB = -colliderDirectionVector * boxHeight / 2.0f + position;
float circleAAngleStart = angle + (direction == CapsuleDirection2D.Vertical ? 0.0f : -90.0f);
float circleAAngleEnd = angle + (direction == CapsuleDirection2D.Vertical ? 180.0f : 90.0f);
float circleBAngleStart = angle + (direction == CapsuleDirection2D.Vertical ? 180.0f : 90.0f);
float circleBAngleEnd = angle + (direction == CapsuleDirection2D.Vertical ? 360.0f : 270.0f);
DrawCircle(colliderCircleA, radius, color, circleAAngleStart, circleAAngleEnd, debug, duration);
DrawCircle(colliderCircleB, radius, color, circleBAngleStart, circleBAngleEnd, debug, duration);
DrawLine(colliderDirectionPerpendicularVector * radius + colliderDirectionVector * boxHeight / 2.0f + position,
colliderDirectionPerpendicularVector * radius - colliderDirectionVector * boxHeight / 2.0f + position, color, debug, duration);
DrawLine(-colliderDirectionPerpendicularVector * radius + colliderDirectionVector * boxHeight / 2.0f + position,
-colliderDirectionPerpendicularVector * radius - colliderDirectionVector * boxHeight / 2.0f + position, color, debug, duration);
}
public static void DrawCapsule2D(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Color color, float duration = 0)
{
DrawCapsuleStructure2D capsuleStructure2D = new DrawCapsuleStructure2D(size, capsuleDirection, angle);
DrawCapsule2DFast(origin, capsuleStructure2D, DrawLine);
void DrawLine(Vector3 a, Vector3 b, float t) => lineDelegate(a, b, color, duration);
}
Rigidbody2D FindFloor()
{
bIsOnGround = false;
CapsuleDirection2D Dir = CapsuleDirection2D.Vertical;
if (Size.x > Size.y)
{
Dir = CapsuleDirection2D.Horizontal;
}
LayerMask Mask = LayerMask.GetMask("Gameplay");
//bIsOnGround = Physics2D.OverlapCapsule(transform.position, Size, Dir, 0, Mask);
//Collider2D Ground = Physics2D.OverlapCapsule(transform.position, Size, Dir, 0, Mask);
Collider2D[] Ground = Physics2D.OverlapCapsuleAll(transform.position, Size, Dir, 0, Mask);
foreach (Collider2D col in Ground)
{
if (col.gameObject != gameObject)
{
bIsOnGround = true;
if (col.GetComponent <Rigidbody2D>())
{
return(col.GetComponent <Rigidbody2D>());
}
}
}
return(null);
}
public static void DrawCapsuleCast2D(
Vector2 origin,
Vector2 size,
CapsuleDirection2D capsuleDirection,
float angle,
Vector2 direction,
float distance,
Color colorStart,
Color colorEnd)
{
direction.EnsureNormalized();
DrawCapsuleStructure2D capsuleStructure2D = new DrawCapsuleStructure2D(size, capsuleDirection, angle);
Color color = colorStart;
DrawCapsule2DFast(origin, capsuleStructure2D, DrawLine);
var scaledDirection = direction * distance;
Vector2 destination = origin + scaledDirection;
float dot = Vector2.Dot(PerpendicularClockwise(capsuleStructure2D.VerticalOffset), direction);
float sign = Mathf.Sign(dot);
float scaledRadius = capsuleStructure2D.Radius * sign;
Vector2 o1 = PerpendicularCounterClockwise(direction) * scaledRadius;
Vector2 o2 = PerpendicularClockwise(direction) * scaledRadius;
Vector2 originA = origin + capsuleStructure2D.VerticalOffset + o1;
Vector2 originB = origin - capsuleStructure2D.VerticalOffset + o2;
Vector2 currentA = originA;
Vector2 currentB = originB;
for (int i = 1; i <= 10; i++)
{
float t = i / (float)10;
color = Color.Lerp(colorStart, colorEnd, t);
Vector2 nextA = originA + scaledDirection * t;
Vector2 nextB = originB + scaledDirection * t;
DrawLine(currentA, nextA, t);
DrawLine(currentB, nextB, t);
currentA = nextA;
currentB = nextB;
}
color = colorEnd;
DrawCapsule2DFast(destination, capsuleStructure2D, DrawLine);
void DrawLine(Vector3 a, Vector3 b, float v) => lineDelegate(a, b, color);
}
public static void DrawCapsuleCast2D(Vector2 origin,
Vector2 size,
CapsuleDirection2D capsuleDirection,
float angle,
Vector2 direction,
RaycastHit2D[] hits,
float distance,
int count,
Color startColor,
Color endColor,
Color hitColor)
{
DrawCapsuleCast2D(origin, size, capsuleDirection, angle, direction, distance, startColor, endColor);
DrawCapsuleCast2DHits(hits, origin, size, capsuleDirection, angle, direction, hitColor, count);
}
// Start is called before the first frame update
void Start()
{
thrustDirection = new Vector2(1.0f, 0.0f);
CapsuleCollider2D capsuleCollider2D = GetComponent <CapsuleCollider2D>();
direction = capsuleCollider2D.direction;
size = capsuleCollider2D.size;
rigidbody2d = GetComponent <Rigidbody2D>();
// start spawn timer
spawnTimer = gameObject.AddComponent <Timer>();
spawnTimer.Duration = SpawnDelaySeconds;
spawnTimer.Run();
}
public override void UpdateIfNeeded()
{
CapsuleCollider2D capsule = collider as CapsuleCollider2D;
if (capsule != null && (capsule.size != size ||
capsule.direction != direction ||
capsule.offset != center))
{
size = capsule.size;
direction = capsule.direction;
center = capsule.offset;
adaptor.Set(center,
(capsule.direction == CapsuleDirection2D.Horizontal ? size.y : size.x) * 0.5f,
Mathf.Max(size.x, size.y),
capsule.direction == CapsuleDirection2D.Horizontal ? 0 : 1);
Oni.UpdateShape(oniShape, ref adaptor);
}
}
private void Awake()
{
myVelocity = Vector2.zero;
// Setting up references.
priv_Anim = GetComponent <Animator>();
priv_Rigidbody2D = GetComponent <Rigidbody2D>();
quickCapsule = GetComponent <CapsuleCollider2D>();
crouchCheckPosition = new Vector3(
quickCapsule.offset.x * Mathf.Abs(transform.lossyScale.x),
(quickCapsule.offset.y + quickCapsule.size.y * 0.0125f) * transform.lossyScale.y,
transform.position.z);
crouchCheckSize = new Vector2(
quickCapsule.size.x * 0.95f * Mathf.Abs(transform.lossyScale.x),
quickCapsule.size.y * 0.975f * transform.lossyScale.y);
crouchCheckDirection = quickCapsule.direction;
//not necessary, but initializing the enums here to make myself feel better
stateGrounded = PlayerStateGrounded.Idle;
stateAerial = PlayerStateAerial.No;
stateCrouch = PlayerStateCrouch.No;
myOriginalMaxSpeed = myMaxSpeed;
}
public DrawCapsuleStructure2D(
Vector2 size,
CapsuleDirection2D capsuleDirection,
float angle)
{
if (capsuleDirection == CapsuleDirection2D.Horizontal)
{
float temp = size.y;
size.y = size.x;
size.x = temp;
angle += 180;
}
Radius = size.x * 0.5f;
float vertical = Mathf.Max(0, size.y - size.x) * 0.5f;
GetRotationCoefficients(angle, out var s, out var c);
VerticalOffset = RotateFast(new Vector2(0, vertical), s, c);
Left = new Vector2(c, s);
ScaledLeft = Left * Radius;
ScaledRight = -ScaledLeft;
}
public int OverlapCapsule(Vector2 point, Vector2 size, CapsuleDirection2D direction, float angle, Collider2D[] results, int layerMask = Physics2D.DefaultRaycastLayers)
{
return(_world.OverlapCapsule(point, size, direction, angle, results, layerMask));
}
/// <summary>
/// <para>Casts a capsule into the scene, returning colliders that contact with it into the provided results array.</para>
/// </summary>
/// <param name="origin">The point in 2D space where the shape originates.</param>
/// <param name="size">The size of the shape.</param>
/// <param name="capsuleDirection">The direction of the capsule.</param>
/// <param name="angle">The angle of the shape (in degrees).</param>
/// <param name="direction">Vector representing the direction to cast the shape.</param>
/// <param name="results">Array to receive results.</param>
/// <param name="distance">Maximum distance over which to cast the shape.</param>
/// <param name="layerMask">Filter to detect Colliders only on certain layers.</param>
/// <param name="minDepth">Only include objects with a Z coordinate (depth) greater than this value.</param>
/// <param name="maxDepth">Only include objects with a Z coordinate (depth) less than this value.</param>
/// <returns>
/// <para>The number of results returned.</para>
/// </returns>
public static int CapsuleCastNonAlloc(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, RaycastHit2D[] results, [DefaultValue("Mathf.Infinity")] float distance, [DefaultValue("DefaultRaycastLayers")] int layerMask, [DefaultValue("-Mathf.Infinity")] float minDepth, [DefaultValue("Mathf.Infinity")] float maxDepth)
{
return INTERNAL_CALL_CapsuleCastNonAlloc(ref origin, ref size, capsuleDirection, angle, ref direction, results, distance, layerMask, minDepth, maxDepth);
}
private static extern void INTERNAL_CALL_Internal_CapsuleCast(ref Vector2 origin, ref Vector2 size, CapsuleDirection2D capsuleDirection, float angle, ref Vector2 direction, float distance, int layerMask, float minDepth, float maxDepth, out RaycastHit2D raycastHit);
public static RaycastHit2D CapsuleCast(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, float distance, int layerMask, float minDepth)
{
float positiveInfinity = float.PositiveInfinity;
return CapsuleCast(origin, size, capsuleDirection, angle, direction, distance, layerMask, minDepth, positiveInfinity);
}
public static RaycastHit2D[] CapsuleCastAll(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, float distance, int layerMask)
{
float positiveInfinity = float.PositiveInfinity;
float negativeInfinity = float.NegativeInfinity;
return INTERNAL_CALL_CapsuleCastAll(ref origin, ref size, capsuleDirection, angle, ref direction, distance, layerMask, negativeInfinity, positiveInfinity);
}
public static Collider2D[] OverlapCapsuleAll(Vector2 point, Vector2 size, CapsuleDirection2D direction, float angle, int layerMask)
{
float positiveInfinity = float.PositiveInfinity;
float negativeInfinity = float.NegativeInfinity;
return INTERNAL_CALL_OverlapCapsuleAll(ref point, ref size, direction, angle, layerMask, negativeInfinity, positiveInfinity);
}
/// <summary>
/// <para>Get a list of all colliders that fall within a capsule area.</para>
/// </summary>
/// <param name="point">Center of the capsule.</param>
/// <param name="size">Size of the capsule.</param>
/// <param name="direction">The direction of the capsule.</param>
/// <param name="angle">Angle of the capsule.</param>
/// <param name="results">Array to receive results.</param>
/// <param name="layerMask">Filter to check objects only on specific layers.</param>
/// <param name="minDepth">Only include objects with a Z coordinate (depth) greater than this value.</param>
/// <param name="maxDepth">Only include objects with a Z coordinate (depth) less than this value.</param>
/// <returns>
/// <para>The number of results returned.</para>
/// </returns>
public static int OverlapCapsuleNonAlloc(Vector2 point, Vector2 size, CapsuleDirection2D direction, float angle, Collider2D[] results, [DefaultValue("DefaultRaycastLayers")] int layerMask, [DefaultValue("-Mathf.Infinity")] float minDepth, [DefaultValue("Mathf.Infinity")] float maxDepth)
{
return INTERNAL_CALL_OverlapCapsuleNonAlloc(ref point, ref size, direction, angle, results, layerMask, minDepth, maxDepth);
}
public static void DrawCapsule2D(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, bool hit, float duration = 0) => DrawCapsule2D(origin, size, capsuleDirection, angle, hit ? HitColor : RayColor, duration);
public static void DrawCapsuleCast2D(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, float distance) => DrawCapsuleCast2D(origin, size, capsuleDirection, angle, direction, distance, StartColor, EndColor);
private static extern void CapsuleCast_Internal_Injected(ref PhysicsScene2D physicsScene, ref Vector2 origin, ref Vector2 size, CapsuleDirection2D capsuleDirection, float angle, ref Vector2 direction, float distance, ref ContactFilter2D contactFilter, out RaycastHit2D ret);
public static void DrawCapsuleCast2D(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, RaycastHit2D[] hits, float distance, int count) => DrawCapsuleCast2D(origin, size, capsuleDirection, angle, direction, hits, distance, count, StartColor, EndColor, HitColor);
private static extern int CapsuleCastList_Internal_Injected(ref PhysicsScene2D physicsScene, ref Vector2 origin, ref Vector2 size, CapsuleDirection2D capsuleDirection, float angle, ref Vector2 direction, float distance, ref ContactFilter2D contactFilter, List <RaycastHit2D> results);
private static extern int OverlapCapsuleList_Internal_Injected(ref PhysicsScene2D physicsScene, ref Vector2 point, ref Vector2 size, CapsuleDirection2D direction, float angle, ref ContactFilter2D contactFilter, List <Collider2D> results);
public int OverlapCapsule(Vector2 point, Vector2 size, CapsuleDirection2D direction, float angle, ContactFilter2D contactFilter, List <Collider2D> results)
{
return(_world.OverlapCapsule(point, size, direction, angle, contactFilter, results));
}
private void SetCrouchState(CapsuleDirection2D direction, float sizeX, float sizeY)
{
playerCollider.direction = direction;
playerCollider.size = new Vector2(sizeX, sizeY);
}
public static void DrawCapsuleCast2DHits(RaycastHit2D[] hits, Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, int maxCount = -1) => DrawCapsuleCast2DHits(hits, origin, size, capsuleDirection, angle, direction, HitColor, maxCount);
public int OverlapCapsule(Vector2 point, Vector2 size, CapsuleDirection2D direction, float angle, Collider2D[] results, [DefaultValue("Physics2D.DefaultRaycastLayers")] int layerMask = -5)
{
ContactFilter2D contactFilter = ContactFilter2D.CreateLegacyFilter(layerMask, float.NegativeInfinity, float.PositiveInfinity);
return(PhysicsScene2D.OverlapCapsuleArray_Internal(this, point, size, direction, angle, contactFilter, results));
}
public Collider2D OverlapCapsule(Vector2 point, Vector2 size, CapsuleDirection2D direction, float angle, ContactFilter2D contactFilter)
{
return(PhysicsScene2D.OverlapCapsule_Internal(this, point, size, direction, angle, contactFilter));
}
public static int OverlapCapsuleNonAlloc(Vector2 point, Vector2 size, CapsuleDirection2D direction, float angle, Collider2D[] results, int layerMask, float minDepth)
{
float positiveInfinity = float.PositiveInfinity;
return INTERNAL_CALL_OverlapCapsuleNonAlloc(ref point, ref size, direction, angle, results, layerMask, minDepth, positiveInfinity);
}
private static int OverlapCapsuleList_Internal(PhysicsScene2D physicsScene, Vector2 point, Vector2 size, CapsuleDirection2D direction, float angle, ContactFilter2D contactFilter, [NotNull("ArgumentNullException")] List <Collider2D> results)
{
return(PhysicsScene2D.OverlapCapsuleList_Internal_Injected(ref physicsScene, ref point, ref size, direction, angle, ref contactFilter, results));
}
private static Collider2D OverlapCapsule_Internal(PhysicsScene2D physicsScene, Vector2 point, Vector2 size, CapsuleDirection2D direction, float angle, ContactFilter2D contactFilter)
{
return(PhysicsScene2D.OverlapCapsule_Internal_Injected(ref physicsScene, ref point, ref size, direction, angle, ref contactFilter));
}
/// <summary>
/// Adjusts the position of the attack spawner based on current direction state
/// </summary>
private void RecalculatePosition()
{
//get center offset (due to pivot changes)
//float spriteHeight = spriteRenderer.bounds.size.y / 32f; //characters will always be 32ppu
//Debug.Log(spriteHeight);
Vector2 center = spriteRenderer.bounds.center;
Direction direction;
//get direction from whichever controller component this entity has
direction = controller.Direction;
// move spawn point into position
if (direction == Direction.East)
{
attackCapsuleDirection = CapsuleDirection2D.Horizontal;
attackCapsuleRotation = 0;
attackSpawnPoint = new Vector2(transform.position.x + (meleeRange / 2f), center.y);
}
else if (direction == Direction.West)
{
attackCapsuleDirection = CapsuleDirection2D.Horizontal;
attackCapsuleRotation = 0;
attackSpawnPoint = new Vector2(transform.position.x - (meleeRange / 2f), center.y);
}
else if (direction == Direction.North)
{
attackCapsuleDirection = CapsuleDirection2D.Vertical;
attackCapsuleRotation = 0;
attackSpawnPoint = new Vector2(transform.position.x, center.y + (meleeRange / 2f));
}
else if (direction == Direction.South)
{
attackCapsuleDirection = CapsuleDirection2D.Vertical;
attackCapsuleRotation = 0;
attackSpawnPoint = new Vector2(transform.position.x, center.y - (meleeRange / 2f));
}
//intermediate directions
else if (direction == Direction.NorthWest)
{
attackCapsuleDirection = CapsuleDirection2D.Horizontal;
attackCapsuleRotation = -45f;
attackSpawnPoint = new Vector2(transform.position.x - (meleeRange / 2f), center.y + (meleeRange / 2f));
}
else if (direction == Direction.NorthEast)
{
attackCapsuleDirection = CapsuleDirection2D.Horizontal;
attackCapsuleRotation = 45f;
attackSpawnPoint = new Vector2(transform.position.x + (meleeRange / 2f), center.y + (meleeRange / 2f));
}
else if (direction == Direction.SouthWest)
{
attackCapsuleDirection = CapsuleDirection2D.Horizontal;
attackCapsuleRotation = 45f;
attackSpawnPoint = new Vector2(transform.position.x - (meleeRange / 2f), center.y - (meleeRange / 2f));
}
else if (direction == Direction.SouthEast)
{
attackCapsuleDirection = CapsuleDirection2D.Horizontal;
attackCapsuleRotation = -45f;
attackSpawnPoint = new Vector2(transform.position.x + (meleeRange / 2f), center.y - (meleeRange / 2f));
}
}
/// <summary>
/// <para>Casts a capsule against colliders in the scene, returning the first collider to contact with it.</para>
/// </summary>
/// <param name="origin">The point in 2D space where the shape originates.</param>
/// <param name="size">The size of the shape.</param>
/// <param name="capsuleDirection">The direction of the capsule.</param>
/// <param name="angle">The angle of the shape (in degrees).</param>
/// <param name="direction">Vector representing the direction to cast the shape.</param>
/// <param name="distance">Maximum distance over which to cast the shape.</param>
/// <param name="layerMask">Filter to detect Colliders only on certain layers.</param>
/// <param name="minDepth">Only include objects with a Z coordinate (depth) greater than this value.</param>
/// <param name="maxDepth">Only include objects with a Z coordinate (depth) less than this value.</param>
/// <returns>
/// <para>The cast results returned.</para>
/// </returns>
public static RaycastHit2D CapsuleCast(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, [DefaultValue("Mathf.Infinity")] float distance, [DefaultValue("DefaultRaycastLayers")] int layerMask, [DefaultValue("-Mathf.Infinity")] float minDepth, [DefaultValue("Mathf.Infinity")] float maxDepth)
{
RaycastHit2D hitd;
Internal_CapsuleCast(origin, size, capsuleDirection, angle, direction, distance, layerMask, minDepth, maxDepth, out hitd);
return hitd;
}
public int OverlapCapsule(Vector2 point, Vector2 size, CapsuleDirection2D direction, float angle, ContactFilter2D contactFilter, List <Collider2D> results)
{
return(PhysicsScene2D.OverlapCapsuleList_Internal(this, point, size, direction, angle, contactFilter, results));
}
public static int CapsuleCastNonAlloc(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, RaycastHit2D[] results, float distance, int layerMask, float minDepth)
{
float positiveInfinity = float.PositiveInfinity;
return INTERNAL_CALL_CapsuleCastNonAlloc(ref origin, ref size, capsuleDirection, angle, ref direction, results, distance, layerMask, minDepth, positiveInfinity);
}
private static void Internal_CapsuleCast(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, float distance, int layerMask, float minDepth, float maxDepth, out RaycastHit2D raycastHit)
{
INTERNAL_CALL_Internal_CapsuleCast(ref origin, ref size, capsuleDirection, angle, ref direction, distance, layerMask, minDepth, maxDepth, out raycastHit);
}
private static extern int INTERNAL_CALL_CapsuleCastNonAlloc(ref Vector2 origin, ref Vector2 size, CapsuleDirection2D capsuleDirection, float angle, ref Vector2 direction, RaycastHit2D[] results, float distance, int layerMask, float minDepth, float maxDepth);
public int CastCapsule(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, float distance, ContactFilter2D contactFilter, List <RaycastHit2D> results)
{
return(_world.CapsuleCast(origin, size, capsuleDirection, angle, direction, distance, contactFilter, results));
}
private static extern int INTERNAL_CALL_OverlapCapsuleNonAlloc(ref Vector2 point, ref Vector2 size, CapsuleDirection2D direction, float angle, Collider2D[] results, int layerMask, float minDepth, float maxDepth);
public Collider2D OverlapCapsule(Vector2 point, Vector2 size, CapsuleDirection2D direction, float angle, ContactFilter2D contactFilter)
{
return(_world.OverlapCapsule(point, size, direction, angle, contactFilter));
}
private static int CapsuleCastList_Internal(PhysicsScene2D physicsScene, Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, float distance, ContactFilter2D contactFilter, [NotNull("ArgumentNullException")] List <RaycastHit2D> results)
{
return(PhysicsScene2D.CapsuleCastList_Internal_Injected(ref physicsScene, ref origin, ref size, capsuleDirection, angle, ref direction, distance, ref contactFilter, results));
}
public int CastCapsule(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, float distance, RaycastHit2D[] results, int layerMask = Physics2D.DefaultRaycastLayers)
{
return(_world.CapsuleCast(origin, size, capsuleDirection, angle, direction, distance, results, layerMask));
}
