protected override bool DisableHoverClick(TransformEventData data) { if (!enableFistHover) { return(false); } #if !CP_ORION LeapMotionEventData ldata = data as LeapMotionEventData; if (ldata == null) { return(false); } float radius = ldata.hand.GetLeapHand().SphereRadius; //Debug.Log("fist radius " + radius); bool hasFist = radius < 40f; if (hasFist && !ldata.hadFist) { print("reseting time for fist"); // Reset the time since entered. ldata.timeSinceEntered = Time.unscaledTime; } if (!hasFist && ldata.hadFist) { ldata.SetProgress(0f); ldata.timeSinceEntered = Time.unscaledTime; } ldata.hadFist = hasFist; return(!hasFist); #else return(false); #endif }
/* We should activate if we're enabled, there's a pointer of ours in * the scene, and it's moved recently. */ public override bool ShouldActivateModule() { if (!enabled) { return(false); } // If we moved recently, then we should probably activate. foreach (PointerEventData eventData in m_PointerData.Values) { TransformEventData eventDataP = (TransformEventData)eventData; Transform pointer = eventDataP.pointer; if (pointer != null && !Mathf.Approximately((pointer.position - eventDataP.lastPosition).magnitude, 0f)) { eventDataP.lastPosition = pointer.position; eventDataP.timeSinceMoved = Time.unscaledTime; } if (pointer != null && (Time.unscaledTime - eventDataP.timeSinceMoved) < timeToDeactivate) { return(true); } } return(false); }
/* The open source code says this is protected but with Unity 4.6.1, * it's not callable from an inherited. Returns true if created, * false otherwise.*/ protected new bool GetPointerData(int id, out PointerEventData data, bool create) { if (!m_PointerData.TryGetValue(id, out data) && create) { data = new TransformEventData(eventSystem) { pointerId = id, }; m_PointerData.Add(id, data); return(true); } return(false); }
// Maybe instead of an image, it should be just some object that // has the following properties? // ProgressIndicator.proportion // ProgressIndicator.screenLocation // ProgressIndicator.worldLocation /* * Register a pointer with a particular transform and pointer ID. */ public void RegisterPointer(int id, Transform pointer, Image progressBar) { print("register pointer id " + id); PointerEventData eventData; bool newData = GetPointerData(id, out eventData, true); newData |= true; // XXX avoid the warning that newData is never used. TransformEventData eData = (TransformEventData)eventData; //print("set pointer"); eData.pointer = pointer; //print("set pointer " + eData.pointer); eData.progressBar = progressBar; // pointer = t; // pointerId = id; // lastPosition = pointer.position; }
/* * Process UI input event using the screen coordinates of the * pointer's position. */ public override void Process() { foreach (int pointerId in m_PointerData.Keys) { PointerEventData eventData; bool newData = GetPointerData(pointerId, out eventData, false); newData &= true; // XXX remove warning TransformEventData eData = (TransformEventData)eventData; // We only process if we have a pointer. if (eData.pointer == null) { continue; } var screenPosition = Camera.main.WorldToScreenPoint(eData.pointer.position); Vector2 newPosition = new Vector2(screenPosition.x, screenPosition.y); eventData.delta = newPosition - eventData.position; eventData.position = newPosition; //eventData.pointerPress = null; eventSystem.RaycastAll(eventData, m_RaycastResultCache); var raycast = FindFirstRaycast(m_RaycastResultCache); eventData.pointerCurrentRaycast = raycast; m_RaycastResultCache.Clear(); var currentOverGo = eventData.pointerCurrentRaycast.gameObject; if (enableHoverClick && !DisableHoverClick(eData)) { // If we enter a thing that is clickable, we wait, then draw // the animation. Once the animation finishes, we click it. if (eventData.pointerEnter == currentOverGo && eData.timeSinceEntered > eData.timeSinceClicked && !eventData.dragging && IsClickable(currentOverGo)) { //print("1"); // We're hovering over the same item. float enteredDuration = Time.unscaledTime - eData.timeSinceEntered; if (enteredDuration < preProgress) { //print("2"); // We don't show the progress immediately; we wait a little while. eData.SetProgress(0f); } else { //print("3"); // Let's show the current progress. float progress = (enteredDuration - preProgress) / timeToFill; eData.SetProgress(progress); if (progress >= 1f) { //print("4"); // Click. if (enableHoverDrag && IsDraggable(currentOverGo)) { if (!eventData.dragging) { // Press down. ProcessGesturePress(eventData, true, false); eventData.dragging = true; } else { // Release click. Assert.IsNotNull(eventData); ProcessGesturePress(eventData, false, true); } } else { ProcessGesturePress(eventData, true, true); // This is probably wrong. eventData.selectedObject = null; } eData.timeSinceClicked = Time.unscaledTime; // Reset. eData.SetProgress(0f); // Whew. These things are hard to manage. //eventData.pointerEnter = null; } } } else if (eventData.pointerEnter != currentOverGo) { if (eventData.dragging && IsClickable(currentOverGo) // Make sure CurrentOverGo is not the pointerDrag // and that it's not a child of the pointerDrag. && eventData.pointerDrag != currentOverGo && !currentOverGo.transform.IsChildOf(eventData.pointerDrag.transform)) { // Release! ProcessGesturePress(eventData, false, true); //print("over other thing and dragging " + currentOverGo); //Debug.Log("Hi", currentOverGo); } //print("5"); // We're over something but we don't think it's clickable. eData.SetProgress(0f); eData.timeSinceEntered = Time.unscaledTime; } } if (shouldClick.Count != 0 && shouldClick.Contains(eventData.pointerId)) { ProcessGesturePress(eventData, true, true); ((TransformEventData)eventData).timeSinceClicked = Time.unscaledTime; eData.SetProgress(0f); shouldClick.Remove(eventData.pointerId); } ProcessMove(eventData); if (enableHoverDrag) { ProcessDrag(eventData); } } }
/* * If hover click is enabled, this method can disable it temporarily. */ protected virtual bool DisableHoverClick(TransformEventData data) { return(false); }