public int CastAll(Vector3 direction, ICollection <RaycastHit> results, float distance, int layerMask, QueryTriggerInteraction query)
{
if (results == null)
{
throw new System.ArgumentNullException("results");
}
using (var set = TempCollection.GetSet <RaycastHit>())
{
foreach (var c in _colliders)
{
GeomUtil.GetGeom(c).CastAll(direction, set, distance, layerMask, query);
}
if (set.Count > 0)
{
var e = set.GetEnumerator();
while (e.MoveNext())
{
results.Add(e.Current);
}
return(set.Count);
}
}
return(0);
}
public static int OverlapGeomAgainst(IPhysicsGeom geom, ICollection<Collider> results, IEnumerable<Collider> colliders, int layerMask = Physics.AllLayers, QueryTriggerInteraction query = QueryTriggerInteraction.UseGlobal)
{
if (results == null) throw new System.ArgumentNullException("results");
if (geom == null) return 0;
if (colliders == null) return 0;
int cnt = 0;
using (var set = TempCollection.GetSet<Collider>())
{
if (geom.Overlap(set, layerMask, query) > 0)
{
var e = LightEnumerator.Create<Collider>(colliders);
while (e.MoveNext())
{
if (set.Contains(e.Current))
{
cnt++;
results.Add(e.Current);
}
}
}
}
return cnt;
}
public static string[] GetCustomAccessorIds(System.Type tp, System.Predicate <CustomAccessorData> predicate = null)
{
if (tp == null)
{
throw new System.ArgumentNullException("tp");
}
if (_targetToCustomAccessor == null)
{
BuildAccessorDictionary();
}
using (var set = TempCollection.GetSet <string>())
{
var e = _targetToCustomAccessor.GetEnumerator();
while (e.MoveNext())
{
var lst = e.Current.Value;
for (int i = 0; i < lst.Count; i++)
{
if (lst[i].TargetType.IsAssignableFrom(tp) &&
(predicate == null || predicate(lst[i])))
{
set.Add(e.Current.Key);
break;
}
}
}
return(set.ToArray());
}
}
public void FixedUpdate()
{
if (_fixedSequences.Count > 0)
{
using (var set = TempCollection.GetSet <ISequence>())
{
var e2 = _fixedSequences.GetEnumerator();
while (e2.MoveNext())
{
if (e2.Current.Update())
{
set.Add(e2.Current);
}
}
if (set.Count > 0)
{
e2 = set.GetEnumerator();
while (e2.MoveNext())
{
_fixedSequences.Remove(e2.Current);
}
}
}
}
}
public static void Add(T listener)
{
if (_receivers == null)
{
_receivers = new HashSet <T>();
}
switch (_state)
{
case ExecutingState.None:
_receivers.Add(listener);
break;
case ExecutingState.Executing:
if (_toAdd == null)
{
_toAdd = TempCollection.GetSet <T>();
}
_toAdd.Add(listener);
break;
case ExecutingState.CleaningUp:
_receivers.Add(listener);
break;
}
}
public static bool CheckGeomAgainst(IPhysicsGeom geom, IEnumerable <Collider> colliders, int layerMask = Physics.AllLayers, QueryTriggerInteraction query = QueryTriggerInteraction.UseGlobal)
{
if (geom == null)
{
return(false);
}
if (colliders == null)
{
return(false);
}
using (var set = TempCollection.GetSet <Collider>())
{
if (geom.Overlap(set, layerMask, query) > 0)
{
var e = LightEnumerator.Create <Collider>(colliders);
while (e.MoveNext())
{
if (set.Contains(e.Current))
{
return(true);
}
}
}
}
return(false);
}
public int Overlap(ICollection <Collider> results, int layerMask, QueryTriggerInteraction query)
{
if (results == null)
{
throw new System.ArgumentNullException("results");
}
using (var set = TempCollection.GetSet <Collider>())
{
foreach (var c in _colliders)
{
GeomUtil.GetGeom(c).Overlap(set, layerMask, query);
}
if (set.Count > 0)
{
var e = set.GetEnumerator();
while (e.MoveNext())
{
results.Add(e.Current);
}
return(set.Count);
}
}
return(0);
}
void IUpdateable.Update()
{
if (_currentToken == null)
{
GameLoopEntry.UpdatePump.Remove(this);
return;
}
TempHashSet <AudibleSensor> activeSet = null;
if (_activeSensors.Count > 0)
{
activeSet = TempCollection.GetSet(_activeSensors);
}
var pos = this.transform.position;
float d, r;
var e = AudibleSensor.Pool.GetEnumerator();
while (e.MoveNext())
{
var sensor = e.Current;
if (_activeSensors.Contains(sensor) || sensor.Ignores(this))
{
continue;
}
d = (sensor.transform.position - pos).sqrMagnitude;
r = (sensor.Range + _range);
if (d < r * r)
{
_activeSensors.Add(sensor);
sensor.SignalEnterSiren(this);
}
}
if (activeSet != null)
{
var e2 = activeSet.GetEnumerator();
while (e2.MoveNext())
{
var sensor = e.Current;
d = (sensor.transform.position - pos).sqrMagnitude;
r = (sensor.Range + _range);
if (d < r * r)
{
sensor.SignalSirenStay(this);
}
else
{
_activeSensors.Remove(sensor);
sensor.SignalExitSiren(this);
}
}
activeSet.Dispose();
}
}
public static int OverlapGeomIgnoring(IPhysicsGeom geom, ICollection <Collider> results, IEnumerable <Collider> ignoredColliders, int layerMask = Physics.AllLayers, QueryTriggerInteraction query = QueryTriggerInteraction.UseGlobal)
{
if (results == null)
{
throw new System.ArgumentNullException("results");
}
if (geom == null)
{
return(0);
}
int cnt = 0;
using (var set = TempCollection.GetSet <Collider>())
{
if (geom.Overlap(set, layerMask, query) > 0)
{
var e = set.GetEnumerator();
while (e.MoveNext())
{
if (!ignoredColliders.Contains(e.Current))
{
cnt++;
results.Add(e.Current);
}
}
}
}
return(cnt);
}
public static void Remove(T listener)
{
if (_receivers == null || _receivers.Count == 0)
{
return;
}
switch (_state)
{
case ExecutingState.None:
_receivers.Remove(listener);
break;
case ExecutingState.Executing:
if (_toRemove == null)
{
_toRemove = TempCollection.GetSet <T>();
}
_toRemove.Add(listener);
break;
case ExecutingState.CleaningUp:
_receivers.Remove(listener);
break;
}
}
/// <summary>
/// Create a MessageToken to invoke at a later point. If no targets found null is returned.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="includeDisabledComponents"></param>
/// <returns></returns>
public static MessageToken <T> CreateFindAndBroadcastToken <T>(bool includeDisabledComponents = false) where T : class
{
using (var lst = TempCollection.GetSet <T>())
{
ObjUtil.FindObjectsOfInterface <T>(lst);
if (lst.Count == 0)
{
return(null);
}
if (includeDisabledComponents)
{
return(new MessageToken <T>(lst.ToArray()));
}
using (var lst2 = TempCollection.GetList <T>(lst.Count))
{
var e = lst.GetEnumerator();
while (e.MoveNext())
{
if (TargetIsValid(e.Current))
{
lst.Add(e.Current);
}
}
if (lst.Count > 0)
{
return(new MessageToken <T>(lst2.ToArray()));
}
}
}
return(null);
}
private static TempHashSet <System.Type> ReduceLikeTypes(System.Type[] arr)
{
var set = TempCollection.GetSet <System.Type>();
foreach (var tp in arr)
{
if (set.Contains(tp))
{
continue;
}
var e = set.GetEnumerator();
bool donotadd = false;
while (e.MoveNext())
{
if (TypeUtil.IsType(tp, e.Current))
{
donotadd = true;
break;
}
if (TypeUtil.IsType(e.Current, tp))
{
set.Remove(e.Current);
break;
}
}
if (!donotadd)
{
set.Add(tp);
}
}
return(set);
}
/// <summary>
/// Adds targets to a Trigger/SPEvent.
///
/// This method applies changes to the SerializedProperty. Only call if you expect this behaviour.
/// </summary>
/// <param name="triggerProperty"></param>
/// <param name="objs"></param>
public static void AddObjectsToTrigger(SerializedProperty triggerProperty, UnityEngine.Object[] objs)
{
if (triggerProperty == null)
{
throw new System.ArgumentNullException("triggerProperty");
}
if (triggerProperty.serializedObject.isEditingMultipleObjects)
{
throw new System.ArgumentException("Can not use this method for multi-selected SerializedObjects.", "triggerProperty");
}
try
{
triggerProperty.serializedObject.ApplyModifiedProperties();
var trigger = EditorHelper.GetTargetObjectOfProperty(triggerProperty) as BaseSPEvent;
if (trigger == null)
{
return;
}
Undo.RecordObject(triggerProperty.serializedObject.targetObject, "Add Trigger Targets");
using (var set = TempCollection.GetSet <UnityEngine.Object>())
{
for (int i = 0; i < trigger.Targets.Count; i++)
{
set.Add(trigger.Targets[i].Target);
}
foreach (var obj in objs)
{
if (set.Contains(obj))
{
continue;
}
set.Add(obj);
var targ = trigger.AddNew();
if (EventTriggerTarget.IsValidTriggerTarget(obj, TriggerActivationType.TriggerAllOnTarget))
{
targ.ConfigureTriggerAll(obj);
}
else
{
targ.ConfigureCallMethod(obj, "");
}
targ.Weight = 1f;
}
}
triggerProperty.serializedObject.Update();
}
catch (System.Exception ex)
{
Debug.LogException(ex);
}
}
/// <summary>
/// Replace all references to 'old' with 'replacement' as a service.
/// This is usually used when decorating an existing service.
/// </summary>
/// <param name="old">The service to replace</param>
/// <param name="replacement">The service to replace with</param>
/// <param name="keepOldIfCannotReplace">If the service look-up type does not match the replacement type, should 'old' be left in place or removed for that look-up type</param>
private static void ReplaceReferences(IService old, IService replacement)
{
if (old != null)
{
_services.Remove(old);
old.Disposed -= OnServiceInadvertentlyDisposed;
}
if (replacement != null)
{
_services.Add(replacement);
//make sure we don't add it multiple times
replacement.Disposed -= OnServiceInadvertentlyDisposed;
replacement.Disposed += OnServiceInadvertentlyDisposed;
}
//Find all references
using (var cache = TempCollection.GetSet <System.Type>())
{
var e1 = _serviceTable.GetEnumerator();
while (e1.MoveNext())
{
if (object.ReferenceEquals(e1.Current.Value, old))
{
cache.Add(e1.Current.Key);
}
}
//Replace references
var rtp = replacement != null?replacement.GetType() : null;
var e2 = cache.GetEnumerator();
while (e2.MoveNext())
{
bool cannotReplace = (rtp != null && !e2.Current.IsAssignableFrom(rtp));
if (cannotReplace || replacement == null)
{
_serviceTable.Remove(e2.Current);
}
else
{
_serviceTable[e2.Current] = replacement;
}
var field = GetStaticEntryFieldInfo(e2.Current, false);
if (field != null)
{
field.SetValue(null, cannotReplace ? null : replacement);
}
}
}
}
public override bool Trigger(object sender, object arg)
{
if (!this.CanTrigger)
{
return(false);
}
switch (_targetSearchMode)
{
case TargetMode.All:
foreach (var t1 in _targets)
{
foreach (var t2 in t1.GetTargets <UnityEngine.Object>(arg))
{
if (t2 != null)
{
_action.ActivateTrigger(this, t2);
}
}
}
break;
case TargetMode.First:
foreach (var t1 in _targets)
{
var t2 = t1.GetTarget <UnityEngine.Object>(arg);
if (t2 != null)
{
_action.ActivateTrigger(this, t2);
}
}
break;
case TargetMode.FirstUnique:
using (var set = TempCollection.GetSet <UnityEngine.Object>())
{
foreach (var t1 in _targets)
{
foreach (var t2 in t1.GetTargets <UnityEngine.Object>(arg))
{
if (t2 != null && !set.Contains(t2))
{
set.Add(t2);
_action.ActivateTrigger(this, t2);
break;
}
}
}
}
break;
}
return(true);
}
public static object[] GetAllFromSource(System.Type tp, object obj)
{
if (obj == null)
{
return(ArrayUtil.Empty <object>());
}
using (var set = TempCollection.GetSet <object>())
{
var otp = obj.GetType();
if (TypeUtil.IsType(otp, tp))
{
set.Add(obj);
}
if (obj is IComponent)
{
var c = (obj as IComponent).component;
if (!object.ReferenceEquals(c, null) && TypeUtil.IsType(c.GetType(), tp))
{
set.Add(c);
}
}
var go = GameObjectUtil.GetGameObjectFromSource(obj);
if (go != null)
{
if (typeof(SPEntity).IsAssignableFrom(tp))
{
var entity = SPEntity.Pool.GetFromSource(tp, go);
if (entity != null)
{
set.Add(entity);
}
}
else if (ComponentUtil.IsAcceptableComponentType(tp))
{
using (var lst = TempCollection.GetList <UnityEngine.Component>())
{
go.GetComponents(tp, lst);
var e = lst.GetEnumerator();
while (e.MoveNext())
{
set.Add(e.Current);
}
}
}
}
return(set.Count > 0 ? set.ToArray() : ArrayUtil.Empty <object>());
}
}
public static T[] GetAllFromSource <T>(object obj) where T : class
{
if (obj == null)
{
return(ArrayUtil.Empty <T>());
}
using (var set = TempCollection.GetSet <T>())
{
if (obj is T)
{
set.Add(obj as T);
}
if (obj is IComponent)
{
var c = (obj as IComponent).component;
if (c is T)
{
set.Add(c as T);
}
}
var go = GameObjectUtil.GetGameObjectFromSource(obj);
if (go is T)
{
set.Add(go as T);
}
//if (go != null && ComponentUtil.IsAcceptableComponentType(typeof(T))) go.GetComponentsAlt<T>(set);
if (go != null)
{
var tp = typeof(T);
if (typeof(SPEntity).IsAssignableFrom(tp))
{
var entity = SPEntity.Pool.GetFromSource(tp, go) as T;
if (entity != null)
{
set.Add(entity);
}
}
if (ComponentUtil.IsAcceptableComponentType(tp))
{
go.GetComponentsAlt <T>(set);
}
}
return(set.Count > 0 ? set.ToArray() : ArrayUtil.Empty <T>());
}
}
public static T[] FindObjectsOfInterface <T>() where T : class
{
var tp = typeof(T);
var map = GetInterfaceComponentMap(tp);
using (var lst = TempCollection.GetSet <T>())
{
foreach (var ctp in map)
{
foreach (var obj in UnityEngine.Object.FindObjectsOfType(ctp))
{
lst.Add(obj as T);
}
}
return(lst.ToArray());
}
}
public static bool CheckGeomIgnoring(IPhysicsGeom geom, IEnumerable<Collider> ignoredColliders, int layerMask = Physics.AllLayers, QueryTriggerInteraction query = QueryTriggerInteraction.UseGlobal)
{
if (geom == null) return false;
using (var set = TempCollection.GetSet<Collider>())
{
if(geom.Overlap(set, layerMask, query) > 0)
{
var e = set.GetEnumerator();
while(e.MoveNext())
{
if (!ignoredColliders.Contains(e.Current)) return true;
}
}
}
return false;
}
public static void Remove(T listener)
{
if (_receivers == null || _receivers.Count == 0)
{
return;
}
if (_executing)
{
if (_toRemove == null)
{
_toRemove = TempCollection.GetSet <T>();
}
_toRemove.Add(listener);
}
else
{
_receivers.Remove(listener);
}
}
public static void Add(T listener)
{
if (_receivers == null)
{
_receivers = new HashSet <T>();
}
if (_executing)
{
if (_toAdd == null)
{
_toAdd = TempCollection.GetSet <T>();
}
_toAdd.Add(listener);
}
else
{
_receivers.Add(listener);
}
}
/// <summary>
/// Broadcast a message globally to all that match T. This can be slow, use sparingly.
/// </summary>
/// <typeparam name="TInterface"></typeparam>
/// <typeparam name="TArg"></typeparam>
/// <param name="arg"></param>
/// <param name="functor"></param>
public static void FindAndBroadcast <TInterface, TArg>(TArg arg, System.Action <TInterface, TArg> functor, bool includeDisabledComponents = false) where TInterface : class
{
if (functor == null)
{
throw new System.ArgumentNullException("functor");
}
using (var lst = TempCollection.GetSet <TInterface>())
{
ObjUtil.FindObjectsOfInterface <TInterface>(lst);
var e = lst.GetEnumerator();
while (e.MoveNext())
{
if (includeDisabledComponents || TargetIsValid(e.Current))
{
functor(e.Current, arg);
}
}
}
}
public static void ClearAll(bool destroyIfCan = false, bool donotSignalUnregister = false)
{
using (var types = TempCollection.GetSet <System.Type>(_serviceTable.Keys))
using (var services = TempCollection.GetSet <IService>(_serviceTable.Values))
{
//Replace references
var e2 = types.GetEnumerator();
while (e2.MoveNext())
{
var field = GetStaticEntryFieldInfo(e2.Current, false);
if (field != null)
{
field.SetValue(null, null);
}
}
//Signal
if (!donotSignalUnregister)
{
foreach (var service in services)
{
if (service is UnityEngine.Object)
{
service.SignalServiceUnregistered();
}
}
}
if (destroyIfCan)
{
foreach (var service in services)
{
if (service is UnityEngine.Object)
{
ObjUtil.SmartDestroy(service as UnityEngine.Object);
}
}
}
}
}
/// <summary>
/// Broadcast a message globally to all that match T. This can be slow, use sparingly.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="functor"></param>
public static void FindAndBroadcast <T>(System.Action <T> functor, bool includeDisabledComponents = false) where T : class
{
if (functor == null)
{
throw new System.ArgumentNullException("functor");
}
using (var coll = TempCollection.GetSet <T>())
{
ObjUtil.FindObjectsOfInterface <T>(coll);
GlobalMessagePool <T> .CopyReceivers(coll);
var e = coll.GetEnumerator();
while (e.MoveNext())
{
if (includeDisabledComponents || TargetIsValid(e.Current))
{
functor(e.Current);
}
}
}
}
/// <summary>
/// Call once per frame
/// </summary>
private void Update()
{
var e = _dict.GetEnumerator();
while (e.MoveNext())
{
if (e.Current.Value.Active)
{
e.Current.Value.Update();
}
}
if (_sequences.Count > 0)
{
using (var set = TempCollection.GetSet <ISequence>())
{
var e2 = _sequences.GetEnumerator();
while (e2.MoveNext())
{
if (e2.Current.Update())
{
set.Add(e2.Current);
}
}
if (set.Count > 0)
{
e2 = set.GetEnumerator();
while (e2.MoveNext())
{
_sequences.Remove(e2.Current);
}
}
}
}
}
public override int SenseAll <T>(ICollection <T> lst, System.Func <T, bool> p = null)
{
if (lst == null)
{
throw new System.ArgumentNullException("lst");
}
if (lst.IsReadOnly)
{
throw new System.ArgumentException("List to fill can not be read-only.", "lst");
}
if (_sensors == null)
{
this.SyncChildSensors();
}
if (_sensors.Length == 0)
{
return(0);
}
if (_mustBeVisibleByAll && _sensors.Length > 1)
{
using (var set = com.spacepuppy.Collections.TempCollection.GetSet <T>())
{
int resultCnt = 0;
_sensors[0].SenseAll <T>(set, p);
var e = set.GetEnumerator();
while (e.MoveNext())
{
int cnt = 1;
for (int i = 1; i < _sensors.Length; i++)
{
if (!_sensors[i].Visible(e.Current))
{
cnt++;
}
}
if (cnt == _sensors.Length)
{
resultCnt++;
lst.Add(e.Current);
}
}
return(resultCnt);
}
}
else
{
/*
* //todo - make distinct
* int cnt = 0;
* for (int i = 0; i < _sensors.Length; i++)
* {
* cnt += _sensors[i].SenseAll<T>(lst, p);
* }
* return cnt;
*/
using (var set = TempCollection.GetSet <T>())
{
for (int i = 0; i < _sensors.Length; i++)
{
_sensors[i].SenseAll <T>(set, p);
}
var e = set.GetEnumerator();
while (e.MoveNext())
{
lst.Add(e.Current);
}
return(set.Count);
}
}
}
public static int OverlapCapsule(Vector3 point1, Vector3 point2, float radius, ICollection<Collider> results,
int layerMask = Physics.AllLayers, QueryTriggerInteraction query = QueryTriggerInteraction.UseGlobal)
{
if (results == null) throw new System.ArgumentNullException("results");
//note, HashSets are inherently unique collections... so no need to check if contains during second and third overlaps
using (var tmpSet = TempCollection.GetSet<Collider>())
{
if (VectorUtil.FuzzyEquals(point1, point2))
{
int cnt = Physics.OverlapSphereNonAlloc(point1, radius, _nonallocColliderBuffer, layerMask, query);
for (int i = 0; i < cnt; i++)
{
tmpSet.Add(_nonallocColliderBuffer[i]);
_nonallocColliderBuffer[i] = null;
}
}
else
{
if (_nonallocColliderBuffer == null) _nonallocColliderBuffer = new Collider[MAX_BUFFER];
if (_nonallocRaycastBuffer == null) _nonallocRaycastBuffer = new RaycastHit[MAX_BUFFER];
int cnt;
cnt = Physics.OverlapSphereNonAlloc(point1, radius, _nonallocColliderBuffer, layerMask, query);
for (int i = 0; i < cnt; i++)
{
tmpSet.Add(_nonallocColliderBuffer[i]);
_nonallocColliderBuffer[i] = null;
}
cnt = Physics.OverlapSphereNonAlloc(point2, radius, _nonallocColliderBuffer, layerMask, query);
for (int i = 0; i < cnt; i++)
{
tmpSet.Add(_nonallocColliderBuffer[i]);
_nonallocColliderBuffer[i] = null;
}
var dir = point2 - point1;
var dist = dir.magnitude;
cnt = Physics.SphereCastNonAlloc(point1, radius, dir.normalized, _nonallocRaycastBuffer, dist, layerMask, query);
for (int i = 0; i < cnt; i++)
{
tmpSet.Add(_nonallocRaycastBuffer[i].collider);
_nonallocRaycastBuffer[i] = default(RaycastHit);
}
}
//done, now fill collection
if (results is Collider[])
{
var arr = results as Collider[];
int cnt = Mathf.Min(arr.Length, tmpSet.Count);
int i = -1;
var e = tmpSet.GetEnumerator();
while (e.MoveNext() && ++i < cnt)
{
arr[i] = e.Current;
}
return cnt;
}
else
{
if (results is List<Collider>)
{
var lst = results as List<Collider>;
var num = tmpSet.Count + lst.Count;
if (lst.Capacity < num) lst.Capacity = num;
}
var e = tmpSet.GetEnumerator();
while (e.MoveNext())
{
results.Add(e.Current);
}
return tmpSet.Count;
}
}
}
public static T[] GetAllFromSource <T>(object obj, bool includeChildren = false) where T : class
{
if (obj == null)
{
return(ArrayUtil.Empty <T>());
}
using (var set = TempCollection.GetSet <T>())
{
if (obj is T)
{
set.Add(obj as T);
}
if (obj is IComponent)
{
var c = (obj as IComponent).component;
if (c is T)
{
set.Add(c as T);
}
}
var go = GameObjectUtil.GetGameObjectFromSource(obj);
if (go is T)
{
set.Add(go as T);
}
//if (go != null && ComponentUtil.IsAcceptableComponentType(typeof(T))) go.GetComponentsAlt<T>(set);
if (go != null)
{
var tp = typeof(T);
if (typeof(SPEntity).IsAssignableFrom(tp))
{
var entity = SPEntity.Pool.GetFromSource(tp, go) as T;
if (entity != null)
{
set.Add(entity);
}
}
else if (typeof(UnityEngine.GameObject).IsAssignableFrom(tp))
{
if (includeChildren)
{
using (var lst = TempCollection.GetList <UnityEngine.Transform>())
{
go.GetComponentsInChildren <UnityEngine.Transform>(lst);
var e = lst.GetEnumerator();
while (e.MoveNext())
{
set.Add(e.Current.gameObject as T);
}
}
}
}
if (ComponentUtil.IsAcceptableComponentType(tp))
{
if (includeChildren)
{
go.GetChildComponents <T>(set, true);
}
else
{
go.GetComponents <T>(set);
}
}
}
return(set.Count > 0 ? set.ToArray() : ArrayUtil.Empty <T>());
}
}
void IUpdateable.Update()
{
//stop if we shouldn't be running
if (!_activelyScanning || !this.isActiveAndEnabled || _intersectingObjects.Count == 0)
{
this.StopUpdate();
return;
}
//check timer
if (_activeScanInterval > 0f)
{
_timer += Time.unscaledDeltaTime;
if (_timer < _activeScanInterval)
{
return;
}
}
_timer = 0f;
//perform scan of current objects
bool containsActiveObjects = _activeObjects.Count > 0;
using (var toRemove = TempCollection.GetSet <GameObject>())
{
var e = _intersectingObjects.GetEnumerator();
while (e.MoveNext())
{
if (!ObjUtil.IsObjectAlive(e.Current) || !e.Current.activeInHierarchy)
{
_activeObjects.Remove(e.Current);
toRemove.Add(e.Current);
continue;
}
if (_mask.Value != null)
{
if (_mask.Value.Intersects(e.Current))
{
_activeObjects.Add(e.Current);
}
else
{
_activeObjects.Remove(e.Current);
}
}
}
if (toRemove.Count > 0)
{
e = toRemove.GetEnumerator();
while (e.MoveNext())
{
_intersectingObjects.Remove(e.Current);
}
}
}
//wrap up by firing of appropriate events
if (_activeObjects.Count == 0 && _intersectingObjects.Count == 0)
{
this.StopUpdate();
}
if (containsActiveObjects)
{
if (_activeObjects.Count == 0)
{
_onTriggerLastExited.ActivateTrigger(this, null);
}
}
else
{
if (_activeObjects.Count > 0)
{
_onTriggerOccupied.ActivateTrigger(this, null);
}
}
}
