public PhysicsObject(Rigidbody rigidbody, Collider[] colliders, PhysicsLayer layer)
{
Rigidbody = rigidbody;
Colliders = colliders;
PhysicsLayer = layer;
GameObject = rigidbody.gameObject;
}
void OnValidate()
{
if (PhysicsLayer == null)
{
PhysicsLayer = PhysicsLayer.GetLayer(Layer.Object);
}
}
/// <summary>
/// Process the collision between objects and check if it should be ignored
/// </summary>
/// <param name="objectCollider"></param>
/// <param name="collision"></param>
public bool ProcessCollision(Collider objectCollider, Collision collision)
{
PhysicsLayer otherLayer;
if (!_physicsObjects.ContainsKey(collision.transform))
{
otherLayer = PhysicsLayer.GetLayer(Layer.UnityDefault);
}
else
{
otherLayer = _physicsObjects[collision.transform].PhysicsLayer;
}
PhysicsObject physicsObject = null;
if (GetPhysicsObject(objectCollider.gameObject, out physicsObject))
{
if (physicsObject.PhysicsLayer == null)
{
physicsObject.PhysicsLayer = PhysicsLayer.GetLayer(Layer.UnityDefault);
Debug.LogWarning("PhysicsLayer not assigned. UnityDefault layer automatically inserted instead.");
}
if (!physicsObject.PhysicsLayer.CanCollideWith(otherLayer))
{
Physics.IgnoreCollision(objectCollider, collision.collider, true);
return(false);
}
}
return(true);
}
//public void ResetPreferenceSuggestions()
//{
// PhysicsPreferences.ShouldPromptGravitySettings = true;
// PhysicsPreferences.ShouldPromptDefaultSolverIterations = true;
// PhysicsPreferences.ShouldPromptDefaultSolverVelocityIterations = true;
// PhysicsPreferences.ShouldPromptFixedTimestep = true;
//}
IEnumerator RegisterNonPhysicsObjects()
{
var sceneColliders = GameObject.FindObjectsOfType <Collider>();
yield return(null);
List <Collider> physicsobjectColliders = new List <Collider>();
foreach (var pObject in _physicsObjects.Values)
{
physicsobjectColliders.AddRange(pObject.Colliders);
}
sceneColliders = sceneColliders.Except(physicsobjectColliders).Where(coll => coll != null && !coll.isTrigger).ToArray();
var defaultLayer = PhysicsLayer.GetLayer(Layer.UnityDefault);
IgnoreCollidersCollisionOnLayers(sceneColliders, defaultLayer.DisallowedCollisions);
}
// Use this for initialization
void Awake()
{
Rigidbody = gameObject.GetComponent <Rigidbody>();
if (Rigidbody == null)
{
Rigidbody = gameObject.AddComponent <Rigidbody>();
}
Rigidbody.collisionDetectionMode = CollisionDetectionMode.Discrete;
Rigidbody.useGravity = false;
Detector = gameObject.AddComponent <CollisionDetector>();
var layer = PhysicsLayer.GetLayer(Layer.Phalange);
Detector.PhysicsLayers = layer.AllowedCollisions;
PhysicsManager.Instance.Register(GetComponents <Collider>(), GetComponent <Rigidbody>(), layer);
}
/// <summary>
/// Register a physics object to the physics manager.
/// </summary>
/// <param name="colliders">All of the colliders on the given object</param>
/// <param name="rigidbody"></param>
public void Register(Collider[] colliders, Rigidbody rigidbody, PhysicsLayer type)
{
if (rigidbody == null)
{
Debug.LogError("Rigidbody can not be null");
}
if (!_physicsObjects.ContainsKey(rigidbody.transform))
{
PhysicsObject pObject = new PhysicsObject(rigidbody, colliders, type);
_physicsObjects.Add(rigidbody.transform, pObject);
List <Collider> colliderList;
if (_layerColliders.TryGetValue(type, out colliderList))
{
colliderList.AddRange(colliders);
}
}
else
{
HashSet <Collider> newCollection = new HashSet <Collider>(_physicsObjects[rigidbody.transform].Colliders);
foreach (var collider1 in colliders)
{
newCollection.Add(collider1);
}
_physicsObjects[rigidbody.transform].Colliders = newCollection.ToArray();
}
foreach (var collider in colliders)
{
RegisterChild(collider.gameObject, rigidbody.gameObject);
}
foreach (var coll in colliders.Where(c => !c.isTrigger))
{
IgnoreColliderCollisionOnLayers(coll, PhysicsLayer.Layers.Where(layer => !type.AllowedCollisions.Contains(layer)));
}
}
public PhysicsObject[] GetPhysicsObjectsWithLayer(PhysicsLayer physicsLayer)
{
return(_physicsObjects.Values.Where(physicsObject => physicsObject.PhysicsLayer == physicsLayer).ToArray());
}
public IEnumerable <PhysicsObject> GetTriggerObjectsInLayer(PhysicsLayer layer)
{
return(_triggerObjects.Values.Where(pObject => pObject.PhysicsLayer == layer));
}
public IEnumerable <PhysicsObject> GetTriggerObjectsInLayer(Layer layer)
{
return(GetTriggerObjectsInLayer(PhysicsLayer.GetLayer(layer)));
}
public IEnumerable <PhysicsObject> GetCollidingObjectsInLayer(PhysicsLayer layer)
{
return(_collidingObjects.Values.Where(pObject => pObject.PhysicsLayer == layer));
}
public IEnumerable <PhysicsObject> GetCollidingObjectsInLayer(Layer layer)
{
return(GetCollidingObjectsInLayer(PhysicsLayer.GetLayer(layer)));
}
public bool CanCollideWith(PhysicsLayer otherLayer)
{
return(AllowedCollisions.Contains(otherLayer));
}
/// <summary>
/// Happens when the manus hand exits a trigger
/// </summary>
/// <param name="collider"></param>
void OnTriggerExit(Collider collider)
{
PhysicsObject physicsObject = null;
if (!PhysicsManager.Instance.GetPhysicsObject(collider.gameObject, out physicsObject) || physicsObject.PhysicsLayer == PhysicsLayer.GetLayer(Layer.Phalange))
{
return;
}
var interactable = collider.GetComponent <Interactable>();
if (interactable == null)
{
interactable = physicsObject.GameObject.GetComponent <Interactable>();
}
_collidingInteractables.Remove(interactable);
}
