niko
2378 lines
109 KiB
C#
2378 lines
109 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Runtime.CompilerServices;
|
|
using UnityEngine.Internal;
|
|
using UnityEngine.Scripting;
|
|
|
|
namespace UnityEngine
|
|
{
|
|
// Token: 0x02000179 RID: 377
|
|
public class Physics2D
|
|
{
|
|
// Token: 0x17000635 RID: 1589
|
|
// (get) Token: 0x06001BDE RID: 7134
|
|
// (set) Token: 0x06001BDF RID: 7135
|
|
[ThreadAndSerializationSafe]
|
|
public static extern int velocityIterations
|
|
{
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
get;
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
set;
|
|
}
|
|
|
|
// Token: 0x17000636 RID: 1590
|
|
// (get) Token: 0x06001BE0 RID: 7136
|
|
// (set) Token: 0x06001BE1 RID: 7137
|
|
public static extern int positionIterations
|
|
{
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
get;
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
set;
|
|
}
|
|
|
|
// Token: 0x17000637 RID: 1591
|
|
// (get) Token: 0x06001BE2 RID: 7138 RVA: 0x00021F38 File Offset: 0x00020138
|
|
// (set) Token: 0x06001BE3 RID: 7139 RVA: 0x00021F58 File Offset: 0x00020158
|
|
public static Vector2 gravity
|
|
{
|
|
get
|
|
{
|
|
Vector2 vector;
|
|
Physics2D.INTERNAL_get_gravity(out vector);
|
|
return vector;
|
|
}
|
|
set
|
|
{
|
|
Physics2D.INTERNAL_set_gravity(ref value);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06001BE4 RID: 7140
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern void INTERNAL_get_gravity(out Vector2 value);
|
|
|
|
// Token: 0x06001BE5 RID: 7141
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern void INTERNAL_set_gravity(ref Vector2 value);
|
|
|
|
// Token: 0x17000638 RID: 1592
|
|
// (get) Token: 0x06001BE6 RID: 7142
|
|
// (set) Token: 0x06001BE7 RID: 7143
|
|
public static extern bool queriesHitTriggers
|
|
{
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
get;
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
set;
|
|
}
|
|
|
|
// Token: 0x17000639 RID: 1593
|
|
// (get) Token: 0x06001BE8 RID: 7144
|
|
// (set) Token: 0x06001BE9 RID: 7145
|
|
public static extern bool queriesStartInColliders
|
|
{
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
get;
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
set;
|
|
}
|
|
|
|
// Token: 0x1700063A RID: 1594
|
|
// (get) Token: 0x06001BEA RID: 7146
|
|
// (set) Token: 0x06001BEB RID: 7147
|
|
public static extern bool changeStopsCallbacks
|
|
{
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
get;
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
set;
|
|
}
|
|
|
|
// Token: 0x1700063B RID: 1595
|
|
// (get) Token: 0x06001BEC RID: 7148
|
|
// (set) Token: 0x06001BED RID: 7149
|
|
public static extern bool callbacksOnDisable
|
|
{
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
get;
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
set;
|
|
}
|
|
|
|
// Token: 0x1700063C RID: 1596
|
|
// (get) Token: 0x06001BEE RID: 7150
|
|
// (set) Token: 0x06001BEF RID: 7151
|
|
public static extern bool autoSimulation
|
|
{
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
get;
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
set;
|
|
}
|
|
|
|
// Token: 0x1700063D RID: 1597
|
|
// (get) Token: 0x06001BF0 RID: 7152
|
|
// (set) Token: 0x06001BF1 RID: 7153
|
|
public static extern float velocityThreshold
|
|
{
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
get;
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
set;
|
|
}
|
|
|
|
// Token: 0x1700063E RID: 1598
|
|
// (get) Token: 0x06001BF2 RID: 7154
|
|
// (set) Token: 0x06001BF3 RID: 7155
|
|
public static extern float maxLinearCorrection
|
|
{
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
get;
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
set;
|
|
}
|
|
|
|
// Token: 0x1700063F RID: 1599
|
|
// (get) Token: 0x06001BF4 RID: 7156
|
|
// (set) Token: 0x06001BF5 RID: 7157
|
|
public static extern float maxAngularCorrection
|
|
{
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
get;
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
set;
|
|
}
|
|
|
|
// Token: 0x17000640 RID: 1600
|
|
// (get) Token: 0x06001BF6 RID: 7158
|
|
// (set) Token: 0x06001BF7 RID: 7159
|
|
public static extern float maxTranslationSpeed
|
|
{
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
get;
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
set;
|
|
}
|
|
|
|
// Token: 0x17000641 RID: 1601
|
|
// (get) Token: 0x06001BF8 RID: 7160
|
|
// (set) Token: 0x06001BF9 RID: 7161
|
|
public static extern float maxRotationSpeed
|
|
{
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
get;
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
set;
|
|
}
|
|
|
|
// Token: 0x17000642 RID: 1602
|
|
// (get) Token: 0x06001BFA RID: 7162
|
|
// (set) Token: 0x06001BFB RID: 7163
|
|
public static extern float defaultContactOffset
|
|
{
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
get;
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
set;
|
|
}
|
|
|
|
// Token: 0x17000643 RID: 1603
|
|
// (get) Token: 0x06001BFC RID: 7164
|
|
// (set) Token: 0x06001BFD RID: 7165
|
|
public static extern float baumgarteScale
|
|
{
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
get;
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
set;
|
|
}
|
|
|
|
// Token: 0x17000644 RID: 1604
|
|
// (get) Token: 0x06001BFE RID: 7166
|
|
// (set) Token: 0x06001BFF RID: 7167
|
|
public static extern float baumgarteTOIScale
|
|
{
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
get;
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
set;
|
|
}
|
|
|
|
// Token: 0x17000645 RID: 1605
|
|
// (get) Token: 0x06001C00 RID: 7168
|
|
// (set) Token: 0x06001C01 RID: 7169
|
|
public static extern float timeToSleep
|
|
{
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
get;
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
set;
|
|
}
|
|
|
|
// Token: 0x17000646 RID: 1606
|
|
// (get) Token: 0x06001C02 RID: 7170
|
|
// (set) Token: 0x06001C03 RID: 7171
|
|
public static extern float linearSleepTolerance
|
|
{
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
get;
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
set;
|
|
}
|
|
|
|
// Token: 0x17000647 RID: 1607
|
|
// (get) Token: 0x06001C04 RID: 7172
|
|
// (set) Token: 0x06001C05 RID: 7173
|
|
public static extern float angularSleepTolerance
|
|
{
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
get;
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
set;
|
|
}
|
|
|
|
// Token: 0x17000648 RID: 1608
|
|
// (get) Token: 0x06001C06 RID: 7174
|
|
// (set) Token: 0x06001C07 RID: 7175
|
|
public static extern bool alwaysShowColliders
|
|
{
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
get;
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
set;
|
|
}
|
|
|
|
// Token: 0x17000649 RID: 1609
|
|
// (get) Token: 0x06001C08 RID: 7176
|
|
// (set) Token: 0x06001C09 RID: 7177
|
|
public static extern bool showColliderSleep
|
|
{
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
get;
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
set;
|
|
}
|
|
|
|
// Token: 0x1700064A RID: 1610
|
|
// (get) Token: 0x06001C0A RID: 7178
|
|
// (set) Token: 0x06001C0B RID: 7179
|
|
public static extern bool showColliderContacts
|
|
{
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
get;
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
set;
|
|
}
|
|
|
|
// Token: 0x1700064B RID: 1611
|
|
// (get) Token: 0x06001C0C RID: 7180
|
|
// (set) Token: 0x06001C0D RID: 7181
|
|
public static extern bool showColliderAABB
|
|
{
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
get;
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
set;
|
|
}
|
|
|
|
// Token: 0x1700064C RID: 1612
|
|
// (get) Token: 0x06001C0E RID: 7182
|
|
// (set) Token: 0x06001C0F RID: 7183
|
|
public static extern float contactArrowScale
|
|
{
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
get;
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
set;
|
|
}
|
|
|
|
// Token: 0x1700064D RID: 1613
|
|
// (get) Token: 0x06001C10 RID: 7184 RVA: 0x00021F64 File Offset: 0x00020164
|
|
// (set) Token: 0x06001C11 RID: 7185 RVA: 0x00021F84 File Offset: 0x00020184
|
|
public static Color colliderAwakeColor
|
|
{
|
|
get
|
|
{
|
|
Color color;
|
|
Physics2D.INTERNAL_get_colliderAwakeColor(out color);
|
|
return color;
|
|
}
|
|
set
|
|
{
|
|
Physics2D.INTERNAL_set_colliderAwakeColor(ref value);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06001C12 RID: 7186
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern void INTERNAL_get_colliderAwakeColor(out Color value);
|
|
|
|
// Token: 0x06001C13 RID: 7187
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern void INTERNAL_set_colliderAwakeColor(ref Color value);
|
|
|
|
// Token: 0x1700064E RID: 1614
|
|
// (get) Token: 0x06001C14 RID: 7188 RVA: 0x00021F90 File Offset: 0x00020190
|
|
// (set) Token: 0x06001C15 RID: 7189 RVA: 0x00021FB0 File Offset: 0x000201B0
|
|
public static Color colliderAsleepColor
|
|
{
|
|
get
|
|
{
|
|
Color color;
|
|
Physics2D.INTERNAL_get_colliderAsleepColor(out color);
|
|
return color;
|
|
}
|
|
set
|
|
{
|
|
Physics2D.INTERNAL_set_colliderAsleepColor(ref value);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06001C16 RID: 7190
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern void INTERNAL_get_colliderAsleepColor(out Color value);
|
|
|
|
// Token: 0x06001C17 RID: 7191
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern void INTERNAL_set_colliderAsleepColor(ref Color value);
|
|
|
|
// Token: 0x1700064F RID: 1615
|
|
// (get) Token: 0x06001C18 RID: 7192 RVA: 0x00021FBC File Offset: 0x000201BC
|
|
// (set) Token: 0x06001C19 RID: 7193 RVA: 0x00021FDC File Offset: 0x000201DC
|
|
public static Color colliderContactColor
|
|
{
|
|
get
|
|
{
|
|
Color color;
|
|
Physics2D.INTERNAL_get_colliderContactColor(out color);
|
|
return color;
|
|
}
|
|
set
|
|
{
|
|
Physics2D.INTERNAL_set_colliderContactColor(ref value);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06001C1A RID: 7194
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern void INTERNAL_get_colliderContactColor(out Color value);
|
|
|
|
// Token: 0x06001C1B RID: 7195
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern void INTERNAL_set_colliderContactColor(ref Color value);
|
|
|
|
// Token: 0x17000650 RID: 1616
|
|
// (get) Token: 0x06001C1C RID: 7196 RVA: 0x00021FE8 File Offset: 0x000201E8
|
|
// (set) Token: 0x06001C1D RID: 7197 RVA: 0x00022008 File Offset: 0x00020208
|
|
public static Color colliderAABBColor
|
|
{
|
|
get
|
|
{
|
|
Color color;
|
|
Physics2D.INTERNAL_get_colliderAABBColor(out color);
|
|
return color;
|
|
}
|
|
set
|
|
{
|
|
Physics2D.INTERNAL_set_colliderAABBColor(ref value);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06001C1E RID: 7198
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern void INTERNAL_get_colliderAABBColor(out Color value);
|
|
|
|
// Token: 0x06001C1F RID: 7199
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern void INTERNAL_set_colliderAABBColor(ref Color value);
|
|
|
|
// Token: 0x06001C20 RID: 7200
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
public static extern bool Simulate(float step);
|
|
|
|
// Token: 0x06001C21 RID: 7201
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
public static extern void IgnoreCollision(Collider2D collider1, Collider2D collider2, [DefaultValue("true")] bool ignore);
|
|
|
|
// Token: 0x06001C22 RID: 7202 RVA: 0x00022014 File Offset: 0x00020214
|
|
[ExcludeFromDocs]
|
|
public static void IgnoreCollision(Collider2D collider1, Collider2D collider2)
|
|
{
|
|
bool flag = true;
|
|
Physics2D.IgnoreCollision(collider1, collider2, flag);
|
|
}
|
|
|
|
// Token: 0x06001C23 RID: 7203
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
public static extern bool GetIgnoreCollision(Collider2D collider1, Collider2D collider2);
|
|
|
|
// Token: 0x06001C24 RID: 7204
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
public static extern void IgnoreLayerCollision(int layer1, int layer2, [DefaultValue("true")] bool ignore);
|
|
|
|
// Token: 0x06001C25 RID: 7205 RVA: 0x0002202C File Offset: 0x0002022C
|
|
[ExcludeFromDocs]
|
|
public static void IgnoreLayerCollision(int layer1, int layer2)
|
|
{
|
|
bool flag = true;
|
|
Physics2D.IgnoreLayerCollision(layer1, layer2, flag);
|
|
}
|
|
|
|
// Token: 0x06001C26 RID: 7206
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
public static extern bool GetIgnoreLayerCollision(int layer1, int layer2);
|
|
|
|
// Token: 0x06001C27 RID: 7207
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
public static extern void SetLayerCollisionMask(int layer, int layerMask);
|
|
|
|
// Token: 0x06001C28 RID: 7208
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
public static extern int GetLayerCollisionMask(int layer);
|
|
|
|
// Token: 0x06001C29 RID: 7209
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
public static extern bool IsTouching(Collider2D collider1, Collider2D collider2);
|
|
|
|
// Token: 0x06001C2A RID: 7210 RVA: 0x00022044 File Offset: 0x00020244
|
|
public static bool IsTouching(Collider2D collider1, Collider2D collider2, ContactFilter2D contactFilter)
|
|
{
|
|
return Physics2D.Internal_IsTouching(collider1, collider2, contactFilter);
|
|
}
|
|
|
|
// Token: 0x06001C2B RID: 7211 RVA: 0x00022064 File Offset: 0x00020264
|
|
private static bool Internal_IsTouching(Collider2D collider1, Collider2D collider2, ContactFilter2D contactFilter)
|
|
{
|
|
return Physics2D.INTERNAL_CALL_Internal_IsTouching(collider1, collider2, ref contactFilter);
|
|
}
|
|
|
|
// Token: 0x06001C2C RID: 7212
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern bool INTERNAL_CALL_Internal_IsTouching(Collider2D collider1, Collider2D collider2, ref ContactFilter2D contactFilter);
|
|
|
|
// Token: 0x06001C2D RID: 7213 RVA: 0x00022084 File Offset: 0x00020284
|
|
public static bool IsTouching(Collider2D collider, ContactFilter2D contactFilter)
|
|
{
|
|
return Physics2D.INTERNAL_CALL_IsTouching(collider, ref contactFilter);
|
|
}
|
|
|
|
// Token: 0x06001C2E RID: 7214
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern bool INTERNAL_CALL_IsTouching(Collider2D collider, ref ContactFilter2D contactFilter);
|
|
|
|
// Token: 0x06001C2F RID: 7215
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
public static extern bool IsTouchingLayers(Collider2D collider, [DefaultValue("AllLayers")] int layerMask);
|
|
|
|
// Token: 0x06001C30 RID: 7216 RVA: 0x000220A4 File Offset: 0x000202A4
|
|
[ExcludeFromDocs]
|
|
public static bool IsTouchingLayers(Collider2D collider)
|
|
{
|
|
int num = -1;
|
|
return Physics2D.IsTouchingLayers(collider, num);
|
|
}
|
|
|
|
// Token: 0x06001C31 RID: 7217
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
public static extern ColliderDistance2D Distance(Collider2D colliderA, Collider2D colliderB);
|
|
|
|
// Token: 0x06001C32 RID: 7218 RVA: 0x000220C4 File Offset: 0x000202C4
|
|
internal static void SetEditorDragMovement(bool dragging, GameObject[] objs)
|
|
{
|
|
foreach (Rigidbody2D rigidbody2D in Physics2D.m_LastDisabledRigidbody2D)
|
|
{
|
|
if (rigidbody2D != null)
|
|
{
|
|
rigidbody2D.SetDragBehaviour(false);
|
|
}
|
|
}
|
|
Physics2D.m_LastDisabledRigidbody2D.Clear();
|
|
if (dragging)
|
|
{
|
|
foreach (GameObject gameObject in objs)
|
|
{
|
|
Rigidbody2D[] componentsInChildren = gameObject.GetComponentsInChildren<Rigidbody2D>(false);
|
|
foreach (Rigidbody2D rigidbody2D2 in componentsInChildren)
|
|
{
|
|
Physics2D.m_LastDisabledRigidbody2D.Add(rigidbody2D2);
|
|
rigidbody2D2.SetDragBehaviour(true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x06001C33 RID: 7219 RVA: 0x000221AC File Offset: 0x000203AC
|
|
[ExcludeFromDocs]
|
|
public static RaycastHit2D Linecast(Vector2 start, Vector2 end, int layerMask, float minDepth)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
return Physics2D.Linecast(start, end, layerMask, minDepth, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C34 RID: 7220 RVA: 0x000221D4 File Offset: 0x000203D4
|
|
[ExcludeFromDocs]
|
|
public static RaycastHit2D Linecast(Vector2 start, Vector2 end, int layerMask)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
return Physics2D.Linecast(start, end, layerMask, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C35 RID: 7221 RVA: 0x00022200 File Offset: 0x00020400
|
|
[ExcludeFromDocs]
|
|
public static RaycastHit2D Linecast(Vector2 start, Vector2 end)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
int num = -5;
|
|
return Physics2D.Linecast(start, end, num, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C36 RID: 7222 RVA: 0x00022230 File Offset: 0x00020430
|
|
public static RaycastHit2D Linecast(Vector2 start, Vector2 end, [DefaultValue("DefaultRaycastLayers")] int layerMask, [DefaultValue("-Mathf.Infinity")] float minDepth, [DefaultValue("Mathf.Infinity")] float maxDepth)
|
|
{
|
|
ContactFilter2D contactFilter2D = ContactFilter2D.CreateLegacyFilter(layerMask, minDepth, maxDepth);
|
|
RaycastHit2D raycastHit2D;
|
|
Physics2D.Internal_Linecast(start, end, contactFilter2D, out raycastHit2D);
|
|
return raycastHit2D;
|
|
}
|
|
|
|
// Token: 0x06001C37 RID: 7223 RVA: 0x0002225C File Offset: 0x0002045C
|
|
[ExcludeFromDocs]
|
|
public static RaycastHit2D[] LinecastAll(Vector2 start, Vector2 end, int layerMask, float minDepth)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
return Physics2D.LinecastAll(start, end, layerMask, minDepth, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C38 RID: 7224 RVA: 0x00022284 File Offset: 0x00020484
|
|
[ExcludeFromDocs]
|
|
public static RaycastHit2D[] LinecastAll(Vector2 start, Vector2 end, int layerMask)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
return Physics2D.LinecastAll(start, end, layerMask, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C39 RID: 7225 RVA: 0x000222B0 File Offset: 0x000204B0
|
|
[ExcludeFromDocs]
|
|
public static RaycastHit2D[] LinecastAll(Vector2 start, Vector2 end)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
int num = -5;
|
|
return Physics2D.LinecastAll(start, end, num, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C3A RID: 7226 RVA: 0x000222E0 File Offset: 0x000204E0
|
|
public static RaycastHit2D[] LinecastAll(Vector2 start, Vector2 end, [DefaultValue("DefaultRaycastLayers")] int layerMask, [DefaultValue("-Mathf.Infinity")] float minDepth, [DefaultValue("Mathf.Infinity")] float maxDepth)
|
|
{
|
|
ContactFilter2D contactFilter2D = ContactFilter2D.CreateLegacyFilter(layerMask, minDepth, maxDepth);
|
|
return Physics2D.Internal_LinecastAll(start, end, contactFilter2D);
|
|
}
|
|
|
|
// Token: 0x06001C3B RID: 7227 RVA: 0x00022308 File Offset: 0x00020508
|
|
[ExcludeFromDocs]
|
|
public static int LinecastNonAlloc(Vector2 start, Vector2 end, RaycastHit2D[] results, int layerMask, float minDepth)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
return Physics2D.LinecastNonAlloc(start, end, results, layerMask, minDepth, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C3C RID: 7228 RVA: 0x00022330 File Offset: 0x00020530
|
|
[ExcludeFromDocs]
|
|
public static int LinecastNonAlloc(Vector2 start, Vector2 end, RaycastHit2D[] results, int layerMask)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
return Physics2D.LinecastNonAlloc(start, end, results, layerMask, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C3D RID: 7229 RVA: 0x0002235C File Offset: 0x0002055C
|
|
[ExcludeFromDocs]
|
|
public static int LinecastNonAlloc(Vector2 start, Vector2 end, RaycastHit2D[] results)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
int num = -5;
|
|
return Physics2D.LinecastNonAlloc(start, end, results, num, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C3E RID: 7230 RVA: 0x0002238C File Offset: 0x0002058C
|
|
public static int LinecastNonAlloc(Vector2 start, Vector2 end, RaycastHit2D[] results, [DefaultValue("DefaultRaycastLayers")] int layerMask, [DefaultValue("-Mathf.Infinity")] float minDepth, [DefaultValue("Mathf.Infinity")] float maxDepth)
|
|
{
|
|
ContactFilter2D contactFilter2D = ContactFilter2D.CreateLegacyFilter(layerMask, minDepth, maxDepth);
|
|
return Physics2D.Internal_LinecastNonAlloc(start, end, contactFilter2D, results);
|
|
}
|
|
|
|
// Token: 0x06001C3F RID: 7231 RVA: 0x000223B8 File Offset: 0x000205B8
|
|
public static int Linecast(Vector2 start, Vector2 end, ContactFilter2D contactFilter, RaycastHit2D[] results)
|
|
{
|
|
return Physics2D.Internal_LinecastNonAlloc(start, end, contactFilter, results);
|
|
}
|
|
|
|
// Token: 0x06001C40 RID: 7232 RVA: 0x000223D8 File Offset: 0x000205D8
|
|
private static void Internal_Linecast(Vector2 start, Vector2 end, ContactFilter2D contactFilter, out RaycastHit2D raycastHit)
|
|
{
|
|
Physics2D.INTERNAL_CALL_Internal_Linecast(ref start, ref end, ref contactFilter, out raycastHit);
|
|
}
|
|
|
|
// Token: 0x06001C41 RID: 7233
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern void INTERNAL_CALL_Internal_Linecast(ref Vector2 start, ref Vector2 end, ref ContactFilter2D contactFilter, out RaycastHit2D raycastHit);
|
|
|
|
// Token: 0x06001C42 RID: 7234 RVA: 0x000223E8 File Offset: 0x000205E8
|
|
private static RaycastHit2D[] Internal_LinecastAll(Vector2 start, Vector2 end, ContactFilter2D contactFilter)
|
|
{
|
|
return Physics2D.INTERNAL_CALL_Internal_LinecastAll(ref start, ref end, ref contactFilter);
|
|
}
|
|
|
|
// Token: 0x06001C43 RID: 7235
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern RaycastHit2D[] INTERNAL_CALL_Internal_LinecastAll(ref Vector2 start, ref Vector2 end, ref ContactFilter2D contactFilter);
|
|
|
|
// Token: 0x06001C44 RID: 7236 RVA: 0x00022408 File Offset: 0x00020608
|
|
private static int Internal_LinecastNonAlloc(Vector2 start, Vector2 end, ContactFilter2D contactFilter, RaycastHit2D[] results)
|
|
{
|
|
return Physics2D.INTERNAL_CALL_Internal_LinecastNonAlloc(ref start, ref end, ref contactFilter, results);
|
|
}
|
|
|
|
// Token: 0x06001C45 RID: 7237
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern int INTERNAL_CALL_Internal_LinecastNonAlloc(ref Vector2 start, ref Vector2 end, ref ContactFilter2D contactFilter, RaycastHit2D[] results);
|
|
|
|
// Token: 0x06001C46 RID: 7238 RVA: 0x0002242C File Offset: 0x0002062C
|
|
[RequiredByNativeCode]
|
|
[ExcludeFromDocs]
|
|
public static RaycastHit2D Raycast(Vector2 origin, Vector2 direction, float distance, int layerMask, float minDepth)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
return Physics2D.Raycast(origin, direction, distance, layerMask, minDepth, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C47 RID: 7239 RVA: 0x00022454 File Offset: 0x00020654
|
|
[ExcludeFromDocs]
|
|
public static RaycastHit2D Raycast(Vector2 origin, Vector2 direction, float distance, int layerMask)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
return Physics2D.Raycast(origin, direction, distance, layerMask, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C48 RID: 7240 RVA: 0x00022480 File Offset: 0x00020680
|
|
[ExcludeFromDocs]
|
|
public static RaycastHit2D Raycast(Vector2 origin, Vector2 direction, float distance)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
int num = -5;
|
|
return Physics2D.Raycast(origin, direction, distance, num, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C49 RID: 7241 RVA: 0x000224B0 File Offset: 0x000206B0
|
|
[ExcludeFromDocs]
|
|
public static RaycastHit2D Raycast(Vector2 origin, Vector2 direction)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
int num = -5;
|
|
float positiveInfinity2 = float.PositiveInfinity;
|
|
return Physics2D.Raycast(origin, direction, positiveInfinity2, num, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C4A RID: 7242 RVA: 0x000224E8 File Offset: 0x000206E8
|
|
public static RaycastHit2D Raycast(Vector2 origin, Vector2 direction, [DefaultValue("Mathf.Infinity")] float distance, [DefaultValue("DefaultRaycastLayers")] int layerMask, [DefaultValue("-Mathf.Infinity")] float minDepth, [DefaultValue("Mathf.Infinity")] float maxDepth)
|
|
{
|
|
ContactFilter2D contactFilter2D = ContactFilter2D.CreateLegacyFilter(layerMask, minDepth, maxDepth);
|
|
RaycastHit2D raycastHit2D;
|
|
Physics2D.Internal_Raycast(origin, direction, distance, contactFilter2D, out raycastHit2D);
|
|
return raycastHit2D;
|
|
}
|
|
|
|
// Token: 0x06001C4B RID: 7243 RVA: 0x00022514 File Offset: 0x00020714
|
|
[ExcludeFromDocs]
|
|
public static RaycastHit2D[] RaycastAll(Vector2 origin, Vector2 direction, float distance, int layerMask, float minDepth)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
return Physics2D.RaycastAll(origin, direction, distance, layerMask, minDepth, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C4C RID: 7244 RVA: 0x0002253C File Offset: 0x0002073C
|
|
[ExcludeFromDocs]
|
|
public static RaycastHit2D[] RaycastAll(Vector2 origin, Vector2 direction, float distance, int layerMask)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
return Physics2D.RaycastAll(origin, direction, distance, layerMask, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C4D RID: 7245 RVA: 0x00022568 File Offset: 0x00020768
|
|
[ExcludeFromDocs]
|
|
public static RaycastHit2D[] RaycastAll(Vector2 origin, Vector2 direction, float distance)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
int num = -5;
|
|
return Physics2D.RaycastAll(origin, direction, distance, num, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C4E RID: 7246 RVA: 0x00022598 File Offset: 0x00020798
|
|
[ExcludeFromDocs]
|
|
public static RaycastHit2D[] RaycastAll(Vector2 origin, Vector2 direction)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
int num = -5;
|
|
float positiveInfinity2 = float.PositiveInfinity;
|
|
return Physics2D.RaycastAll(origin, direction, positiveInfinity2, num, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C4F RID: 7247 RVA: 0x000225D0 File Offset: 0x000207D0
|
|
public static RaycastHit2D[] RaycastAll(Vector2 origin, Vector2 direction, [DefaultValue("Mathf.Infinity")] float distance, [DefaultValue("DefaultRaycastLayers")] int layerMask, [DefaultValue("-Mathf.Infinity")] float minDepth, [DefaultValue("Mathf.Infinity")] float maxDepth)
|
|
{
|
|
ContactFilter2D contactFilter2D = ContactFilter2D.CreateLegacyFilter(layerMask, minDepth, maxDepth);
|
|
return Physics2D.Internal_RaycastAll(origin, direction, distance, contactFilter2D);
|
|
}
|
|
|
|
// Token: 0x06001C50 RID: 7248 RVA: 0x000225FC File Offset: 0x000207FC
|
|
[ExcludeFromDocs]
|
|
public static int RaycastNonAlloc(Vector2 origin, Vector2 direction, RaycastHit2D[] results, float distance, int layerMask, float minDepth)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
return Physics2D.RaycastNonAlloc(origin, direction, results, distance, layerMask, minDepth, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C51 RID: 7249 RVA: 0x00022628 File Offset: 0x00020828
|
|
[ExcludeFromDocs]
|
|
public static int RaycastNonAlloc(Vector2 origin, Vector2 direction, RaycastHit2D[] results, float distance, int layerMask)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
return Physics2D.RaycastNonAlloc(origin, direction, results, distance, layerMask, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C52 RID: 7250 RVA: 0x00022658 File Offset: 0x00020858
|
|
[ExcludeFromDocs]
|
|
public static int RaycastNonAlloc(Vector2 origin, Vector2 direction, RaycastHit2D[] results, float distance)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
int num = -5;
|
|
return Physics2D.RaycastNonAlloc(origin, direction, results, distance, num, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C53 RID: 7251 RVA: 0x00022688 File Offset: 0x00020888
|
|
[ExcludeFromDocs]
|
|
public static int RaycastNonAlloc(Vector2 origin, Vector2 direction, RaycastHit2D[] results)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
int num = -5;
|
|
float positiveInfinity2 = float.PositiveInfinity;
|
|
return Physics2D.RaycastNonAlloc(origin, direction, results, positiveInfinity2, num, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C54 RID: 7252 RVA: 0x000226C0 File Offset: 0x000208C0
|
|
public static int RaycastNonAlloc(Vector2 origin, Vector2 direction, RaycastHit2D[] results, [DefaultValue("Mathf.Infinity")] float distance, [DefaultValue("DefaultRaycastLayers")] int layerMask, [DefaultValue("-Mathf.Infinity")] float minDepth, [DefaultValue("Mathf.Infinity")] float maxDepth)
|
|
{
|
|
ContactFilter2D contactFilter2D = ContactFilter2D.CreateLegacyFilter(layerMask, minDepth, maxDepth);
|
|
return Physics2D.Internal_RaycastNonAlloc(origin, direction, distance, contactFilter2D, results);
|
|
}
|
|
|
|
// Token: 0x06001C55 RID: 7253 RVA: 0x000226EC File Offset: 0x000208EC
|
|
[ExcludeFromDocs]
|
|
public static int Raycast(Vector2 origin, Vector2 direction, ContactFilter2D contactFilter, RaycastHit2D[] results)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
return Physics2D.Raycast(origin, direction, contactFilter, results, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C56 RID: 7254 RVA: 0x00022714 File Offset: 0x00020914
|
|
public static int Raycast(Vector2 origin, Vector2 direction, ContactFilter2D contactFilter, RaycastHit2D[] results, [DefaultValue("Mathf.Infinity")] float distance)
|
|
{
|
|
return Physics2D.Internal_RaycastNonAlloc(origin, direction, distance, contactFilter, results);
|
|
}
|
|
|
|
// Token: 0x06001C57 RID: 7255 RVA: 0x00022734 File Offset: 0x00020934
|
|
private static void Internal_Raycast(Vector2 origin, Vector2 direction, float distance, ContactFilter2D contactFilter, out RaycastHit2D raycastHit)
|
|
{
|
|
Physics2D.INTERNAL_CALL_Internal_Raycast(ref origin, ref direction, distance, ref contactFilter, out raycastHit);
|
|
}
|
|
|
|
// Token: 0x06001C58 RID: 7256
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern void INTERNAL_CALL_Internal_Raycast(ref Vector2 origin, ref Vector2 direction, float distance, ref ContactFilter2D contactFilter, out RaycastHit2D raycastHit);
|
|
|
|
// Token: 0x06001C59 RID: 7257 RVA: 0x00022748 File Offset: 0x00020948
|
|
private static RaycastHit2D[] Internal_RaycastAll(Vector2 origin, Vector2 direction, float distance, ContactFilter2D contactFilter)
|
|
{
|
|
return Physics2D.INTERNAL_CALL_Internal_RaycastAll(ref origin, ref direction, distance, ref contactFilter);
|
|
}
|
|
|
|
// Token: 0x06001C5A RID: 7258
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern RaycastHit2D[] INTERNAL_CALL_Internal_RaycastAll(ref Vector2 origin, ref Vector2 direction, float distance, ref ContactFilter2D contactFilter);
|
|
|
|
// Token: 0x06001C5B RID: 7259 RVA: 0x0002276C File Offset: 0x0002096C
|
|
private static int Internal_RaycastNonAlloc(Vector2 origin, Vector2 direction, float distance, ContactFilter2D contactFilter, RaycastHit2D[] results)
|
|
{
|
|
return Physics2D.INTERNAL_CALL_Internal_RaycastNonAlloc(ref origin, ref direction, distance, ref contactFilter, results);
|
|
}
|
|
|
|
// Token: 0x06001C5C RID: 7260
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern int INTERNAL_CALL_Internal_RaycastNonAlloc(ref Vector2 origin, ref Vector2 direction, float distance, ref ContactFilter2D contactFilter, RaycastHit2D[] results);
|
|
|
|
// Token: 0x06001C5D RID: 7261 RVA: 0x00022790 File Offset: 0x00020990
|
|
[ExcludeFromDocs]
|
|
public static RaycastHit2D CircleCast(Vector2 origin, float radius, Vector2 direction, float distance, int layerMask, float minDepth)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
return Physics2D.CircleCast(origin, radius, direction, distance, layerMask, minDepth, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C5E RID: 7262 RVA: 0x000227BC File Offset: 0x000209BC
|
|
[ExcludeFromDocs]
|
|
public static RaycastHit2D CircleCast(Vector2 origin, float radius, Vector2 direction, float distance, int layerMask)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
return Physics2D.CircleCast(origin, radius, direction, distance, layerMask, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C5F RID: 7263 RVA: 0x000227EC File Offset: 0x000209EC
|
|
[ExcludeFromDocs]
|
|
public static RaycastHit2D CircleCast(Vector2 origin, float radius, Vector2 direction, float distance)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
int num = -5;
|
|
return Physics2D.CircleCast(origin, radius, direction, distance, num, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C60 RID: 7264 RVA: 0x0002281C File Offset: 0x00020A1C
|
|
[ExcludeFromDocs]
|
|
public static RaycastHit2D CircleCast(Vector2 origin, float radius, Vector2 direction)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
int num = -5;
|
|
float positiveInfinity2 = float.PositiveInfinity;
|
|
return Physics2D.CircleCast(origin, radius, direction, positiveInfinity2, num, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C61 RID: 7265 RVA: 0x00022854 File Offset: 0x00020A54
|
|
public static RaycastHit2D CircleCast(Vector2 origin, float radius, Vector2 direction, [DefaultValue("Mathf.Infinity")] float distance, [DefaultValue("DefaultRaycastLayers")] int layerMask, [DefaultValue("-Mathf.Infinity")] float minDepth, [DefaultValue("Mathf.Infinity")] float maxDepth)
|
|
{
|
|
ContactFilter2D contactFilter2D = ContactFilter2D.CreateLegacyFilter(layerMask, minDepth, maxDepth);
|
|
RaycastHit2D raycastHit2D;
|
|
Physics2D.Internal_CircleCast(origin, radius, direction, distance, contactFilter2D, out raycastHit2D);
|
|
return raycastHit2D;
|
|
}
|
|
|
|
// Token: 0x06001C62 RID: 7266 RVA: 0x00022884 File Offset: 0x00020A84
|
|
[ExcludeFromDocs]
|
|
public static RaycastHit2D[] CircleCastAll(Vector2 origin, float radius, Vector2 direction, float distance, int layerMask, float minDepth)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
return Physics2D.CircleCastAll(origin, radius, direction, distance, layerMask, minDepth, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C63 RID: 7267 RVA: 0x000228B0 File Offset: 0x00020AB0
|
|
[ExcludeFromDocs]
|
|
public static RaycastHit2D[] CircleCastAll(Vector2 origin, float radius, Vector2 direction, float distance, int layerMask)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
return Physics2D.CircleCastAll(origin, radius, direction, distance, layerMask, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C64 RID: 7268 RVA: 0x000228E0 File Offset: 0x00020AE0
|
|
[ExcludeFromDocs]
|
|
public static RaycastHit2D[] CircleCastAll(Vector2 origin, float radius, Vector2 direction, float distance)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
int num = -5;
|
|
return Physics2D.CircleCastAll(origin, radius, direction, distance, num, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C65 RID: 7269 RVA: 0x00022910 File Offset: 0x00020B10
|
|
[ExcludeFromDocs]
|
|
public static RaycastHit2D[] CircleCastAll(Vector2 origin, float radius, Vector2 direction)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
int num = -5;
|
|
float positiveInfinity2 = float.PositiveInfinity;
|
|
return Physics2D.CircleCastAll(origin, radius, direction, positiveInfinity2, num, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C66 RID: 7270 RVA: 0x00022948 File Offset: 0x00020B48
|
|
public static RaycastHit2D[] CircleCastAll(Vector2 origin, float radius, Vector2 direction, [DefaultValue("Mathf.Infinity")] float distance, [DefaultValue("DefaultRaycastLayers")] int layerMask, [DefaultValue("-Mathf.Infinity")] float minDepth, [DefaultValue("Mathf.Infinity")] float maxDepth)
|
|
{
|
|
ContactFilter2D contactFilter2D = ContactFilter2D.CreateLegacyFilter(layerMask, minDepth, maxDepth);
|
|
return Physics2D.Internal_CircleCastAll(origin, radius, direction, distance, contactFilter2D);
|
|
}
|
|
|
|
// Token: 0x06001C67 RID: 7271 RVA: 0x00022974 File Offset: 0x00020B74
|
|
[ExcludeFromDocs]
|
|
public static int CircleCastNonAlloc(Vector2 origin, float radius, Vector2 direction, RaycastHit2D[] results, float distance, int layerMask, float minDepth)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
return Physics2D.CircleCastNonAlloc(origin, radius, direction, results, distance, layerMask, minDepth, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C68 RID: 7272 RVA: 0x000229A0 File Offset: 0x00020BA0
|
|
[ExcludeFromDocs]
|
|
public static int CircleCastNonAlloc(Vector2 origin, float radius, Vector2 direction, RaycastHit2D[] results, float distance, int layerMask)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
return Physics2D.CircleCastNonAlloc(origin, radius, direction, results, distance, layerMask, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C69 RID: 7273 RVA: 0x000229D0 File Offset: 0x00020BD0
|
|
[ExcludeFromDocs]
|
|
public static int CircleCastNonAlloc(Vector2 origin, float radius, Vector2 direction, RaycastHit2D[] results, float distance)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
int num = -5;
|
|
return Physics2D.CircleCastNonAlloc(origin, radius, direction, results, distance, num, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C6A RID: 7274 RVA: 0x00022A04 File Offset: 0x00020C04
|
|
[ExcludeFromDocs]
|
|
public static int CircleCastNonAlloc(Vector2 origin, float radius, Vector2 direction, RaycastHit2D[] results)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
int num = -5;
|
|
float positiveInfinity2 = float.PositiveInfinity;
|
|
return Physics2D.CircleCastNonAlloc(origin, radius, direction, results, positiveInfinity2, num, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C6B RID: 7275 RVA: 0x00022A40 File Offset: 0x00020C40
|
|
public static int CircleCastNonAlloc(Vector2 origin, float radius, Vector2 direction, RaycastHit2D[] results, [DefaultValue("Mathf.Infinity")] float distance, [DefaultValue("DefaultRaycastLayers")] int layerMask, [DefaultValue("-Mathf.Infinity")] float minDepth, [DefaultValue("Mathf.Infinity")] float maxDepth)
|
|
{
|
|
ContactFilter2D contactFilter2D = ContactFilter2D.CreateLegacyFilter(layerMask, minDepth, maxDepth);
|
|
return Physics2D.Internal_CircleCastNonAlloc(origin, radius, direction, distance, contactFilter2D, results);
|
|
}
|
|
|
|
// Token: 0x06001C6C RID: 7276 RVA: 0x00022A70 File Offset: 0x00020C70
|
|
[ExcludeFromDocs]
|
|
public static int CircleCast(Vector2 origin, float radius, Vector2 direction, ContactFilter2D contactFilter, RaycastHit2D[] results)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
return Physics2D.CircleCast(origin, radius, direction, contactFilter, results, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C6D RID: 7277 RVA: 0x00022A98 File Offset: 0x00020C98
|
|
public static int CircleCast(Vector2 origin, float radius, Vector2 direction, ContactFilter2D contactFilter, RaycastHit2D[] results, [DefaultValue("Mathf.Infinity")] float distance)
|
|
{
|
|
return Physics2D.Internal_CircleCastNonAlloc(origin, radius, direction, distance, contactFilter, results);
|
|
}
|
|
|
|
// Token: 0x06001C6E RID: 7278 RVA: 0x00022ABC File Offset: 0x00020CBC
|
|
private static void Internal_CircleCast(Vector2 origin, float radius, Vector2 direction, float distance, ContactFilter2D contactFilter, out RaycastHit2D raycastHit)
|
|
{
|
|
Physics2D.INTERNAL_CALL_Internal_CircleCast(ref origin, radius, ref direction, distance, ref contactFilter, out raycastHit);
|
|
}
|
|
|
|
// Token: 0x06001C6F RID: 7279
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern void INTERNAL_CALL_Internal_CircleCast(ref Vector2 origin, float radius, ref Vector2 direction, float distance, ref ContactFilter2D contactFilter, out RaycastHit2D raycastHit);
|
|
|
|
// Token: 0x06001C70 RID: 7280 RVA: 0x00022AD0 File Offset: 0x00020CD0
|
|
private static RaycastHit2D[] Internal_CircleCastAll(Vector2 origin, float radius, Vector2 direction, float distance, ContactFilter2D contactFilter)
|
|
{
|
|
return Physics2D.INTERNAL_CALL_Internal_CircleCastAll(ref origin, radius, ref direction, distance, ref contactFilter);
|
|
}
|
|
|
|
// Token: 0x06001C71 RID: 7281
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern RaycastHit2D[] INTERNAL_CALL_Internal_CircleCastAll(ref Vector2 origin, float radius, ref Vector2 direction, float distance, ref ContactFilter2D contactFilter);
|
|
|
|
// Token: 0x06001C72 RID: 7282 RVA: 0x00022AF4 File Offset: 0x00020CF4
|
|
private static int Internal_CircleCastNonAlloc(Vector2 origin, float radius, Vector2 direction, float distance, ContactFilter2D contactFilter, RaycastHit2D[] results)
|
|
{
|
|
return Physics2D.INTERNAL_CALL_Internal_CircleCastNonAlloc(ref origin, radius, ref direction, distance, ref contactFilter, results);
|
|
}
|
|
|
|
// Token: 0x06001C73 RID: 7283
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern int INTERNAL_CALL_Internal_CircleCastNonAlloc(ref Vector2 origin, float radius, ref Vector2 direction, float distance, ref ContactFilter2D contactFilter, RaycastHit2D[] results);
|
|
|
|
// Token: 0x06001C74 RID: 7284 RVA: 0x00022B18 File Offset: 0x00020D18
|
|
[ExcludeFromDocs]
|
|
public static RaycastHit2D BoxCast(Vector2 origin, Vector2 size, float angle, Vector2 direction, float distance, int layerMask, float minDepth)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
return Physics2D.BoxCast(origin, size, angle, direction, distance, layerMask, minDepth, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C75 RID: 7285 RVA: 0x00022B44 File Offset: 0x00020D44
|
|
[ExcludeFromDocs]
|
|
public static RaycastHit2D BoxCast(Vector2 origin, Vector2 size, float angle, Vector2 direction, float distance, int layerMask)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
return Physics2D.BoxCast(origin, size, angle, direction, distance, layerMask, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C76 RID: 7286 RVA: 0x00022B74 File Offset: 0x00020D74
|
|
[ExcludeFromDocs]
|
|
public static RaycastHit2D BoxCast(Vector2 origin, Vector2 size, float angle, Vector2 direction, float distance)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
int num = -5;
|
|
return Physics2D.BoxCast(origin, size, angle, direction, distance, num, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C77 RID: 7287 RVA: 0x00022BA8 File Offset: 0x00020DA8
|
|
[ExcludeFromDocs]
|
|
public static RaycastHit2D BoxCast(Vector2 origin, Vector2 size, float angle, Vector2 direction)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
int num = -5;
|
|
float positiveInfinity2 = float.PositiveInfinity;
|
|
return Physics2D.BoxCast(origin, size, angle, direction, positiveInfinity2, num, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C78 RID: 7288 RVA: 0x00022BE4 File Offset: 0x00020DE4
|
|
public static RaycastHit2D BoxCast(Vector2 origin, Vector2 size, float angle, Vector2 direction, [DefaultValue("Mathf.Infinity")] float distance, [DefaultValue("DefaultRaycastLayers")] int layerMask, [DefaultValue("-Mathf.Infinity")] float minDepth, [DefaultValue("Mathf.Infinity")] float maxDepth)
|
|
{
|
|
ContactFilter2D contactFilter2D = ContactFilter2D.CreateLegacyFilter(layerMask, minDepth, maxDepth);
|
|
RaycastHit2D raycastHit2D;
|
|
Physics2D.Internal_BoxCast(origin, size, angle, direction, distance, contactFilter2D, out raycastHit2D);
|
|
return raycastHit2D;
|
|
}
|
|
|
|
// Token: 0x06001C79 RID: 7289 RVA: 0x00022C14 File Offset: 0x00020E14
|
|
[ExcludeFromDocs]
|
|
public static RaycastHit2D[] BoxCastAll(Vector2 origin, Vector2 size, float angle, Vector2 direction, float distance, int layerMask, float minDepth)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
return Physics2D.BoxCastAll(origin, size, angle, direction, distance, layerMask, minDepth, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C7A RID: 7290 RVA: 0x00022C40 File Offset: 0x00020E40
|
|
[ExcludeFromDocs]
|
|
public static RaycastHit2D[] BoxCastAll(Vector2 origin, Vector2 size, float angle, Vector2 direction, float distance, int layerMask)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
return Physics2D.BoxCastAll(origin, size, angle, direction, distance, layerMask, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C7B RID: 7291 RVA: 0x00022C70 File Offset: 0x00020E70
|
|
[ExcludeFromDocs]
|
|
public static RaycastHit2D[] BoxCastAll(Vector2 origin, Vector2 size, float angle, Vector2 direction, float distance)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
int num = -5;
|
|
return Physics2D.BoxCastAll(origin, size, angle, direction, distance, num, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C7C RID: 7292 RVA: 0x00022CA4 File Offset: 0x00020EA4
|
|
[ExcludeFromDocs]
|
|
public static RaycastHit2D[] BoxCastAll(Vector2 origin, Vector2 size, float angle, Vector2 direction)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
int num = -5;
|
|
float positiveInfinity2 = float.PositiveInfinity;
|
|
return Physics2D.BoxCastAll(origin, size, angle, direction, positiveInfinity2, num, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C7D RID: 7293 RVA: 0x00022CE0 File Offset: 0x00020EE0
|
|
public static RaycastHit2D[] BoxCastAll(Vector2 origin, Vector2 size, float angle, Vector2 direction, [DefaultValue("Mathf.Infinity")] float distance, [DefaultValue("DefaultRaycastLayers")] int layerMask, [DefaultValue("-Mathf.Infinity")] float minDepth, [DefaultValue("Mathf.Infinity")] float maxDepth)
|
|
{
|
|
ContactFilter2D contactFilter2D = ContactFilter2D.CreateLegacyFilter(layerMask, minDepth, maxDepth);
|
|
return Physics2D.Internal_BoxCastAll(origin, size, angle, direction, distance, contactFilter2D);
|
|
}
|
|
|
|
// Token: 0x06001C7E RID: 7294 RVA: 0x00022D10 File Offset: 0x00020F10
|
|
[ExcludeFromDocs]
|
|
public static int BoxCastNonAlloc(Vector2 origin, Vector2 size, float angle, Vector2 direction, RaycastHit2D[] results, float distance, int layerMask, float minDepth)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
return Physics2D.BoxCastNonAlloc(origin, size, angle, direction, results, distance, layerMask, minDepth, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C7F RID: 7295 RVA: 0x00022D40 File Offset: 0x00020F40
|
|
[ExcludeFromDocs]
|
|
public static int BoxCastNonAlloc(Vector2 origin, Vector2 size, float angle, Vector2 direction, RaycastHit2D[] results, float distance, int layerMask)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
return Physics2D.BoxCastNonAlloc(origin, size, angle, direction, results, distance, layerMask, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C80 RID: 7296 RVA: 0x00022D74 File Offset: 0x00020F74
|
|
[ExcludeFromDocs]
|
|
public static int BoxCastNonAlloc(Vector2 origin, Vector2 size, float angle, Vector2 direction, RaycastHit2D[] results, float distance)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
int num = -5;
|
|
return Physics2D.BoxCastNonAlloc(origin, size, angle, direction, results, distance, num, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C81 RID: 7297 RVA: 0x00022DA8 File Offset: 0x00020FA8
|
|
[ExcludeFromDocs]
|
|
public static int BoxCastNonAlloc(Vector2 origin, Vector2 size, float angle, Vector2 direction, RaycastHit2D[] results)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
int num = -5;
|
|
float positiveInfinity2 = float.PositiveInfinity;
|
|
return Physics2D.BoxCastNonAlloc(origin, size, angle, direction, results, positiveInfinity2, num, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C82 RID: 7298 RVA: 0x00022DE4 File Offset: 0x00020FE4
|
|
public static int BoxCastNonAlloc(Vector2 origin, Vector2 size, 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)
|
|
{
|
|
ContactFilter2D contactFilter2D = ContactFilter2D.CreateLegacyFilter(layerMask, minDepth, maxDepth);
|
|
return Physics2D.Internal_BoxCastNonAlloc(origin, size, angle, direction, distance, contactFilter2D, results);
|
|
}
|
|
|
|
// Token: 0x06001C83 RID: 7299 RVA: 0x00022E14 File Offset: 0x00021014
|
|
[ExcludeFromDocs]
|
|
public static int BoxCast(Vector2 origin, Vector2 size, float angle, Vector2 direction, ContactFilter2D contactFilter, RaycastHit2D[] results)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
return Physics2D.BoxCast(origin, size, angle, direction, contactFilter, results, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C84 RID: 7300 RVA: 0x00022E40 File Offset: 0x00021040
|
|
public static int BoxCast(Vector2 origin, Vector2 size, float angle, Vector2 direction, ContactFilter2D contactFilter, RaycastHit2D[] results, [DefaultValue("Mathf.Infinity")] float distance)
|
|
{
|
|
return Physics2D.Internal_BoxCastNonAlloc(origin, size, angle, direction, distance, contactFilter, results);
|
|
}
|
|
|
|
// Token: 0x06001C85 RID: 7301 RVA: 0x00022E64 File Offset: 0x00021064
|
|
private static void Internal_BoxCast(Vector2 origin, Vector2 size, float angle, Vector2 direction, float distance, ContactFilter2D contactFilter, out RaycastHit2D raycastHit)
|
|
{
|
|
Physics2D.INTERNAL_CALL_Internal_BoxCast(ref origin, ref size, angle, ref direction, distance, ref contactFilter, out raycastHit);
|
|
}
|
|
|
|
// Token: 0x06001C86 RID: 7302
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern void INTERNAL_CALL_Internal_BoxCast(ref Vector2 origin, ref Vector2 size, float angle, ref Vector2 direction, float distance, ref ContactFilter2D contactFilter, out RaycastHit2D raycastHit);
|
|
|
|
// Token: 0x06001C87 RID: 7303 RVA: 0x00022E7C File Offset: 0x0002107C
|
|
private static RaycastHit2D[] Internal_BoxCastAll(Vector2 origin, Vector2 size, float angle, Vector2 direction, float distance, ContactFilter2D contactFilter)
|
|
{
|
|
return Physics2D.INTERNAL_CALL_Internal_BoxCastAll(ref origin, ref size, angle, ref direction, distance, ref contactFilter);
|
|
}
|
|
|
|
// Token: 0x06001C88 RID: 7304
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern RaycastHit2D[] INTERNAL_CALL_Internal_BoxCastAll(ref Vector2 origin, ref Vector2 size, float angle, ref Vector2 direction, float distance, ref ContactFilter2D contactFilter);
|
|
|
|
// Token: 0x06001C89 RID: 7305 RVA: 0x00022EA4 File Offset: 0x000210A4
|
|
private static int Internal_BoxCastNonAlloc(Vector2 origin, Vector2 size, float angle, Vector2 direction, float distance, ContactFilter2D contactFilter, RaycastHit2D[] results)
|
|
{
|
|
return Physics2D.INTERNAL_CALL_Internal_BoxCastNonAlloc(ref origin, ref size, angle, ref direction, distance, ref contactFilter, results);
|
|
}
|
|
|
|
// Token: 0x06001C8A RID: 7306
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern int INTERNAL_CALL_Internal_BoxCastNonAlloc(ref Vector2 origin, ref Vector2 size, float angle, ref Vector2 direction, float distance, ref ContactFilter2D contactFilter, RaycastHit2D[] results);
|
|
|
|
// Token: 0x06001C8B RID: 7307 RVA: 0x00022ECC File Offset: 0x000210CC
|
|
[ExcludeFromDocs]
|
|
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 Physics2D.CapsuleCast(origin, size, capsuleDirection, angle, direction, distance, layerMask, minDepth, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C8C RID: 7308 RVA: 0x00022EFC File Offset: 0x000210FC
|
|
[ExcludeFromDocs]
|
|
public static RaycastHit2D CapsuleCast(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, float distance, int layerMask)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
return Physics2D.CapsuleCast(origin, size, capsuleDirection, angle, direction, distance, layerMask, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C8D RID: 7309 RVA: 0x00022F30 File Offset: 0x00021130
|
|
[ExcludeFromDocs]
|
|
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 num = -5;
|
|
return Physics2D.CapsuleCast(origin, size, capsuleDirection, angle, direction, distance, num, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C8E RID: 7310 RVA: 0x00022F64 File Offset: 0x00021164
|
|
[ExcludeFromDocs]
|
|
public static RaycastHit2D CapsuleCast(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
int num = -5;
|
|
float positiveInfinity2 = float.PositiveInfinity;
|
|
return Physics2D.CapsuleCast(origin, size, capsuleDirection, angle, direction, positiveInfinity2, num, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C8F RID: 7311 RVA: 0x00022FA0 File Offset: 0x000211A0
|
|
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)
|
|
{
|
|
ContactFilter2D contactFilter2D = ContactFilter2D.CreateLegacyFilter(layerMask, minDepth, maxDepth);
|
|
RaycastHit2D raycastHit2D;
|
|
Physics2D.Internal_CapsuleCast(origin, size, capsuleDirection, angle, direction, distance, contactFilter2D, out raycastHit2D);
|
|
return raycastHit2D;
|
|
}
|
|
|
|
// Token: 0x06001C90 RID: 7312 RVA: 0x00022FD4 File Offset: 0x000211D4
|
|
[ExcludeFromDocs]
|
|
public static RaycastHit2D[] CapsuleCastAll(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, float distance, int layerMask, float minDepth)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
return Physics2D.CapsuleCastAll(origin, size, capsuleDirection, angle, direction, distance, layerMask, minDepth, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C91 RID: 7313 RVA: 0x00023004 File Offset: 0x00021204
|
|
[ExcludeFromDocs]
|
|
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 Physics2D.CapsuleCastAll(origin, size, capsuleDirection, angle, direction, distance, layerMask, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C92 RID: 7314 RVA: 0x00023038 File Offset: 0x00021238
|
|
[ExcludeFromDocs]
|
|
public static RaycastHit2D[] CapsuleCastAll(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, float distance)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
int num = -5;
|
|
return Physics2D.CapsuleCastAll(origin, size, capsuleDirection, angle, direction, distance, num, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C93 RID: 7315 RVA: 0x0002306C File Offset: 0x0002126C
|
|
[ExcludeFromDocs]
|
|
public static RaycastHit2D[] CapsuleCastAll(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
int num = -5;
|
|
float positiveInfinity2 = float.PositiveInfinity;
|
|
return Physics2D.CapsuleCastAll(origin, size, capsuleDirection, angle, direction, positiveInfinity2, num, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C94 RID: 7316 RVA: 0x000230A8 File Offset: 0x000212A8
|
|
public static RaycastHit2D[] CapsuleCastAll(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)
|
|
{
|
|
ContactFilter2D contactFilter2D = ContactFilter2D.CreateLegacyFilter(layerMask, minDepth, maxDepth);
|
|
return Physics2D.Internal_CapsuleCastAll(origin, size, capsuleDirection, angle, direction, distance, contactFilter2D);
|
|
}
|
|
|
|
// Token: 0x06001C95 RID: 7317 RVA: 0x000230D8 File Offset: 0x000212D8
|
|
[ExcludeFromDocs]
|
|
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 Physics2D.CapsuleCastNonAlloc(origin, size, capsuleDirection, angle, direction, results, distance, layerMask, minDepth, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C96 RID: 7318 RVA: 0x00023108 File Offset: 0x00021308
|
|
[ExcludeFromDocs]
|
|
public static int CapsuleCastNonAlloc(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, RaycastHit2D[] results, float distance, int layerMask)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
return Physics2D.CapsuleCastNonAlloc(origin, size, capsuleDirection, angle, direction, results, distance, layerMask, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C97 RID: 7319 RVA: 0x0002313C File Offset: 0x0002133C
|
|
[ExcludeFromDocs]
|
|
public static int CapsuleCastNonAlloc(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, RaycastHit2D[] results, float distance)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
int num = -5;
|
|
return Physics2D.CapsuleCastNonAlloc(origin, size, capsuleDirection, angle, direction, results, distance, num, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C98 RID: 7320 RVA: 0x00023174 File Offset: 0x00021374
|
|
[ExcludeFromDocs]
|
|
public static int CapsuleCastNonAlloc(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, RaycastHit2D[] results)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
int num = -5;
|
|
float positiveInfinity2 = float.PositiveInfinity;
|
|
return Physics2D.CapsuleCastNonAlloc(origin, size, capsuleDirection, angle, direction, results, positiveInfinity2, num, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C99 RID: 7321 RVA: 0x000231B4 File Offset: 0x000213B4
|
|
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)
|
|
{
|
|
ContactFilter2D contactFilter2D = ContactFilter2D.CreateLegacyFilter(layerMask, minDepth, maxDepth);
|
|
return Physics2D.Internal_CapsuleCastNonAlloc(origin, size, capsuleDirection, angle, direction, distance, contactFilter2D, results);
|
|
}
|
|
|
|
// Token: 0x06001C9A RID: 7322 RVA: 0x000231E8 File Offset: 0x000213E8
|
|
[ExcludeFromDocs]
|
|
public static int CapsuleCast(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, ContactFilter2D contactFilter, RaycastHit2D[] results)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
return Physics2D.CapsuleCast(origin, size, capsuleDirection, angle, direction, contactFilter, results, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001C9B RID: 7323 RVA: 0x00023214 File Offset: 0x00021414
|
|
public static int CapsuleCast(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, ContactFilter2D contactFilter, RaycastHit2D[] results, [DefaultValue("Mathf.Infinity")] float distance)
|
|
{
|
|
return Physics2D.Internal_CapsuleCastNonAlloc(origin, size, capsuleDirection, angle, direction, distance, contactFilter, results);
|
|
}
|
|
|
|
// Token: 0x06001C9C RID: 7324 RVA: 0x0002323C File Offset: 0x0002143C
|
|
private static void Internal_CapsuleCast(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, float distance, ContactFilter2D contactFilter, out RaycastHit2D raycastHit)
|
|
{
|
|
Physics2D.INTERNAL_CALL_Internal_CapsuleCast(ref origin, ref size, capsuleDirection, angle, ref direction, distance, ref contactFilter, out raycastHit);
|
|
}
|
|
|
|
// Token: 0x06001C9D RID: 7325
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern void INTERNAL_CALL_Internal_CapsuleCast(ref Vector2 origin, ref Vector2 size, CapsuleDirection2D capsuleDirection, float angle, ref Vector2 direction, float distance, ref ContactFilter2D contactFilter, out RaycastHit2D raycastHit);
|
|
|
|
// Token: 0x06001C9E RID: 7326 RVA: 0x00023254 File Offset: 0x00021454
|
|
private static RaycastHit2D[] Internal_CapsuleCastAll(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, float distance, ContactFilter2D contactFilter)
|
|
{
|
|
return Physics2D.INTERNAL_CALL_Internal_CapsuleCastAll(ref origin, ref size, capsuleDirection, angle, ref direction, distance, ref contactFilter);
|
|
}
|
|
|
|
// Token: 0x06001C9F RID: 7327
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern RaycastHit2D[] INTERNAL_CALL_Internal_CapsuleCastAll(ref Vector2 origin, ref Vector2 size, CapsuleDirection2D capsuleDirection, float angle, ref Vector2 direction, float distance, ref ContactFilter2D contactFilter);
|
|
|
|
// Token: 0x06001CA0 RID: 7328 RVA: 0x0002327C File Offset: 0x0002147C
|
|
private static int Internal_CapsuleCastNonAlloc(Vector2 origin, Vector2 size, CapsuleDirection2D capsuleDirection, float angle, Vector2 direction, float distance, ContactFilter2D contactFilter, RaycastHit2D[] results)
|
|
{
|
|
return Physics2D.INTERNAL_CALL_Internal_CapsuleCastNonAlloc(ref origin, ref size, capsuleDirection, angle, ref direction, distance, ref contactFilter, results);
|
|
}
|
|
|
|
// Token: 0x06001CA1 RID: 7329
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern int INTERNAL_CALL_Internal_CapsuleCastNonAlloc(ref Vector2 origin, ref Vector2 size, CapsuleDirection2D capsuleDirection, float angle, ref Vector2 direction, float distance, ref ContactFilter2D contactFilter, RaycastHit2D[] results);
|
|
|
|
// Token: 0x06001CA2 RID: 7330 RVA: 0x000232A4 File Offset: 0x000214A4
|
|
private static void Internal_GetRayIntersection(Ray ray, float distance, int layerMask, out RaycastHit2D raycastHit)
|
|
{
|
|
Physics2D.INTERNAL_CALL_Internal_GetRayIntersection(ref ray, distance, layerMask, out raycastHit);
|
|
}
|
|
|
|
// Token: 0x06001CA3 RID: 7331
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern void INTERNAL_CALL_Internal_GetRayIntersection(ref Ray ray, float distance, int layerMask, out RaycastHit2D raycastHit);
|
|
|
|
// Token: 0x06001CA4 RID: 7332 RVA: 0x000232B4 File Offset: 0x000214B4
|
|
[ExcludeFromDocs]
|
|
public static RaycastHit2D GetRayIntersection(Ray ray, float distance)
|
|
{
|
|
int num = -5;
|
|
return Physics2D.GetRayIntersection(ray, distance, num);
|
|
}
|
|
|
|
// Token: 0x06001CA5 RID: 7333 RVA: 0x000232D4 File Offset: 0x000214D4
|
|
[ExcludeFromDocs]
|
|
public static RaycastHit2D GetRayIntersection(Ray ray)
|
|
{
|
|
int num = -5;
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
return Physics2D.GetRayIntersection(ray, positiveInfinity, num);
|
|
}
|
|
|
|
// Token: 0x06001CA6 RID: 7334 RVA: 0x000232FC File Offset: 0x000214FC
|
|
public static RaycastHit2D GetRayIntersection(Ray ray, [DefaultValue("Mathf.Infinity")] float distance, [DefaultValue("DefaultRaycastLayers")] int layerMask)
|
|
{
|
|
RaycastHit2D raycastHit2D;
|
|
Physics2D.Internal_GetRayIntersection(ray, distance, layerMask, out raycastHit2D);
|
|
return raycastHit2D;
|
|
}
|
|
|
|
// Token: 0x06001CA7 RID: 7335 RVA: 0x0002331C File Offset: 0x0002151C
|
|
[RequiredByNativeCode]
|
|
public static RaycastHit2D[] GetRayIntersectionAll(Ray ray, [DefaultValue("Mathf.Infinity")] float distance, [DefaultValue("DefaultRaycastLayers")] int layerMask)
|
|
{
|
|
return Physics2D.INTERNAL_CALL_GetRayIntersectionAll(ref ray, distance, layerMask);
|
|
}
|
|
|
|
// Token: 0x06001CA8 RID: 7336 RVA: 0x0002333C File Offset: 0x0002153C
|
|
[ExcludeFromDocs]
|
|
public static RaycastHit2D[] GetRayIntersectionAll(Ray ray, float distance)
|
|
{
|
|
int num = -5;
|
|
return Physics2D.INTERNAL_CALL_GetRayIntersectionAll(ref ray, distance, num);
|
|
}
|
|
|
|
// Token: 0x06001CA9 RID: 7337 RVA: 0x00023360 File Offset: 0x00021560
|
|
[ExcludeFromDocs]
|
|
public static RaycastHit2D[] GetRayIntersectionAll(Ray ray)
|
|
{
|
|
int num = -5;
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
return Physics2D.INTERNAL_CALL_GetRayIntersectionAll(ref ray, positiveInfinity, num);
|
|
}
|
|
|
|
// Token: 0x06001CAA RID: 7338
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern RaycastHit2D[] INTERNAL_CALL_GetRayIntersectionAll(ref Ray ray, float distance, int layerMask);
|
|
|
|
// Token: 0x06001CAB RID: 7339 RVA: 0x00023388 File Offset: 0x00021588
|
|
public static int GetRayIntersectionNonAlloc(Ray ray, RaycastHit2D[] results, [DefaultValue("Mathf.Infinity")] float distance, [DefaultValue("DefaultRaycastLayers")] int layerMask)
|
|
{
|
|
return Physics2D.INTERNAL_CALL_GetRayIntersectionNonAlloc(ref ray, results, distance, layerMask);
|
|
}
|
|
|
|
// Token: 0x06001CAC RID: 7340 RVA: 0x000233A8 File Offset: 0x000215A8
|
|
[ExcludeFromDocs]
|
|
public static int GetRayIntersectionNonAlloc(Ray ray, RaycastHit2D[] results, float distance)
|
|
{
|
|
int num = -5;
|
|
return Physics2D.INTERNAL_CALL_GetRayIntersectionNonAlloc(ref ray, results, distance, num);
|
|
}
|
|
|
|
// Token: 0x06001CAD RID: 7341 RVA: 0x000233CC File Offset: 0x000215CC
|
|
[ExcludeFromDocs]
|
|
public static int GetRayIntersectionNonAlloc(Ray ray, RaycastHit2D[] results)
|
|
{
|
|
int num = -5;
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
return Physics2D.INTERNAL_CALL_GetRayIntersectionNonAlloc(ref ray, results, positiveInfinity, num);
|
|
}
|
|
|
|
// Token: 0x06001CAE RID: 7342
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern int INTERNAL_CALL_GetRayIntersectionNonAlloc(ref Ray ray, RaycastHit2D[] results, float distance, int layerMask);
|
|
|
|
// Token: 0x06001CAF RID: 7343 RVA: 0x000233F4 File Offset: 0x000215F4
|
|
[ExcludeFromDocs]
|
|
public static Collider2D OverlapPoint(Vector2 point, int layerMask, float minDepth)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
return Physics2D.OverlapPoint(point, layerMask, minDepth, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001CB0 RID: 7344 RVA: 0x00023418 File Offset: 0x00021618
|
|
[ExcludeFromDocs]
|
|
public static Collider2D OverlapPoint(Vector2 point, int layerMask)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
return Physics2D.OverlapPoint(point, layerMask, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001CB1 RID: 7345 RVA: 0x00023444 File Offset: 0x00021644
|
|
[ExcludeFromDocs]
|
|
public static Collider2D OverlapPoint(Vector2 point)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
int num = -5;
|
|
return Physics2D.OverlapPoint(point, num, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001CB2 RID: 7346 RVA: 0x00023474 File Offset: 0x00021674
|
|
public static Collider2D OverlapPoint(Vector2 point, [DefaultValue("DefaultRaycastLayers")] int layerMask, [DefaultValue("-Mathf.Infinity")] float minDepth, [DefaultValue("Mathf.Infinity")] float maxDepth)
|
|
{
|
|
ContactFilter2D contactFilter2D = ContactFilter2D.CreateLegacyFilter(layerMask, minDepth, maxDepth);
|
|
return Physics2D.Internal_OverlapPoint(point, contactFilter2D);
|
|
}
|
|
|
|
// Token: 0x06001CB3 RID: 7347 RVA: 0x0002349C File Offset: 0x0002169C
|
|
[ExcludeFromDocs]
|
|
public static Collider2D[] OverlapPointAll(Vector2 point, int layerMask, float minDepth)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
return Physics2D.OverlapPointAll(point, layerMask, minDepth, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001CB4 RID: 7348 RVA: 0x000234C0 File Offset: 0x000216C0
|
|
[ExcludeFromDocs]
|
|
public static Collider2D[] OverlapPointAll(Vector2 point, int layerMask)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
return Physics2D.OverlapPointAll(point, layerMask, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001CB5 RID: 7349 RVA: 0x000234EC File Offset: 0x000216EC
|
|
[ExcludeFromDocs]
|
|
public static Collider2D[] OverlapPointAll(Vector2 point)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
int num = -5;
|
|
return Physics2D.OverlapPointAll(point, num, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001CB6 RID: 7350 RVA: 0x0002351C File Offset: 0x0002171C
|
|
public static Collider2D[] OverlapPointAll(Vector2 point, [DefaultValue("DefaultRaycastLayers")] int layerMask, [DefaultValue("-Mathf.Infinity")] float minDepth, [DefaultValue("Mathf.Infinity")] float maxDepth)
|
|
{
|
|
ContactFilter2D contactFilter2D = ContactFilter2D.CreateLegacyFilter(layerMask, minDepth, maxDepth);
|
|
return Physics2D.Internal_OverlapPointAll(point, contactFilter2D);
|
|
}
|
|
|
|
// Token: 0x06001CB7 RID: 7351 RVA: 0x00023544 File Offset: 0x00021744
|
|
[ExcludeFromDocs]
|
|
public static int OverlapPointNonAlloc(Vector2 point, Collider2D[] results, int layerMask, float minDepth)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
return Physics2D.OverlapPointNonAlloc(point, results, layerMask, minDepth, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001CB8 RID: 7352 RVA: 0x0002356C File Offset: 0x0002176C
|
|
[ExcludeFromDocs]
|
|
public static int OverlapPointNonAlloc(Vector2 point, Collider2D[] results, int layerMask)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
return Physics2D.OverlapPointNonAlloc(point, results, layerMask, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001CB9 RID: 7353 RVA: 0x00023598 File Offset: 0x00021798
|
|
[ExcludeFromDocs]
|
|
public static int OverlapPointNonAlloc(Vector2 point, Collider2D[] results)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
int num = -5;
|
|
return Physics2D.OverlapPointNonAlloc(point, results, num, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001CBA RID: 7354 RVA: 0x000235C8 File Offset: 0x000217C8
|
|
public static int OverlapPointNonAlloc(Vector2 point, Collider2D[] results, [DefaultValue("DefaultRaycastLayers")] int layerMask, [DefaultValue("-Mathf.Infinity")] float minDepth, [DefaultValue("Mathf.Infinity")] float maxDepth)
|
|
{
|
|
ContactFilter2D contactFilter2D = ContactFilter2D.CreateLegacyFilter(layerMask, minDepth, maxDepth);
|
|
return Physics2D.Internal_OverlapPointNonAlloc(point, contactFilter2D, results);
|
|
}
|
|
|
|
// Token: 0x06001CBB RID: 7355 RVA: 0x000235F0 File Offset: 0x000217F0
|
|
public static int OverlapPoint(Vector2 point, ContactFilter2D contactFilter, Collider2D[] results)
|
|
{
|
|
return Physics2D.Internal_OverlapPointNonAlloc(point, contactFilter, results);
|
|
}
|
|
|
|
// Token: 0x06001CBC RID: 7356 RVA: 0x00023610 File Offset: 0x00021810
|
|
private static Collider2D Internal_OverlapPoint(Vector2 point, ContactFilter2D contactFilter)
|
|
{
|
|
return Physics2D.INTERNAL_CALL_Internal_OverlapPoint(ref point, ref contactFilter);
|
|
}
|
|
|
|
// Token: 0x06001CBD RID: 7357
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern Collider2D INTERNAL_CALL_Internal_OverlapPoint(ref Vector2 point, ref ContactFilter2D contactFilter);
|
|
|
|
// Token: 0x06001CBE RID: 7358 RVA: 0x00023630 File Offset: 0x00021830
|
|
private static Collider2D[] Internal_OverlapPointAll(Vector2 point, ContactFilter2D contactFilter)
|
|
{
|
|
return Physics2D.INTERNAL_CALL_Internal_OverlapPointAll(ref point, ref contactFilter);
|
|
}
|
|
|
|
// Token: 0x06001CBF RID: 7359
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern Collider2D[] INTERNAL_CALL_Internal_OverlapPointAll(ref Vector2 point, ref ContactFilter2D contactFilter);
|
|
|
|
// Token: 0x06001CC0 RID: 7360 RVA: 0x00023650 File Offset: 0x00021850
|
|
private static int Internal_OverlapPointNonAlloc(Vector2 point, ContactFilter2D contactFilter, Collider2D[] results)
|
|
{
|
|
return Physics2D.INTERNAL_CALL_Internal_OverlapPointNonAlloc(ref point, ref contactFilter, results);
|
|
}
|
|
|
|
// Token: 0x06001CC1 RID: 7361
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern int INTERNAL_CALL_Internal_OverlapPointNonAlloc(ref Vector2 point, ref ContactFilter2D contactFilter, Collider2D[] results);
|
|
|
|
// Token: 0x06001CC2 RID: 7362 RVA: 0x00023670 File Offset: 0x00021870
|
|
[ExcludeFromDocs]
|
|
public static Collider2D OverlapCircle(Vector2 point, float radius, int layerMask, float minDepth)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
return Physics2D.OverlapCircle(point, radius, layerMask, minDepth, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001CC3 RID: 7363 RVA: 0x00023698 File Offset: 0x00021898
|
|
[ExcludeFromDocs]
|
|
public static Collider2D OverlapCircle(Vector2 point, float radius, int layerMask)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
return Physics2D.OverlapCircle(point, radius, layerMask, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001CC4 RID: 7364 RVA: 0x000236C4 File Offset: 0x000218C4
|
|
[ExcludeFromDocs]
|
|
public static Collider2D OverlapCircle(Vector2 point, float radius)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
int num = -5;
|
|
return Physics2D.OverlapCircle(point, radius, num, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001CC5 RID: 7365 RVA: 0x000236F4 File Offset: 0x000218F4
|
|
public static Collider2D OverlapCircle(Vector2 point, float radius, [DefaultValue("DefaultRaycastLayers")] int layerMask, [DefaultValue("-Mathf.Infinity")] float minDepth, [DefaultValue("Mathf.Infinity")] float maxDepth)
|
|
{
|
|
ContactFilter2D contactFilter2D = ContactFilter2D.CreateLegacyFilter(layerMask, minDepth, maxDepth);
|
|
return Physics2D.Internal_OverlapCircle(point, radius, contactFilter2D);
|
|
}
|
|
|
|
// Token: 0x06001CC6 RID: 7366 RVA: 0x0002371C File Offset: 0x0002191C
|
|
[ExcludeFromDocs]
|
|
public static Collider2D[] OverlapCircleAll(Vector2 point, float radius, int layerMask, float minDepth)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
return Physics2D.OverlapCircleAll(point, radius, layerMask, minDepth, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001CC7 RID: 7367 RVA: 0x00023744 File Offset: 0x00021944
|
|
[ExcludeFromDocs]
|
|
public static Collider2D[] OverlapCircleAll(Vector2 point, float radius, int layerMask)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
return Physics2D.OverlapCircleAll(point, radius, layerMask, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001CC8 RID: 7368 RVA: 0x00023770 File Offset: 0x00021970
|
|
[ExcludeFromDocs]
|
|
public static Collider2D[] OverlapCircleAll(Vector2 point, float radius)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
int num = -5;
|
|
return Physics2D.OverlapCircleAll(point, radius, num, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001CC9 RID: 7369 RVA: 0x000237A0 File Offset: 0x000219A0
|
|
public static Collider2D[] OverlapCircleAll(Vector2 point, float radius, [DefaultValue("DefaultRaycastLayers")] int layerMask, [DefaultValue("-Mathf.Infinity")] float minDepth, [DefaultValue("Mathf.Infinity")] float maxDepth)
|
|
{
|
|
ContactFilter2D contactFilter2D = ContactFilter2D.CreateLegacyFilter(layerMask, minDepth, maxDepth);
|
|
return Physics2D.Internal_OverlapCircleAll(point, radius, contactFilter2D);
|
|
}
|
|
|
|
// Token: 0x06001CCA RID: 7370 RVA: 0x000237C8 File Offset: 0x000219C8
|
|
[ExcludeFromDocs]
|
|
public static int OverlapCircleNonAlloc(Vector2 point, float radius, Collider2D[] results, int layerMask, float minDepth)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
return Physics2D.OverlapCircleNonAlloc(point, radius, results, layerMask, minDepth, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001CCB RID: 7371 RVA: 0x000237F0 File Offset: 0x000219F0
|
|
[ExcludeFromDocs]
|
|
public static int OverlapCircleNonAlloc(Vector2 point, float radius, Collider2D[] results, int layerMask)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
return Physics2D.OverlapCircleNonAlloc(point, radius, results, layerMask, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001CCC RID: 7372 RVA: 0x0002381C File Offset: 0x00021A1C
|
|
[ExcludeFromDocs]
|
|
public static int OverlapCircleNonAlloc(Vector2 point, float radius, Collider2D[] results)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
int num = -5;
|
|
return Physics2D.OverlapCircleNonAlloc(point, radius, results, num, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001CCD RID: 7373 RVA: 0x0002384C File Offset: 0x00021A4C
|
|
public static int OverlapCircleNonAlloc(Vector2 point, float radius, Collider2D[] results, [DefaultValue("DefaultRaycastLayers")] int layerMask, [DefaultValue("-Mathf.Infinity")] float minDepth, [DefaultValue("Mathf.Infinity")] float maxDepth)
|
|
{
|
|
ContactFilter2D contactFilter2D = ContactFilter2D.CreateLegacyFilter(layerMask, minDepth, maxDepth);
|
|
return Physics2D.Internal_OverlapCircleNonAlloc(point, radius, contactFilter2D, results);
|
|
}
|
|
|
|
// Token: 0x06001CCE RID: 7374 RVA: 0x00023878 File Offset: 0x00021A78
|
|
public static int OverlapCircle(Vector2 point, float radius, ContactFilter2D contactFilter, Collider2D[] results)
|
|
{
|
|
return Physics2D.Internal_OverlapCircleNonAlloc(point, radius, contactFilter, results);
|
|
}
|
|
|
|
// Token: 0x06001CCF RID: 7375 RVA: 0x00023898 File Offset: 0x00021A98
|
|
private static Collider2D Internal_OverlapCircle(Vector2 point, float radius, ContactFilter2D contactFilter)
|
|
{
|
|
return Physics2D.INTERNAL_CALL_Internal_OverlapCircle(ref point, radius, ref contactFilter);
|
|
}
|
|
|
|
// Token: 0x06001CD0 RID: 7376
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern Collider2D INTERNAL_CALL_Internal_OverlapCircle(ref Vector2 point, float radius, ref ContactFilter2D contactFilter);
|
|
|
|
// Token: 0x06001CD1 RID: 7377 RVA: 0x000238B8 File Offset: 0x00021AB8
|
|
private static Collider2D[] Internal_OverlapCircleAll(Vector2 point, float radius, ContactFilter2D contactFilter)
|
|
{
|
|
return Physics2D.INTERNAL_CALL_Internal_OverlapCircleAll(ref point, radius, ref contactFilter);
|
|
}
|
|
|
|
// Token: 0x06001CD2 RID: 7378
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern Collider2D[] INTERNAL_CALL_Internal_OverlapCircleAll(ref Vector2 point, float radius, ref ContactFilter2D contactFilter);
|
|
|
|
// Token: 0x06001CD3 RID: 7379 RVA: 0x000238D8 File Offset: 0x00021AD8
|
|
private static int Internal_OverlapCircleNonAlloc(Vector2 point, float radius, ContactFilter2D contactFilter, Collider2D[] results)
|
|
{
|
|
return Physics2D.INTERNAL_CALL_Internal_OverlapCircleNonAlloc(ref point, radius, ref contactFilter, results);
|
|
}
|
|
|
|
// Token: 0x06001CD4 RID: 7380
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern int INTERNAL_CALL_Internal_OverlapCircleNonAlloc(ref Vector2 point, float radius, ref ContactFilter2D contactFilter, Collider2D[] results);
|
|
|
|
// Token: 0x06001CD5 RID: 7381 RVA: 0x000238F8 File Offset: 0x00021AF8
|
|
[ExcludeFromDocs]
|
|
public static Collider2D OverlapBox(Vector2 point, Vector2 size, float angle, int layerMask, float minDepth)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
return Physics2D.OverlapBox(point, size, angle, layerMask, minDepth, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001CD6 RID: 7382 RVA: 0x00023920 File Offset: 0x00021B20
|
|
[ExcludeFromDocs]
|
|
public static Collider2D OverlapBox(Vector2 point, Vector2 size, float angle, int layerMask)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
return Physics2D.OverlapBox(point, size, angle, layerMask, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001CD7 RID: 7383 RVA: 0x0002394C File Offset: 0x00021B4C
|
|
[ExcludeFromDocs]
|
|
public static Collider2D OverlapBox(Vector2 point, Vector2 size, float angle)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
int num = -5;
|
|
return Physics2D.OverlapBox(point, size, angle, num, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001CD8 RID: 7384 RVA: 0x0002397C File Offset: 0x00021B7C
|
|
public static Collider2D OverlapBox(Vector2 point, Vector2 size, float angle, [DefaultValue("DefaultRaycastLayers")] int layerMask, [DefaultValue("-Mathf.Infinity")] float minDepth, [DefaultValue("Mathf.Infinity")] float maxDepth)
|
|
{
|
|
ContactFilter2D contactFilter2D = ContactFilter2D.CreateLegacyFilter(layerMask, minDepth, maxDepth);
|
|
return Physics2D.Internal_OverlapBox(point, size, angle, contactFilter2D);
|
|
}
|
|
|
|
// Token: 0x06001CD9 RID: 7385 RVA: 0x000239A8 File Offset: 0x00021BA8
|
|
[ExcludeFromDocs]
|
|
public static Collider2D[] OverlapBoxAll(Vector2 point, Vector2 size, float angle, int layerMask, float minDepth)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
return Physics2D.OverlapBoxAll(point, size, angle, layerMask, minDepth, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001CDA RID: 7386 RVA: 0x000239D0 File Offset: 0x00021BD0
|
|
[ExcludeFromDocs]
|
|
public static Collider2D[] OverlapBoxAll(Vector2 point, Vector2 size, float angle, int layerMask)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
return Physics2D.OverlapBoxAll(point, size, angle, layerMask, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001CDB RID: 7387 RVA: 0x000239FC File Offset: 0x00021BFC
|
|
[ExcludeFromDocs]
|
|
public static Collider2D[] OverlapBoxAll(Vector2 point, Vector2 size, float angle)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
int num = -5;
|
|
return Physics2D.OverlapBoxAll(point, size, angle, num, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001CDC RID: 7388 RVA: 0x00023A2C File Offset: 0x00021C2C
|
|
public static Collider2D[] OverlapBoxAll(Vector2 point, Vector2 size, float angle, [DefaultValue("DefaultRaycastLayers")] int layerMask, [DefaultValue("-Mathf.Infinity")] float minDepth, [DefaultValue("Mathf.Infinity")] float maxDepth)
|
|
{
|
|
ContactFilter2D contactFilter2D = ContactFilter2D.CreateLegacyFilter(layerMask, minDepth, maxDepth);
|
|
return Physics2D.Internal_OverlapBoxAll(point, size, angle, contactFilter2D);
|
|
}
|
|
|
|
// Token: 0x06001CDD RID: 7389 RVA: 0x00023A58 File Offset: 0x00021C58
|
|
[ExcludeFromDocs]
|
|
public static int OverlapBoxNonAlloc(Vector2 point, Vector2 size, float angle, Collider2D[] results, int layerMask, float minDepth)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
return Physics2D.OverlapBoxNonAlloc(point, size, angle, results, layerMask, minDepth, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001CDE RID: 7390 RVA: 0x00023A84 File Offset: 0x00021C84
|
|
[ExcludeFromDocs]
|
|
public static int OverlapBoxNonAlloc(Vector2 point, Vector2 size, float angle, Collider2D[] results, int layerMask)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
return Physics2D.OverlapBoxNonAlloc(point, size, angle, results, layerMask, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001CDF RID: 7391 RVA: 0x00023AB4 File Offset: 0x00021CB4
|
|
[ExcludeFromDocs]
|
|
public static int OverlapBoxNonAlloc(Vector2 point, Vector2 size, float angle, Collider2D[] results)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
int num = -5;
|
|
return Physics2D.OverlapBoxNonAlloc(point, size, angle, results, num, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001CE0 RID: 7392 RVA: 0x00023AE4 File Offset: 0x00021CE4
|
|
public static int OverlapBoxNonAlloc(Vector2 point, Vector2 size, float angle, Collider2D[] results, [DefaultValue("DefaultRaycastLayers")] int layerMask, [DefaultValue("-Mathf.Infinity")] float minDepth, [DefaultValue("Mathf.Infinity")] float maxDepth)
|
|
{
|
|
ContactFilter2D contactFilter2D = ContactFilter2D.CreateLegacyFilter(layerMask, minDepth, maxDepth);
|
|
return Physics2D.Internal_OverlapBoxNonAlloc(point, size, angle, contactFilter2D, results);
|
|
}
|
|
|
|
// Token: 0x06001CE1 RID: 7393 RVA: 0x00023B10 File Offset: 0x00021D10
|
|
public static int OverlapBox(Vector2 point, Vector2 size, float angle, ContactFilter2D contactFilter, Collider2D[] results)
|
|
{
|
|
return Physics2D.Internal_OverlapBoxNonAlloc(point, size, angle, contactFilter, results);
|
|
}
|
|
|
|
// Token: 0x06001CE2 RID: 7394 RVA: 0x00023B30 File Offset: 0x00021D30
|
|
private static Collider2D Internal_OverlapBox(Vector2 point, Vector2 size, float angle, ContactFilter2D contactFilter)
|
|
{
|
|
return Physics2D.INTERNAL_CALL_Internal_OverlapBox(ref point, ref size, angle, ref contactFilter);
|
|
}
|
|
|
|
// Token: 0x06001CE3 RID: 7395
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern Collider2D INTERNAL_CALL_Internal_OverlapBox(ref Vector2 point, ref Vector2 size, float angle, ref ContactFilter2D contactFilter);
|
|
|
|
// Token: 0x06001CE4 RID: 7396 RVA: 0x00023B54 File Offset: 0x00021D54
|
|
private static Collider2D[] Internal_OverlapBoxAll(Vector2 point, Vector2 size, float angle, ContactFilter2D contactFilter)
|
|
{
|
|
return Physics2D.INTERNAL_CALL_Internal_OverlapBoxAll(ref point, ref size, angle, ref contactFilter);
|
|
}
|
|
|
|
// Token: 0x06001CE5 RID: 7397
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern Collider2D[] INTERNAL_CALL_Internal_OverlapBoxAll(ref Vector2 point, ref Vector2 size, float angle, ref ContactFilter2D contactFilter);
|
|
|
|
// Token: 0x06001CE6 RID: 7398 RVA: 0x00023B78 File Offset: 0x00021D78
|
|
private static int Internal_OverlapBoxNonAlloc(Vector2 point, Vector2 size, float angle, ContactFilter2D contactFilter, Collider2D[] results)
|
|
{
|
|
return Physics2D.INTERNAL_CALL_Internal_OverlapBoxNonAlloc(ref point, ref size, angle, ref contactFilter, results);
|
|
}
|
|
|
|
// Token: 0x06001CE7 RID: 7399
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern int INTERNAL_CALL_Internal_OverlapBoxNonAlloc(ref Vector2 point, ref Vector2 size, float angle, ref ContactFilter2D contactFilter, Collider2D[] results);
|
|
|
|
// Token: 0x06001CE8 RID: 7400 RVA: 0x00023B9C File Offset: 0x00021D9C
|
|
[ExcludeFromDocs]
|
|
public static Collider2D OverlapArea(Vector2 pointA, Vector2 pointB, int layerMask, float minDepth)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
return Physics2D.OverlapArea(pointA, pointB, layerMask, minDepth, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001CE9 RID: 7401 RVA: 0x00023BC4 File Offset: 0x00021DC4
|
|
[ExcludeFromDocs]
|
|
public static Collider2D OverlapArea(Vector2 pointA, Vector2 pointB, int layerMask)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
return Physics2D.OverlapArea(pointA, pointB, layerMask, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001CEA RID: 7402 RVA: 0x00023BF0 File Offset: 0x00021DF0
|
|
[ExcludeFromDocs]
|
|
public static Collider2D OverlapArea(Vector2 pointA, Vector2 pointB)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
int num = -5;
|
|
return Physics2D.OverlapArea(pointA, pointB, num, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001CEB RID: 7403 RVA: 0x00023C20 File Offset: 0x00021E20
|
|
public static Collider2D OverlapArea(Vector2 pointA, Vector2 pointB, [DefaultValue("DefaultRaycastLayers")] int layerMask, [DefaultValue("-Mathf.Infinity")] float minDepth, [DefaultValue("Mathf.Infinity")] float maxDepth)
|
|
{
|
|
ContactFilter2D contactFilter2D = ContactFilter2D.CreateLegacyFilter(layerMask, minDepth, maxDepth);
|
|
return Physics2D.Internal_OverlapArea(pointA, pointB, contactFilter2D);
|
|
}
|
|
|
|
// Token: 0x06001CEC RID: 7404 RVA: 0x00023C48 File Offset: 0x00021E48
|
|
[ExcludeFromDocs]
|
|
public static Collider2D[] OverlapAreaAll(Vector2 pointA, Vector2 pointB, int layerMask, float minDepth)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
return Physics2D.OverlapAreaAll(pointA, pointB, layerMask, minDepth, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001CED RID: 7405 RVA: 0x00023C70 File Offset: 0x00021E70
|
|
[ExcludeFromDocs]
|
|
public static Collider2D[] OverlapAreaAll(Vector2 pointA, Vector2 pointB, int layerMask)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
return Physics2D.OverlapAreaAll(pointA, pointB, layerMask, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001CEE RID: 7406 RVA: 0x00023C9C File Offset: 0x00021E9C
|
|
[ExcludeFromDocs]
|
|
public static Collider2D[] OverlapAreaAll(Vector2 pointA, Vector2 pointB)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
int num = -5;
|
|
return Physics2D.OverlapAreaAll(pointA, pointB, num, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001CEF RID: 7407 RVA: 0x00023CCC File Offset: 0x00021ECC
|
|
public static Collider2D[] OverlapAreaAll(Vector2 pointA, Vector2 pointB, [DefaultValue("DefaultRaycastLayers")] int layerMask, [DefaultValue("-Mathf.Infinity")] float minDepth, [DefaultValue("Mathf.Infinity")] float maxDepth)
|
|
{
|
|
ContactFilter2D contactFilter2D = ContactFilter2D.CreateLegacyFilter(layerMask, minDepth, maxDepth);
|
|
return Physics2D.Internal_OverlapAreaAll(pointA, pointB, contactFilter2D);
|
|
}
|
|
|
|
// Token: 0x06001CF0 RID: 7408 RVA: 0x00023CF4 File Offset: 0x00021EF4
|
|
[ExcludeFromDocs]
|
|
public static int OverlapAreaNonAlloc(Vector2 pointA, Vector2 pointB, Collider2D[] results, int layerMask, float minDepth)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
return Physics2D.OverlapAreaNonAlloc(pointA, pointB, results, layerMask, minDepth, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001CF1 RID: 7409 RVA: 0x00023D1C File Offset: 0x00021F1C
|
|
[ExcludeFromDocs]
|
|
public static int OverlapAreaNonAlloc(Vector2 pointA, Vector2 pointB, Collider2D[] results, int layerMask)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
return Physics2D.OverlapAreaNonAlloc(pointA, pointB, results, layerMask, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001CF2 RID: 7410 RVA: 0x00023D48 File Offset: 0x00021F48
|
|
[ExcludeFromDocs]
|
|
public static int OverlapAreaNonAlloc(Vector2 pointA, Vector2 pointB, Collider2D[] results)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
int num = -5;
|
|
return Physics2D.OverlapAreaNonAlloc(pointA, pointB, results, num, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001CF3 RID: 7411 RVA: 0x00023D78 File Offset: 0x00021F78
|
|
public static int OverlapAreaNonAlloc(Vector2 pointA, Vector2 pointB, Collider2D[] results, [DefaultValue("DefaultRaycastLayers")] int layerMask, [DefaultValue("-Mathf.Infinity")] float minDepth, [DefaultValue("Mathf.Infinity")] float maxDepth)
|
|
{
|
|
ContactFilter2D contactFilter2D = ContactFilter2D.CreateLegacyFilter(layerMask, minDepth, maxDepth);
|
|
return Physics2D.Internal_OverlapAreaNonAlloc(pointA, pointB, contactFilter2D, results);
|
|
}
|
|
|
|
// Token: 0x06001CF4 RID: 7412 RVA: 0x00023DA4 File Offset: 0x00021FA4
|
|
public static int OverlapArea(Vector2 pointA, Vector2 pointB, ContactFilter2D contactFilter, Collider2D[] results)
|
|
{
|
|
return Physics2D.Internal_OverlapAreaNonAlloc(pointA, pointB, contactFilter, results);
|
|
}
|
|
|
|
// Token: 0x06001CF5 RID: 7413 RVA: 0x00023DC4 File Offset: 0x00021FC4
|
|
private static Collider2D Internal_OverlapArea(Vector2 pointA, Vector2 pointB, ContactFilter2D contactFilter)
|
|
{
|
|
return Physics2D.INTERNAL_CALL_Internal_OverlapArea(ref pointA, ref pointB, ref contactFilter);
|
|
}
|
|
|
|
// Token: 0x06001CF6 RID: 7414
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern Collider2D INTERNAL_CALL_Internal_OverlapArea(ref Vector2 pointA, ref Vector2 pointB, ref ContactFilter2D contactFilter);
|
|
|
|
// Token: 0x06001CF7 RID: 7415 RVA: 0x00023DE4 File Offset: 0x00021FE4
|
|
private static Collider2D[] Internal_OverlapAreaAll(Vector2 pointA, Vector2 pointB, ContactFilter2D contactFilter)
|
|
{
|
|
return Physics2D.INTERNAL_CALL_Internal_OverlapAreaAll(ref pointA, ref pointB, ref contactFilter);
|
|
}
|
|
|
|
// Token: 0x06001CF8 RID: 7416
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern Collider2D[] INTERNAL_CALL_Internal_OverlapAreaAll(ref Vector2 pointA, ref Vector2 pointB, ref ContactFilter2D contactFilter);
|
|
|
|
// Token: 0x06001CF9 RID: 7417 RVA: 0x00023E04 File Offset: 0x00022004
|
|
private static int Internal_OverlapAreaNonAlloc(Vector2 pointA, Vector2 pointB, ContactFilter2D contactFilter, Collider2D[] results)
|
|
{
|
|
return Physics2D.INTERNAL_CALL_Internal_OverlapAreaNonAlloc(ref pointA, ref pointB, ref contactFilter, results);
|
|
}
|
|
|
|
// Token: 0x06001CFA RID: 7418
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern int INTERNAL_CALL_Internal_OverlapAreaNonAlloc(ref Vector2 pointA, ref Vector2 pointB, ref ContactFilter2D contactFilter, Collider2D[] results);
|
|
|
|
// Token: 0x06001CFB RID: 7419 RVA: 0x00023E28 File Offset: 0x00022028
|
|
[ExcludeFromDocs]
|
|
public static Collider2D OverlapCapsule(Vector2 point, Vector2 size, CapsuleDirection2D direction, float angle, int layerMask, float minDepth)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
return Physics2D.OverlapCapsule(point, size, direction, angle, layerMask, minDepth, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001CFC RID: 7420 RVA: 0x00023E54 File Offset: 0x00022054
|
|
[ExcludeFromDocs]
|
|
public static Collider2D OverlapCapsule(Vector2 point, Vector2 size, CapsuleDirection2D direction, float angle, int layerMask)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
return Physics2D.OverlapCapsule(point, size, direction, angle, layerMask, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001CFD RID: 7421 RVA: 0x00023E84 File Offset: 0x00022084
|
|
[ExcludeFromDocs]
|
|
public static Collider2D OverlapCapsule(Vector2 point, Vector2 size, CapsuleDirection2D direction, float angle)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
int num = -5;
|
|
return Physics2D.OverlapCapsule(point, size, direction, angle, num, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001CFE RID: 7422 RVA: 0x00023EB4 File Offset: 0x000220B4
|
|
public static Collider2D OverlapCapsule(Vector2 point, Vector2 size, CapsuleDirection2D direction, float angle, [DefaultValue("DefaultRaycastLayers")] int layerMask, [DefaultValue("-Mathf.Infinity")] float minDepth, [DefaultValue("Mathf.Infinity")] float maxDepth)
|
|
{
|
|
ContactFilter2D contactFilter2D = ContactFilter2D.CreateLegacyFilter(layerMask, minDepth, maxDepth);
|
|
return Physics2D.Internal_OverlapCapsule(point, size, direction, angle, contactFilter2D);
|
|
}
|
|
|
|
// Token: 0x06001CFF RID: 7423 RVA: 0x00023EE0 File Offset: 0x000220E0
|
|
[ExcludeFromDocs]
|
|
public static Collider2D[] OverlapCapsuleAll(Vector2 point, Vector2 size, CapsuleDirection2D direction, float angle, int layerMask, float minDepth)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
return Physics2D.OverlapCapsuleAll(point, size, direction, angle, layerMask, minDepth, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001D00 RID: 7424 RVA: 0x00023F0C File Offset: 0x0002210C
|
|
[ExcludeFromDocs]
|
|
public static Collider2D[] OverlapCapsuleAll(Vector2 point, Vector2 size, CapsuleDirection2D direction, float angle, int layerMask)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
return Physics2D.OverlapCapsuleAll(point, size, direction, angle, layerMask, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001D01 RID: 7425 RVA: 0x00023F3C File Offset: 0x0002213C
|
|
[ExcludeFromDocs]
|
|
public static Collider2D[] OverlapCapsuleAll(Vector2 point, Vector2 size, CapsuleDirection2D direction, float angle)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
int num = -5;
|
|
return Physics2D.OverlapCapsuleAll(point, size, direction, angle, num, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001D02 RID: 7426 RVA: 0x00023F6C File Offset: 0x0002216C
|
|
public static Collider2D[] OverlapCapsuleAll(Vector2 point, Vector2 size, CapsuleDirection2D direction, float angle, [DefaultValue("DefaultRaycastLayers")] int layerMask, [DefaultValue("-Mathf.Infinity")] float minDepth, [DefaultValue("Mathf.Infinity")] float maxDepth)
|
|
{
|
|
ContactFilter2D contactFilter2D = ContactFilter2D.CreateLegacyFilter(layerMask, minDepth, maxDepth);
|
|
return Physics2D.Internal_OverlapCapsuleAll(point, size, direction, angle, contactFilter2D);
|
|
}
|
|
|
|
// Token: 0x06001D03 RID: 7427 RVA: 0x00023F98 File Offset: 0x00022198
|
|
[ExcludeFromDocs]
|
|
public static int OverlapCapsuleNonAlloc(Vector2 point, Vector2 size, CapsuleDirection2D direction, float angle, Collider2D[] results, int layerMask, float minDepth)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
return Physics2D.OverlapCapsuleNonAlloc(point, size, direction, angle, results, layerMask, minDepth, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001D04 RID: 7428 RVA: 0x00023FC4 File Offset: 0x000221C4
|
|
[ExcludeFromDocs]
|
|
public static int OverlapCapsuleNonAlloc(Vector2 point, Vector2 size, CapsuleDirection2D direction, float angle, Collider2D[] results, int layerMask)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
return Physics2D.OverlapCapsuleNonAlloc(point, size, direction, angle, results, layerMask, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001D05 RID: 7429 RVA: 0x00023FF4 File Offset: 0x000221F4
|
|
[ExcludeFromDocs]
|
|
public static int OverlapCapsuleNonAlloc(Vector2 point, Vector2 size, CapsuleDirection2D direction, float angle, Collider2D[] results)
|
|
{
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
float negativeInfinity = float.NegativeInfinity;
|
|
int num = -5;
|
|
return Physics2D.OverlapCapsuleNonAlloc(point, size, direction, angle, results, num, negativeInfinity, positiveInfinity);
|
|
}
|
|
|
|
// Token: 0x06001D06 RID: 7430 RVA: 0x00024028 File Offset: 0x00022228
|
|
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)
|
|
{
|
|
ContactFilter2D contactFilter2D = ContactFilter2D.CreateLegacyFilter(layerMask, minDepth, maxDepth);
|
|
return Physics2D.Internal_OverlapCapsuleNonAlloc(point, size, direction, angle, contactFilter2D, results);
|
|
}
|
|
|
|
// Token: 0x06001D07 RID: 7431 RVA: 0x00024058 File Offset: 0x00022258
|
|
public static int OverlapCapsule(Vector2 point, Vector2 size, CapsuleDirection2D direction, float angle, ContactFilter2D contactFilter, Collider2D[] results)
|
|
{
|
|
return Physics2D.Internal_OverlapCapsuleNonAlloc(point, size, direction, angle, contactFilter, results);
|
|
}
|
|
|
|
// Token: 0x06001D08 RID: 7432 RVA: 0x0002407C File Offset: 0x0002227C
|
|
private static Collider2D Internal_OverlapCapsule(Vector2 point, Vector2 size, CapsuleDirection2D direction, float angle, ContactFilter2D contactFilter)
|
|
{
|
|
return Physics2D.INTERNAL_CALL_Internal_OverlapCapsule(ref point, ref size, direction, angle, ref contactFilter);
|
|
}
|
|
|
|
// Token: 0x06001D09 RID: 7433
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern Collider2D INTERNAL_CALL_Internal_OverlapCapsule(ref Vector2 point, ref Vector2 size, CapsuleDirection2D direction, float angle, ref ContactFilter2D contactFilter);
|
|
|
|
// Token: 0x06001D0A RID: 7434 RVA: 0x000240A0 File Offset: 0x000222A0
|
|
private static Collider2D[] Internal_OverlapCapsuleAll(Vector2 point, Vector2 size, CapsuleDirection2D direction, float angle, ContactFilter2D contactFilter)
|
|
{
|
|
return Physics2D.INTERNAL_CALL_Internal_OverlapCapsuleAll(ref point, ref size, direction, angle, ref contactFilter);
|
|
}
|
|
|
|
// Token: 0x06001D0B RID: 7435
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern Collider2D[] INTERNAL_CALL_Internal_OverlapCapsuleAll(ref Vector2 point, ref Vector2 size, CapsuleDirection2D direction, float angle, ref ContactFilter2D contactFilter);
|
|
|
|
// Token: 0x06001D0C RID: 7436 RVA: 0x000240C4 File Offset: 0x000222C4
|
|
private static int Internal_OverlapCapsuleNonAlloc(Vector2 point, Vector2 size, CapsuleDirection2D direction, float angle, ContactFilter2D contactFilter, Collider2D[] results)
|
|
{
|
|
return Physics2D.INTERNAL_CALL_Internal_OverlapCapsuleNonAlloc(ref point, ref size, direction, angle, ref contactFilter, results);
|
|
}
|
|
|
|
// Token: 0x06001D0D RID: 7437
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern int INTERNAL_CALL_Internal_OverlapCapsuleNonAlloc(ref Vector2 point, ref Vector2 size, CapsuleDirection2D direction, float angle, ref ContactFilter2D contactFilter, Collider2D[] results);
|
|
|
|
// Token: 0x06001D0E RID: 7438 RVA: 0x000240E8 File Offset: 0x000222E8
|
|
public static int OverlapCollider(Collider2D collider, ContactFilter2D contactFilter, Collider2D[] results)
|
|
{
|
|
return Physics2D.INTERNAL_CALL_OverlapCollider(collider, ref contactFilter, results);
|
|
}
|
|
|
|
// Token: 0x06001D0F RID: 7439
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern int INTERNAL_CALL_OverlapCollider(Collider2D collider, ref ContactFilter2D contactFilter, Collider2D[] results);
|
|
|
|
// Token: 0x06001D10 RID: 7440
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
internal static extern Rigidbody2D GetRigidbodyFromInstanceID(int instanceID);
|
|
|
|
// Token: 0x06001D11 RID: 7441
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
internal static extern Collider2D GetColliderFromInstanceID(int instanceID);
|
|
|
|
// Token: 0x06001D12 RID: 7442 RVA: 0x00024108 File Offset: 0x00022308
|
|
private static int GetColliderContacts(Collider2D collider, ContactFilter2D contactFilter, ContactPoint2D[] results)
|
|
{
|
|
return Physics2D.INTERNAL_CALL_GetColliderContacts(collider, ref contactFilter, results);
|
|
}
|
|
|
|
// Token: 0x06001D13 RID: 7443
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern int INTERNAL_CALL_GetColliderContacts(Collider2D collider, ref ContactFilter2D contactFilter, ContactPoint2D[] results);
|
|
|
|
// Token: 0x06001D14 RID: 7444 RVA: 0x00024128 File Offset: 0x00022328
|
|
private static int GetRigidbodyContacts(Rigidbody2D rigidbody, ContactFilter2D contactFilter, ContactPoint2D[] results)
|
|
{
|
|
return Physics2D.INTERNAL_CALL_GetRigidbodyContacts(rigidbody, ref contactFilter, results);
|
|
}
|
|
|
|
// Token: 0x06001D15 RID: 7445
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern int INTERNAL_CALL_GetRigidbodyContacts(Rigidbody2D rigidbody, ref ContactFilter2D contactFilter, ContactPoint2D[] results);
|
|
|
|
// Token: 0x06001D16 RID: 7446 RVA: 0x00024148 File Offset: 0x00022348
|
|
private static int GetColliderContactsCollidersOnly(Collider2D collider, ContactFilter2D contactFilter, Collider2D[] results)
|
|
{
|
|
return Physics2D.INTERNAL_CALL_GetColliderContactsCollidersOnly(collider, ref contactFilter, results);
|
|
}
|
|
|
|
// Token: 0x06001D17 RID: 7447
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern int INTERNAL_CALL_GetColliderContactsCollidersOnly(Collider2D collider, ref ContactFilter2D contactFilter, Collider2D[] results);
|
|
|
|
// Token: 0x06001D18 RID: 7448 RVA: 0x00024168 File Offset: 0x00022368
|
|
private static int GetRigidbodyContactsCollidersOnly(Rigidbody2D rigidbody, ContactFilter2D contactFilter, Collider2D[] results)
|
|
{
|
|
return Physics2D.INTERNAL_CALL_GetRigidbodyContactsCollidersOnly(rigidbody, ref contactFilter, results);
|
|
}
|
|
|
|
// Token: 0x06001D19 RID: 7449
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern int INTERNAL_CALL_GetRigidbodyContactsCollidersOnly(Rigidbody2D rigidbody, ref ContactFilter2D contactFilter, Collider2D[] results);
|
|
|
|
// Token: 0x06001D1A RID: 7450 RVA: 0x00024188 File Offset: 0x00022388
|
|
public static int GetContacts(Collider2D collider, ContactPoint2D[] contacts)
|
|
{
|
|
return Physics2D.GetColliderContacts(collider, default(ContactFilter2D).NoFilter(), contacts);
|
|
}
|
|
|
|
// Token: 0x06001D1B RID: 7451 RVA: 0x000241B4 File Offset: 0x000223B4
|
|
public static int GetContacts(Collider2D collider, ContactFilter2D contactFilter, ContactPoint2D[] contacts)
|
|
{
|
|
return Physics2D.GetColliderContacts(collider, contactFilter, contacts);
|
|
}
|
|
|
|
// Token: 0x06001D1C RID: 7452 RVA: 0x000241D4 File Offset: 0x000223D4
|
|
public static int GetContacts(Collider2D collider, Collider2D[] colliders)
|
|
{
|
|
return Physics2D.GetColliderContactsCollidersOnly(collider, default(ContactFilter2D).NoFilter(), colliders);
|
|
}
|
|
|
|
// Token: 0x06001D1D RID: 7453 RVA: 0x00024200 File Offset: 0x00022400
|
|
public static int GetContacts(Collider2D collider, ContactFilter2D contactFilter, Collider2D[] colliders)
|
|
{
|
|
return Physics2D.GetColliderContactsCollidersOnly(collider, contactFilter, colliders);
|
|
}
|
|
|
|
// Token: 0x06001D1E RID: 7454 RVA: 0x00024220 File Offset: 0x00022420
|
|
public static int GetContacts(Rigidbody2D rigidbody, ContactPoint2D[] contacts)
|
|
{
|
|
return Physics2D.GetRigidbodyContacts(rigidbody, default(ContactFilter2D).NoFilter(), contacts);
|
|
}
|
|
|
|
// Token: 0x06001D1F RID: 7455 RVA: 0x0002424C File Offset: 0x0002244C
|
|
public static int GetContacts(Rigidbody2D rigidbody, ContactFilter2D contactFilter, ContactPoint2D[] contacts)
|
|
{
|
|
return Physics2D.GetRigidbodyContacts(rigidbody, contactFilter, contacts);
|
|
}
|
|
|
|
// Token: 0x06001D20 RID: 7456 RVA: 0x0002426C File Offset: 0x0002246C
|
|
public static int GetContacts(Rigidbody2D rigidbody, Collider2D[] colliders)
|
|
{
|
|
return Physics2D.GetRigidbodyContactsCollidersOnly(rigidbody, default(ContactFilter2D).NoFilter(), colliders);
|
|
}
|
|
|
|
// Token: 0x06001D21 RID: 7457 RVA: 0x00024298 File Offset: 0x00022498
|
|
public static int GetContacts(Rigidbody2D rigidbody, ContactFilter2D contactFilter, Collider2D[] colliders)
|
|
{
|
|
return Physics2D.GetRigidbodyContactsCollidersOnly(rigidbody, contactFilter, colliders);
|
|
}
|
|
|
|
// Token: 0x04000417 RID: 1047
|
|
public const int IgnoreRaycastLayer = 4;
|
|
|
|
// Token: 0x04000418 RID: 1048
|
|
public const int DefaultRaycastLayers = -5;
|
|
|
|
// Token: 0x04000419 RID: 1049
|
|
public const int AllLayers = -1;
|
|
|
|
// Token: 0x0400041A RID: 1050
|
|
private static List<Rigidbody2D> m_LastDisabledRigidbody2D = new List<Rigidbody2D>();
|
|
}
|
|
}
|