protected int _timeToDie = 0; // Timer after _timeToLive goes negative before deactivation. public override void Init(IInteractionBehaviour interactionBehaviour, ActivityManager manager) { _interactionBehaviour = interactionBehaviour; _manager = manager; Revive(); _rigidbody = GetComponent<Rigidbody>(); }
protected override bool checkShouldGraspAtemporal(IInteractionBehaviour intObj) { var sphere = singleContactBone.collider as SphereCollider; return(intObj.GetHoverDistance(sphere.transform.TransformPoint(sphere.center)) < sphere.transform.TransformVector(Vector3.right).magnitude *sphere.radius); }
/// <summary> /// Unregisters an InteractionObject from this manager. This removes it from the internal /// scene and prevents any further interaction. /// /// Trying to unregister a behaviour that is not registered is safe and is a no-op. /// </summary> public void UnregisterInteractionBehaviour(IInteractionBehaviour interactionBehaviour) { if (_graspedBehaviours.Remove(interactionBehaviour)) { for (var it = _idToInteractionHand.GetEnumerator(); it.MoveNext();) { var interactionHand = it.Current.Value; if (interactionHand.graspedObject == interactionBehaviour) { try { if (interactionHand.isUntracked) { interactionHand.MarkTimeout(); } else { interactionHand.ReleaseObject(); } } catch (Exception e) { //Only log to console //We want to continue so we can destroy the shape and dispatch OnUnregister Debug.LogException(e); } break; } } } _activityManager.Unregister(interactionBehaviour); _grabClassifier.UnregisterInteractionBehaviour(interactionBehaviour); }
/// <summary> /// Forces the given object to be released by any hands currently holding it. Will return true /// only if there was at least one hand holding the object. /// </summary> public bool ReleaseObject(IInteractionBehaviour graspedObject) { if (!_graspedBehaviours.Remove(graspedObject)) { return(false); } for (var it = _idToInteractionHand.GetEnumerator(); it.MoveNext();) { var interactionHand = it.Current.Value; if (interactionHand.graspedObject == graspedObject) { if (interactionHand.isUntracked) { interactionHand.MarkTimeout(); } else { if (_graspingEnabled) { } interactionHand.ReleaseObject(); InteractionBrushHand ibHand; if ((ibHand = _handPool.GetHandModel <InteractionBrushHand>(interactionHand.hand.Id)) != null) { ibHand.enableSoftContact(); } } } } return(true); }
protected override bool checkShouldGrasp(out IInteractionBehaviour objectToGrasp) { var toGrasp = OverlapSphereGetClosest(singleContactBone.collider as SphereCollider, manager.GetInteractionLayerMask()); if (toGrasp == null) { objectToGrasp = null; return(false); } var intObj = toGrasp.attachedRigidbody.GetComponent <InteractionBehaviour>(); if (intObj != null && !intObj.ignoreGrasping && enableKeyboardControl && Input.GetKey(graspKey)) { objectToGrasp = intObj; return(true); } else { objectToGrasp = null; return(false); } }
protected virtual void dispatchOnHandsHolding(List <Hand> hands, IInteractionBehaviour interactionBehaviour, bool isPhysics) { for (int j = 0; j < hands.Count; j++) { var hand = hands[j]; InteractionHand interactionHand; if (_idToInteractionHand.TryGetValue(hand.Id, out interactionHand)) { if (interactionHand.graspedObject == interactionBehaviour) { _holdingHands.Add(hand); } } } try { if (isPhysics) { interactionBehaviour.NotifyHandsHoldPhysics(_holdingHands); } else { interactionBehaviour.NotifyHandsHoldGraphics(_holdingHands); } } catch (Exception e) { _activityManager.NotifyMisbehaving(interactionBehaviour); Debug.LogException(e); } _holdingHands.Clear(); }
/// <summary> /// Forces a hand to grasp the given interaction behaviour. The grasp will only be terminated when /// the hand either times out or the user calls ReleaseHand. /// </summary> /// <param name="hand"></param> public void GraspWithHand(Hand hand, IInteractionBehaviour interactionBehaviour) { if (!_activityManager.IsRegistered(interactionBehaviour)) { throw new InvalidOperationException("Cannot grasp " + interactionBehaviour + " because it is not registered with this manager."); } InteractionHand interactionHand; if (!_idToInteractionHand.TryGetValue(hand.Id, out interactionHand)) { throw new InvalidOperationException("Hand with id " + hand.Id + " is not registered with this manager."); } if (interactionHand.graspedObject != null) { throw new InvalidOperationException("Cannot grasp with hand " + hand.Id + " because that hand is already grasping " + interactionHand.graspedObject); } //Ensure behaviour is active already _activityManager.Activate(interactionBehaviour); if (!interactionBehaviour.IsBeingGrasped) { _graspedBehaviours.Add(interactionBehaviour); } interactionHand.GraspObject(interactionBehaviour, isUserGrasp: true); }
public void Deactivate(IInteractionBehaviour interactionBehaviour) { IActivityMonitor monitor; if (_registeredBehaviours.TryGetValue(interactionBehaviour, out monitor)) { if (monitor != null) { //The monitor that is last in the array of monitors IInteractionBehaviour lastBehaviour = _activeBehaviours[_activeBehaviours.Count - 1]; IActivityMonitor lastMonitor = _registeredBehaviours[lastBehaviour]; //Replace the monitor we are going to destroy with the last monitor _activeBehaviours[monitor.arrayIndex] = lastBehaviour; //Make sure to update the index of the moved monitor! lastMonitor.arrayIndex = monitor.arrayIndex; //Remove the empty space at the end _activeBehaviours.RemoveAt(_activeBehaviours.Count - 1); _registeredBehaviours[interactionBehaviour] = null; UnityEngine.Object.Destroy(monitor); if (OnDeactivate != null) { OnDeactivate(interactionBehaviour); } } } }
public IActivityMonitor Activate(IInteractionBehaviour interactionBehaviour) { IActivityMonitor monitor; if (_registeredBehaviours.TryGetValue(interactionBehaviour, out monitor)) { if (monitor == null) { if (_maxDepth == 1) { monitor = interactionBehaviour.gameObject.AddComponent <ActivityMonitorLite>(); } else { monitor = interactionBehaviour.gameObject.AddComponent <ActivityMonitor>(); } monitor.Init(interactionBehaviour, this); _registeredBehaviours[interactionBehaviour] = monitor; monitor.arrayIndex = _activeBehaviours.Count; _activeBehaviours.Add(interactionBehaviour); if (OnActivate != null) { OnActivate(interactionBehaviour); } } } return(monitor); }
public void UpdateBehaviour(IInteractionBehaviour behaviour, Hand _hand) { using (new ProfilerSample("Update Individual Classifier", behaviour.gameObject)) { GrabClassifierHeuristics.GrabClassifier classifier; Dictionary <IInteractionBehaviour, GrabClassifierHeuristics.GrabClassifier> classifiers = (_hand.IsLeft ? leftGrabClassifiers : rightGrabClassifiers); if (!classifiers.TryGetValue(behaviour, out classifier)) { classifier = new GrabClassifierHeuristics.GrabClassifier(behaviour.gameObject); classifiers.Add(behaviour, classifier); } //Do the actual grab classification logic fillClassifier(_hand, ref classifier); GrabClassifierHeuristics.UpdateClassifier(classifier, collidingCandidates, numberOfColliders, scaledGrabParams); if (classifier.isGrabbing != classifier.prevGrabbing) { if (classifier.isGrabbing) { if (!_manager.TwoHandedGrasping) { _manager.ReleaseObject(behaviour); } _manager.GraspWithHand(_hand, behaviour); } else if (behaviour.IsBeingGraspedByHand(_hand.Id)) { _manager.ReleaseHand(_hand.Id); classifier.coolDownProgress = 0f; } } classifier.prevGrabbing = classifier.isGrabbing; } }
public void EnsureActive(IInteractionBehaviour interactionBehaviour) { if (!_activityManager.IsActive(interactionBehaviour)) { _activityManager.Activate(interactionBehaviour); } }
/// <summary> /// Unregisters an InteractionObject from this manager. This removes it from the internal /// scene and prevents any further interaction. /// /// Trying to unregister a behaviour that is not registered is safe and is a no-op. /// </summary> public void UnregisterInteractionBehaviour(IInteractionBehaviour interactionBehaviour) { if (_graspedBehaviours.Remove(interactionBehaviour)) { foreach (var interactionHand in _idToInteractionHand.Values) { if (interactionHand.graspedObject == interactionBehaviour) { try { if (interactionHand.isUntracked) { interactionHand.MarkTimeout(); } else { interactionHand.ReleaseObject(); } } catch (Exception e) { //Only log to console //We want to continue so we can destroy the shape and dispatch OnUnregister Debug.LogException(e); } break; } } } _activityManager.Unregister(interactionBehaviour); }
/// <summary> /// Forces the given object to be released by any hands currently holding it. Will return true /// only if there was at least one hand holding the object. /// </summary> public bool ReleaseObject(IInteractionBehaviour graspedObject) { if (!_graspedBehaviours.Remove(graspedObject)) { return(false); } foreach (var interactionHand in _idToInteractionHand.Values) { if (interactionHand.graspedObject == graspedObject) { if (interactionHand.isUntracked) { interactionHand.MarkTimeout(); } else { if (_graspingEnabled) { INTERACTION_HAND_RESULT result = new INTERACTION_HAND_RESULT(); result.classification = ManipulatorMode.Contact; result.handFlags = HandResultFlags.ManipulatorMode; result.instanceHandle = new INTERACTION_SHAPE_INSTANCE_HANDLE(); InteractionC.OverrideHandResult(ref _scene, (uint)interactionHand.hand.Id, ref result); } interactionHand.ReleaseObject(); } } } return(true); }
public override void SwapGrasp(IInteractionBehaviour replacement) { var original = graspedObject; base.SwapGrasp(replacement); grabClassifier.SwapClassifierState(original, replacement); }
protected int _timeToDie = 0; // Timer after _timeToLive goes negative before deactivation. public override void Init(IInteractionBehaviour interactionBehaviour, ActivityManager manager) { _interactionBehaviour = interactionBehaviour; _manager = manager; Revive(); _rigidbody = GetComponent <Rigidbody>(); }
protected override void onObjectUnregistered(IInteractionBehaviour intObj) { if (graspedObject == intObj) { Debug.LogError("Object was unregistered while grasped by the " + "InteractionTestController: " + intObj.name); } }
IEnumerator graspWatcher() { bool graspingState = false; IInteractionBehaviour graspedObject; int handId = 0; while (true) { if (interactionManager != null) { Leap.Hand hand = HandModel.GetLeapHand(); if (hand != null) { handId = hand.Id; } else { handId = 0; } interactionManager.TryGetGraspedObject(handId, out graspedObject); graspingState = false; if (graspedObject != null) { if ((AnyInteractionObject || (TagName != "" && graspedObject.gameObject.tag == TagName))) { graspingState = true; } else { for (int o = 0; o < TargetObjects.Length; o++) { if (TargetObjects[o] == graspedObject) { graspingState = true; break; } } } } if (graspingState) { if (_currentObj != graspedObject) { _currentObj = graspedObject; OnGrasp.Invoke(_currentObj); } Activate(); } else { _currentObj = null; Deactivate(); } } yield return(new WaitForSeconds(Period)); } }
void IInternalInteractionManager.NotifyIntObjRemovedNoContactLayer(IInteractionBehaviour intObj, int layer, bool refreshImmediately) { _intObjNoContactLayers[layer].Remove(intObj); if (refreshImmediately) { refreshInteractionLayerMask(); } }
public static void NotifyIntObjHasNewNoContactLayer(this IInternalInteractionManager manager, IInteractionBehaviour intObj, int oldNoContactLayer, int newNoContactLayer) { manager.NotifyIntObjRemovedNoContactLayer(intObj, oldNoContactLayer, false); manager.NotifyIntObjAddedNoContactLayer(intObj, newNoContactLayer, false); manager.RefreshLayersNow(); }
public void Register(IInteractionBehaviour behaviour) { //Do nothing if already registered if (_registeredBehaviours.ContainsKey(behaviour)) { return; } _registeredBehaviours.Add(behaviour, null); behaviour.NotifyRegistered(); }
public bool IsActive(IInteractionBehaviour interactionBehaviour) { IActivityMonitor monitor; if (_registeredBehaviours.TryGetValue(interactionBehaviour, out monitor)) { return(monitor != null); } return(false); // Not even registered. }
private void assertIsRegisteredWithThisManager(IInteractionBehaviour interactionObj) { Assert.IsTrue(interactionObj.IsRegisteredWithManager, "Object must be registered with a manager."); Assert.AreEqual(interactionObj.Manager, this, "Object must be registered with this manager."); Assert.IsTrue(interactionObj.isActiveAndEnabled, "Object must be active and enabled."); }
protected virtual void destroyInteractionShape(IInteractionBehaviour interactionBehaviour) { INTERACTION_SHAPE_INSTANCE_HANDLE instanceHandle = interactionBehaviour.ShapeInstanceHandle; _instanceHandleToBehaviour.Remove(instanceHandle); InteractionC.DestroyShapeInstance(ref _scene, ref instanceHandle); interactionBehaviour.NotifyInteractionShapeDestroyed(); }
private void assertIsRegisteredWithThisManager(IInteractionBehaviour interactionObj) { Assert.IsTrue(interactionObj.IsRegisteredWithManager, "Object must be registered with a manager."); Assert.AreEqual(interactionObj.Manager, this, "Object must be registered with this manager."); Assert.IsTrue(interactionObj.isActiveAndEnabled, "Object must be active and enabled."); }
private void handleCollision(Collision collision) { IInteractionBehaviour otherBehaviour = null; ActivityMonitor neighbor = collision.gameObject.GetComponent <ActivityMonitor>(); if (neighbor != null) { if (arrayIndex > neighbor.arrayIndex) { return; // Only need to do this on one side of a pair. } otherBehaviour = neighbor._interactionBehaviour; } else { if (_timeToLive <= 1) { return; // Do not activate neighbor. } otherBehaviour = collision.gameObject.GetComponent <IInteractionBehaviour>(); if (otherBehaviour == null) { return; } // Unregistered behaviours will fail to activate. neighbor = _manager.Activate(otherBehaviour) as ActivityMonitor; if (neighbor != null) { neighbor._timeToLive = _timeToLive - 1; } return; } // Allow different managers. if (!_manager.IsRegistered(otherBehaviour)) { return; } // propagate both ways int nextTime = ((_timeToLive > neighbor._timeToLive) ? _timeToLive : neighbor._timeToLive) - 1; if (_timeToLive < nextTime) { _timeToLive = nextTime; } else if (neighbor._timeToLive < nextTime) { neighbor._timeToLive = nextTime; } }
private void tryNotify(Collider other) { IInteractionBehaviour ib = other.GetComponentInParent <IInteractionBehaviour>(); if (ib) { manager.EnsureActive(ib); _dislocatedCounter = 0; ib.NotifyBrushDislocated(); } }
protected override bool checkShouldRelease(out IInteractionBehaviour objectToRelease) { bool shouldRelease = _graspButtonUp && isGraspingObject; objectToRelease = null; if (shouldRelease) { objectToRelease = graspedObject; } return(shouldRelease); }
public void Register(IInteractionBehaviour behaviour) { //Do nothing if already registered if (_registeredBehaviours.ContainsKey(behaviour)) { return; } _registeredBehaviours.Add(behaviour, null); behaviour.NotifyRegistered(); }
protected override bool checkShouldRelease(out IInteractionBehaviour objectToRelease) { if (enableKeyboardControl && Input.GetKeyDown(releaseKey)) { objectToRelease = graspedObject; return(true); } else { objectToRelease = null; return(false); } }
protected int _timeToDie = 0; // Timer after _timeToLive goes negative before deactivation. public override void Init(IInteractionBehaviour interactionBehaviour, ActivityManager manager) { _interactionBehaviour = interactionBehaviour; _manager = manager; Revive(); _rigidbody = GetComponent <Rigidbody>(); _prevPosition = _rigidbody.position; _prevVelocity = _rigidbody.velocity; _prevRotation = _rigidbody.rotation; _prevAngularVelocity = _rigidbody.angularVelocity; }
public void Unregister(IInteractionBehaviour behaviour) { //Do nothing if not registered if (!_registeredBehaviours.ContainsKey(behaviour)) { return; } if (IsActive(behaviour)) { Deactivate(behaviour); } _registeredBehaviours.Remove(behaviour); behaviour.NotifyUnregistered(); }
void IInternalInteractionManager.NotifyIntObjAddedNoContactLayer(IInteractionBehaviour intObj, int layer, bool refreshImmediately) { if (!_intObjNoContactLayers.ContainsKey(layer)) { _intObjNoContactLayers[layer] = new HashSet <IInteractionBehaviour>(); } _intObjNoContactLayers[layer].Add(intObj); if (refreshImmediately) { refreshInteractionLayerMask(); } }
public static bool ShouldIgnoreHover(this IInteractionBehaviour intObj, InteractionController controller) { switch (intObj.ignoreHoverMode) { case IgnoreHoverMode.None: return(false); case IgnoreHoverMode.Left: return(!controller.isTracked || controller.isLeft); case IgnoreHoverMode.Right: return(!controller.isTracked || controller.isRight); case IgnoreHoverMode.Both: default: return(true); } }
protected override bool checkShouldGrasp(out IInteractionBehaviour objectToGrasp) { bool shouldGrasp = !isGraspingObject && (_graspButtonDown || _graspButtonDownSlopTimer > 0F) && _closestGraspableObject != null; objectToGrasp = null; if (shouldGrasp) { objectToGrasp = _closestGraspableObject; } return(shouldGrasp); }
protected virtual void destroyInteractionShape(IInteractionBehaviour interactionBehaviour) { INTERACTION_SHAPE_INSTANCE_HANDLE instanceHandle = interactionBehaviour.ShapeInstanceHandle; _instanceHandleToBehaviour.Remove(instanceHandle); InteractionC.DestroyShapeInstance(ref _scene, ref instanceHandle); interactionBehaviour.NotifyInteractionShapeDestroyed(); }
public void GraspObject(IInteractionBehaviour obj, bool isUserGrasp) { this.isUserGrasp = isUserGrasp; graspedObject = obj; graspedObject.NotifyHandGrasped(hand); }
/// <summary> /// Tries to find an InteractionObject that is currently being grasped by a Hand with /// the given ID. /// </summary> public bool TryGetGraspedObject(int handId, out IInteractionBehaviour graspedObject) { for (int i = 0; i < _graspedBehaviours.Count; i++) { var iObj = _graspedBehaviours[i]; if (iObj.IsBeingGraspedByHand(handId)) { graspedObject = iObj; return true; } } graspedObject = null; return false; }
public override void Init(IInteractionBehaviour interactionBehaviour, ActivityManager manager) { base.Init(interactionBehaviour, manager); bool wasSleeping = _rigidbody.IsSleeping(); //We need to do this in order to force Unity to reconsider collision callbacks for this object //Otherwise scripts added in the middle of a collision never recieve the Stay callbacks. Collider singleCollider = GetComponentInChildren<Collider>(); if (singleCollider != null) { Physics.IgnoreCollision(singleCollider, singleCollider, true); Physics.IgnoreCollision(singleCollider, singleCollider, false); } if (wasSleeping) { _rigidbody.Sleep(); } }
public static int hysteresisTimeout = 5; //In fixed frames public abstract void Init(IInteractionBehaviour interactionBehaviour, ActivityManager manager);
/// <summary> /// Forces the given object to be released by any hands currently holding it. Will return true /// only if there was at least one hand holding the object. /// </summary> public bool ReleaseObject(IInteractionBehaviour graspedObject) { if (!_graspedBehaviours.Remove(graspedObject)) { return false; } foreach (var interactionHand in _idToInteractionHand.Values) { if (interactionHand.graspedObject == graspedObject) { if (interactionHand.isUntracked) { interactionHand.MarkTimeout(); } else { if (_graspingEnabled) { INTERACTION_HAND_RESULT result = new INTERACTION_HAND_RESULT(); result.classification = ManipulatorMode.Contact; result.handFlags = HandResultFlags.ManipulatorMode; result.instanceHandle = new INTERACTION_SHAPE_INSTANCE_HANDLE(); InteractionC.OverrideHandResult(ref _scene, (uint)interactionHand.hand.Id, ref result); } interactionHand.ReleaseObject(); } } } return true; }
public bool IsActive(IInteractionBehaviour interactionBehaviour) { IActivityMonitor monitor; if (_registeredBehaviours.TryGetValue(interactionBehaviour, out monitor)) { return monitor != null; } return false; // Not even registered. }
public void NotifyMisbehaving(IInteractionBehaviour behaviour) { _misbehavingBehaviours.Add(behaviour); }
/// <summary> /// Unregisters an InteractionObject from this manager. This removes it from the internal /// scene and prevents any further interaction. /// /// Trying to unregister a behaviour that is not registered is safe and is a no-op. /// </summary> public void UnregisterInteractionBehaviour(IInteractionBehaviour interactionBehaviour) { if (_graspedBehaviours.Remove(interactionBehaviour)) { foreach (var interactionHand in _idToInteractionHand.Values) { if (interactionHand.graspedObject == interactionBehaviour) { try { if (interactionHand.isUntracked) { interactionHand.MarkTimeout(); } else { interactionHand.ReleaseObject(); } } catch (Exception e) { //Only log to console //We want to continue so we can destroy the shape and dispatch OnUnregister Debug.LogException(e); } break; } } } _activityManager.Unregister(interactionBehaviour); }
public void EnsureActive(IInteractionBehaviour interactionBehaviour) { if (!_activityManager.IsActive(interactionBehaviour)) { _activityManager.Activate(interactionBehaviour); } }
protected virtual void dispatchOnHandsHolding(List<Hand> hands, IInteractionBehaviour interactionBehaviour, bool isPhysics) { for (int j = 0; j < hands.Count; j++) { var hand = hands[j]; InteractionHand interactionHand; if (_idToInteractionHand.TryGetValue(hand.Id, out interactionHand)) { if (interactionHand.graspedObject == interactionBehaviour) { _holdingHands.Add(hand); } } } try { if (isPhysics) { interactionBehaviour.NotifyHandsHoldPhysics(_holdingHands); } else { interactionBehaviour.NotifyHandsHoldGraphics(_holdingHands); } } catch (Exception e) { _activityManager.NotifyMisbehaving(interactionBehaviour); Debug.LogException(e); } _holdingHands.Clear(); }
public bool IsRegistered(IInteractionBehaviour interactionBehaviour) { return _registeredBehaviours.ContainsKey(interactionBehaviour); }
/// <summary> /// Forces a hand to grasp the given interaction behaviour. The grasp will only be terminated when /// the hand either times out or the user calls ReleaseHand. /// </summary> /// <param name="hand"></param> public void GraspWithHand(Hand hand, IInteractionBehaviour interactionBehaviour) { if (!_activityManager.IsRegistered(interactionBehaviour)) { throw new InvalidOperationException("Cannot grasp " + interactionBehaviour + " because it is not registered with this manager."); } InteractionHand interactionHand; if (!_idToInteractionHand.TryGetValue(hand.Id, out interactionHand)) { throw new InvalidOperationException("Hand with id " + hand.Id + " is not registered with this manager."); } if (interactionHand.graspedObject != null) { throw new InvalidOperationException("Cannot grasp with hand " + hand.Id + " because that hand is already grasping " + interactionHand.graspedObject); } //Ensure behaviour is active already _activityManager.Activate(interactionBehaviour); if (!interactionBehaviour.IsBeingGrasped) { _graspedBehaviours.Add(interactionBehaviour); } interactionHand.GraspObject(interactionBehaviour, isUserGrasp: true); }
protected virtual void createInteractionShape(IInteractionBehaviour interactionBehaviour) { INTERACTION_SHAPE_DESCRIPTION_HANDLE descriptionHandle = interactionBehaviour.ShapeDescriptionHandle; INTERACTION_SHAPE_INSTANCE_HANDLE instanceHandle = new INTERACTION_SHAPE_INSTANCE_HANDLE(); INTERACTION_CREATE_SHAPE_INFO createInfo; INTERACTION_TRANSFORM createTransform; interactionBehaviour.GetInteractionShapeCreationInfo(out createInfo, out createTransform); InteractionC.CreateShapeInstance(ref _scene, ref descriptionHandle, ref createTransform, ref createInfo, out instanceHandle); _instanceHandleToBehaviour[instanceHandle] = interactionBehaviour; interactionBehaviour.NotifyInteractionShapeCreated(instanceHandle); }
public void Deactivate(IInteractionBehaviour interactionBehaviour) { IActivityMonitor monitor; if (_registeredBehaviours.TryGetValue(interactionBehaviour, out monitor)) { if (monitor != null) { //The monitor that is last in the array of monitors IInteractionBehaviour lastBehaviour = _activeBehaviours[_activeBehaviours.Count - 1]; IActivityMonitor lastMonitor = _registeredBehaviours[lastBehaviour]; //Replace the monitor we are going to destroy with the last monitor _activeBehaviours[monitor.arrayIndex] = lastBehaviour; //Make sure to update the index of the moved monitor! lastMonitor.arrayIndex = monitor.arrayIndex; //Remove the empty space at the end _activeBehaviours.RemoveAt(_activeBehaviours.Count - 1); _registeredBehaviours[interactionBehaviour] = null; UnityEngine.Object.Destroy(monitor); if (OnDeactivate != null) { OnDeactivate(interactionBehaviour); } } } }
/// <summary> /// Registers an InteractionObject with this manager, which automatically adds the objects /// representation into the internal interaction scene. If the manager is disabled, /// the registration will still succeed and the object will be added to the internal scene /// when the manager is next enabled. /// /// Trying to register a behaviour that is already registered is safe and is a no-op. /// </summary> public void RegisterInteractionBehaviour(IInteractionBehaviour interactionBehaviour) { _activityManager.Register(interactionBehaviour); }
public IActivityMonitor Activate(IInteractionBehaviour interactionBehaviour) { IActivityMonitor monitor; if (_registeredBehaviours.TryGetValue(interactionBehaviour, out monitor)) { if (monitor == null) { if (_maxDepth == 1) { monitor = interactionBehaviour.gameObject.AddComponent<ActivityMonitorLite>(); } else { monitor = interactionBehaviour.gameObject.AddComponent<ActivityMonitor>(); } monitor.Init(interactionBehaviour, this); _registeredBehaviours[interactionBehaviour] = monitor; monitor.arrayIndex = _activeBehaviours.Count; _activeBehaviours.Add(interactionBehaviour); if (OnActivate != null) { OnActivate(interactionBehaviour); } } } return monitor; }