private void ProcessLine(LineSegment line, ref MLInputDevice inputDevice)
{
Vector3?endPoint = null;
Vector3 normal = Vector3.zero;
MLInputDeviceEventData pointerEventData = _cachedTrackedPointerEventData;
if (pointerEventData == null)
{
return;
}
pointerEventData.Reset();
inputDevice.CopyTo(ref pointerEventData);
pointerEventData.pointerCurrentRaycast = PerformRaycast(pointerEventData);
GameObject currentRaycastObject = pointerEventData.pointerCurrentRaycast.gameObject;
// enable cursor for any canvas UI or any game object with an Event Trigger (assuming camera has physics raycaster on it)
if (currentRaycastObject != null &&
(currentRaycastObject.GetComponent <RectTransform>() != null || currentRaycastObject.GetComponent <EventTrigger>() != null))
{
// Relies on TrackedDeviceRaycaster and 3D world position to work with event system
RaycastResult result = pointerEventData.pointerCurrentRaycast;
endPoint = result.worldPosition;
normal = result.worldNormal;
}
inputDevice.CopyFrom(pointerEventData);
inputDevice.OnFrameFinished();
line.Set(inputDevice.Position, endPoint, normal);
}
/// <summary/>
protected override void Start()
{
base.Start();
_headpose = Camera.main;
if (_headpose == null)
{
Debug.LogError("Error: MLInputModule, no camera found tagged as MainCamera, disabling script.");
enabled = false;
return;
}
// Eye Tracking
if (_pointerInput == PointerInputType.EyeTracking)
{
#if PLATFORM_LUMIN
MLResult result = MLEyes.Start();
if (!result.IsOk)
{
Debug.LogErrorFormat("Error: MLInputModule failed starting MLEyes, disabling script. Reason: {0}", result);
enabled = false;
return;
}
#endif
}
#if PLATFORM_LUMIN
// Controllers
if (!MLInput.IsStarted)
{
MLInput.Configuration config = new MLInput.Configuration(true);
MLResult result = MLInput.Start(config);
if (!result.IsOk)
{
Debug.LogErrorFormat("Error: MLInputModule failed starting MLInput, disabling script. Reason: {0}", result);
enabled = false;
return;
}
}
#endif
AddController(0);
AddController(1);
#if PLATFORM_LUMIN
// Track connect / disconnect
MLInput.OnControllerConnected += HandleOnControllerConnected;
MLInput.OnControllerDisconnected += HandleOnControllerDisconnected;
_pointerInputDevice = new MLInputDevice();
_pointerInputDevice.Initialize();
_cachedTrackedPointerEventData = new MLInputDeviceEventData(eventSystem);
#endif
}
/// <summary>
/// Copies input data from input class.
/// </summary>
/// <param name="eventData">Class to copy the data from.</param>
public void CopyFrom(MLInputDeviceEventData eventData)
{
this.internalData.PointerTarget = eventData.pointerEnter;
this.internalData.IsDragging = eventData.dragging;
this.internalData.PressedTime = eventData.clickTime;
this.internalData.PressedPosition = eventData.pressPosition;
this.internalData.PressedRaycast = eventData.pointerPressRaycast;
this.internalData.PressedGameObject = eventData.pointerPress;
this.internalData.PressedGameObjectRaw = eventData.rawPointerPress;
this.internalData.DraggedGameObject = eventData.pointerDrag;
this.internalData.HoverTargets.Clear();
this.internalData.HoverTargets.AddRange(eventData.hovered);
}
/// <summary/>
protected override void Start()
{
base.Start();
if (_mainCanvas == null)
{
Debug.LogError("Error: MLInputModule, _mainCanvas field is empty, disabling script.");
enabled = false;
return;
}
_mainCamera = Camera.main;
if (_mainCamera == null)
{
Debug.LogError("Error: MLInputModule, no camera found tagged as MainCamera, disabling script.");
enabled = false;
return;
}
_mainCanvas.worldCamera = _mainCamera;
SceneManager.activeSceneChanged += ChangedActiveScene;
#if PLATFORM_LUMIN
// Controllers
if (!MLInput.IsStarted)
{
MLInput.Configuration config = new MLInput.Configuration(true);
MLInput.SetConfig(config);
}
#endif
AddController(0);
AddController(1);
#if PLATFORM_LUMIN
// Track connect / disconnect
MLInput.OnControllerConnected += HandleOnControllerConnected;
MLInput.OnControllerDisconnected += HandleOnControllerDisconnected;
_pointerInputDevice = new MLInputDevice();
_pointerInputDevice.Initialize();
_cachedTrackedPointerEventData = new MLInputDeviceEventData(eventSystem);
#endif
}
/// <summary>
/// Copies input data to input class.
/// </summary>
/// <param name="eventData">Class to copy the data to.</param>
public void CopyTo(ref MLInputDeviceEventData eventData)
{
eventData.Ray = new Ray(this.position, this.orientation * Vector3.forward);
eventData.MaxDistance = 1000;
// Demolish the position so we don't trigger any checks from the Graphics Raycaster.
eventData.position = new Vector2(float.MinValue, float.MinValue);
eventData.pointerEnter = this.internalData.PointerTarget;
eventData.dragging = this.internalData.IsDragging;
eventData.clickTime = this.internalData.PressedTime;
eventData.pressPosition = this.internalData.PressedPosition;
eventData.pointerPressRaycast = this.internalData.PressedRaycast;
eventData.pointerPress = this.internalData.PressedGameObject;
eventData.rawPointerPress = this.internalData.PressedGameObjectRaw;
eventData.pointerDrag = this.internalData.DraggedGameObject;
eventData.scrollDelta = this.ScrollDelta;
eventData.hovered.Clear();
eventData.hovered.AddRange(this.internalData.HoverTargets);
}
private void ProcessButton(ButtonDeltaState mouseButtonChanges, ref MLInputDeviceEventData eventData)
{
var currentOverGo = eventData.pointerCurrentRaycast.gameObject;
if (mouseButtonChanges == ButtonDeltaState.Pressed)
{
eventData.eligibleForClick = true;
eventData.delta = Vector2.zero;
eventData.dragging = false;
eventData.pressPosition = eventData.position;
eventData.pointerPressRaycast = eventData.pointerCurrentRaycast;
var selectHandlerGO = ExecuteEvents.GetEventHandler <ISelectHandler>(currentOverGo);
// If we have clicked something new, deselect the old thing
// and leave 'selection handling' up to the press event.
if (selectHandlerGO != eventSystem.currentSelectedGameObject)
{
eventSystem.SetSelectedGameObject(null, eventData);
}
// search for the control that will receive the press.
// if we can't find a press handler set the press
// handler to be what would receive a click.
var newPressed = ExecuteEvents.ExecuteHierarchy(currentOverGo, eventData, ExecuteEvents.pointerDownHandler);
// We didn't find a press handler, so we search for a click handler.
if (newPressed == null)
{
newPressed = ExecuteEvents.GetEventHandler <IPointerClickHandler>(currentOverGo);
}
var time = Time.unscaledTime;
if (newPressed == eventData.lastPress && ((time - eventData.clickTime) < _triggerClickSpeed))
{
++eventData.clickCount;
}
else
{
eventData.clickCount = 1;
}
eventData.clickTime = time;
eventData.pointerPress = newPressed;
eventData.rawPointerPress = currentOverGo;
// Save the drag handler for drag events during this mouse down.
eventData.pointerDrag = ExecuteEvents.GetEventHandler <IDragHandler>(currentOverGo);
if (eventData.pointerDrag != null)
{
ExecuteEvents.Execute(eventData.pointerDrag, eventData, ExecuteEvents.initializePotentialDrag);
}
}
else if (mouseButtonChanges == ButtonDeltaState.Released)
{
ExecuteEvents.Execute(eventData.pointerPress, eventData, ExecuteEvents.pointerUpHandler);
var pointerUpHandler = ExecuteEvents.GetEventHandler <IPointerClickHandler>(currentOverGo);
if (eventData.pointerPress == pointerUpHandler && eventData.eligibleForClick)
{
ExecuteEvents.Execute(eventData.pointerPress, eventData, ExecuteEvents.pointerClickHandler);
}
else if (eventData.dragging && eventData.pointerDrag != null)
{
ExecuteEvents.ExecuteHierarchy(currentOverGo, eventData, ExecuteEvents.dropHandler);
ExecuteEvents.Execute(eventData.pointerDrag, eventData, ExecuteEvents.endDragHandler);
}
eventData.eligibleForClick = eventData.dragging = false;
eventData.pointerPress = eventData.rawPointerPress = eventData.pointerDrag = null;
}
}
private void PerformRaycast(MLInputDeviceEventData eventData, List <RaycastResult> resultAppendList)
{
if (Canvas == null)
{
return;
}
var ray = eventData.Ray;
Debug.DrawRay(ray.origin, ray.direction, Color.red);
var hitDistance = eventData.MaxDistance;
if (BlockingObjects == GraphicRaycaster.BlockingObjects.All || BlockingObjects == GraphicRaycaster.BlockingObjects.ThreeD)
{
var hits = Physics.RaycastAll(ray, hitDistance, _blockingMask);
if (hits.Length > 0 && hits[0].distance < hitDistance)
{
hitDistance = hits[0].distance;
}
}
if (BlockingObjects == GraphicRaycaster.BlockingObjects.All || BlockingObjects == GraphicRaycaster.BlockingObjects.TwoD)
{
var raycastDistance = hitDistance;
var hits = Physics2D.GetRayIntersectionAll(ray, raycastDistance, _blockingMask);
if (hits.Length > 0 && hits[0].fraction * raycastDistance < hitDistance)
{
hitDistance = hits[0].fraction * raycastDistance;
}
}
_raycastResultsCache.Clear();
SortedRaycastGraphics(Canvas, ray, _raycastResultsCache);
// Now that we have a list of sorted hits, process any extra settings and filters.
for (var i = 0; i < _raycastResultsCache.Count; i++)
{
var validHit = true;
var hitData = _raycastResultsCache[i];
var go = hitData.Graphic.gameObject;
if (IgnoreReversedGraphics)
{
var forward = ray.direction;
var goDirection = go.transform.rotation * Vector3.forward;
validHit = Vector3.Dot(forward, goDirection) > 0;
}
validHit &= hitData.Distance < hitDistance;
if (validHit)
{
var castResult = new RaycastResult
{
gameObject = go,
module = this,
distance = hitData.Distance,
index = resultAppendList.Count,
depth = hitData.Graphic.depth,
worldNormal = hitData.WorldHitNormal,
worldPosition = hitData.WorldHitPosition
};
resultAppendList.Add(castResult);
}
}
}
