2025 lines
56 KiB
C#
2025 lines
56 KiB
C#
/*
|
||
********************************************************************************
|
||
*Copyright(C),coolae.net
|
||
*Author: chenbin
|
||
*Version: 2.0
|
||
*Date: 2017-01-09
|
||
*Description: 在NGUI的uicamera的基础上作了修改，这样支持在3d场景中单独控制操作控制
|
||
*Others:
|
||
*History:
|
||
*********************************************************************************
|
||
*/
|
||
|
||
using UnityEngine;
|
||
using System.Collections.Generic;
|
||
|
||
#if UNITY_EDITOR
|
||
using UnityEditor;
|
||
#endif
|
||
|
||
/// <summary>
|
||
/// This script should be attached to each camera that's used to draw the objects with
|
||
/// UI components on them. This may mean only one camera (main camera or your UI camera),
|
||
/// or multiple cameras if you happen to have multiple viewports. Failing to attach this
|
||
/// script simply means that objects drawn by this camera won't receive UI notifications:
|
||
///
|
||
/// * OnHover (isOver) is sent when the mouse hovers over a collider or moves away.
|
||
/// * OnPress (isDown) is sent when a mouse button gets pressed on the collider.
|
||
/// * OnSelect (selected) is sent when a mouse button is first pressed on an object. Repeated presses won't result in an OnSelect(true).
|
||
/// * OnClick () is sent when a mouse is pressed and released on the same object.
|
||
/// UICamera.currentTouchID tells you which button was clicked.
|
||
/// * OnDoubleClick () is sent when the click happens twice within a fourth of a second.
|
||
/// UICamera.currentTouchID tells you which button was clicked.
|
||
///
|
||
/// * OnDragStart () is sent to a game object under the touch just before the OnDrag() notifications begin.
|
||
/// * OnDrag (delta) is sent to an object that's being dragged.
|
||
/// * OnDragOver (draggedObject) is sent to a game object when another object is dragged over its area.
|
||
/// * OnDragOut (draggedObject) is sent to a game object when another object is dragged out of its area.
|
||
/// * OnDragEnd () is sent to a dragged object when the drag event finishes.
|
||
///
|
||
/// * OnTooltip (show) is sent when the mouse hovers over a collider for some time without moving.
|
||
/// * OnScroll (float delta) is sent out when the mouse scroll wheel is moved.
|
||
/// * OnKey (KeyCode key) is sent when keyboard or controller input is used.
|
||
/// </summary>
|
||
|
||
namespace Coolape
|
||
{
|
||
|
||
[RequireComponent (typeof(Camera))]
|
||
public class MyMainCamera : MonoBehaviour
|
||
{
|
||
/// <summary>
|
||
/// The isbe controled.是否是被ui控制,需要和CLUIDrag4World接合起来用
|
||
/// </summary>
|
||
public bool isbeControled = false;
|
||
//add by chenbin
|
||
|
||
public enum ControlScheme
|
||
{
|
||
Mouse,
|
||
Touch,
|
||
Controller,
|
||
}
|
||
|
||
/// <summary>
|
||
/// Whether the touch event will be sending out the OnClick notification at the end.
|
||
/// </summary>
|
||
|
||
public enum ClickNotification
|
||
{
|
||
None,
|
||
Always,
|
||
BasedOnDelta,
|
||
}
|
||
|
||
/// <summary>
|
||
/// Ambiguous mouse, touch, or controller event.
|
||
/// </summary>
|
||
|
||
public class MouseOrTouch
|
||
{
|
||
public Vector2 pos;
|
||
// Current position of the mouse or touch event
|
||
public Vector2 lastPos;
|
||
// Previous position of the mouse or touch event
|
||
public Vector2 delta;
|
||
// Delta since last update
|
||
public Vector2 totalDelta;
|
||
// Delta since the event started being tracked
|
||
|
||
public Camera pressedCam;
|
||
// Camera that the OnPress(true) was fired with
|
||
|
||
public GameObject last;
|
||
// Last object under the touch or mouse
|
||
public GameObject current;
|
||
// Current game object under the touch or mouse
|
||
public GameObject pressed;
|
||
// Last game object to receive OnPress
|
||
public GameObject dragged;
|
||
// Game object that's being dragged
|
||
|
||
public float pressTime = 0f;
|
||
// When the touch event started
|
||
public float clickTime = 0f;
|
||
// The last time a click event was sent out
|
||
|
||
public ClickNotification clickNotification = ClickNotification.Always;
|
||
public bool touchBegan = true;
|
||
public bool pressStarted = false;
|
||
public bool dragStarted = false;
|
||
|
||
/// <summary>
|
||
/// Delta time since the touch operation started.
|
||
/// </summary>
|
||
|
||
public float deltaTime { get { return RealTime.time - pressTime; } }
|
||
|
||
/// <summary>
|
||
/// Returns whether this touch is currently over a UI element.
|
||
/// </summary>
|
||
|
||
public bool isOverUI {
|
||
get {
|
||
return current != null && current != fallThrough && NGUITools.FindInParents<UIRoot> (current) != null;
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Camera type controls how raycasts are handled by the UICamera.
|
||
/// </summary>
|
||
|
||
public enum EventType : int
|
||
{
|
||
World_3D,
|
||
// Perform a Physics.Raycast and sort by distance to the point that was hit.
|
||
UI_3D,
|
||
// Perform a Physics.Raycast and sort by widget depth.
|
||
World_2D,
|
||
// Perform a Physics2D.OverlapPoint
|
||
UI_2D,
|
||
// Physics2D.OverlapPoint then sort by widget depth
|
||
}
|
||
|
||
/// <summary>
|
||
/// List of all active cameras in the scene.
|
||
/// </summary>
|
||
|
||
static public BetterList<MyMainCamera> list = new BetterList<MyMainCamera> ();
|
||
|
||
public delegate bool GetKeyStateFunc (KeyCode key);
|
||
|
||
public delegate float GetAxisFunc (string name);
|
||
|
||
/// <summary>
|
||
/// GetKeyDown function -- return whether the specified key was pressed this Update().
|
||
/// </summary>
|
||
|
||
static public GetKeyStateFunc GetKeyDown = Input.GetKeyDown;
|
||
|
||
/// <summary>
|
||
/// GetKeyDown function -- return whether the specified key was released this Update().
|
||
/// </summary>
|
||
|
||
static public GetKeyStateFunc GetKeyUp = Input.GetKeyUp;
|
||
|
||
/// <summary>
|
||
/// GetKey function -- return whether the specified key is currently held.
|
||
/// </summary>
|
||
|
||
static public GetKeyStateFunc GetKey = Input.GetKey;
|
||
|
||
/// <summary>
|
||
/// GetAxis function -- return the state of the specified axis.
|
||
/// </summary>
|
||
|
||
static public GetAxisFunc GetAxis = Input.GetAxis;
|
||
|
||
public delegate void OnScreenResize ();
|
||
|
||
/// <summary>
|
||
/// Delegate triggered when the screen size changes for any reason.
|
||
/// Subscribe to it if you don't want to compare Screen.width and Screen.height each frame.
|
||
/// </summary>
|
||
|
||
static public OnScreenResize onScreenResize;
|
||
|
||
/// <summary>
|
||
/// Event type -- use "UI" for your user interfaces, and "World" for your game camera.
|
||
/// This setting changes how raycasts are handled. Raycasts have to be more complicated for UI cameras.
|
||
/// </summary>
|
||
|
||
public EventType eventType = EventType.UI_3D;
|
||
|
||
/// <summary>
|
||
/// By default, events will go to rigidbodies when the Event Type is not UI.
|
||
/// You can change this behaviour back to how it was pre-3.7.0 using this flag.
|
||
/// </summary>
|
||
|
||
public bool eventsGoToColliders = false;
|
||
|
||
/// <summary>
|
||
/// Which layers will receive events.
|
||
/// </summary>
|
||
|
||
public LayerMask eventReceiverMask = -1;
|
||
|
||
/// <summary>
|
||
/// If 'true', currently hovered object will be shown in the top left corner.
|
||
/// </summary>
|
||
|
||
public bool debug = false;
|
||
|
||
/// <summary>
|
||
/// Whether the mouse input is used.
|
||
/// </summary>
|
||
|
||
public bool useMouse = true;
|
||
|
||
/// <summary>
|
||
/// Whether the touch-based input is used.
|
||
/// </summary>
|
||
|
||
public bool useTouch = true;
|
||
|
||
/// <summary>
|
||
/// Whether multi-touch is allowed.
|
||
/// </summary>
|
||
|
||
public bool allowMultiTouch = true;
|
||
|
||
/// <summary>
|
||
/// Whether the keyboard events will be processed.
|
||
/// </summary>
|
||
|
||
public bool useKeyboard = true;
|
||
|
||
/// <summary>
|
||
/// Whether the joystick and controller events will be processed.
|
||
/// </summary>
|
||
|
||
public bool useController = true;
|
||
|
||
[System.Obsolete ("Use new OnDragStart / OnDragOver / OnDragOut / OnDragEnd events instead")]
|
||
public bool stickyPress { get { return true; } }
|
||
|
||
/// <summary>
|
||
/// Whether the tooltip will disappear as soon as the mouse moves (false) or only if the mouse moves outside of the widget's area (true).
|
||
/// </summary>
|
||
|
||
public bool stickyTooltip = true;
|
||
|
||
/// <summary>
|
||
/// How long of a delay to expect before showing the tooltip.
|
||
/// </summary>
|
||
|
||
public float tooltipDelay = 1f;
|
||
|
||
/// <summary>
|
||
/// If enabled, a tooltip will be shown after touch gets pressed on something and held for more than "tooltipDelay" seconds.
|
||
/// </summary>
|
||
|
||
public bool longPressTooltip = false;
|
||
|
||
/// <summary>
|
||
/// How much the mouse has to be moved after pressing a button before it starts to send out drag events.
|
||
/// </summary>
|
||
|
||
public float mouseDragThreshold = 4f;
|
||
|
||
/// <summary>
|
||
/// How far the mouse is allowed to move in pixels before it's no longer considered for click events, if the click notification is based on delta.
|
||
/// </summary>
|
||
|
||
public float mouseClickThreshold = 10f;
|
||
|
||
/// <summary>
|
||
/// How much the mouse has to be moved after pressing a button before it starts to send out drag events.
|
||
/// </summary>
|
||
|
||
public float touchDragThreshold = 40f;
|
||
|
||
/// <summary>
|
||
/// How far the touch is allowed to move in pixels before it's no longer considered for click events, if the click notification is based on delta.
|
||
/// </summary>
|
||
|
||
public float touchClickThreshold = 40f;
|
||
|
||
/// <summary>
|
||
/// Raycast range distance. By default it's as far as the camera can see.
|
||
/// </summary>
|
||
|
||
public float rangeDistance = -1f;
|
||
|
||
/// <summary>
|
||
/// Name of the axis used for scrolling.
|
||
/// </summary>
|
||
|
||
public string scrollAxisName = "Mouse ScrollWheel";
|
||
|
||
/// <summary>
|
||
/// Name of the axis used to send up and down key events.
|
||
/// </summary>
|
||
|
||
public string verticalAxisName = "Vertical";
|
||
|
||
/// <summary>
|
||
/// Name of the axis used to send left and right key events.
|
||
/// </summary>
|
||
|
||
public string horizontalAxisName = "Horizontal";
|
||
|
||
/// <summary>
|
||
/// Simulate a right-click on OSX when the Command key is held and a left-click is used (for trackpad).
|
||
/// </summary>
|
||
|
||
public bool commandClick = true;
|
||
|
||
/// <summary>
|
||
/// Various keys used by the camera.
|
||
/// </summary>
|
||
|
||
public KeyCode submitKey0 = KeyCode.Return;
|
||
public KeyCode submitKey1 = KeyCode.JoystickButton0;
|
||
public KeyCode cancelKey0 = KeyCode.Escape;
|
||
public KeyCode cancelKey1 = KeyCode.JoystickButton1;
|
||
|
||
public delegate void OnCustomInput ();
|
||
|
||
/// <summary>
|
||
/// Custom input processing logic, if desired. For example: WP7 touches.
|
||
/// Use UICamera.current to get the current camera.
|
||
/// </summary>
|
||
|
||
static public OnCustomInput onCustomInput;
|
||
|
||
/// <summary>
|
||
/// Whether tooltips will be shown or not.
|
||
/// </summary>
|
||
|
||
static public bool showTooltips = true;
|
||
|
||
/// <summary>
|
||
/// Position of the last touch (or mouse) event.
|
||
/// </summary>
|
||
|
||
static public Vector2 lastTouchPosition = Vector2.zero;
|
||
|
||
/// <summary>
|
||
/// Position of the last touch (or mouse) event in the world.
|
||
/// </summary>
|
||
|
||
static public Vector3 lastWorldPosition = Vector3.zero;
|
||
|
||
/// <summary>
|
||
/// Last raycast hit prior to sending out the event. This is useful if you want detailed information
|
||
/// about what was actually hit in your OnClick, OnHover, and other event functions.
|
||
/// Note that this is not going to be valid if you're using 2D colliders.
|
||
/// </summary>
|
||
|
||
static public RaycastHit lastHit;
|
||
|
||
/// <summary>
|
||
/// UICamera that sent out the event.
|
||
/// </summary>
|
||
|
||
static public MyMainCamera current = null;
|
||
|
||
/// <summary>
|
||
/// Last camera active prior to sending out the event. This will always be the camera that actually sent out the event.
|
||
/// </summary>
|
||
|
||
static public Camera currentCamera = null;
|
||
|
||
/// <summary>
|
||
/// Current control scheme. Set automatically when events arrive.
|
||
/// </summary>
|
||
|
||
static public ControlScheme currentScheme = ControlScheme.Controller;
|
||
|
||
/// <summary>
|
||
/// ID of the touch or mouse operation prior to sending out the event. Mouse ID is '-1' for left, '-2' for right mouse button, '-3' for middle.
|
||
/// </summary>
|
||
|
||
static public int currentTouchID = -100;
|
||
|
||
/// <summary>
|
||
/// Key that triggered the event, if any.
|
||
/// </summary>
|
||
|
||
static public KeyCode currentKey = KeyCode.None;
|
||
|
||
/// <summary>
|
||
/// Ray projected into the screen underneath the current touch.
|
||
/// </summary>
|
||
|
||
static public Ray currentRay {
|
||
get {
|
||
return (currentCamera != null && currentTouch != null) ?
|
||
currentCamera.ScreenPointToRay (currentTouch.pos) : new Ray ();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Current touch, set before any event function gets called.
|
||
/// </summary>
|
||
|
||
static public MouseOrTouch currentTouch = null;
|
||
|
||
/// <summary>
|
||
/// Whether an input field currently has focus.
|
||
/// </summary>
|
||
|
||
static public bool inputHasFocus = false;
|
||
|
||
// Obsolete, kept for backwards compatibility.
|
||
static GameObject mGenericHandler;
|
||
|
||
/// <summary>
|
||
/// If set, this game object will receive all events regardless of whether they were handled or not.
|
||
/// </summary>
|
||
|
||
[System.Obsolete ("Use delegates instead such as UICamera.onClick, UICamera.onHover, etc.")]
|
||
static public GameObject genericEventHandler { get { return mGenericHandler; } set { mGenericHandler = value; } }
|
||
|
||
/// <summary>
|
||
/// If events don't get handled, they will be forwarded to this game object.
|
||
/// </summary>
|
||
|
||
static public GameObject fallThrough;
|
||
|
||
public delegate void MoveDelegate (Vector2 delta);
|
||
|
||
public delegate void VoidDelegate (GameObject go);
|
||
|
||
public delegate void BoolDelegate (GameObject go, bool state);
|
||
|
||
public delegate void FloatDelegate (GameObject go, float delta);
|
||
|
||
public delegate void VectorDelegate (GameObject go, Vector2 delta);
|
||
|
||
public delegate void ObjectDelegate (GameObject go, GameObject obj);
|
||
|
||
public delegate void KeyCodeDelegate (GameObject go, KeyCode key);
|
||
|
||
/// <summary>
|
||
/// These notifications are sent out prior to the actual event going out.
|
||
/// </summary>
|
||
|
||
static public VoidDelegate onClick;
|
||
static public VoidDelegate onDoubleClick;
|
||
static public BoolDelegate onHover;
|
||
static public BoolDelegate onPress;
|
||
static public BoolDelegate onSelect;
|
||
static public FloatDelegate onScroll;
|
||
static public VectorDelegate onDrag;
|
||
static public VoidDelegate onDragStart;
|
||
static public ObjectDelegate onDragOver;
|
||
static public ObjectDelegate onDragOut;
|
||
static public VoidDelegate onDragEnd;
|
||
static public ObjectDelegate onDrop;
|
||
static public KeyCodeDelegate onKey;
|
||
static public BoolDelegate onTooltip;
|
||
static public MoveDelegate onMouseMove;
|
||
|
||
// Selected widget (for input)
|
||
static GameObject mCurrentSelection = null;
|
||
|
||
// Mouse events
|
||
static MouseOrTouch[] mMouse = new MouseOrTouch[] { new MouseOrTouch (), new MouseOrTouch (), new MouseOrTouch () };
|
||
|
||
// The last object to receive OnHover
|
||
static GameObject mHover;
|
||
|
||
// Joystick/controller/keyboard event
|
||
static public MouseOrTouch controller = new MouseOrTouch ();
|
||
|
||
// Used to ensure that joystick-based controls don't trigger that often
|
||
static float mNextEvent = 0f;
|
||
|
||
/// <summary>
|
||
/// List of all the active touches.
|
||
/// </summary>
|
||
|
||
static public List<MouseOrTouch> activeTouches = new List<MouseOrTouch> ();
|
||
|
||
// Used internally to store IDs of active touches
|
||
static List<int> mTouchIDs = new List<int> ();
|
||
|
||
// Used to detect screen dimension changes
|
||
static int mWidth = 0;
|
||
static int mHeight = 0;
|
||
|
||
// Tooltip widget (mouse only)
|
||
GameObject mTooltip = null;
|
||
|
||
// Mouse input is turned off on iOS
|
||
Camera mCam = null;
|
||
float mTooltipTime = 0f;
|
||
float mNextRaycast = 0f;
|
||
|
||
/// <summary>
|
||
/// Helper function that determines if this script should be handling the events.
|
||
/// </summary>
|
||
|
||
bool handlesEvents { get { return eventHandler == this; } }
|
||
|
||
/// <summary>
|
||
/// Caching is always preferable for performance.
|
||
/// </summary>
|
||
|
||
#if UNITY_4_3 || UNITY_4_5 || UNITY_4_6
|
||
public Camera cachedCamera { get { if (mCam == null) mCam = camera; return mCam; } }
|
||
#else
|
||
public Camera cachedCamera {
|
||
get {
|
||
if (mCam == null)
|
||
mCam = GetComponent<Camera> ();
|
||
return mCam;
|
||
}
|
||
}
|
||
#endif
|
||
|
||
/// <summary>
|
||
/// Set to 'true' just before OnDrag-related events are sent. No longer needed, but kept for backwards compatibility.
|
||
/// </summary>
|
||
|
||
static public bool isDragging = false;
|
||
|
||
/// <summary>
|
||
/// The object hit by the last Raycast that was the result of a mouse or touch event.
|
||
/// </summary>
|
||
|
||
static public GameObject hoveredObject;
|
||
|
||
/// <summary>
|
||
/// Whether the last raycast was over the UI.
|
||
/// </summary>
|
||
|
||
static public bool isOverUI {
|
||
get {
|
||
if (currentTouch != null)
|
||
return currentTouch.isOverUI;
|
||
if (hoveredObject == null)
|
||
return false;
|
||
if (hoveredObject == fallThrough)
|
||
return false;
|
||
return NGUITools.FindInParents<UIRoot> (hoveredObject) != null;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Option to manually set the selected game object.
|
||
/// </summary>
|
||
|
||
static public GameObject selectedObject {
|
||
get {
|
||
if (mCurrentSelection)
|
||
return mCurrentSelection;
|
||
return null;
|
||
}
|
||
set {
|
||
if (mCurrentSelection == value)
|
||
return;
|
||
|
||
bool shouldRestore = false;
|
||
|
||
if (currentTouch == null) {
|
||
shouldRestore = true;
|
||
currentTouchID = -100;
|
||
currentTouch = controller;
|
||
currentScheme = ControlScheme.Controller;
|
||
}
|
||
|
||
inputHasFocus = false;
|
||
if (onSelect != null)
|
||
onSelect (selectedObject, false);
|
||
Notify (mCurrentSelection, "OnSelect", false);
|
||
mCurrentSelection = value;
|
||
|
||
if (mCurrentSelection != null) {
|
||
if (shouldRestore) {
|
||
MyMainCamera cam = (mCurrentSelection != null) ? FindCameraForLayer (mCurrentSelection.layer) : MyMainCamera.list [0];
|
||
|
||
if (cam != null) {
|
||
current = cam;
|
||
currentCamera = cam.cachedCamera;
|
||
}
|
||
}
|
||
|
||
inputHasFocus = (mCurrentSelection.activeInHierarchy && mCurrentSelection.GetComponent<UIInput> () != null);
|
||
if (onSelect != null)
|
||
onSelect (mCurrentSelection, true);
|
||
Notify (mCurrentSelection, "OnSelect", true);
|
||
}
|
||
|
||
if (shouldRestore) {
|
||
current = null;
|
||
currentCamera = null;
|
||
currentTouch = null;
|
||
currentTouchID = -100;
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Returns 'true' if any of the active touch, mouse or controller is currently holding the specified object.
|
||
/// </summary>
|
||
|
||
static public bool IsPressed (GameObject go)
|
||
{
|
||
for (int i = 0; i < 3; ++i)
|
||
if (mMouse [i].pressed == go)
|
||
return true;
|
||
for (int i = 0, imax = activeTouches.Count; i < imax; ++i) {
|
||
MouseOrTouch touch = activeTouches [i];
|
||
if (touch.pressed == go)
|
||
return true;
|
||
}
|
||
if (controller.pressed == go)
|
||
return true;
|
||
return false;
|
||
}
|
||
|
||
[System.Obsolete ("Use either 'CountInputSources()' or 'activeTouches.Count'")]
|
||
static public int touchCount { get { return CountInputSources (); } }
|
||
|
||
/// <summary>
|
||
/// Number of active touches from all sources.
|
||
/// Note that this will include the sum of touch, mouse and controller events.
|
||
/// If you want only touch events, use activeTouches.Count.
|
||
/// </summary>
|
||
|
||
static public int CountInputSources ()
|
||
{
|
||
int count = 0;
|
||
|
||
for (int i = 0, imax = activeTouches.Count; i < imax; ++i) {
|
||
MouseOrTouch touch = activeTouches [i];
|
||
if (touch.pressed != null)
|
||
++count;
|
||
}
|
||
|
||
for (int i = 0; i < mMouse.Length; ++i)
|
||
if (mMouse [i].pressed != null)
|
||
++count;
|
||
|
||
if (controller.pressed != null)
|
||
++count;
|
||
|
||
return count;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Number of active drag events from all sources.
|
||
/// </summary>
|
||
|
||
static public int dragCount {
|
||
get {
|
||
int count = 0;
|
||
|
||
for (int i = 0, imax = activeTouches.Count; i < imax; ++i) {
|
||
MouseOrTouch touch = activeTouches [i];
|
||
if (touch.dragged != null)
|
||
++count;
|
||
}
|
||
|
||
for (int i = 0; i < mMouse.Length; ++i)
|
||
if (mMouse [i].dragged != null)
|
||
++count;
|
||
|
||
if (controller.dragged != null)
|
||
++count;
|
||
|
||
return count;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Convenience function that returns the main HUD camera.
|
||
/// </summary>
|
||
|
||
static public Camera mainCamera {
|
||
get {
|
||
MyMainCamera mouse = eventHandler;
|
||
return (mouse != null) ? mouse.cachedCamera : null;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Event handler for all types of events.
|
||
/// </summary>
|
||
|
||
static public MyMainCamera eventHandler {
|
||
get {
|
||
for (int i = 0; i < list.size; ++i) {
|
||
// Invalid or inactive entry -- keep going
|
||
MyMainCamera cam = list.buffer [i];
|
||
if (cam == null || !cam.enabled || !NGUITools.GetActive (cam.gameObject))
|
||
continue;
|
||
return cam;
|
||
}
|
||
return null;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Static comparison function used for sorting.
|
||
/// </summary>
|
||
|
||
static int CompareFunc (MyMainCamera a, MyMainCamera b)
|
||
{
|
||
if (a.cachedCamera.depth < b.cachedCamera.depth)
|
||
return 1;
|
||
if (a.cachedCamera.depth > b.cachedCamera.depth)
|
||
return -1;
|
||
return 0;
|
||
}
|
||
|
||
struct DepthEntry
|
||
{
|
||
public int depth;
|
||
public RaycastHit hit;
|
||
public Vector3 point;
|
||
public GameObject go;
|
||
}
|
||
|
||
static DepthEntry mHit = new DepthEntry ();
|
||
static BetterList<DepthEntry> mHits = new BetterList<DepthEntry> ();
|
||
|
||
/// <summary>
|
||
/// Find the rigidbody on the parent, but return 'null' if a UIPanel is found instead.
|
||
/// The idea is: send events to the rigidbody in the world, but to colliders in the UI.
|
||
/// </summary>
|
||
|
||
static Rigidbody FindRootRigidbody (Transform trans)
|
||
{
|
||
while (trans != null) {
|
||
if (trans.GetComponent<UIPanel> () != null)
|
||
return null;
|
||
#if UNITY_4_3 || UNITY_4_5 || UNITY_4_6
|
||
Rigidbody rb = trans.rigidbody;
|
||
#else
|
||
Rigidbody rb = trans.GetComponent<Rigidbody> ();
|
||
#endif
|
||
if (rb != null)
|
||
return rb;
|
||
trans = trans.parent;
|
||
}
|
||
return null;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Find the 2D rigidbody on the parent, but return 'null' if a UIPanel is found instead.
|
||
/// </summary>
|
||
|
||
static Rigidbody2D FindRootRigidbody2D (Transform trans)
|
||
{
|
||
while (trans != null) {
|
||
if (trans.GetComponent<UIPanel> () != null)
|
||
return null;
|
||
#if UNITY_4_3 || UNITY_4_5 || UNITY_4_6
|
||
Rigidbody2D rb = trans.rigidbody2D;
|
||
#else
|
||
Rigidbody2D rb = trans.GetComponent<Rigidbody2D> ();
|
||
#endif
|
||
if (rb != null)
|
||
return rb;
|
||
trans = trans.parent;
|
||
}
|
||
return null;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Returns the object under the specified position.
|
||
/// </summary>
|
||
|
||
static public bool Raycast (Vector3 inPos)
|
||
{
|
||
for (int i = 0; i < list.size; ++i) {
|
||
MyMainCamera cam = list.buffer [i];
|
||
|
||
// Skip inactive scripts
|
||
if (!cam.enabled || !NGUITools.GetActive (cam.gameObject))
|
||
continue;
|
||
|
||
// Convert to view space
|
||
currentCamera = cam.cachedCamera;
|
||
Vector3 pos = currentCamera.ScreenToViewportPoint (inPos);
|
||
if (float.IsNaN (pos.x) || float.IsNaN (pos.y))
|
||
continue;
|
||
|
||
// If it's outside the camera's viewport, do nothing
|
||
if (pos.x < 0f || pos.x > 1f || pos.y < 0f || pos.y > 1f)
|
||
continue;
|
||
|
||
// Cast a ray into the screen
|
||
Ray ray = currentCamera.ScreenPointToRay (inPos);
|
||
|
||
// Raycast into the screen
|
||
int mask = currentCamera.cullingMask & (int)cam.eventReceiverMask;
|
||
float dist = (cam.rangeDistance > 0f) ? cam.rangeDistance : currentCamera.farClipPlane - currentCamera.nearClipPlane;
|
||
|
||
if (cam.eventType == EventType.World_3D) {
|
||
if (Physics.Raycast (ray, out lastHit, dist, mask)) {
|
||
lastWorldPosition = lastHit.point;
|
||
hoveredObject = lastHit.collider.gameObject;
|
||
|
||
if (!list [0].eventsGoToColliders) {
|
||
Rigidbody rb = FindRootRigidbody (hoveredObject.transform);
|
||
if (rb != null)
|
||
hoveredObject = rb.gameObject;
|
||
}
|
||
return true;
|
||
}
|
||
continue;
|
||
} else if (cam.eventType == EventType.UI_3D) {
|
||
RaycastHit[] hits = Physics.RaycastAll (ray, dist, mask);
|
||
|
||
if (hits.Length > 1) {
|
||
for (int b = 0; b < hits.Length; ++b) {
|
||
GameObject go = hits [b].collider.gameObject;
|
||
UIWidget w = go.GetComponent<UIWidget> ();
|
||
|
||
if (w != null) {
|
||
if (!w.isVisible)
|
||
continue;
|
||
if (w.hitCheck != null && !w.hitCheck (hits [b].point))
|
||
continue;
|
||
} else {
|
||
UIRect rect = NGUITools.FindInParents<UIRect> (go);
|
||
if (rect != null && rect.finalAlpha < 0.001f)
|
||
continue;
|
||
}
|
||
|
||
mHit.depth = NGUITools.CalculateRaycastDepth (go);
|
||
|
||
if (mHit.depth != int.MaxValue) {
|
||
mHit.hit = hits [b];
|
||
mHit.point = hits [b].point;
|
||
mHit.go = hits [b].collider.gameObject;
|
||
mHits.Add (mHit);
|
||
}
|
||
}
|
||
|
||
mHits.Sort (delegate(DepthEntry r1, DepthEntry r2) {
|
||
return r2.depth.CompareTo (r1.depth);
|
||
});
|
||
|
||
for (int b = 0; b < mHits.size; ++b) {
|
||
#if UNITY_FLASH
|
||
if (IsVisible(mHits.buffer[b]))
|
||
#else
|
||
if (IsVisible (ref mHits.buffer [b]))
|
||
#endif
|
||
{
|
||
lastHit = mHits [b].hit;
|
||
hoveredObject = mHits [b].go;
|
||
lastWorldPosition = mHits [b].point;
|
||
mHits.Clear ();
|
||
return true;
|
||
}
|
||
}
|
||
mHits.Clear ();
|
||
} else if (hits.Length == 1) {
|
||
GameObject go = hits [0].collider.gameObject;
|
||
UIWidget w = go.GetComponent<UIWidget> ();
|
||
|
||
if (w != null) {
|
||
if (!w.isVisible)
|
||
continue;
|
||
if (w.hitCheck != null && !w.hitCheck (hits [0].point))
|
||
continue;
|
||
} else {
|
||
UIRect rect = NGUITools.FindInParents<UIRect> (go);
|
||
if (rect != null && rect.finalAlpha < 0.001f)
|
||
continue;
|
||
}
|
||
|
||
if (IsVisible (hits [0].point, hits [0].collider.gameObject)) {
|
||
lastHit = hits [0];
|
||
lastWorldPosition = hits [0].point;
|
||
hoveredObject = lastHit.collider.gameObject;
|
||
return true;
|
||
}
|
||
}
|
||
continue;
|
||
} else if (cam.eventType == EventType.World_2D) {
|
||
if (m2DPlane.Raycast (ray, out dist)) {
|
||
Vector3 point = ray.GetPoint (dist);
|
||
Collider2D c2d = Physics2D.OverlapPoint (point, mask);
|
||
|
||
if (c2d) {
|
||
lastWorldPosition = point;
|
||
hoveredObject = c2d.gameObject;
|
||
|
||
if (!cam.eventsGoToColliders) {
|
||
Rigidbody2D rb = FindRootRigidbody2D (hoveredObject.transform);
|
||
if (rb != null)
|
||
hoveredObject = rb.gameObject;
|
||
}
|
||
return true;
|
||
}
|
||
}
|
||
continue;
|
||
} else if (cam.eventType == EventType.UI_2D) {
|
||
if (m2DPlane.Raycast (ray, out dist)) {
|
||
lastWorldPosition = ray.GetPoint (dist);
|
||
Collider2D[] hits = Physics2D.OverlapPointAll (lastWorldPosition, mask);
|
||
|
||
if (hits.Length > 1) {
|
||
for (int b = 0; b < hits.Length; ++b) {
|
||
GameObject go = hits [b].gameObject;
|
||
UIWidget w = go.GetComponent<UIWidget> ();
|
||
|
||
if (w != null) {
|
||
if (!w.isVisible)
|
||
continue;
|
||
if (w.hitCheck != null && !w.hitCheck (lastWorldPosition))
|
||
continue;
|
||
} else {
|
||
UIRect rect = NGUITools.FindInParents<UIRect> (go);
|
||
if (rect != null && rect.finalAlpha < 0.001f)
|
||
continue;
|
||
}
|
||
|
||
mHit.depth = NGUITools.CalculateRaycastDepth (go);
|
||
|
||
if (mHit.depth != int.MaxValue) {
|
||
mHit.go = go;
|
||
mHit.point = lastWorldPosition;
|
||
mHits.Add (mHit);
|
||
}
|
||
}
|
||
|
||
mHits.Sort (delegate(DepthEntry r1, DepthEntry r2) {
|
||
return r2.depth.CompareTo (r1.depth);
|
||
});
|
||
|
||
for (int b = 0; b < mHits.size; ++b) {
|
||
#if UNITY_FLASH
|
||
if (IsVisible(mHits.buffer[b]))
|
||
#else
|
||
if (IsVisible (ref mHits.buffer [b]))
|
||
#endif
|
||
{
|
||
hoveredObject = mHits [b].go;
|
||
mHits.Clear ();
|
||
return true;
|
||
}
|
||
}
|
||
mHits.Clear ();
|
||
} else if (hits.Length == 1) {
|
||
GameObject go = hits [0].gameObject;
|
||
UIWidget w = go.GetComponent<UIWidget> ();
|
||
|
||
if (w != null) {
|
||
if (!w.isVisible)
|
||
continue;
|
||
if (w.hitCheck != null && !w.hitCheck (lastWorldPosition))
|
||
continue;
|
||
} else {
|
||
UIRect rect = NGUITools.FindInParents<UIRect> (go);
|
||
if (rect != null && rect.finalAlpha < 0.001f)
|
||
continue;
|
||
}
|
||
|
||
if (IsVisible (lastWorldPosition, go)) {
|
||
hoveredObject = go;
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
continue;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
static Plane m2DPlane = new Plane (Vector3.back, 0f);
|
||
|
||
/// <summary>
|
||
/// Helper function to check if the specified hit is visible by the panel.
|
||
/// </summary>
|
||
|
||
static bool IsVisible (Vector3 worldPoint, GameObject go)
|
||
{
|
||
UIPanel panel = NGUITools.FindInParents<UIPanel> (go);
|
||
|
||
while (panel != null) {
|
||
if (!panel.IsVisible (worldPoint))
|
||
return false;
|
||
panel = panel.parentPanel;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Helper function to check if the specified hit is visible by the panel.
|
||
/// </summary>
|
||
|
||
#if UNITY_FLASH
|
||
static bool IsVisible (DepthEntry de)
|
||
#else
|
||
static bool IsVisible (ref DepthEntry de)
|
||
#endif
|
||
{
|
||
UIPanel panel = NGUITools.FindInParents<UIPanel> (de.go);
|
||
|
||
while (panel != null) {
|
||
if (!panel.IsVisible (de.point))
|
||
return false;
|
||
panel = panel.parentPanel;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Whether the specified object should be highlighted.
|
||
/// </summary>
|
||
|
||
static public bool IsHighlighted (GameObject go)
|
||
{
|
||
if (MyMainCamera.currentScheme == MyMainCamera.ControlScheme.Mouse)
|
||
return (MyMainCamera.hoveredObject == go);
|
||
|
||
if (MyMainCamera.currentScheme == MyMainCamera.ControlScheme.Controller)
|
||
return (MyMainCamera.selectedObject == go);
|
||
|
||
return false;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Find the camera responsible for handling events on objects of the specified layer.
|
||
/// </summary>
|
||
|
||
static public MyMainCamera FindCameraForLayer (int layer)
|
||
{
|
||
int layerMask = 1 << layer;
|
||
|
||
for (int i = 0; i < list.size; ++i) {
|
||
MyMainCamera cam = list.buffer [i];
|
||
Camera uc = cam.cachedCamera;
|
||
if ((uc != null) && (uc.cullingMask & layerMask) != 0)
|
||
return cam;
|
||
}
|
||
return null;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Using the keyboard will result in 1 or -1, depending on whether up or down keys have been pressed.
|
||
/// </summary>
|
||
|
||
static int GetDirection (KeyCode up, KeyCode down)
|
||
{
|
||
if (GetKeyDown (up))
|
||
return 1;
|
||
if (GetKeyDown (down))
|
||
return -1;
|
||
return 0;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Using the keyboard will result in 1 or -1, depending on whether up or down keys have been pressed.
|
||
/// </summary>
|
||
|
||
static int GetDirection (KeyCode up0, KeyCode up1, KeyCode down0, KeyCode down1)
|
||
{
|
||
if (GetKeyDown (up0) || GetKeyDown (up1))
|
||
return 1;
|
||
if (GetKeyDown (down0) || GetKeyDown (down1))
|
||
return -1;
|
||
return 0;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Using the joystick to move the UI results in 1 or -1 if the threshold has been passed, mimicking up/down keys.
|
||
/// </summary>
|
||
|
||
static int GetDirection (string axis)
|
||
{
|
||
float time = RealTime.time;
|
||
|
||
if (mNextEvent < time && !string.IsNullOrEmpty (axis)) {
|
||
float val = GetAxis (axis);
|
||
|
||
if (val > 0.75f) {
|
||
mNextEvent = time + 0.25f;
|
||
return 1;
|
||
}
|
||
|
||
if (val < -0.75f) {
|
||
mNextEvent = time + 0.25f;
|
||
return -1;
|
||
}
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
static int mNotifying = 0;
|
||
|
||
/// <summary>
|
||
/// Generic notification function. Used in place of SendMessage to shorten the code and allow for more than one receiver.
|
||
/// </summary>
|
||
|
||
static public void Notify (GameObject go, string funcName, object obj)
|
||
{
|
||
if (mNotifying > 10)
|
||
return;
|
||
|
||
if (NGUITools.GetActive (go)) {
|
||
++mNotifying;
|
||
//NGUIDebug.Log(funcName + "(" + obj + ") on " + (go != null ? go.name : "<null>") + "; " + currentTouchID + ", " + Input.touchCount);
|
||
go.SendMessage (funcName, obj, SendMessageOptions.DontRequireReceiver);
|
||
if (mGenericHandler != null && mGenericHandler != go)
|
||
mGenericHandler.SendMessage (funcName, obj, SendMessageOptions.DontRequireReceiver);
|
||
--mNotifying;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Get the details of the specified mouse button.
|
||
/// </summary>
|
||
|
||
static public MouseOrTouch GetMouse (int button)
|
||
{
|
||
return mMouse [button];
|
||
}
|
||
|
||
/// <summary>
|
||
/// Get or create a touch event. If you are trying to iterate through a list of active touches, use activeTouches instead.
|
||
/// </summary>
|
||
|
||
static public MouseOrTouch GetTouch (int id)
|
||
{
|
||
if (id < 0)
|
||
return GetMouse (-id - 1);
|
||
|
||
for (int i = 0, imax = mTouchIDs.Count; i < imax; ++i)
|
||
if (mTouchIDs [i] == id)
|
||
return activeTouches [i];
|
||
|
||
MouseOrTouch touch = new MouseOrTouch ();
|
||
touch.pressTime = RealTime.time;
|
||
touch.touchBegan = true;
|
||
activeTouches.Add (touch);
|
||
mTouchIDs.Add (id);
|
||
return touch;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Remove a touch event from the list.
|
||
/// </summary>
|
||
|
||
static public void RemoveTouch (int id)
|
||
{
|
||
for (int i = 0, imax = mTouchIDs.Count; i < imax; ++i) {
|
||
if (mTouchIDs [i] == id) {
|
||
mTouchIDs.RemoveAt (i);
|
||
activeTouches.RemoveAt (i);
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Add this camera to the list.
|
||
/// </summary>
|
||
|
||
void Awake ()
|
||
{
|
||
mWidth = Screen.width;
|
||
mHeight = Screen.height;
|
||
|
||
if (Application.platform == RuntimePlatform.Android ||
|
||
Application.platform == RuntimePlatform.IPhonePlayer
|
||
|| Application.platform == RuntimePlatform.WP8Player
|
||
|| Application.platform == RuntimePlatform.BlackBerryPlayer) {
|
||
useTouch = true;
|
||
useMouse = false;
|
||
useKeyboard = false;
|
||
useController = false;
|
||
} else if (Application.platform == RuntimePlatform.PS3 ||
|
||
Application.platform == RuntimePlatform.XBOX360) {
|
||
useMouse = false;
|
||
useTouch = false;
|
||
useKeyboard = false;
|
||
useController = true;
|
||
}
|
||
|
||
// Save the starting mouse position
|
||
mMouse [0].pos = Input.mousePosition;
|
||
|
||
for (int i = 1; i < 3; ++i) {
|
||
mMouse [i].pos = mMouse [0].pos;
|
||
mMouse [i].lastPos = mMouse [0].pos;
|
||
}
|
||
lastTouchPosition = mMouse [0].pos;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Sort the list when enabled.
|
||
/// </summary>
|
||
|
||
void OnEnable ()
|
||
{
|
||
list.Add (this);
|
||
list.Sort (CompareFunc);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Remove this camera from the list.
|
||
/// </summary>
|
||
|
||
void OnDisable ()
|
||
{
|
||
list.Remove (this);
|
||
}
|
||
|
||
/// <summary>
|
||
/// We don't want the camera to send out any kind of mouse events.
|
||
/// </summary>
|
||
|
||
void Start ()
|
||
{
|
||
if (eventType != EventType.World_3D && cachedCamera.transparencySortMode != TransparencySortMode.Orthographic)
|
||
cachedCamera.transparencySortMode = TransparencySortMode.Orthographic;
|
||
|
||
if (Application.isPlaying) {
|
||
// Always set a fallthrough object
|
||
if (fallThrough == null) {
|
||
UIRoot root = NGUITools.FindInParents<UIRoot> (gameObject);
|
||
|
||
if (root != null) {
|
||
fallThrough = root.gameObject;
|
||
} else {
|
||
Transform t = transform;
|
||
fallThrough = (t.parent != null) ? t.parent.gameObject : gameObject;
|
||
}
|
||
}
|
||
cachedCamera.eventMask = 0;
|
||
}
|
||
if (handlesEvents)
|
||
NGUIDebug.debugRaycast = debug;
|
||
}
|
||
|
||
#if UNITY_EDITOR
|
||
void OnValidate ()
|
||
{
|
||
Start ();
|
||
}
|
||
#endif
|
||
|
||
/// <summary>
|
||
/// Check the input and send out appropriate events.
|
||
/// </summary>
|
||
|
||
public void Update ()
|
||
{
|
||
// Only the first UI layer should be processing events
|
||
#if UNITY_EDITOR
|
||
if (!Application.isPlaying || !handlesEvents)
|
||
return;
|
||
#else
|
||
if (!handlesEvents) return;
|
||
#endif
|
||
current = this;
|
||
|
||
// Process touch events first
|
||
if (useTouch)
|
||
ProcessTouches ();
|
||
else if (useMouse)
|
||
ProcessMouse ();
|
||
|
||
// Custom input processing
|
||
if (onCustomInput != null)
|
||
onCustomInput ();
|
||
|
||
// Clear the selection on the cancel key, but only if mouse input is allowed
|
||
if (useMouse && mCurrentSelection != null) {
|
||
if (cancelKey0 != KeyCode.None && GetKeyDown (cancelKey0)) {
|
||
currentScheme = ControlScheme.Controller;
|
||
currentKey = cancelKey0;
|
||
selectedObject = null;
|
||
} else if (cancelKey1 != KeyCode.None && GetKeyDown (cancelKey1)) {
|
||
currentScheme = ControlScheme.Controller;
|
||
currentKey = cancelKey1;
|
||
selectedObject = null;
|
||
}
|
||
}
|
||
|
||
// If nothing is selected, input focus is lost
|
||
if (mCurrentSelection == null) {
|
||
inputHasFocus = false;
|
||
} else if (!mCurrentSelection || !mCurrentSelection.activeInHierarchy) {
|
||
inputHasFocus = false;
|
||
mCurrentSelection = null;
|
||
}
|
||
|
||
// Update the keyboard and joystick events
|
||
if ((useKeyboard || useController) && mCurrentSelection != null)
|
||
ProcessOthers ();
|
||
|
||
// If it's time to show a tooltip, inform the object we're hovering over
|
||
if (useMouse && mHover != null) {
|
||
float scroll = !string.IsNullOrEmpty (scrollAxisName) ? GetAxis (scrollAxisName) : 0f;
|
||
|
||
if (scroll != 0f) {
|
||
if (onScroll != null)
|
||
onScroll (mHover, scroll);
|
||
Notify (mHover, "OnScroll", scroll);
|
||
}
|
||
|
||
if (showTooltips && mTooltipTime != 0f && (mTooltipTime < RealTime.time ||
|
||
GetKey (KeyCode.LeftShift) || GetKey (KeyCode.RightShift))) {
|
||
mTooltip = mHover;
|
||
currentTouch = mMouse [0];
|
||
currentTouchID = -1;
|
||
ShowTooltip (true);
|
||
}
|
||
}
|
||
|
||
current = null;
|
||
currentTouchID = -100;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Keep an eye on screen size changes.
|
||
/// </summary>
|
||
|
||
public void LateUpdate ()
|
||
{
|
||
#if UNITY_EDITOR
|
||
if (!Application.isPlaying || !handlesEvents)
|
||
return;
|
||
#else
|
||
if (!handlesEvents) return;
|
||
#endif
|
||
int w = Screen.width;
|
||
int h = Screen.height;
|
||
|
||
if (w != mWidth || h != mHeight) {
|
||
mWidth = w;
|
||
mHeight = h;
|
||
|
||
UIRoot.Broadcast ("UpdateAnchors");
|
||
|
||
if (onScreenResize != null)
|
||
onScreenResize ();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Update mouse input.
|
||
/// </summary>
|
||
|
||
public void ProcessMouse ()
|
||
{
|
||
// Is any button currently pressed?
|
||
bool isPressed = false;
|
||
bool justPressed = false;
|
||
|
||
for (int i = 0; i < 3; ++i) {
|
||
if (Input.GetMouseButtonDown (i)) {
|
||
currentScheme = ControlScheme.Mouse;
|
||
justPressed = true;
|
||
isPressed = true;
|
||
} else if (Input.GetMouseButton (i)) {
|
||
currentScheme = ControlScheme.Mouse;
|
||
isPressed = true;
|
||
}
|
||
}
|
||
|
||
// We're currently using touches -- do nothing
|
||
if (currentScheme == ControlScheme.Touch)
|
||
return;
|
||
|
||
// Update the position and delta
|
||
Vector2 pos = Input.mousePosition;
|
||
Vector2 delta = pos - mMouse [0].pos;
|
||
float sqrMag = delta.sqrMagnitude;
|
||
bool posChanged = false;
|
||
|
||
if (currentScheme != ControlScheme.Mouse) {
|
||
if (sqrMag < 0.001f)
|
||
return; // Nothing changed and we are not using the mouse -- exit
|
||
currentScheme = ControlScheme.Mouse;
|
||
posChanged = true;
|
||
} else if (sqrMag > 0.001f)
|
||
posChanged = true;
|
||
|
||
lastTouchPosition = pos;
|
||
|
||
// Propagate the updates to the other mouse buttons
|
||
for (int i = 0; i < 3; ++i) {
|
||
mMouse [i].pos = pos;
|
||
mMouse [i].delta = delta;
|
||
}
|
||
|
||
// No need to perform raycasts every frame
|
||
if (isPressed || posChanged || mNextRaycast < RealTime.time) {
|
||
mNextRaycast = RealTime.time + 0.02f;
|
||
if (!Raycast (Input.mousePosition))
|
||
hoveredObject = fallThrough;
|
||
if (hoveredObject == null)
|
||
hoveredObject = mGenericHandler;
|
||
for (int i = 0; i < 3; ++i)
|
||
mMouse [i].current = hoveredObject;
|
||
}
|
||
|
||
bool highlightChanged = (mMouse [0].last != mMouse [0].current);
|
||
if (highlightChanged)
|
||
currentScheme = ControlScheme.Mouse;
|
||
currentTouch = mMouse [0];
|
||
currentTouchID = -1;
|
||
|
||
if (isPressed) {
|
||
// A button was pressed -- cancel the tooltip
|
||
mTooltipTime = 0f;
|
||
} else if (posChanged && (!stickyTooltip || highlightChanged)) {
|
||
if (mTooltipTime != 0f) {
|
||
// Delay the tooltip
|
||
mTooltipTime = RealTime.time + tooltipDelay;
|
||
} else if (mTooltip != null) {
|
||
// Hide the tooltip
|
||
ShowTooltip (false);
|
||
}
|
||
}
|
||
|
||
// Generic mouse move notifications
|
||
if (posChanged && onMouseMove != null) {
|
||
onMouseMove (currentTouch.delta);
|
||
currentTouch = null;
|
||
}
|
||
|
||
// The button was released over a different object -- remove the highlight from the previous
|
||
if ((justPressed || !isPressed) && mHover != null && highlightChanged) {
|
||
if (mTooltip != null)
|
||
ShowTooltip (false);
|
||
if (onHover != null)
|
||
onHover (mHover, false);
|
||
Notify (mHover, "OnHover", false);
|
||
mHover = null;
|
||
}
|
||
|
||
// Process all 3 mouse buttons as individual touches
|
||
for (int i = 0; i < 3; ++i) {
|
||
bool pressed = Input.GetMouseButtonDown (i);
|
||
bool unpressed = Input.GetMouseButtonUp (i);
|
||
if (pressed || unpressed)
|
||
currentScheme = ControlScheme.Mouse;
|
||
currentTouch = mMouse [i];
|
||
|
||
#if UNITY_STANDALONE_OSX || UNITY_EDITOR_OSX
|
||
if (commandClick && i == 0 && (Input.GetKey (KeyCode.LeftControl) || Input.GetKey (KeyCode.RightControl))) {
|
||
currentTouchID = -2;
|
||
currentKey = KeyCode.Mouse1;
|
||
} else
|
||
#endif
|
||
{
|
||
currentTouchID = -1 - i;
|
||
currentKey = KeyCode.Mouse0 + i;
|
||
}
|
||
|
||
// We don't want to update the last camera while there is a touch happening
|
||
if (pressed) {
|
||
currentTouch.pressedCam = currentCamera;
|
||
currentTouch.pressTime = RealTime.time;
|
||
} else if (currentTouch.pressed != null)
|
||
currentCamera = currentTouch.pressedCam;
|
||
|
||
// Process the mouse events
|
||
ProcessTouch (pressed, unpressed);
|
||
currentKey = KeyCode.None;
|
||
}
|
||
|
||
// If nothing is pressed and there is an object under the touch, highlight it
|
||
if (!isPressed && highlightChanged) {
|
||
currentScheme = ControlScheme.Mouse;
|
||
mTooltipTime = RealTime.time + tooltipDelay;
|
||
mHover = mMouse [0].current;
|
||
currentTouch = mMouse [0];
|
||
currentTouchID = -1;
|
||
if (onHover != null)
|
||
onHover (mHover, true);
|
||
Notify (mHover, "OnHover", true);
|
||
}
|
||
currentTouch = null;
|
||
|
||
// Update the last value
|
||
mMouse [0].last = mMouse [0].current;
|
||
for (int i = 1; i < 3; ++i)
|
||
mMouse [i].last = mMouse [0].last;
|
||
}
|
||
|
||
static bool mUsingTouchEvents = true;
|
||
|
||
public class Touch
|
||
{
|
||
public int fingerId;
|
||
public TouchPhase phase = TouchPhase.Began;
|
||
public Vector2 position;
|
||
public int tapCount = 0;
|
||
}
|
||
|
||
public delegate int GetTouchCountCallback ();
|
||
|
||
public delegate Touch GetTouchCallback (int index);
|
||
|
||
static public GetTouchCountCallback GetInputTouchCount;
|
||
static public GetTouchCallback GetInputTouch;
|
||
|
||
/// <summary>
|
||
/// Update touch-based events.
|
||
/// </summary>
|
||
|
||
int oldTouchCount = 0;
|
||
// add by chenbin
|
||
public void ProcessTouches ()
|
||
{
|
||
int count = (GetInputTouchCount == null) ? Input.touchCount : GetInputTouchCount ();
|
||
|
||
for (int i = 0; i < count; ++i) {
|
||
int fingerId;
|
||
TouchPhase phase;
|
||
Vector2 position;
|
||
int tapCount;
|
||
|
||
if (GetInputTouch == null) {
|
||
UnityEngine.Touch touch = Input.GetTouch (i);
|
||
phase = touch.phase;
|
||
fingerId = touch.fingerId;
|
||
position = touch.position;
|
||
tapCount = touch.tapCount;
|
||
} else {
|
||
Touch touch = GetInputTouch (i);
|
||
phase = touch.phase;
|
||
fingerId = touch.fingerId;
|
||
position = touch.position;
|
||
tapCount = touch.tapCount;
|
||
}
|
||
|
||
currentTouchID = allowMultiTouch ? fingerId : 1;
|
||
currentTouch = GetTouch (currentTouchID);
|
||
|
||
bool pressed = (phase == TouchPhase.Began) || currentTouch.touchBegan;
|
||
bool unpressed = (phase == TouchPhase.Canceled) || (phase == TouchPhase.Ended);
|
||
currentTouch.touchBegan = false;
|
||
|
||
// Assume touch-based control
|
||
currentScheme = ControlScheme.Touch;
|
||
|
||
// Although input.deltaPosition can be used, calculating it manually is safer (just in case)
|
||
// currentTouch.delta = pressed ? Vector2.zero : position - currentTouch.pos;
|
||
#region modify by chenbin
|
||
if (Input.touchCount == oldTouchCount) {
|
||
currentTouch.delta = pressed ? Vector2.zero : position - currentTouch.pos;
|
||
} else {
|
||
currentTouch.delta = Vector2.zero;
|
||
}
|
||
#endregion
|
||
currentTouch.pos = position;
|
||
|
||
// Raycast into the screen
|
||
if (!Raycast (currentTouch.pos))
|
||
hoveredObject = fallThrough;
|
||
if (hoveredObject == null)
|
||
hoveredObject = mGenericHandler;
|
||
currentTouch.last = currentTouch.current;
|
||
currentTouch.current = hoveredObject;
|
||
lastTouchPosition = currentTouch.pos;
|
||
|
||
// We don't want to update the last camera while there is a touch happening
|
||
if (pressed)
|
||
currentTouch.pressedCam = currentCamera;
|
||
else if (currentTouch.pressed != null)
|
||
currentCamera = currentTouch.pressedCam;
|
||
|
||
// Double-tap support
|
||
if (tapCount > 1)
|
||
currentTouch.clickTime = RealTime.time;
|
||
|
||
// Process the events from this touch
|
||
ProcessTouch (pressed, unpressed);
|
||
|
||
// If the touch has ended, remove it from the list
|
||
if (unpressed)
|
||
RemoveTouch (currentTouchID);
|
||
|
||
currentTouch.last = null;
|
||
currentTouch = null;
|
||
|
||
// Don't consider other touches
|
||
if (!allowMultiTouch)
|
||
break;
|
||
}
|
||
|
||
if (count == 0) {
|
||
// Skip the first frame after using touch events
|
||
if (mUsingTouchEvents) {
|
||
mUsingTouchEvents = false;
|
||
return;
|
||
}
|
||
|
||
if (useMouse)
|
||
ProcessMouse ();
|
||
#if UNITY_EDITOR
|
||
else if (GetInputTouch == null)
|
||
ProcessFakeTouches ();
|
||
#endif
|
||
} else
|
||
mUsingTouchEvents = true;
|
||
|
||
oldTouchCount = count; // add by chenbin
|
||
}
|
||
|
||
/// <summary>
|
||
/// Process fake touch events where the mouse acts as a touch device.
|
||
/// Useful for testing mobile functionality in the editor.
|
||
/// </summary>
|
||
|
||
void ProcessFakeTouches ()
|
||
{
|
||
bool pressed = Input.GetMouseButtonDown (0);
|
||
bool unpressed = Input.GetMouseButtonUp (0);
|
||
bool held = Input.GetMouseButton (0);
|
||
|
||
if (pressed || unpressed || held) {
|
||
currentTouchID = 1;
|
||
currentTouch = mMouse [0];
|
||
currentTouch.touchBegan = pressed;
|
||
if (pressed)
|
||
currentTouch.pressTime = RealTime.time;
|
||
|
||
Vector2 pos = Input.mousePosition;
|
||
currentTouch.delta = pressed ? Vector2.zero : pos - currentTouch.pos;
|
||
currentTouch.pos = pos;
|
||
|
||
// Raycast into the screen
|
||
if (!Raycast (currentTouch.pos))
|
||
hoveredObject = fallThrough;
|
||
if (hoveredObject == null)
|
||
hoveredObject = mGenericHandler;
|
||
currentTouch.last = currentTouch.current;
|
||
currentTouch.current = hoveredObject;
|
||
lastTouchPosition = currentTouch.pos;
|
||
|
||
// We don't want to update the last camera while there is a touch happening
|
||
if (pressed)
|
||
currentTouch.pressedCam = currentCamera;
|
||
else if (currentTouch.pressed != null)
|
||
currentCamera = currentTouch.pressedCam;
|
||
|
||
// Process the events from this touch
|
||
ProcessTouch (pressed, unpressed);
|
||
|
||
// If the touch has ended, remove it from the list
|
||
if (unpressed)
|
||
RemoveTouch (currentTouchID);
|
||
currentTouch.last = null;
|
||
currentTouch = null;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Process keyboard and joystick events.
|
||
/// </summary>
|
||
|
||
public void ProcessOthers ()
|
||
{
|
||
currentTouchID = -100;
|
||
currentTouch = controller;
|
||
|
||
bool submitKeyDown = false;
|
||
bool submitKeyUp = false;
|
||
|
||
if (submitKey0 != KeyCode.None && GetKeyDown (submitKey0)) {
|
||
currentKey = submitKey0;
|
||
submitKeyDown = true;
|
||
}
|
||
|
||
if (submitKey1 != KeyCode.None && GetKeyDown (submitKey1)) {
|
||
currentKey = submitKey1;
|
||
submitKeyDown = true;
|
||
}
|
||
|
||
if (submitKey0 != KeyCode.None && GetKeyUp (submitKey0)) {
|
||
currentKey = submitKey0;
|
||
submitKeyUp = true;
|
||
}
|
||
|
||
if (submitKey1 != KeyCode.None && GetKeyUp (submitKey1)) {
|
||
currentKey = submitKey1;
|
||
submitKeyUp = true;
|
||
}
|
||
|
||
if (submitKeyDown)
|
||
currentTouch.pressTime = RealTime.time;
|
||
|
||
if (submitKeyDown || submitKeyUp) {
|
||
currentScheme = ControlScheme.Controller;
|
||
currentTouch.last = currentTouch.current;
|
||
currentTouch.current = mCurrentSelection;
|
||
ProcessTouch (submitKeyDown, submitKeyUp);
|
||
currentTouch.last = null;
|
||
}
|
||
|
||
int vertical = 0;
|
||
int horizontal = 0;
|
||
|
||
if (useKeyboard) {
|
||
if (inputHasFocus) {
|
||
vertical += GetDirection (KeyCode.UpArrow, KeyCode.DownArrow);
|
||
horizontal += GetDirection (KeyCode.RightArrow, KeyCode.LeftArrow);
|
||
} else {
|
||
vertical += GetDirection (KeyCode.W, KeyCode.UpArrow, KeyCode.S, KeyCode.DownArrow);
|
||
horizontal += GetDirection (KeyCode.D, KeyCode.RightArrow, KeyCode.A, KeyCode.LeftArrow);
|
||
}
|
||
}
|
||
|
||
if (useController) {
|
||
if (!string.IsNullOrEmpty (verticalAxisName))
|
||
vertical += GetDirection (verticalAxisName);
|
||
if (!string.IsNullOrEmpty (horizontalAxisName))
|
||
horizontal += GetDirection (horizontalAxisName);
|
||
}
|
||
|
||
// Send out key notifications
|
||
if (vertical != 0) {
|
||
currentScheme = ControlScheme.Controller;
|
||
KeyCode key = vertical > 0 ? KeyCode.UpArrow : KeyCode.DownArrow;
|
||
if (onKey != null)
|
||
onKey (mCurrentSelection, key);
|
||
Notify (mCurrentSelection, "OnKey", key);
|
||
}
|
||
|
||
if (horizontal != 0) {
|
||
currentScheme = ControlScheme.Controller;
|
||
KeyCode key = horizontal > 0 ? KeyCode.RightArrow : KeyCode.LeftArrow;
|
||
if (onKey != null)
|
||
onKey (mCurrentSelection, key);
|
||
Notify (mCurrentSelection, "OnKey", key);
|
||
}
|
||
|
||
if (useKeyboard && GetKeyDown (KeyCode.Tab)) {
|
||
currentKey = KeyCode.Tab;
|
||
currentScheme = ControlScheme.Controller;
|
||
if (onKey != null)
|
||
onKey (mCurrentSelection, KeyCode.Tab);
|
||
Notify (mCurrentSelection, "OnKey", KeyCode.Tab);
|
||
}
|
||
|
||
// Send out the cancel key notification
|
||
if (cancelKey0 != KeyCode.None && GetKeyDown (cancelKey0)) {
|
||
currentKey = cancelKey0;
|
||
currentScheme = ControlScheme.Controller;
|
||
if (onKey != null)
|
||
onKey (mCurrentSelection, KeyCode.Escape);
|
||
Notify (mCurrentSelection, "OnKey", KeyCode.Escape);
|
||
}
|
||
|
||
if (cancelKey1 != KeyCode.None && GetKeyDown (cancelKey1)) {
|
||
currentKey = cancelKey1;
|
||
currentScheme = ControlScheme.Controller;
|
||
if (onKey != null)
|
||
onKey (mCurrentSelection, KeyCode.Escape);
|
||
Notify (mCurrentSelection, "OnKey", KeyCode.Escape);
|
||
}
|
||
|
||
currentTouch = null;
|
||
currentKey = KeyCode.None;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Process the press part of a touch.
|
||
/// </summary>
|
||
|
||
void ProcessPress (bool pressed, float click, float drag)
|
||
{
|
||
// Send out the press message
|
||
if (pressed) {
|
||
if (mTooltip != null)
|
||
ShowTooltip (false);
|
||
currentTouch.pressStarted = true;
|
||
if (onPress != null && currentTouch.pressed)
|
||
onPress (currentTouch.pressed, false);
|
||
|
||
Notify (currentTouch.pressed, "OnPress", false);
|
||
|
||
currentTouch.pressed = currentTouch.current;
|
||
currentTouch.dragged = currentTouch.current;
|
||
currentTouch.clickNotification = ClickNotification.BasedOnDelta;
|
||
currentTouch.totalDelta = Vector2.zero;
|
||
currentTouch.dragStarted = false;
|
||
|
||
if (onPress != null && currentTouch.pressed)
|
||
onPress (currentTouch.pressed, true);
|
||
|
||
Notify (currentTouch.pressed, "OnPress", true);
|
||
|
||
if (mTooltip != null)
|
||
ShowTooltip (false);
|
||
selectedObject = currentTouch.pressed;
|
||
} else if (currentTouch.pressed != null && (currentTouch.delta.sqrMagnitude != 0f || currentTouch.current != currentTouch.last)) {
|
||
// Keep track of the total movement
|
||
currentTouch.totalDelta += currentTouch.delta;
|
||
float mag = currentTouch.totalDelta.sqrMagnitude;
|
||
bool justStarted = false;
|
||
|
||
// If the drag process hasn't started yet but we've already moved off the object, start it immediately
|
||
if (!currentTouch.dragStarted && currentTouch.last != currentTouch.current) {
|
||
currentTouch.dragStarted = true;
|
||
currentTouch.delta = currentTouch.totalDelta;
|
||
|
||
// OnDragOver is sent for consistency, so that OnDragOut is always preceded by OnDragOver
|
||
isDragging = true;
|
||
|
||
if (onDragStart != null)
|
||
onDragStart (currentTouch.dragged);
|
||
Notify (currentTouch.dragged, "OnDragStart", null);
|
||
|
||
if (onDragOver != null)
|
||
onDragOver (currentTouch.last, currentTouch.dragged);
|
||
Notify (currentTouch.last, "OnDragOver", currentTouch.dragged);
|
||
|
||
isDragging = false;
|
||
} else if (!currentTouch.dragStarted && drag < mag) {
|
||
// If the drag event has not yet started, see if we've dragged the touch far enough to start it
|
||
justStarted = true;
|
||
currentTouch.dragStarted = true;
|
||
currentTouch.delta = currentTouch.totalDelta;
|
||
}
|
||
|
||
// If we're dragging the touch, send out drag events
|
||
if (currentTouch.dragStarted) {
|
||
if (mTooltip != null)
|
||
ShowTooltip (false);
|
||
|
||
isDragging = true;
|
||
bool isDisabled = (currentTouch.clickNotification == ClickNotification.None);
|
||
|
||
if (justStarted) {
|
||
if (onDragStart != null)
|
||
onDragStart (currentTouch.dragged);
|
||
Notify (currentTouch.dragged, "OnDragStart", null);
|
||
|
||
if (onDragOver != null)
|
||
onDragOver (currentTouch.last, currentTouch.dragged);
|
||
Notify (currentTouch.current, "OnDragOver", currentTouch.dragged);
|
||
} else if (currentTouch.last != currentTouch.current) {
|
||
if (onDragStart != null)
|
||
onDragStart (currentTouch.dragged);
|
||
Notify (currentTouch.last, "OnDragOut", currentTouch.dragged);
|
||
|
||
if (onDragOver != null)
|
||
onDragOver (currentTouch.last, currentTouch.dragged);
|
||
Notify (currentTouch.current, "OnDragOver", currentTouch.dragged);
|
||
}
|
||
|
||
if (onDrag != null)
|
||
onDrag (currentTouch.dragged, currentTouch.delta);
|
||
Notify (currentTouch.dragged, "OnDrag", currentTouch.delta);
|
||
|
||
currentTouch.last = currentTouch.current;
|
||
isDragging = false;
|
||
|
||
if (isDisabled) {
|
||
// If the notification status has already been disabled, keep it as such
|
||
currentTouch.clickNotification = ClickNotification.None;
|
||
} else if (currentTouch.clickNotification == ClickNotification.BasedOnDelta && click < mag) {
|
||
// We've dragged far enough to cancel the click
|
||
currentTouch.clickNotification = ClickNotification.None;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Process the release part of a touch.
|
||
/// </summary>
|
||
#region add by chenbin
|
||
public float dragThreshold {
|
||
get {
|
||
bool isMouse = (currentScheme == ControlScheme.Mouse);
|
||
float drag = isMouse ? mouseDragThreshold : touchDragThreshold;
|
||
return drag;
|
||
}
|
||
}
|
||
|
||
public void ProcessRelease ()
|
||
{
|
||
bool isMouse = (currentScheme == ControlScheme.Mouse);
|
||
float drag = isMouse ? mouseDragThreshold : touchDragThreshold;
|
||
// So we can use sqrMagnitude below
|
||
drag *= drag;
|
||
ProcessRelease (isMouse, drag);
|
||
}
|
||
|
||
#endregion
|
||
|
||
void ProcessRelease (bool isMouse, float drag)
|
||
{
|
||
// Send out the unpress message
|
||
if (currentTouch == null)
|
||
return;
|
||
currentTouch.pressStarted = false;
|
||
//if (mTooltip != null) ShowTooltip(false);
|
||
|
||
if (currentTouch.pressed != null) {
|
||
// If there was a drag event in progress, make sure OnDragOut gets sent
|
||
if (currentTouch.dragStarted) {
|
||
if (onDragOut != null)
|
||
onDragOut (currentTouch.last, currentTouch.dragged);
|
||
Notify (currentTouch.last, "OnDragOut", currentTouch.dragged);
|
||
|
||
if (onDragEnd != null)
|
||
onDragEnd (currentTouch.dragged);
|
||
Notify (currentTouch.dragged, "OnDragEnd", null);
|
||
}
|
||
|
||
// Send the notification of a touch ending
|
||
if (onPress != null)
|
||
onPress (currentTouch.pressed, false);
|
||
Notify (currentTouch.pressed, "OnPress", false);
|
||
|
||
// Send a hover message to the object
|
||
if (isMouse) {
|
||
if (onHover != null)
|
||
onHover (currentTouch.current, true);
|
||
Notify (currentTouch.current, "OnHover", true);
|
||
}
|
||
mHover = currentTouch.current;
|
||
|
||
// If the button/touch was released on the same object, consider it a click and select it
|
||
if (currentTouch.dragged == currentTouch.current ||
|
||
(currentScheme != ControlScheme.Controller &&
|
||
currentTouch.clickNotification != ClickNotification.None &&
|
||
currentTouch.totalDelta.sqrMagnitude < drag)) {
|
||
// If the touch should consider clicks, send out an OnClick notification
|
||
if (currentTouch.clickNotification != ClickNotification.None && currentTouch.pressed == currentTouch.current) {
|
||
float time = RealTime.time;
|
||
|
||
if (onClick != null)
|
||
onClick (currentTouch.pressed);
|
||
Notify (currentTouch.pressed, "OnClick", null);
|
||
|
||
if (currentTouch.clickTime + 0.35f > time) {
|
||
if (onDoubleClick != null)
|
||
onDoubleClick (currentTouch.pressed);
|
||
Notify (currentTouch.pressed, "OnDoubleClick", null);
|
||
}
|
||
currentTouch.clickTime = time;
|
||
}
|
||
} else if (currentTouch.dragStarted) { // The button/touch was released on a different object
|
||
// Send a drop notification (for drag & drop)
|
||
if (onDrop != null)
|
||
onDrop (currentTouch.current, currentTouch.dragged);
|
||
Notify (currentTouch.current, "OnDrop", currentTouch.dragged);
|
||
}
|
||
}
|
||
currentTouch.dragStarted = false;
|
||
currentTouch.pressed = null;
|
||
currentTouch.dragged = null;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Process the events of the specified touch.
|
||
/// </summary>
|
||
|
||
public void ProcessTouch (bool pressed, bool released)
|
||
{
|
||
// Whether we're using the mouse
|
||
bool isMouse = (currentScheme == ControlScheme.Mouse);
|
||
float drag = isMouse ? mouseDragThreshold : touchDragThreshold;
|
||
float click = isMouse ? mouseClickThreshold : touchClickThreshold;
|
||
|
||
// So we can use sqrMagnitude below
|
||
drag *= drag;
|
||
click *= click;
|
||
|
||
if (currentTouch.pressed != null) {
|
||
if (released)
|
||
ProcessRelease (isMouse, drag);
|
||
ProcessPress (pressed, click, drag);
|
||
|
||
// Hold event = show tooltip
|
||
if (currentTouch.pressed == currentTouch.current &&
|
||
currentTouch.clickNotification != ClickNotification.None &&
|
||
!currentTouch.dragStarted && currentTouch.deltaTime > tooltipDelay) {
|
||
currentTouch.clickNotification = ClickNotification.None;
|
||
|
||
if (longPressTooltip) {
|
||
mTooltip = currentTouch.pressed;
|
||
ShowTooltip (true);
|
||
}
|
||
Notify (currentTouch.current, "OnLongPress", null);
|
||
}
|
||
} else if (isMouse || pressed || released) {
|
||
ProcessPress (pressed, click, drag);
|
||
if (released)
|
||
ProcessRelease (isMouse, drag);
|
||
}
|
||
|
||
//modify by chenbin
|
||
if (isbeControled && released) {
|
||
enabled = false;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Show or hide the tooltip.
|
||
/// </summary>
|
||
|
||
public void ShowTooltip (bool val)
|
||
{
|
||
mTooltipTime = 0f;
|
||
if (onTooltip != null)
|
||
onTooltip (mTooltip, val);
|
||
Notify (mTooltip, "OnTooltip", val);
|
||
if (!val)
|
||
mTooltip = null;
|
||
}
|
||
}
|
||
}
|