//------------------------------------Private Functions-------------------------------------
private void CheckForCollision(PSI_Collider col1, PSI_Collider col2)
{
// Sphere on sphere.
if (col1.pColliderType == ColliderType.Sphere && col2.pColliderType == ColliderType.Sphere)
{
if (PSI_Physics.SphereSphereCollisionOccured((PSI_SphereCollider)col1, (PSI_SphereCollider)col2))
{
PSI_Physics.HandleSphereSphereCollision((PSI_SphereCollider)col1, (PSI_SphereCollider)col2);
FindObjectOfType <DebugManager>().CollisionOccured(col1, col2);
}
}
// AABB on AABB.
if (col1.pColliderType == ColliderType.AABB && col2.pColliderType == ColliderType.AABB)
{
if (PSI_Physics.AABBAABBCollisionOccured((PSI_AABBCollider)col1, (PSI_AABBCollider)col2))
{
PSI_Physics.HandleAABBAABBCollision((PSI_AABBCollider)col1, (PSI_AABBCollider)col2);
FindObjectOfType <DebugManager>().CollisionOccured(col1, col2);
}
}
// Sphere on plane.
if ((col1.pColliderType == ColliderType.Sphere && col2.pColliderType == ColliderType.Plane) ||
(col1.pColliderType == ColliderType.Plane && col2.pColliderType == ColliderType.Sphere))
{
PSI_SphereCollider sphere = (PSI_SphereCollider)((col1.pColliderType == ColliderType.Sphere) ? col1 : col2);
PSI_PlaneCollider plane = (PSI_PlaneCollider)((col1.pColliderType == ColliderType.Sphere) ? col2 : col1);
if (PSI_Physics.SpherePlaneCollisionOccured(sphere, plane))
{
PSI_Physics.HandleSpherePlaneCollision(sphere, plane);
FindObjectOfType <DebugManager>().CollisionOccured(col1, col2);
}
}
}
public void RemoveCollider(PSI_Collider collider)
{
if (mColliders.Contains(collider))
{
mColliders.Remove(collider);
}
}
//-------------------------------------Public Functions-------------------------------------
public void AddCollider(PSI_Collider collider)
{
if (!mColliders.Contains(collider))
{
mColliders.Add(collider);
}
}
public void RemoveCollider(PSI_Collider collider)
{
// Removing a collider from the list of colliders in the scene.
if (mColliders.Contains(collider))
{
mColliders.Remove(collider);
}
}
//-------------------------------------Public Functions-------------------------------------
public void AddCollider(PSI_Collider collider)
{
// Adding a new collider to the list of colliders in the scene.
if (!mColliders.Contains(collider))
{
mColliders.Add(collider);
}
}
private static void ApplyFriction(PSI_Collider col, PSI_Collider_Plane planeCol, Vector3 collisionPoint)
{
// Calculating and applying friction to a body moving along a plane.
if (!col.pRigidbody)
{
return;
}
var incline = Vector3.Angle(Vector3.up, planeCol.pNormal);
var normalForce = col.pRigidbody.Mass * 9.81f * Mathf.Cos(incline);
var coeffFriction = col.pRigidbody.CoeffOfFrict;
var friction = coeffFriction * normalForce;
col.pRigidbody.AddFrictionAtPoint(friction * -col.pRigidbody.Velocity.normalized, collisionPoint);
}
public void CollisionOccured(PSI_Collider col1, PSI_Collider col2)
{
PSI_Collider colToAdd = null;
if (col1.gameObject == mSelectedObject)
{
colToAdd = col2;
}
else if (col2.gameObject == mSelectedObject)
{
colToAdd = col1;
}
if (colToAdd != null)
{
mCollisionObjects.Remove(colToAdd);
mCollisionObjects.Add(colToAdd);
}
}
private static void ResolveCollisionOverlaps(PSI_Collider col1, PSI_Collider col2, Vector3 collisionAxis, float overlap)
{
// Calculating the invese masses of the bodies.
var inverseMass1 = col1.pRigidbody ? 1.0f / col1.pRigidbody.Mass : 0f;
var inverseMass2 = col2.pRigidbody ? 1.0f / col2.pRigidbody.Mass : 0f;
if (inverseMass1 + inverseMass2 == 0f)
{
return;
}
// Translating the bodies by an amount proportional to their
// inverse mass so that they are no longer overlapping.
var minTranslationVector = -collisionAxis.normalized * Mathf.Abs(overlap);
col1.transform.Translate(minTranslationVector * (inverseMass1 / (inverseMass1 + inverseMass2)), Space.World);
col2.transform.Translate(-minTranslationVector * (inverseMass2 / (inverseMass1 + inverseMass2)), Space.World);
}
private static void ApplyImpulses(PSI_Collider col1, PSI_Collider col2, Vector3 collisionAxis, Vector3 collisionPoint)
{
// Gathering the necessary physics properties from the bodies.
Vector3[] velocities = new Vector3[] { Vector3.zero, Vector3.zero };
float[] inverseMasses = new float[] { 0f, 0f };
float[] coeffsOfRes = new float[] { 1f, 1f };
PSI_Rigidbody[] rbs = new PSI_Rigidbody[] { col1.pRigidbody, col2.pRigidbody };
for (int j = 0; j < 2; j++)
{
if (rbs[j] != null)
{
velocities[j] = rbs[j].Velocity;
inverseMasses[j] = 1.0f / rbs[j].Mass;
coeffsOfRes[j] = rbs[j].CoeffOfRest;
}
}
// Calculating the impact velocity.
var impactVelocity = velocities[0] - velocities[1];
// Determining the difference between the collision axis and the impact velocity.
var vn = Vector3.Dot(impactVelocity, -collisionAxis.normalized);
if (vn > 0.0f)
{
return;
}
// Calculating the final collision impulse.
var finalCoeffOfRest = coeffsOfRes[0] * coeffsOfRes[1];
var i = (-(1.0f + finalCoeffOfRest) * vn) / (inverseMasses[0] + inverseMasses[1]);
var impulse = -collisionAxis.normalized * i;
// Applying the collision impulse to the bodies.
if (rbs[0] != null)
{
rbs[0].ApplyImpulseAtPoint(impulse, collisionPoint);
}
if (rbs[1] != null)
{
rbs[1].ApplyImpulseAtPoint(impulse, collisionPoint);
}
}
//------------------------------------Private Functions-------------------------------------
private void CheckForCollision(PSI_Collider col1, PSI_Collider col2)
{
bool collisionOccurred = false;
PSI_Collision collision = new PSI_Collision();
collision.col1 = col1;
collision.col2 = col2;
// Sphere on sphere.
if (col1.pType == ColliderType.Sphere && col2.pType == ColliderType.Sphere)
{
collisionOccurred = PSI_PhysicsUtils.SphereSphereCollisionCheck((PSI_Collider_Sphere)col1, (PSI_Collider_Sphere)col2, out collision.point);
}
// Sphere on plane.
if ((col1.pType == ColliderType.Sphere && col2.pType == ColliderType.Plane) ||
(col1.pType == ColliderType.Plane && col2.pType == ColliderType.Sphere))
{
PSI_Collider_Sphere sphere = (PSI_Collider_Sphere)((col1.pType == ColliderType.Sphere) ? col1 : col2);
PSI_Collider_Plane plane = (PSI_Collider_Plane)((col1.pType == ColliderType.Sphere) ? col2 : col1);
if (PSI_PhysicsUtils.SpherePlaneCollisionOccured(sphere, plane, out collision.point))
{
collisionOccurred = true;
}
}
// Sphere on box.
if ((col1.pType == ColliderType.Sphere && col2.pType == ColliderType.Box) ||
(col1.pType == ColliderType.Box && col2.pType == ColliderType.Sphere))
{
PSI_Collider_Sphere sphere = (PSI_Collider_Sphere)((col1.pType == ColliderType.Sphere) ? col1 : col2);
PSI_Collider_Box box = (PSI_Collider_Box)((col1.pType == ColliderType.Sphere) ? col2 : col1);
if (PSI_PhysicsUtils.SphereBoxCollisionOccured(sphere, box, out collision.point))
{
collisionOccurred = true;
}
}
// Box on box.
if ((col1.pType == ColliderType.Box && col2.pType == ColliderType.Box))
{
if (PSI_PhysicsUtils.BoxBoxCollisionOccured((PSI_Collider_Box)col1, (PSI_Collider_Box)col2, out collision.point))
{
collisionOccurred = true;
}
}
// Box on plane.
if ((col1.pType == ColliderType.Box && col2.pType == ColliderType.Plane) ||
(col1.pType == ColliderType.Plane && col2.pType == ColliderType.Box))
{
PSI_Collider_Box box = (PSI_Collider_Box)((col1.pType == ColliderType.Box) ? col1 : col2);
PSI_Collider_Plane plane = (PSI_Collider_Plane)((col1.pType == ColliderType.Box) ? col2 : col1);
if (PSI_PhysicsUtils.BoxPlaneCollisionOccured(box, plane, out collision.point))
{
collisionOccurred = true;
}
}
if (collisionOccurred)
{
mCollisionData.Add(collision);
}
}
