private void UpdateButtonDataNearTouch(MixedRealityInteractionMapping interactionMapping)
{
Debug.Assert(interactionMapping.AxisType == AxisType.Digital);
OculusApi.RawNearTouch interactionButton = OculusApi.RawNearTouch.None;
OculusInteractionMapping.TryParseRawNearTouch(interactionMapping, out interactionButton);
//Enum.TryParse<OculusApi.RawNearTouch>(interactionMapping.InputName, out interactionButton);
if (interactionButton != OculusApi.RawNearTouch.None)
{
if (((OculusApi.RawNearTouch)previousState.NearTouches & interactionButton) != 0)
{
interactionMapping.BoolData = false;
}
if ((((OculusApi.RawNearTouch)currentState.NearTouches & interactionButton) != 0) &&
(((OculusApi.RawNearTouch)previousState.NearTouches & interactionButton) == 0))
{
interactionMapping.BoolData = true;
}
//interactionMapping.UpdateInteractionMappingBool(InputSource, ControllerHandedness);
//if (interactionMapping.Changed)
//{
// if (interactionMapping.BoolData)
// {
// InputSystem?.RaiseOnInputDown(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
// }
// else
// {
// InputSystem?.RaiseOnInputUp(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
// }
//}
}
}
private void UpdateButtonData(MixedRealityInteractionMapping interactionMapping)
{
Debug.Assert(interactionMapping.AxisType == AxisType.Digital);
var isHomeButton = interactionMapping.Description.Contains("Home");
// Update the interaction data source
if (!isHomeButton)
{
interactionMapping.BoolData = MlControllerReference.State.ButtonState[(int)MLInputControllerButton.Bumper] > 0;
}
else
{
interactionMapping.BoolData = IsHomePressed;
IsHomePressed = false;
}
// If our value changed raise it.
if (interactionMapping.Changed)
{
// Raise input system Event if it enabled
if (interactionMapping.BoolData)
{
MixedRealityToolkit.InputSystem?.RaiseOnInputDown(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
else
{
MixedRealityToolkit.InputSystem?.RaiseOnInputUp(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
}
if (interactionMapping.Updated)
{
MixedRealityToolkit.InputSystem?.RaiseOnInputPressed(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
}
internal void UpdateVoiceState(bool isPressed)
{
MixedRealityInteractionMapping interactionMapping = null;
for (int i = 0; i < Interactions?.Length; i++)
{
MixedRealityInteractionMapping currentInteractionMapping = Interactions[i];
if (currentInteractionMapping.AxisType == AxisType.Digital && currentInteractionMapping.InputType == DeviceInputType.Select)
{
interactionMapping = currentInteractionMapping;
break;
}
}
if (interactionMapping == null)
{
return;
}
interactionMapping.BoolData = isPressed;
// If our value changed raise it.
if (interactionMapping.Changed)
{
// Raise input system event if it's enabled
if (interactionMapping.BoolData)
{
CoreServices.InputSystem?.RaiseOnInputDown(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
else
{
CoreServices.InputSystem?.RaiseOnInputUp(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
}
}
/// <summary>
/// Update the spatial grip input from the device.
/// </summary>
/// <param name="interactionSourceState">The InteractionSourceState retrieved from the platform.</param>
private void UpdateGripData(InteractionSourceState interactionSourceState, MixedRealityInteractionMapping interactionMapping)
{
switch (interactionMapping.AxisType)
{
case AxisType.SixDof:
{
// The data queried in UpdateSourceData is the grip pose.
// Reuse that data to save two method calls and transforms.
currentGripPose.Position = currentSourcePosition;
currentGripPose.Rotation = currentSourceRotation;
// Update the interaction data source
interactionMapping.PoseData = currentGripPose;
// If our value changed raise it.
if (interactionMapping.Changed)
{
// Raise input system Event if it enabled
InputSystem?.RaisePoseInputChanged(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction, currentGripPose);
}
}
break;
}
}
/// <summary>
/// Update Spatial Pointer Data.
/// </summary>
/// <param name="interactionMapping"></param>
protected void UpdatePoseData(MixedRealityInteractionMapping interactionMapping)
{
Debug.Assert(interactionMapping.AxisType == AxisType.SixDof);
switch (interactionMapping.InputType)
{
case DeviceInputType.SpatialPointer:
pointerOffsetPose.Position = CurrentControllerPose.Position;
pointerOffsetPose.Rotation = CurrentControllerPose.Rotation * Quaternion.AngleAxis(PointerOffsetAngle, Vector3.left);
// Update the interaction data source
interactionMapping.PoseData = pointerOffsetPose;
break;
case DeviceInputType.SpatialGrip:
// Update the interaction data source
interactionMapping.PoseData = CurrentControllerPose;
break;
default:
Debug.LogWarning($"Unhandled Interaction {interactionMapping.Description}");
break;
}
}
/// <inheritdoc />
protected override void UpdateButtonData(MixedRealityInteractionMapping interactionMapping, InputDevice inputDevice)
{
using (UpdateButtonDataPerfMarker.Auto())
{
Debug.Assert(interactionMapping.AxisType == AxisType.Digital);
// Update the interaction data source
switch (interactionMapping.InputType)
{
case DeviceInputType.Select:
if (inputDevice.TryGetFeatureValue(CommonUsages.primaryButton, out bool buttonPressed))
{
interactionMapping.BoolData = buttonPressed;
}
break;
default:
base.UpdateButtonData(interactionMapping, inputDevice);
return;
}
// If our value changed raise it.
if (interactionMapping.Changed)
{
// Raise input system event if it's enabled
if (interactionMapping.BoolData)
{
CoreServices.InputSystem?.RaiseOnInputDown(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
else
{
CoreServices.InputSystem?.RaiseOnInputUp(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
}
}
}
/// <summary>
/// Update spatial pointer and spatial grip data.
/// </summary>
protected override void UpdatePoseData(MixedRealityInteractionMapping interactionMapping, InputDevice inputDevice)
{
using (UpdatePoseDataPerfMarker.Auto())
{
Debug.Assert(interactionMapping.AxisType == AxisType.SixDof);
// Update the interaction data source
switch (interactionMapping.InputType)
{
case DeviceInputType.SpatialPointer:
if (inputDevice.TryGetFeatureValue(CustomUsages.PointerPosition, out currentPointerPosition))
{
currentPointerPose.Position = MixedRealityPlayspace.TransformPoint(currentPointerPosition);
}
if (inputDevice.TryGetFeatureValue(CustomUsages.PointerRotation, out currentPointerRotation))
{
currentPointerPose.Rotation = MixedRealityPlayspace.Rotation * currentPointerRotation;
}
interactionMapping.PoseData = currentPointerPose;
// If our value changed raise it.
if (interactionMapping.Changed)
{
// Raise input system event if it's enabled
CoreServices.InputSystem?.RaisePoseInputChanged(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction, interactionMapping.PoseData);
}
break;
default:
base.UpdatePoseData(interactionMapping, inputDevice);
break;
}
}
}
/// <inheritdoc />
protected override void UpdateSingleAxisData(MixedRealityInteractionMapping interactionMapping, InputDevice inputDevice)
{
using (UpdateSingleAxisDataPerfMarker.Auto())
{
Debug.Assert(interactionMapping.AxisType == AxisType.SingleAxis);
// Update the interaction data source
switch (interactionMapping.InputType)
{
case DeviceInputType.TriggerPress:
case DeviceInputType.GripPress:
if (inputDevice.TryGetFeatureValue(CommonUsages.grip, out float gripAmount))
{
interactionMapping.BoolData = Mathf.Approximately(gripAmount, 1.0f);
}
break;
default:
base.UpdateSingleAxisData(interactionMapping, inputDevice);
return;
}
// If our value changed raise it.
if (interactionMapping.Changed)
{
// Raise bool input system event if it's available
if (interactionMapping.BoolData)
{
CoreServices.InputSystem?.RaiseOnInputDown(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
else
{
CoreServices.InputSystem?.RaiseOnInputUp(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
}
}
}
/// <summary>
/// Update an interaction float data type from a SingleAxis (float) input
/// </summary>
/// <remarks>
/// Raises a FloatInputChanged event when the float data changes
/// </remarks>
internal virtual void UpdateSingleAxisData(MixedRealityInteractionMapping interactionMapping, MotionControllerState controllerState)
{
using (UpdateSingleAxisDataPerfMarker.Auto())
{
Debug.Assert(interactionMapping.AxisType == AxisType.SingleAxis);
// First handle updating the bool values, since those events are only raised once the trigger/gripped is presssed
switch (interactionMapping.InputType)
{
case DeviceInputType.TriggerPress:
var triggerData = controllerState.CurrentReading.GetPressedValue(ControllerInput.Trigger);
interactionMapping.BoolData = triggerData.Equals(1);
break;
case DeviceInputType.GripPress:
var gripData = controllerState.CurrentReading.GetPressedValue(ControllerInput.Grasp);
interactionMapping.BoolData = gripData.Equals(1);
break;
default:
break;
}
// If our value changed raise it.
if (interactionMapping.Changed)
{
// Raise bool input system event if it's available
if (interactionMapping.BoolData)
{
CoreServices.InputSystem?.RaiseOnInputDown(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
else
{
CoreServices.InputSystem?.RaiseOnInputUp(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
}
// Next handle updating the float values
switch (interactionMapping.InputType)
{
case DeviceInputType.Trigger:
var triggerData = controllerState.CurrentReading.GetPressedValue(ControllerInput.Trigger);
interactionMapping.FloatData = triggerData;
break;
case DeviceInputType.Grip:
var gripData = controllerState.CurrentReading.GetPressedValue(ControllerInput.Grasp);
interactionMapping.FloatData = gripData;
break;
default:
return;
}
// If our value changed raise it.
if (interactionMapping.Changed)
{
// Raise float input system event if it's enabled
CoreServices.InputSystem?.RaiseFloatInputChanged(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction, interactionMapping.FloatData);
}
}
}
/// <summary>
/// Update an interaction bool data type from a bool input
/// </summary>
/// <remarks>
/// Raises an Input System "Input Down" event when the key is down, and raises an "Input Up" when it is released (e.g. a Button)
/// </remarks>
internal virtual void UpdateButtonData(MixedRealityInteractionMapping interactionMapping, MotionControllerState controllerState)
{
using (UpdateButtonDataPerfMarker.Auto())
{
// Handedness must be left or right in order to differentiate between buttons for the left and right hand.
MotionControllerHandedness controllerHandedness = controllerState.MotionController.Handedness;
Debug.Assert(controllerHandedness != MotionControllerHandedness.Unknown);
Debug.Assert(interactionMapping.AxisType == AxisType.Digital);
if (interactionMapping.InputType == DeviceInputType.TriggerTouch)
{
var triggerData = controllerState.CurrentReading.GetPressedValue(ControllerInput.Trigger);
interactionMapping.BoolData = !Mathf.Approximately(triggerData, 0.0f);
}
else if (interactionMapping.InputType == DeviceInputType.GripTouch)
{
var gripData = controllerState.CurrentReading.GetPressedValue(ControllerInput.Grasp);
interactionMapping.BoolData = !Mathf.Approximately(gripData, 0.0f);
}
else
{
ControllerInput button;
// Update the interaction data source
// Interactions handled mirror the GenericXRSDKController to maintain parity. ThumbstickTouch and Touchpad are left out
// due to having no ControllerInput equivalents
switch (interactionMapping.InputType)
{
case DeviceInputType.Select:
case DeviceInputType.TriggerNearTouch:
case DeviceInputType.TriggerPress:
button = ControllerInput.Trigger;
break;
case DeviceInputType.GripNearTouch:
case DeviceInputType.GripPress:
button = ControllerInput.Grasp;
break;
case DeviceInputType.ButtonPress:
case DeviceInputType.PrimaryButtonPress:
button = controllerHandedness == MotionControllerHandedness.Left ? ControllerInput.X_Button : ControllerInput.A_Button;
break;
case DeviceInputType.SecondaryButtonPress:
button = controllerHandedness == MotionControllerHandedness.Left ? ControllerInput.Y_Button : ControllerInput.B_Button;
break;
case DeviceInputType.Menu:
button = ControllerInput.Menu;
break;
case DeviceInputType.ThumbStickPress:
button = ControllerInput.Thumbstick;
break;
default:
return;
}
var buttonData = controllerState.CurrentReading.GetPressedValue(button);
interactionMapping.BoolData = Mathf.Approximately(buttonData, 1.0f);
}
// If our value changed raise it.
if (interactionMapping.Changed)
{
// Raise input system event if it's enabled
if (interactionMapping.BoolData)
{
CoreServices.InputSystem?.RaiseOnInputDown(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
else
{
CoreServices.InputSystem?.RaiseOnInputUp(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
}
}
}
/// <summary>
/// Update the Trigger input from the device
/// </summary>
/// <param name="interactionSourceState">The InteractionSourceState retrieved from the platform</param>
/// <param name="interactionMapping"></param>
private void UpdateTriggerData(InteractionSourceState interactionSourceState, MixedRealityInteractionMapping interactionMapping)
{
switch (interactionMapping.InputType)
{
case DeviceInputType.TriggerPress:
//Update the interaction data source
interactionMapping.BoolData = interactionSourceState.grasped;
// If our value changed raise it.
if (interactionMapping.Changed)
{
// Raise input system Event if it enabled
if (interactionSourceState.grasped)
{
MixedRealityToolkit.InputSystem?.RaiseOnInputDown(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
else
{
MixedRealityToolkit.InputSystem?.RaiseOnInputUp(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
}
break;
case DeviceInputType.Select:
{
// Update the interaction data source
interactionMapping.BoolData = interactionSourceState.selectPressed;
// If our value changed raise it.
if (interactionMapping.Changed)
{
// Raise input system Event if it enabled
if (interactionSourceState.selectPressed)
{
MixedRealityToolkit.InputSystem?.RaiseOnInputDown(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
else
{
MixedRealityToolkit.InputSystem?.RaiseOnInputUp(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
}
break;
}
case DeviceInputType.Trigger:
{
// Update the interaction data source
interactionMapping.FloatData = interactionSourceState.selectPressedAmount;
// If our value changed raise it.
if (interactionMapping.Changed)
{
// Raise input system Event if it enabled
MixedRealityToolkit.InputSystem?.RaiseOnInputPressed(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction, interactionSourceState.selectPressedAmount);
}
break;
}
case DeviceInputType.TriggerTouch:
{
// Update the interaction data source
interactionMapping.BoolData = interactionSourceState.selectPressedAmount > 0;
// If our value changed raise it.
if (interactionMapping.Changed)
{
// Raise input system Event if it enabled
if (interactionSourceState.selectPressedAmount > 0)
{
MixedRealityToolkit.InputSystem?.RaiseOnInputDown(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
else
{
MixedRealityToolkit.InputSystem?.RaiseOnInputUp(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
}
break;
}
}
}
/// <summary>
/// Update the touchpad input from the device.
/// </summary>
/// <param name="interactionSourceState">The InteractionSourceState retrieved from the platform.</param>
private void UpdateTouchpadData(InteractionSourceState interactionSourceState, MixedRealityInteractionMapping interactionMapping)
{
using (UpdateTouchpadDataPerfMarker.Auto())
{
switch (interactionMapping.InputType)
{
case DeviceInputType.TouchpadTouch:
{
// Update the interaction data source
interactionMapping.BoolData = interactionSourceState.touchpadTouched;
// If our value changed raise it.
if (interactionMapping.Changed)
{
// Raise input system event if it's enabled
if (interactionSourceState.touchpadTouched)
{
CoreServices.InputSystem?.RaiseOnInputDown(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
else
{
CoreServices.InputSystem?.RaiseOnInputUp(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
}
break;
}
case DeviceInputType.TouchpadPress:
{
// Update the interaction data source
interactionMapping.BoolData = interactionSourceState.touchpadPressed;
// If our value changed raise it.
if (interactionMapping.Changed)
{
// Raise input system event if it's enabled
if (interactionSourceState.touchpadPressed)
{
CoreServices.InputSystem?.RaiseOnInputDown(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
else
{
CoreServices.InputSystem?.RaiseOnInputUp(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
}
break;
}
case DeviceInputType.Touchpad:
{
// Update the interaction data source
interactionMapping.Vector2Data = interactionSourceState.touchpadPosition;
// If our value changed raise it.
if (interactionMapping.Changed)
{
// Raise input system event if it's enabled
CoreServices.InputSystem?.RaisePositionInputChanged(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction, interactionSourceState.touchpadPosition);
}
break;
}
}
}
}
/// <summary>
/// Update the Touchpad input from the device
/// </summary>
/// <param name="interactionSourceState">The InteractionSourceState retrieved from the platform</param>
/// <param name="interactionMapping"></param>
private void UpdateTouchPadData(InteractionSourceState interactionSourceState, MixedRealityInteractionMapping interactionMapping)
{
switch (interactionMapping.InputType)
{
case DeviceInputType.TouchpadTouch:
{
// Update the interaction data source
interactionMapping.BoolData = interactionSourceState.touchpadTouched;
// If our value changed raise it.
if (interactionMapping.Changed)
{
// Raise input system Event if it enabled
if (interactionSourceState.touchpadTouched)
{
MixedRealityToolkit.InputSystem?.RaiseOnInputDown(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
else
{
MixedRealityToolkit.InputSystem?.RaiseOnInputUp(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
}
// If our value was updated, raise it.
if (interactionMapping.Updated)
{
MixedRealityToolkit.InputSystem?.RaiseOnInputPressed(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
break;
}
case DeviceInputType.TouchpadPress:
{
//Update the interaction data source
interactionMapping.BoolData = interactionSourceState.touchpadPressed;
// If our value changed raise it.
if (interactionMapping.Changed)
{
// Raise input system Event if it enabled
if (interactionSourceState.touchpadPressed)
{
MixedRealityToolkit.InputSystem?.RaiseOnInputDown(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
else
{
MixedRealityToolkit.InputSystem?.RaiseOnInputUp(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
}
// If our value was updated, raise it.
if (interactionMapping.Updated)
{
MixedRealityToolkit.InputSystem?.RaiseOnInputPressed(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
break;
}
case DeviceInputType.Touchpad:
{
// Update the interaction data source
interactionMapping.Vector2Data = interactionSourceState.touchpadPosition;
// If our value was updated, raise it.
if (interactionMapping.Updated)
{
// Raise input system Event if it enabled
MixedRealityToolkit.InputSystem?.RaisePositionInputChanged(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction, interactionSourceState.touchpadPosition);
}
break;
}
}
}
/// <summary>
/// Update the thumbstick input from the device.
/// </summary>
/// <param name="interactionSourceState">The InteractionSourceState retrieved from the platform.</param>
private void UpdateThumbstickData(InteractionSourceState interactionSourceState, MixedRealityInteractionMapping interactionMapping)
{
Profiler.BeginSample("[MRTK] WindowsMixedRealityController.UpdateThumbstickData");
switch (interactionMapping.InputType)
{
case DeviceInputType.ThumbStickPress:
{
// Update the interaction data source
interactionMapping.BoolData = interactionSourceState.thumbstickPressed;
// If our value changed raise it.
if (interactionMapping.Changed)
{
// Raise input system event if it's enabled
if (interactionSourceState.thumbstickPressed)
{
CoreServices.InputSystem?.RaiseOnInputDown(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
else
{
CoreServices.InputSystem?.RaiseOnInputUp(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
}
break;
}
case DeviceInputType.ThumbStick:
{
// Update the interaction data source
interactionMapping.Vector2Data = interactionSourceState.thumbstickPosition;
// If our value changed raise it.
if (interactionMapping.Changed)
{
// Raise input system event if it's enabled
CoreServices.InputSystem?.RaisePositionInputChanged(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction, interactionSourceState.thumbstickPosition);
}
break;
}
}
Profiler.EndSample(); // UpdateTouchpadData
}
private void UpdateIndexFingerData(InteractionSourceState interactionSourceState, MixedRealityInteractionMapping interactionMapping)
{
#if WINDOWS_UWP || DOTNETWINRT_PRESENT
UpdateCurrentIndexPose();
// Update the interaction data source
interactionMapping.PoseData = currentIndexPose;
// If our value changed raise it.
if (interactionMapping.Changed)
{
// Raise input system event if it's enabled
CoreServices.InputSystem?.RaisePoseInputChanged(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction, currentIndexPose);
}
#endif // WINDOWS_UWP || DOTNETWINRT_PRESENT
}
/// <summary>
/// Update an Interaction Float data type from a SingleAxis (float) input
/// </summary>
/// <remarks>
/// Raises an Input System "Pressed" event when the float data changes
/// </remarks>
/// <param name="interactionMapping"></param>
protected void UpdateSingleAxisData(MixedRealityInteractionMapping interactionMapping)
{
Debug.Assert(interactionMapping.AxisType == AxisType.SingleAxis);
var singleAxisValue = Input.GetAxis(interactionMapping.AxisCodeX);
float defaultValue = 0f;
switch (interactionMapping.InputType)
{
case DeviceInputType.TriggerPress:
case DeviceInputType.ButtonPress:
// Update the interaction data source
defaultValue = 1f;
interactionMapping.BoolData = singleAxisValue.Equals(defaultValue);
break;
case DeviceInputType.TriggerTouch:
case DeviceInputType.TriggerNearTouch:
case DeviceInputType.ThumbNearTouch:
case DeviceInputType.IndexFingerNearTouch:
case DeviceInputType.MiddleFingerNearTouch:
case DeviceInputType.RingFingerNearTouch:
case DeviceInputType.PinkyFingerNearTouch:
// Update the interaction data source
interactionMapping.BoolData = !singleAxisValue.Equals(defaultValue);
break;
case DeviceInputType.Trigger:
// Update the interaction data source
interactionMapping.FloatData = singleAxisValue;
// If our value was updated, raise it.
if (interactionMapping.Updated)
{
// Raise input system Event if it enabled
MixedRealityToolkit.InputSystem?.RaiseOnInputPressed(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction, interactionMapping.FloatData);
}
return;
default:
Debug.LogWarning($"Unhandled Interaction {interactionMapping.Description}");
return;
}
// If our value was updated, raise it.
if (interactionMapping.Changed)
{
// Raise input system Event if it enabled
if (interactionMapping.BoolData)
{
MixedRealityToolkit.InputSystem?.RaiseOnInputDown(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
else
{
MixedRealityToolkit.InputSystem?.RaiseOnInputUp(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
}
// If our value was updated, raise it.
if (interactionMapping.Updated)
{
MixedRealityToolkit.InputSystem?.RaiseOnInputPressed(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction, singleAxisValue);
}
}
/// <summary>
/// Update an interaction float data type from a SingleAxis (float) input
/// </summary>
/// <remarks>
/// Raises a FloatInputChanged event when the float data changes
/// </remarks>
protected virtual void UpdateSingleAxisData(MixedRealityInteractionMapping interactionMapping, InputDevice inputDevice)
{
using (UpdateSingleAxisDataPerfMarker.Auto())
{
Debug.Assert(interactionMapping.AxisType == AxisType.SingleAxis);
// First handle updating the bool values, since those events are only raised once the trigger/gripped is presssed
switch (interactionMapping.InputType)
{
case DeviceInputType.TriggerPress:
if (inputDevice.TryGetFeatureValue(CommonUsages.triggerButton, out bool triggerPressed))
{
interactionMapping.BoolData = triggerPressed;
}
break;
case DeviceInputType.GripPress:
if (inputDevice.TryGetFeatureValue(CommonUsages.gripButton, out bool gripPressed))
{
interactionMapping.BoolData = gripPressed;
}
break;
default:
break;
}
// If our value changed raise it.
if (interactionMapping.Changed)
{
// Raise bool input system event if it's available
if (interactionMapping.BoolData)
{
CoreServices.InputSystem?.RaiseOnInputDown(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
else
{
CoreServices.InputSystem?.RaiseOnInputUp(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
}
// Next handle updating the float values
switch (interactionMapping.InputType)
{
case DeviceInputType.Trigger:
if (inputDevice.TryGetFeatureValue(CommonUsages.trigger, out float triggerData))
{
interactionMapping.FloatData = triggerData;
}
break;
case DeviceInputType.Grip:
if (inputDevice.TryGetFeatureValue(CommonUsages.grip, out float gripData))
{
interactionMapping.FloatData = gripData;
}
break;
default:
return;
}
// If our value changed raise it.
if (interactionMapping.Changed)
{
// Raise float input system event if it's enabled
CoreServices.InputSystem?.RaiseFloatInputChanged(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction, interactionMapping.FloatData);
}
}
}
private static void Assert_Change_Update(MixedRealityInteractionMapping mapping)
{
Assert.IsTrue(mapping.ControlActivated);
Assert.IsTrue(mapping.Updated);
}
/// <summary>
/// Update the spatial pointer input from the device.
/// </summary>
/// <param name="interactionSourceState">The InteractionSourceState retrieved from the platform.</param>
private void UpdatePointerData(InteractionSourceState interactionSourceState, MixedRealityInteractionMapping interactionMapping)
{
if (interactionSourceState.source.supportsPointing)
{
interactionSourceState.sourcePose.TryGetPosition(out currentPointerPosition, InteractionSourceNode.Pointer);
interactionSourceState.sourcePose.TryGetRotation(out currentPointerRotation, InteractionSourceNode.Pointer);
// We want the source to follow the Playspace, so fold in the playspace transform here to
// put the source pose into world space.
currentPointerPose.Position = MixedRealityPlayspace.TransformPoint(currentPointerPosition);
currentPointerPose.Rotation = MixedRealityPlayspace.Rotation * currentPointerRotation;
}
// Update the interaction data source
interactionMapping.PoseData = currentPointerPose;
// If our value changed raise it.
if (interactionMapping.Changed)
{
// Raise input system Event if it enabled
InputSystem?.RaisePoseInputChanged(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction, currentPointerPose);
}
}
/// <summary>
/// Update an interaction bool data type from a bool input
/// </summary>
/// <remarks>
/// Raises an Input System "Input Down" event when the key is down, and raises an "Input Up" when it is released (e.g. a Button)
/// </remarks>
protected virtual void UpdateButtonData(MixedRealityInteractionMapping interactionMapping, InputDevice inputDevice)
{
using (UpdateButtonDataPerfMarker.Auto())
{
Debug.Assert(interactionMapping.AxisType == AxisType.Digital);
if (interactionMapping.InputType == DeviceInputType.TriggerTouch &&
inputDevice.TryGetFeatureValue(CommonUsages.trigger, out float triggerData))
{
interactionMapping.BoolData = !Mathf.Approximately(triggerData, 0.0f);
}
else
{
InputFeatureUsage <bool> buttonUsage;
// Update the interaction data source
switch (interactionMapping.InputType)
{
case DeviceInputType.Select:
buttonUsage = CommonUsages.triggerButton;
break;
case DeviceInputType.TouchpadTouch:
buttonUsage = CommonUsages.secondary2DAxisTouch;
break;
case DeviceInputType.TouchpadPress:
buttonUsage = CommonUsages.secondary2DAxisClick;
break;
case DeviceInputType.Menu:
buttonUsage = CommonUsages.menuButton;
break;
case DeviceInputType.ThumbStickTouch:
buttonUsage = CommonUsages.primary2DAxisTouch;
break;
case DeviceInputType.ThumbStickPress:
buttonUsage = CommonUsages.primary2DAxisClick;
break;
default:
return;
}
if (inputDevice.TryGetFeatureValue(buttonUsage, out bool buttonPressed))
{
interactionMapping.BoolData = buttonPressed;
}
}
// If our value changed raise it.
if (interactionMapping.Changed)
{
// Raise input system event if it's enabled
if (interactionMapping.BoolData)
{
CoreServices.InputSystem?.RaiseOnInputDown(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
else
{
CoreServices.InputSystem?.RaiseOnInputUp(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
}
}
}
/// <summary>
/// Update the "Spatial Pointer" input from the device
/// </summary>
/// <param name="interactionSourceState">The InteractionSourceState retrieved from the platform</param>
/// <param name="interactionMapping"></param>
private void UpdatePointerData(InteractionSourceState interactionSourceState, MixedRealityInteractionMapping interactionMapping)
{
interactionSourceState.sourcePose.TryGetPosition(out currentPointerPosition, InteractionSourceNode.Pointer);
interactionSourceState.sourcePose.TryGetRotation(out currentPointerRotation, InteractionSourceNode.Pointer);
currentPointerPose.Position = currentPointerPosition;
currentPointerPose.Rotation = currentPointerRotation;
interactionMapping.PoseData = currentPointerPose;
}
private void UpdateIndexFingerMapping(MixedRealityInteractionMapping interactionMapping)
{
Debug.Assert(interactionMapping.AxisType == AxisType.SixDof);
interactionMapping.PoseData = IndexFingerTipPose;
}
/// <summary>
/// Update the trigger and grasped input from the device.
/// </summary>
/// <param name="interactionSourceState">The InteractionSourceState retrieved from the platform.</param>
private void UpdateTriggerData(InteractionSourceState interactionSourceState, MixedRealityInteractionMapping interactionMapping)
{
switch (interactionMapping.InputType)
{
case DeviceInputType.TriggerPress:
{
// Update the interaction data source
interactionMapping.BoolData = interactionSourceState.grasped;
// If our value changed raise it.
if (interactionMapping.Changed)
{
// Raise input system Event if it enabled
if (interactionMapping.BoolData)
{
InputSystem?.RaiseOnInputDown(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
else
{
InputSystem?.RaiseOnInputUp(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
}
break;
}
case DeviceInputType.Select:
{
// Get the select pressed state, factoring in a workaround for Unity issue #1033526.
// When that issue is fixed, it should be possible change the line below to:
// interactionMapping.BoolData = interactionSourceState.selectPressed;
interactionMapping.BoolData = GetSelectPressedWorkaround(interactionSourceState);
// If our value changed raise it.
if (interactionMapping.Changed)
{
// Raise input system Event if it enabled
if (interactionMapping.BoolData)
{
InputSystem?.RaiseOnInputDown(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
else
{
InputSystem?.RaiseOnInputUp(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
}
break;
}
case DeviceInputType.Trigger:
{
// Update the interaction data source
interactionMapping.FloatData = interactionSourceState.selectPressedAmount;
// If our value changed raise it.
if (interactionMapping.Changed)
{
// Raise input system Event if it enabled
InputSystem?.RaiseFloatInputChanged(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction, interactionSourceState.selectPressedAmount);
}
break;
}
case DeviceInputType.TriggerTouch:
{
// Update the interaction data source
interactionMapping.BoolData = interactionSourceState.selectPressedAmount > 0;
// If our value changed raise it.
if (interactionMapping.Changed)
{
// Raise input system Event if it enabled
if (interactionSourceState.selectPressedAmount > 0)
{
InputSystem?.RaiseOnInputDown(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
else
{
InputSystem?.RaiseOnInputUp(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
}
break;
}
}
}
/// <summary>
/// Update the Touchpad input from the device
/// </summary>
/// <param name="interactionSourceState">The InteractionSourceState retrieved from the platform</param>
/// <param name="interactionMapping"></param>
private void UpdateTouchPadData(InteractionSourceState interactionSourceState, MixedRealityInteractionMapping interactionMapping)
{
switch (interactionMapping.InputType)
{
case DeviceInputType.TouchpadTouch:
{
interactionMapping.BoolData = interactionSourceState.touchpadTouched;
break;
}
case DeviceInputType.TouchpadPress:
{
interactionMapping.BoolData = interactionSourceState.touchpadPressed;
break;
}
case DeviceInputType.Touchpad:
{
interactionMapping.Vector2Data = interactionSourceState.touchpadPosition;
break;
}
}
}
private void RenderControllerList(SerializedProperty controllerList)
{
if (thisProfile.MixedRealityControllerMappings.Length != controllerList.arraySize)
{
return;
}
if (InspectorUIUtility.RenderIndentedButton(ControllerAddButtonContent, EditorStyles.miniButton))
{
AddController(controllerList, typeof(GenericJoystickController));
return;
}
controllerRenderList.Clear();
// Generating the set of controllers that belong to each Controller Mapping Signature
Dictionary <ControllerMappingSignature, List <string> > controllersAffectedByMappingSignatures = new Dictionary <ControllerMappingSignature, List <string> >();
for (int i = 0; i < thisProfile.MixedRealityControllerMappings.Length; i++)
{
MixedRealityControllerMapping controllerMapping = thisProfile.MixedRealityControllerMappings[i];
Type controllerType = controllerMapping.ControllerType;
if (controllerType == null)
{
continue;
}
Handedness handedness = controllerMapping.Handedness;
SupportedControllerType supportedControllerType = controllerMapping.SupportedControllerType;
ControllerMappingSignature currentSignature = new ControllerMappingSignature(supportedControllerType, handedness);
if (!controllersAffectedByMappingSignatures.ContainsKey(currentSignature))
{
controllersAffectedByMappingSignatures.Add(currentSignature, new List <string>());
}
controllersAffectedByMappingSignatures[currentSignature].Add(controllerType.ToString());
}
showControllerDefinitions = EditorGUILayout.Foldout(showControllerDefinitions, "Controller Definitions", true);
if (showControllerDefinitions)
{
using (var outerVerticalScope = new GUILayout.VerticalScope())
{
GUILayout.HorizontalScope horizontalScope = null;
for (int i = 0; i < thisProfile.MixedRealityControllerMappings.Length; i++)
{
MixedRealityControllerMapping controllerMapping = thisProfile.MixedRealityControllerMappings[i];
Type controllerType = controllerMapping.ControllerType;
if (controllerType == null)
{
continue;
}
Handedness handedness = controllerMapping.Handedness;
bool useCustomInteractionMappings = controllerMapping.HasCustomInteractionMappings;
SupportedControllerType supportedControllerType = controllerMapping.SupportedControllerType;
var controllerMappingProperty = controllerList.GetArrayElementAtIndex(i);
var handednessProperty = controllerMappingProperty.FindPropertyRelative("handedness");
#region Profile Migration
// Between MRTK v2 RC2 and GA, the HoloLens clicker and HoloLens voice select input were migrated from
// SupportedControllerType.WindowsMixedReality && Handedness.None to SupportedControllerType.GGVHand && Handedness.None
if (supportedControllerType == SupportedControllerType.WindowsMixedReality && handedness == Handedness.None)
{
for (int j = 0; j < thisProfile.MixedRealityControllerMappings.Length; j++)
{
if (thisProfile.MixedRealityControllerMappings[j].SupportedControllerType == SupportedControllerType.GGVHand &&
thisProfile.MixedRealityControllerMappings[j].Handedness == Handedness.None)
{
if (horizontalScope != null)
{
horizontalScope.Dispose(); horizontalScope = null;
}
serializedObject.ApplyModifiedProperties();
for (int k = 0; k < controllerMapping.Interactions.Length; k++)
{
MixedRealityInteractionMapping currentMapping = controllerMapping.Interactions[k];
if (currentMapping.InputType == DeviceInputType.Select)
{
thisProfile.MixedRealityControllerMappings[j].Interactions[0].MixedRealityInputAction = currentMapping.MixedRealityInputAction;
}
else if (currentMapping.InputType == DeviceInputType.SpatialGrip)
{
thisProfile.MixedRealityControllerMappings[j].Interactions[1].MixedRealityInputAction = currentMapping.MixedRealityInputAction;
}
}
serializedObject.Update();
controllerList.DeleteArrayElementAtIndex(i);
EditorUtility.DisplayDialog("Mappings updated", "The \"HoloLens Voice and Clicker\" mappings have been migrated to a new serialization. Please save this asset.", "Okay, thanks!");
return;
}
}
}
#endregion Profile Migration
if (!useCustomInteractionMappings)
{
bool skip = false;
// Merge controllers with the same supported controller type.
for (int j = 0; j < controllerRenderList.Count; j++)
{
if (controllerRenderList[j].SupportedControllerType == supportedControllerType &&
controllerRenderList[j].Handedness == handedness)
{
try
{
thisProfile.MixedRealityControllerMappings[i].SynchronizeInputActions(controllerRenderList[j].Interactions);
}
catch (ArgumentException e)
{
Debug.LogError($"Controller mappings between {thisProfile.MixedRealityControllerMappings[i].Description} and {controllerMapping.Description} do not match. Error message: {e.Message}");
}
serializedObject.ApplyModifiedProperties();
skip = true;
}
}
if (skip)
{
continue;
}
}
controllerRenderList.Add(new ControllerRenderProfile(supportedControllerType, handedness, thisProfile.MixedRealityControllerMappings[i].Interactions));
string controllerTitle = thisProfile.MixedRealityControllerMappings[i].Description;
var interactionsProperty = controllerMappingProperty.FindPropertyRelative("interactions");
if (useCustomInteractionMappings)
{
if (horizontalScope != null)
{
horizontalScope.Dispose(); horizontalScope = null;
}
GUILayout.Space(24f);
using (var verticalScope = new GUILayout.VerticalScope())
{
using (horizontalScope = new GUILayout.HorizontalScope())
{
EditorGUILayout.LabelField(controllerTitle, EditorStyles.boldLabel);
if (GUILayout.Button(ControllerMinusButtonContent, EditorStyles.miniButtonRight, GUILayout.Width(24f)))
{
controllerList.DeleteArrayElementAtIndex(i);
return;
}
}
EditorGUI.BeginChangeCheck();
// Generic Type dropdown
Type[] genericTypes = MixedRealityControllerMappingProfile.CustomControllerMappingTypes;
var genericTypeListContent = new GUIContent[genericTypes.Length];
var genericTypeListIds = new int[genericTypes.Length];
int currentGenericType = -1;
for (int genericTypeIdx = 0; genericTypeIdx < genericTypes.Length; genericTypeIdx++)
{
var attribute = MixedRealityControllerAttribute.Find(genericTypes[genericTypeIdx]);
if (attribute != null)
{
genericTypeListContent[genericTypeIdx] = new GUIContent(attribute.SupportedControllerType.ToString().Replace("Generic", "").ToProperCase() + " Controller");
}
else
{
genericTypeListContent[genericTypeIdx] = new GUIContent("Unknown Controller");
}
genericTypeListIds[genericTypeIdx] = genericTypeIdx;
if (controllerType == genericTypes[genericTypeIdx])
{
currentGenericType = genericTypeIdx;
}
}
Debug.Assert(currentGenericType != -1);
currentGenericType = EditorGUILayout.IntPopup(GenericTypeContent, currentGenericType, genericTypeListContent, genericTypeListIds);
controllerType = genericTypes[currentGenericType];
{
// Handedness dropdown
var attribute = MixedRealityControllerAttribute.Find(controllerType);
if (attribute != null && attribute.SupportedHandedness.Length >= 1)
{
// Make sure handedness is valid for the selected controller type.
if (Array.IndexOf(attribute.SupportedHandedness, (Handedness)handednessProperty.intValue) < 0)
{
handednessProperty.intValue = (int)attribute.SupportedHandedness[0];
}
if (attribute.SupportedHandedness.Length >= 2)
{
var handednessListContent = new GUIContent[attribute.SupportedHandedness.Length];
var handednessListIds = new int[attribute.SupportedHandedness.Length];
for (int handednessIdx = 0; handednessIdx < attribute.SupportedHandedness.Length; handednessIdx++)
{
handednessListContent[handednessIdx] = new GUIContent(attribute.SupportedHandedness[handednessIdx].ToString());
handednessListIds[handednessIdx] = (int)attribute.SupportedHandedness[handednessIdx];
}
handednessProperty.intValue = EditorGUILayout.IntPopup(HandednessTypeContent, handednessProperty.intValue, handednessListContent, handednessListIds);
}
}
else
{
handednessProperty.intValue = (int)Handedness.None;
}
}
if (EditorGUI.EndChangeCheck())
{
interactionsProperty.ClearArray();
serializedObject.ApplyModifiedProperties();
thisProfile.MixedRealityControllerMappings[i].ControllerType.Type = genericTypes[currentGenericType];
thisProfile.MixedRealityControllerMappings[i].SetDefaultInteractionMapping(true);
serializedObject.ApplyModifiedProperties();
return;
}
if (InspectorUIUtility.RenderIndentedButton("Edit Input Action Map"))
{
ControllerPopupWindow.Show(controllerMapping, interactionsProperty, handedness);
}
if (InspectorUIUtility.RenderIndentedButton("Reset Input Actions"))
{
interactionsProperty.ClearArray();
serializedObject.ApplyModifiedProperties();
thisProfile.MixedRealityControllerMappings[i].SetDefaultInteractionMapping(true);
serializedObject.ApplyModifiedProperties();
}
}
}
else
{
if (handedness != Handedness.Right)
{
if (horizontalScope != null)
{
horizontalScope.Dispose(); horizontalScope = null;
}
horizontalScope = new GUILayout.HorizontalScope();
}
var buttonContent = new GUIContent(controllerTitle, ControllerMappingLibrary.GetControllerTextureScaled(controllerType, handedness));
if (GUILayout.Button(buttonContent, MixedRealityStylesUtility.ControllerButtonStyle, GUILayout.Height(128f), GUILayout.MinWidth(32f), GUILayout.ExpandWidth(true)))
{
ControllerMappingSignature buttonSignature = new ControllerMappingSignature(supportedControllerType, handedness);
ControllerPopupWindow.Show(controllerMapping, interactionsProperty, handedness, controllersAffectedByMappingSignatures[buttonSignature]);
}
}
}
if (horizontalScope != null)
{
horizontalScope.Dispose(); horizontalScope = null;
}
}
}
}
/// <summary>
/// Update the Thumbstick input from the device
/// </summary>
/// <param name="interactionSourceState">The InteractionSourceState retrieved from the platform</param>
/// <param name="interactionMapping"></param>
private void UpdateThumbStickData(InteractionSourceState interactionSourceState, MixedRealityInteractionMapping interactionMapping)
{
switch (interactionMapping.InputType)
{
case DeviceInputType.ThumbStickPress:
{
interactionMapping.BoolData = interactionSourceState.thumbstickPressed;
break;
}
case DeviceInputType.ThumbStick:
{
interactionMapping.Vector2Data = interactionSourceState.thumbstickPosition;
break;
}
}
}
/// <summary>
/// Update the "Spatial Pointer" input from the device
/// </summary>
/// <param name="interactionSourceState">The InteractionSourceState retrieved from the platform</param>
/// <param name="interactionMapping"></param>
private void UpdatePointerData(InteractionSourceState interactionSourceState, MixedRealityInteractionMapping interactionMapping)
{
interactionSourceState.sourcePose.TryGetPosition(out currentPointerPosition, InteractionSourceNode.Pointer);
interactionSourceState.sourcePose.TryGetRotation(out currentPointerRotation, InteractionSourceNode.Pointer);
currentPointerPose.Position = currentPointerPosition;
currentPointerPose.Rotation = currentPointerRotation;
// Update the interaction data source
interactionMapping.PoseData = currentPointerPose;
// If our value changed raise it.
if (interactionMapping.Changed)
{
// Raise input system Event if it enabled
MixedRealityToolkit.InputSystem?.RaisePoseInputChanged(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction, currentPointerPose);
}
}
/// <summary>
/// Update the Menu button state.
/// </summary>
/// <param name="interactionSourceState"></param>
/// <param name="interactionMapping"></param>
private void UpdateMenuData(InteractionSourceState interactionSourceState, MixedRealityInteractionMapping interactionMapping)
{
interactionMapping.BoolData = interactionSourceState.menuPressed;
}
/// <summary>
/// Update the thumbstick input from the device.
/// </summary>
/// <param name="interactionSourceState">The InteractionSourceState retrieved from the platform.</param>
private void UpdateThumbstickData(InteractionSourceState interactionSourceState, MixedRealityInteractionMapping interactionMapping)
{
switch (interactionMapping.InputType)
{
case DeviceInputType.ThumbStickPress:
{
// Update the interaction data source
interactionMapping.BoolData = interactionSourceState.thumbstickPressed;
// If our value changed raise it.
if (interactionMapping.Changed)
{
// Raise input system Event if it enabled
if (interactionSourceState.thumbstickPressed)
{
InputSystem?.RaiseOnInputDown(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
else
{
InputSystem?.RaiseOnInputUp(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
}
break;
}
case DeviceInputType.ThumbStick:
{
// Update the interaction data source
interactionMapping.Vector2Data = interactionSourceState.thumbstickPosition;
// If our value changed raise it.
if (interactionMapping.Changed)
{
// Raise input system Event if it enabled
InputSystem?.RaisePositionInputChanged(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction, interactionSourceState.thumbstickPosition);
}
break;
}
}
}
/// <summary>
/// Update the Trigger input from the device
/// </summary>
/// <param name="interactionSourceState">The InteractionSourceState retrieved from the platform</param>
/// <param name="interactionMapping"></param>
private void UpdateTriggerData(InteractionSourceState interactionSourceState, MixedRealityInteractionMapping interactionMapping)
{
switch (interactionMapping.InputType)
{
case DeviceInputType.TriggerPress:
// Update the interaction data source
interactionMapping.BoolData = interactionSourceState.grasped;
// If our value changed raise it.
if (interactionMapping.Changed)
{
// Raise input system Event if it enabled
if (interactionSourceState.grasped)
{
MixedRealityToolkit.InputSystem?.RaiseOnInputDown(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
else
{
MixedRealityToolkit.InputSystem?.RaiseOnInputUp(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
}
break;
case DeviceInputType.Select:
{
bool selectPressed = interactionSourceState.selectPressed;
// BEGIN WORKAROUND: Unity issue #1033526
// See https://issuetracker.unity3d.com/issues/hololens-interactionsourcestate-dot-selectpressed-is-false-when-air-tap-and-hold
// Bug was discovered May 2018 and still exists as of today Feb 2019 in version 2018.3.4f1, timeline for fix is unknown
// The bug only affects the development workflow via Holographic Remoting or Simulation
if (interactionSourceState.source.kind == InteractionSourceKind.Hand)
{
Debug.Assert(!(UnityEngine.XR.WSA.HolographicRemoting.ConnectionState == UnityEngine.XR.WSA.HolographicStreamerConnectionState.Connected &&
interactionSourceState.selectPressed),
"Unity issue #1033526 seems to have been resolved. Please remove this ugly workaround!");
// This workaround is safe as long as all these assumptions hold:
Debug.Assert(!interactionSourceState.source.supportsGrasp);
Debug.Assert(!interactionSourceState.source.supportsMenu);
Debug.Assert(!interactionSourceState.source.supportsPointing);
Debug.Assert(!interactionSourceState.source.supportsThumbstick);
Debug.Assert(!interactionSourceState.source.supportsTouchpad);
selectPressed = interactionSourceState.anyPressed;
}
// END WORKAROUND: Unity issue #1033526
// Update the interaction data source
interactionMapping.BoolData = selectPressed;
// If our value changed raise it.
if (interactionMapping.Changed)
{
// Raise input system Event if it enabled
if (selectPressed)
{
MixedRealityToolkit.InputSystem?.RaiseOnInputDown(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
else
{
MixedRealityToolkit.InputSystem?.RaiseOnInputUp(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
}
break;
}
case DeviceInputType.Trigger:
{
// Update the interaction data source
interactionMapping.FloatData = interactionSourceState.selectPressedAmount;
// If our value changed raise it.
if (interactionMapping.Changed)
{
// Raise input system Event if it enabled
MixedRealityToolkit.InputSystem?.RaiseOnInputPressed(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction, interactionSourceState.selectPressedAmount);
}
break;
}
case DeviceInputType.TriggerTouch:
{
// Update the interaction data source
interactionMapping.BoolData = interactionSourceState.selectPressedAmount > 0;
// If our value changed raise it.
if (interactionMapping.Changed)
{
// Raise input system Event if it enabled
if (interactionSourceState.selectPressedAmount > 0)
{
MixedRealityToolkit.InputSystem?.RaiseOnInputDown(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
else
{
MixedRealityToolkit.InputSystem?.RaiseOnInputUp(InputSource, ControllerHandedness, interactionMapping.MixedRealityInputAction);
}
}
break;
}
}
}
