897 lines
24 KiB
C#
897 lines
24 KiB
C#
using UnityEngine;
|
|
|
|
namespace FIMSpace
|
|
{
|
|
public class FImp_ColliderData_Box : FImp_ColliderData_Base
|
|
{
|
|
private Vector3 boxCenter;
|
|
|
|
private Vector3 right;
|
|
|
|
private Vector3 up;
|
|
|
|
private Vector3 forward;
|
|
|
|
private Vector3 rightN;
|
|
|
|
private Vector3 upN;
|
|
|
|
private Vector3 forwardN;
|
|
|
|
private Vector3 scales;
|
|
|
|
public BoxCollider Box { get; private set; }
|
|
|
|
public BoxCollider2D Box2D { get; private set; }
|
|
|
|
public FImp_ColliderData_Box(BoxCollider collider)
|
|
{
|
|
Is2D = false;
|
|
base.Collider = collider;
|
|
base.Transform = collider.transform;
|
|
Box = collider;
|
|
base.ColliderType = EFColliderType.Box;
|
|
RefreshColliderData();
|
|
previousPosition = base.Transform.position + Vector3.forward * Mathf.Epsilon;
|
|
}
|
|
|
|
public FImp_ColliderData_Box(BoxCollider2D collider2D)
|
|
{
|
|
Is2D = true;
|
|
base.Collider2D = collider2D;
|
|
base.Transform = collider2D.transform;
|
|
Box2D = collider2D;
|
|
base.ColliderType = EFColliderType.Box;
|
|
RefreshColliderData();
|
|
previousPosition = base.Transform.position + Vector3.forward * Mathf.Epsilon;
|
|
}
|
|
|
|
public override void RefreshColliderData()
|
|
{
|
|
if (base.IsStatic)
|
|
{
|
|
return;
|
|
}
|
|
if (base.Collider2D == null)
|
|
{
|
|
bool flag = false;
|
|
if (!base.Transform.position.VIsSame(previousPosition))
|
|
{
|
|
flag = true;
|
|
}
|
|
else if (!base.Transform.rotation.QIsSame(previousRotation))
|
|
{
|
|
flag = true;
|
|
}
|
|
if (flag)
|
|
{
|
|
right = Box.transform.TransformVector(Vector3.right / 2f * Box.size.x);
|
|
up = Box.transform.TransformVector(Vector3.up / 2f * Box.size.y);
|
|
forward = Box.transform.TransformVector(Vector3.forward / 2f * Box.size.z);
|
|
rightN = right.normalized;
|
|
upN = up.normalized;
|
|
forwardN = forward.normalized;
|
|
boxCenter = GetBoxCenter(Box);
|
|
scales = Vector3.Scale(Box.size, Box.transform.lossyScale);
|
|
scales.Normalize();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bool flag2 = false;
|
|
if (Vector2.Distance(base.Transform.position, previousPosition) > Mathf.Epsilon)
|
|
{
|
|
flag2 = true;
|
|
}
|
|
else if (!base.Transform.rotation.QIsSame(previousRotation))
|
|
{
|
|
flag2 = true;
|
|
}
|
|
if (flag2)
|
|
{
|
|
right = Box2D.transform.TransformVector(Vector3.right / 2f * Box2D.size.x);
|
|
up = Box2D.transform.TransformVector(Vector3.up / 2f * Box2D.size.y);
|
|
rightN = right.normalized;
|
|
upN = up.normalized;
|
|
boxCenter = GetBoxCenter(Box2D);
|
|
boxCenter.z = 0f;
|
|
Vector3 lossyScale = base.Transform.lossyScale;
|
|
lossyScale.z = 1f;
|
|
scales = Vector3.Scale(Box2D.size, lossyScale);
|
|
scales.Normalize();
|
|
}
|
|
}
|
|
base.RefreshColliderData();
|
|
previousPosition = base.Transform.position;
|
|
previousRotation = base.Transform.rotation;
|
|
}
|
|
|
|
public override bool PushIfInside(ref Vector3 segmentPosition, float segmentRadius, Vector3 segmentOffset)
|
|
{
|
|
int num = 0;
|
|
Vector3 vector = Vector3.zero;
|
|
Vector3 vector2 = segmentPosition + segmentOffset;
|
|
float planeDistance = PlaneDistance(boxCenter + up, upN, vector2);
|
|
if (SphereInsidePlane(planeDistance, segmentRadius))
|
|
{
|
|
num++;
|
|
}
|
|
else if (SphereIntersectsPlane(planeDistance, segmentRadius))
|
|
{
|
|
num++;
|
|
vector = up;
|
|
}
|
|
planeDistance = PlaneDistance(boxCenter - up, -upN, vector2);
|
|
if (SphereInsidePlane(planeDistance, segmentRadius))
|
|
{
|
|
num++;
|
|
}
|
|
else if (SphereIntersectsPlane(planeDistance, segmentRadius))
|
|
{
|
|
num++;
|
|
vector = -up;
|
|
}
|
|
planeDistance = PlaneDistance(boxCenter - right, -rightN, vector2);
|
|
if (SphereInsidePlane(planeDistance, segmentRadius))
|
|
{
|
|
num++;
|
|
}
|
|
else if (SphereIntersectsPlane(planeDistance, segmentRadius))
|
|
{
|
|
num++;
|
|
vector = -right;
|
|
}
|
|
planeDistance = PlaneDistance(boxCenter + right, rightN, vector2);
|
|
if (SphereInsidePlane(planeDistance, segmentRadius))
|
|
{
|
|
num++;
|
|
}
|
|
else if (SphereIntersectsPlane(planeDistance, segmentRadius))
|
|
{
|
|
num++;
|
|
vector = right;
|
|
}
|
|
bool flag = false;
|
|
if (base.Collider2D == null)
|
|
{
|
|
planeDistance = PlaneDistance(boxCenter + forward, forwardN, vector2);
|
|
if (SphereInsidePlane(planeDistance, segmentRadius))
|
|
{
|
|
num++;
|
|
}
|
|
else if (SphereIntersectsPlane(planeDistance, segmentRadius))
|
|
{
|
|
num++;
|
|
vector = forward;
|
|
}
|
|
planeDistance = PlaneDistance(boxCenter - forward, -forwardN, vector2);
|
|
if (SphereInsidePlane(planeDistance, segmentRadius))
|
|
{
|
|
num++;
|
|
}
|
|
else if (SphereIntersectsPlane(planeDistance, segmentRadius))
|
|
{
|
|
num++;
|
|
vector = -forward;
|
|
}
|
|
if (num == 6)
|
|
{
|
|
flag = true;
|
|
}
|
|
}
|
|
else if (num == 4)
|
|
{
|
|
flag = true;
|
|
}
|
|
if (flag)
|
|
{
|
|
bool flag2 = false;
|
|
if (vector.sqrMagnitude == 0f)
|
|
{
|
|
flag2 = true;
|
|
}
|
|
else if (base.Collider2D == null)
|
|
{
|
|
if (IsInsideBoxCollider(Box, vector2))
|
|
{
|
|
flag2 = true;
|
|
}
|
|
}
|
|
else if (IsInsideBoxCollider(Box2D, vector2))
|
|
{
|
|
flag2 = true;
|
|
}
|
|
Vector3 vector3 = GetNearestPoint(vector2) - vector2;
|
|
if (flag2)
|
|
{
|
|
vector3 += vector3.normalized * segmentRadius;
|
|
}
|
|
else
|
|
{
|
|
vector3 -= vector3.normalized * segmentRadius;
|
|
}
|
|
if (flag2)
|
|
{
|
|
segmentPosition += vector3;
|
|
}
|
|
else if (vector3.sqrMagnitude > 0f)
|
|
{
|
|
segmentPosition += vector3;
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static void PushOutFromBoxCollider(BoxCollider box, Collision collision, float segmentColliderRadius, ref Vector3 segmentPosition, bool is2D = false)
|
|
{
|
|
Vector3 vector = box.transform.TransformVector(Vector3.right / 2f * box.size.x + box.center.x * Vector3.right);
|
|
Vector3 vector2 = box.transform.TransformVector(Vector3.up / 2f * box.size.y + box.center.y * Vector3.up);
|
|
Vector3 vector3 = box.transform.TransformVector(Vector3.forward / 2f * box.size.z + box.center.z * Vector3.forward);
|
|
Vector3 vector4 = Vector3.Scale(box.size, box.transform.lossyScale);
|
|
vector4.Normalize();
|
|
PushOutFromBoxCollider(box, collision, segmentColliderRadius, ref segmentPosition, vector, vector2, vector3, vector4, is2D);
|
|
}
|
|
|
|
public static void PushOutFromBoxCollider(BoxCollider box, float segmentColliderRadius, ref Vector3 segmentPosition, bool is2D = false)
|
|
{
|
|
Vector3 vector = box.transform.TransformVector(Vector3.right / 2f * box.size.x + box.center.x * Vector3.right);
|
|
Vector3 vector2 = box.transform.TransformVector(Vector3.up / 2f * box.size.y + box.center.y * Vector3.up);
|
|
Vector3 vector3 = box.transform.TransformVector(Vector3.forward / 2f * box.size.z + box.center.z * Vector3.forward);
|
|
Vector3.Scale(box.size, box.transform.lossyScale).Normalize();
|
|
Vector3 vector4 = GetBoxCenter(box);
|
|
Vector3 normalized = vector2.normalized;
|
|
Vector3 normalized2 = vector.normalized;
|
|
Vector3 normalized3 = vector3.normalized;
|
|
int num = 0;
|
|
Vector3 vector5 = Vector3.zero;
|
|
float planeDistance = PlaneDistance(vector4 + vector2, normalized, segmentPosition);
|
|
if (SphereInsidePlane(planeDistance, segmentColliderRadius))
|
|
{
|
|
num++;
|
|
}
|
|
else if (SphereIntersectsPlane(planeDistance, segmentColliderRadius))
|
|
{
|
|
num++;
|
|
vector5 = vector2;
|
|
}
|
|
planeDistance = PlaneDistance(vector4 - vector2, -normalized, segmentPosition);
|
|
if (SphereInsidePlane(planeDistance, segmentColliderRadius))
|
|
{
|
|
num++;
|
|
}
|
|
else if (SphereIntersectsPlane(planeDistance, segmentColliderRadius))
|
|
{
|
|
num++;
|
|
vector5 = -vector2;
|
|
}
|
|
planeDistance = PlaneDistance(vector4 - vector, -normalized2, segmentPosition);
|
|
if (SphereInsidePlane(planeDistance, segmentColliderRadius))
|
|
{
|
|
num++;
|
|
}
|
|
else if (SphereIntersectsPlane(planeDistance, segmentColliderRadius))
|
|
{
|
|
num++;
|
|
vector5 = -vector;
|
|
}
|
|
planeDistance = PlaneDistance(vector4 + vector, normalized2, segmentPosition);
|
|
if (SphereInsidePlane(planeDistance, segmentColliderRadius))
|
|
{
|
|
num++;
|
|
}
|
|
else if (SphereIntersectsPlane(planeDistance, segmentColliderRadius))
|
|
{
|
|
num++;
|
|
vector5 = vector;
|
|
}
|
|
planeDistance = PlaneDistance(vector4 + vector3, normalized3, segmentPosition);
|
|
if (SphereInsidePlane(planeDistance, segmentColliderRadius))
|
|
{
|
|
num++;
|
|
}
|
|
else if (SphereIntersectsPlane(planeDistance, segmentColliderRadius))
|
|
{
|
|
num++;
|
|
vector5 = vector3;
|
|
}
|
|
planeDistance = PlaneDistance(vector4 - vector3, -normalized3, segmentPosition);
|
|
if (SphereInsidePlane(planeDistance, segmentColliderRadius))
|
|
{
|
|
num++;
|
|
}
|
|
else if (SphereIntersectsPlane(planeDistance, segmentColliderRadius))
|
|
{
|
|
num++;
|
|
vector5 = -vector3;
|
|
}
|
|
if (num == 6)
|
|
{
|
|
bool flag = false;
|
|
if (vector5.sqrMagnitude == 0f)
|
|
{
|
|
flag = true;
|
|
}
|
|
else if (IsInsideBoxCollider(box, segmentPosition))
|
|
{
|
|
flag = true;
|
|
}
|
|
Vector3 vector6 = GetNearestPoint(segmentPosition, vector4, vector, vector2, vector3, is2D) - segmentPosition;
|
|
if (flag)
|
|
{
|
|
vector6 += vector6.normalized * segmentColliderRadius * 1.01f;
|
|
}
|
|
else
|
|
{
|
|
vector6 -= vector6.normalized * segmentColliderRadius * 1.01f;
|
|
}
|
|
if (flag)
|
|
{
|
|
segmentPosition += vector6;
|
|
}
|
|
else if (vector6.sqrMagnitude > 0f)
|
|
{
|
|
segmentPosition += vector6;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void PushOutFromBoxCollider(BoxCollider box, Collision collision, float segmentColliderRadius, ref Vector3 pos, Vector3 right, Vector3 up, Vector3 forward, Vector3 scales, bool is2D = false)
|
|
{
|
|
Vector3 vector = collision.contacts[0].point;
|
|
Vector3 vector2 = pos - vector;
|
|
Vector3 vector3 = GetBoxCenter(box);
|
|
if (vector2.sqrMagnitude == 0f)
|
|
{
|
|
vector2 = pos - vector3;
|
|
}
|
|
float num = 1f;
|
|
if (IsInsideBoxCollider(box, pos))
|
|
{
|
|
float boxAverageScale = GetBoxAverageScale(box);
|
|
Vector3 targetPlaneNormal = GetTargetPlaneNormal(box, pos, right, up, forward, scales);
|
|
Vector3 normalized = targetPlaneNormal.normalized;
|
|
vector = ((!box.Raycast(new Ray(pos - normalized * boxAverageScale * 3f, normalized), out var hitInfo, boxAverageScale * 4f)) ? GetIntersectOnBoxFromInside(box, vector3, pos, targetPlaneNormal) : hitInfo.point);
|
|
vector2 = vector - pos;
|
|
num = 100f;
|
|
}
|
|
Vector3 vector4 = pos - (vector2 / num + vector2.normalized * 1.15f) / 2f * segmentColliderRadius;
|
|
vector4 = vector - vector4;
|
|
float sqrMagnitude = vector4.sqrMagnitude;
|
|
if (sqrMagnitude > 0f && sqrMagnitude < segmentColliderRadius * segmentColliderRadius * num)
|
|
{
|
|
pos += vector4;
|
|
}
|
|
}
|
|
|
|
public static void PushOutFromBoxCollider(BoxCollider2D box2D, float segmentColliderRadius, ref Vector3 segmentPosition)
|
|
{
|
|
Vector2 vector = box2D.transform.TransformVector(Vector3.right / 2f * box2D.size.x + box2D.offset.x * Vector3.right);
|
|
Vector2 vector2 = box2D.transform.TransformVector(Vector3.up / 2f * box2D.size.y + box2D.offset.y * Vector3.up);
|
|
Vector3 lossyScale = box2D.transform.lossyScale;
|
|
lossyScale.z = 1f;
|
|
((Vector2)Vector3.Scale(box2D.size, lossyScale)).Normalize();
|
|
Vector2 vector3 = GetBoxCenter(box2D);
|
|
Vector2 normalized = vector2.normalized;
|
|
Vector2 normalized2 = vector.normalized;
|
|
int num = 0;
|
|
Vector3 vector4 = Vector3.zero;
|
|
float planeDistance = PlaneDistance(vector3 + vector2, normalized, segmentPosition);
|
|
if (SphereInsidePlane(planeDistance, segmentColliderRadius))
|
|
{
|
|
num++;
|
|
}
|
|
else if (SphereIntersectsPlane(planeDistance, segmentColliderRadius))
|
|
{
|
|
num++;
|
|
vector4 = vector2;
|
|
}
|
|
planeDistance = PlaneDistance(vector3 - vector2, -normalized, segmentPosition);
|
|
if (SphereInsidePlane(planeDistance, segmentColliderRadius))
|
|
{
|
|
num++;
|
|
}
|
|
else if (SphereIntersectsPlane(planeDistance, segmentColliderRadius))
|
|
{
|
|
num++;
|
|
vector4 = -vector2;
|
|
}
|
|
planeDistance = PlaneDistance(vector3 - vector, -normalized2, segmentPosition);
|
|
if (SphereInsidePlane(planeDistance, segmentColliderRadius))
|
|
{
|
|
num++;
|
|
}
|
|
else if (SphereIntersectsPlane(planeDistance, segmentColliderRadius))
|
|
{
|
|
num++;
|
|
vector4 = -vector;
|
|
}
|
|
planeDistance = PlaneDistance(vector3 + vector, normalized2, segmentPosition);
|
|
if (SphereInsidePlane(planeDistance, segmentColliderRadius))
|
|
{
|
|
num++;
|
|
}
|
|
else if (SphereIntersectsPlane(planeDistance, segmentColliderRadius))
|
|
{
|
|
num++;
|
|
vector4 = vector;
|
|
}
|
|
if (num == 4)
|
|
{
|
|
bool flag = false;
|
|
if (vector4.sqrMagnitude == 0f)
|
|
{
|
|
flag = true;
|
|
}
|
|
else if (IsInsideBoxCollider(box2D, segmentPosition))
|
|
{
|
|
flag = true;
|
|
}
|
|
Vector3 vector5 = GetNearestPoint2D(segmentPosition, vector3, vector, vector2) - segmentPosition;
|
|
if (flag)
|
|
{
|
|
vector5 += vector5.normalized * segmentColliderRadius * 1.01f;
|
|
}
|
|
else
|
|
{
|
|
vector5 -= vector5.normalized * segmentColliderRadius * 1.01f;
|
|
}
|
|
if (flag)
|
|
{
|
|
segmentPosition += vector5;
|
|
}
|
|
else if (vector5.sqrMagnitude > 0f)
|
|
{
|
|
segmentPosition += vector5;
|
|
}
|
|
}
|
|
}
|
|
|
|
private Vector3 GetNearestPoint(Vector3 point)
|
|
{
|
|
Vector3 vector = point;
|
|
Vector3 one = Vector3.one;
|
|
one.x = PlaneDistance(boxCenter + right, rightN, point);
|
|
one.y = PlaneDistance(boxCenter + up, upN, point);
|
|
if (base.Collider2D == null)
|
|
{
|
|
one.z = PlaneDistance(boxCenter + forward, forwardN, point);
|
|
}
|
|
Vector3 one2 = Vector3.one;
|
|
one2.x = PlaneDistance(boxCenter - right, -rightN, point);
|
|
one2.y = PlaneDistance(boxCenter - up, -upN, point);
|
|
if (base.Collider2D == null)
|
|
{
|
|
one2.z = PlaneDistance(boxCenter - forward, -forwardN, point);
|
|
}
|
|
float num = 1f;
|
|
float num2 = 1f;
|
|
float num3 = 1f;
|
|
float x;
|
|
if (one.x > one2.x)
|
|
{
|
|
x = one.x;
|
|
num = -1f;
|
|
}
|
|
else
|
|
{
|
|
x = one2.x;
|
|
num = 1f;
|
|
}
|
|
float y;
|
|
if (one.y > one2.y)
|
|
{
|
|
y = one.y;
|
|
num2 = -1f;
|
|
}
|
|
else
|
|
{
|
|
y = one2.y;
|
|
num2 = 1f;
|
|
}
|
|
if (base.Collider2D == null)
|
|
{
|
|
float z;
|
|
if (one.z > one2.z)
|
|
{
|
|
z = one.z;
|
|
num3 = -1f;
|
|
}
|
|
else
|
|
{
|
|
z = one2.z;
|
|
num3 = 1f;
|
|
}
|
|
if (x > z)
|
|
{
|
|
if (x > y)
|
|
{
|
|
return ProjectPointOnPlane(right * num, point, x);
|
|
}
|
|
return ProjectPointOnPlane(up * num2, point, y);
|
|
}
|
|
if (z > y)
|
|
{
|
|
return ProjectPointOnPlane(forward * num3, point, z);
|
|
}
|
|
return ProjectPointOnPlane(up * num2, point, y);
|
|
}
|
|
if (x > y)
|
|
{
|
|
return ProjectPointOnPlane(right * num, point, x);
|
|
}
|
|
return ProjectPointOnPlane(up * num2, point, y);
|
|
}
|
|
|
|
private static Vector3 GetNearestPoint(Vector3 point, Vector3 boxCenter, Vector3 right, Vector3 up, Vector3 forward, bool is2D = false)
|
|
{
|
|
Vector3 vector = point;
|
|
Vector3 one = Vector3.one;
|
|
one.x = PlaneDistance(boxCenter + right, right.normalized, point);
|
|
one.y = PlaneDistance(boxCenter + up, up.normalized, point);
|
|
if (!is2D)
|
|
{
|
|
one.z = PlaneDistance(boxCenter + forward, forward.normalized, point);
|
|
}
|
|
Vector3 one2 = Vector3.one;
|
|
one2.x = PlaneDistance(boxCenter - right, -right.normalized, point);
|
|
one2.y = PlaneDistance(boxCenter - up, -up.normalized, point);
|
|
if (!is2D)
|
|
{
|
|
one2.z = PlaneDistance(boxCenter - forward, -forward.normalized, point);
|
|
}
|
|
float num = 1f;
|
|
float num2 = 1f;
|
|
float num3 = 1f;
|
|
float x;
|
|
if (one.x > one2.x)
|
|
{
|
|
x = one.x;
|
|
num = -1f;
|
|
}
|
|
else
|
|
{
|
|
x = one2.x;
|
|
num = 1f;
|
|
}
|
|
float y;
|
|
if (one.y > one2.y)
|
|
{
|
|
y = one.y;
|
|
num2 = -1f;
|
|
}
|
|
else
|
|
{
|
|
y = one2.y;
|
|
num2 = 1f;
|
|
}
|
|
if (!is2D)
|
|
{
|
|
float z;
|
|
if (one.z > one2.z)
|
|
{
|
|
z = one.z;
|
|
num3 = -1f;
|
|
}
|
|
else
|
|
{
|
|
z = one2.z;
|
|
num3 = 1f;
|
|
}
|
|
if (x > z)
|
|
{
|
|
if (x > y)
|
|
{
|
|
return ProjectPointOnPlane(right * num, point, x);
|
|
}
|
|
return ProjectPointOnPlane(up * num2, point, y);
|
|
}
|
|
if (z > y)
|
|
{
|
|
return ProjectPointOnPlane(forward * num3, point, z);
|
|
}
|
|
return ProjectPointOnPlane(up * num2, point, y);
|
|
}
|
|
if (x > y)
|
|
{
|
|
return ProjectPointOnPlane(right * num, point, x);
|
|
}
|
|
return ProjectPointOnPlane(up * num2, point, y);
|
|
}
|
|
|
|
private static Vector3 GetNearestPoint2D(Vector2 point, Vector2 boxCenter, Vector2 right, Vector2 up)
|
|
{
|
|
Vector3 vector = point;
|
|
Vector3 one = Vector3.one;
|
|
one.x = PlaneDistance(boxCenter + right, right.normalized, point);
|
|
one.y = PlaneDistance(boxCenter + up, up.normalized, point);
|
|
Vector3 one2 = Vector3.one;
|
|
one2.x = PlaneDistance(boxCenter - right, -right.normalized, point);
|
|
one2.y = PlaneDistance(boxCenter - up, -up.normalized, point);
|
|
float num = 1f;
|
|
float num2 = 1f;
|
|
float x;
|
|
if (one.x > one2.x)
|
|
{
|
|
x = one.x;
|
|
num = -1f;
|
|
}
|
|
else
|
|
{
|
|
x = one2.x;
|
|
num = 1f;
|
|
}
|
|
float y;
|
|
if (one.y > one2.y)
|
|
{
|
|
y = one.y;
|
|
num2 = -1f;
|
|
}
|
|
else
|
|
{
|
|
y = one2.y;
|
|
num2 = 1f;
|
|
}
|
|
if (x > y)
|
|
{
|
|
return ProjectPointOnPlane(right * num, point, x);
|
|
}
|
|
return ProjectPointOnPlane(up * num2, point, y);
|
|
}
|
|
|
|
public static Vector3 GetNearestPointOnBox(BoxCollider boxCollider, Vector3 point, bool is2D = false)
|
|
{
|
|
Vector3 vector = boxCollider.transform.TransformVector(Vector3.right / 2f);
|
|
Vector3 vector2 = boxCollider.transform.TransformVector(Vector3.up / 2f);
|
|
Vector3 vector3 = Vector3.forward;
|
|
if (!is2D)
|
|
{
|
|
vector3 = boxCollider.transform.TransformVector(Vector3.forward / 2f);
|
|
}
|
|
Vector3 vector4 = point;
|
|
Vector3 vector5 = GetBoxCenter(boxCollider);
|
|
Vector3 normalized = vector.normalized;
|
|
Vector3 normalized2 = vector2.normalized;
|
|
Vector3 normalized3 = vector3.normalized;
|
|
Vector3 one = Vector3.one;
|
|
one.x = PlaneDistance(vector5 + vector, normalized, point);
|
|
one.y = PlaneDistance(vector5 + vector2, normalized2, point);
|
|
if (!is2D)
|
|
{
|
|
one.z = PlaneDistance(vector5 + vector3, normalized3, point);
|
|
}
|
|
Vector3 one2 = Vector3.one;
|
|
one2.x = PlaneDistance(vector5 - vector, -normalized, point);
|
|
one2.y = PlaneDistance(vector5 - vector2, -normalized2, point);
|
|
if (!is2D)
|
|
{
|
|
one2.z = PlaneDistance(vector5 - vector3, -normalized3, point);
|
|
}
|
|
float num = 1f;
|
|
float num2 = 1f;
|
|
float num3 = 1f;
|
|
float x;
|
|
if (one.x > one2.x)
|
|
{
|
|
x = one.x;
|
|
num = -1f;
|
|
}
|
|
else
|
|
{
|
|
x = one2.x;
|
|
num = 1f;
|
|
}
|
|
float y;
|
|
if (one.y > one2.y)
|
|
{
|
|
y = one.y;
|
|
num2 = -1f;
|
|
}
|
|
else
|
|
{
|
|
y = one2.y;
|
|
num2 = 1f;
|
|
}
|
|
if (!is2D)
|
|
{
|
|
float z;
|
|
if (one.z > one2.z)
|
|
{
|
|
z = one.z;
|
|
num3 = -1f;
|
|
}
|
|
else
|
|
{
|
|
z = one2.z;
|
|
num3 = 1f;
|
|
}
|
|
if (x > z)
|
|
{
|
|
if (x > y)
|
|
{
|
|
return ProjectPointOnPlane(vector * num, point, x);
|
|
}
|
|
return ProjectPointOnPlane(vector2 * num2, point, y);
|
|
}
|
|
if (z > y)
|
|
{
|
|
return ProjectPointOnPlane(vector3 * num3, point, z);
|
|
}
|
|
return ProjectPointOnPlane(vector2 * num2, point, y);
|
|
}
|
|
if (x > y)
|
|
{
|
|
return ProjectPointOnPlane(vector * num, point, x);
|
|
}
|
|
return ProjectPointOnPlane(vector2 * num2, point, y);
|
|
}
|
|
|
|
private static float PlaneDistance(Vector3 planeCenter, Vector3 planeNormal, Vector3 point)
|
|
{
|
|
return Vector3.Dot(point - planeCenter, planeNormal);
|
|
}
|
|
|
|
private static Vector3 ProjectPointOnPlane(Vector3 planeNormal, Vector3 point, float distance)
|
|
{
|
|
Vector3 vector = planeNormal.normalized * distance;
|
|
return point + vector;
|
|
}
|
|
|
|
private static bool SphereInsidePlane(float planeDistance, float pointRadius)
|
|
{
|
|
return 0f - planeDistance > pointRadius;
|
|
}
|
|
|
|
private static bool SphereOutsidePlane(float planeDistance, float pointRadius)
|
|
{
|
|
return planeDistance > pointRadius;
|
|
}
|
|
|
|
private static bool SphereIntersectsPlane(float planeDistance, float pointRadius)
|
|
{
|
|
return Mathf.Abs(planeDistance) <= pointRadius;
|
|
}
|
|
|
|
public static bool IsInsideBoxCollider(BoxCollider collider, Vector3 point, bool is2D = false)
|
|
{
|
|
point = collider.transform.InverseTransformPoint(point) - collider.center;
|
|
float num = collider.size.x * 0.5f;
|
|
float num2 = collider.size.y * 0.5f;
|
|
float num3 = collider.size.z * 0.5f;
|
|
if (point.x < num && point.x > 0f - num && point.y < num2 && point.y > 0f - num2 && point.z < num3)
|
|
{
|
|
return point.z > 0f - num3;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static bool IsInsideBoxCollider(BoxCollider2D collider, Vector3 point)
|
|
{
|
|
point = (Vector2)collider.transform.InverseTransformPoint(point) - collider.offset;
|
|
float num = collider.size.x * 0.5f;
|
|
float num2 = collider.size.y * 0.5f;
|
|
if (point.x < num && point.x > 0f - num && point.y < num2)
|
|
{
|
|
return point.y > 0f - num2;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
protected static float GetBoxAverageScale(BoxCollider box)
|
|
{
|
|
Vector3 lossyScale = box.transform.lossyScale;
|
|
lossyScale = Vector3.Scale(lossyScale, box.size);
|
|
return (lossyScale.x + lossyScale.y + lossyScale.z) / 3f;
|
|
}
|
|
|
|
protected static Vector3 GetBoxCenter(BoxCollider box)
|
|
{
|
|
return box.transform.position + box.transform.TransformVector(box.center);
|
|
}
|
|
|
|
protected static Vector3 GetBoxCenter(BoxCollider2D box)
|
|
{
|
|
return box.transform.position + box.transform.TransformVector(box.offset);
|
|
}
|
|
|
|
protected static Vector3 GetTargetPlaneNormal(BoxCollider boxCollider, Vector3 point, bool is2D = false)
|
|
{
|
|
Vector3 vector = boxCollider.transform.TransformVector(Vector3.right / 2f * boxCollider.size.x);
|
|
Vector3 vector2 = boxCollider.transform.TransformVector(Vector3.up / 2f * boxCollider.size.y);
|
|
Vector3 vector3 = Vector3.forward;
|
|
if (!is2D)
|
|
{
|
|
vector3 = boxCollider.transform.TransformVector(Vector3.forward / 2f * boxCollider.size.z);
|
|
}
|
|
Vector3 vector4 = Vector3.Scale(boxCollider.size, boxCollider.transform.lossyScale);
|
|
vector4.Normalize();
|
|
return GetTargetPlaneNormal(boxCollider, point, vector, vector2, vector3, vector4, is2D);
|
|
}
|
|
|
|
protected static Vector3 GetTargetPlaneNormal(BoxCollider boxCollider, Vector3 point, Vector3 right, Vector3 up, Vector3 forward, Vector3 scales, bool is2D = false)
|
|
{
|
|
Vector3 normalized = (GetBoxCenter(boxCollider) - point).normalized;
|
|
Vector3 vector = default(Vector3);
|
|
vector.x = Vector3.Dot(normalized, right.normalized);
|
|
vector.y = Vector3.Dot(normalized, up.normalized);
|
|
vector.x = vector.x * scales.y * scales.z;
|
|
vector.y = vector.y * scales.x * scales.z;
|
|
if (!is2D)
|
|
{
|
|
vector.z = Vector3.Dot(normalized, forward.normalized);
|
|
vector.z = vector.z * scales.y * scales.x;
|
|
}
|
|
else
|
|
{
|
|
vector.z = 0f;
|
|
}
|
|
vector.Normalize();
|
|
Vector3 vector2 = vector;
|
|
if (vector.x < 0f)
|
|
{
|
|
vector2.x = 0f - vector.x;
|
|
}
|
|
if (vector.y < 0f)
|
|
{
|
|
vector2.y = 0f - vector.y;
|
|
}
|
|
if (vector.z < 0f)
|
|
{
|
|
vector2.z = 0f - vector.z;
|
|
}
|
|
if (vector2.x > vector2.y)
|
|
{
|
|
if (vector2.x > vector2.z || is2D)
|
|
{
|
|
return right * Mathf.Sign(vector.x);
|
|
}
|
|
return forward * Mathf.Sign(vector.z);
|
|
}
|
|
if (vector2.y > vector2.z || is2D)
|
|
{
|
|
return up * Mathf.Sign(vector.y);
|
|
}
|
|
return forward * Mathf.Sign(vector.z);
|
|
}
|
|
|
|
protected static Vector3 GetTargetPlaneNormal(BoxCollider2D boxCollider, Vector2 point, Vector2 right, Vector2 up, Vector2 scales)
|
|
{
|
|
Vector2 normalized = ((Vector2)GetBoxCenter(boxCollider) - point).normalized;
|
|
Vector2 vector = default(Vector2);
|
|
vector.x = Vector3.Dot(normalized, right.normalized);
|
|
vector.y = Vector3.Dot(normalized, up.normalized);
|
|
vector.x *= scales.y;
|
|
vector.y *= scales.x;
|
|
vector.Normalize();
|
|
Vector2 vector2 = vector;
|
|
if (vector.x < 0f)
|
|
{
|
|
vector2.x = 0f - vector.x;
|
|
}
|
|
if (vector.y < 0f)
|
|
{
|
|
vector2.y = 0f - vector.y;
|
|
}
|
|
if (vector2.x > vector2.y)
|
|
{
|
|
return right * Mathf.Sign(vector.x);
|
|
}
|
|
return up * Mathf.Sign(vector.y);
|
|
}
|
|
|
|
protected static Vector3 GetIntersectOnBoxFromInside(BoxCollider boxCollider, Vector3 from, Vector3 to, Vector3 planeNormal)
|
|
{
|
|
Vector3 direction = to - from;
|
|
Plane plane = new Plane(-planeNormal, GetBoxCenter(boxCollider) + planeNormal);
|
|
Vector3 result = to;
|
|
float enter = 0f;
|
|
Ray ray = new Ray(from, direction);
|
|
if (plane.Raycast(ray, out enter))
|
|
{
|
|
result = ray.GetPoint(enter);
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
}
|