public void FakeUpdate()
{
XRControllerState controllerState = new XRControllerState();
UpdateTrackingInput(controllerState);
ApplyControllerState(XRInteractionUpdateOrder.UpdatePhase.Dynamic, controllerState);
}
protected override void UpdateInput(XRControllerState controllerState)
{
// Reset all of the input values
// Check select action, apply to controller
// Check activate action, apply to controller
// Check UI action, apply to controller
}
/// <summary>
/// Draw the <paramref name="frame"/> stored in the recording.
/// </summary>
/// <param name="frame">The controller frame to draw.</param>
protected virtual void DrawRecordingFrame(XRControllerState frame)
{
EditorGUILayout.BeginHorizontal();
EditorGUILayout.FloatField((float)frame.time, GUILayout.ExpandWidth(true));
EditorGUILayout.TextField(frame.position.ToString(), GUILayout.Width(120));
EditorGUILayout.TextField(frame.rotation.ToString(), GUILayout.Width(160));
EditorGUILayout.Toggle(frame.selectInteractionState.active, GUILayout.MaxWidth(14));
EditorGUILayout.Toggle(frame.activateInteractionState.active, GUILayout.MaxWidth(14));
EditorGUILayout.Toggle(frame.uiPressInteractionState.active, GUILayout.MaxWidth(14));
EditorGUILayout.EndHorizontal();
}
private void Update()
{
if (Input.GetKeyDown(KeyCode.Z) && !isPressed)
{
XRControllerState state = new XRControllerState();
//state.activateInteractionState.active = true;
state.selectInteractionState.active = true;
state.selectInteractionState.activatedThisFrame = true;
//interactor.interactionManager.RegisterInteractable(gameObject.GetComponent<XRGrabInteractable>());
interactor.xrController.SetControllerState(state);
//interactor.interactionManager.HoverEnter(interactor, gameObject.GetComponent<XRGrabInteractable>());
//interactor.interactionManager.SelectEnter(interactor, gameObject.GetComponent<XRGrabInteractable>());
interactor.interactionManager.ForceSelect(interactor, gameObject.GetComponent <XRGrabInteractable>());
print("Selected");
}
}
protected override void ApplyControllerState(XRInteractionUpdateOrder.UpdatePhase updatePhase, XRControllerState controllerState)
{
}
public void AddRecordingFrame(XRControllerState state)
{
frames.Add(new XRControllerState(state));
}
public IEnumerator RayInteractorCanSelectAndReleaseInteractable([ValueSource(nameof(s_SelectActionTriggers))] XRBaseControllerInteractor.InputTriggerType selectActionTrigger)
{
var manager = TestUtilities.CreateInteractionManager();
var interactor = TestUtilities.CreateRayInteractor();
interactor.transform.position = Vector3.zero;
interactor.transform.forward = Vector3.forward;
interactor.selectActionTrigger = selectActionTrigger;
var interactable = TestUtilities.CreateSimpleInteractable();
interactable.transform.position = interactor.transform.position + interactor.transform.forward * 5.0f;
var controller = interactor.GetComponent <XRBaseController>();
var controllerState = new XRControllerState(0f, Vector3.zero, Quaternion.identity, false, false, false);
controller.SetControllerState(controllerState);
yield return(new WaitForFixedUpdate());
yield return(null);
Assert.That(controllerState.selectInteractionState.active, Is.False);
Assert.That(interactable.isHovered, Is.True);
Assert.That(interactable.isSelected, Is.False);
Assert.That(interactor.isSelectActive, Is.False);
// Press Grip
controllerState.selectInteractionState = new InteractionState {
active = true, activatedThisFrame = true
};
yield return(null);
Assert.That(controllerState.selectInteractionState.active, Is.True);
Assert.That(controllerState.selectInteractionState.activatedThisFrame, Is.True);
Assert.That(interactable.isHovered, Is.True);
Assert.That(interactable.isSelected, Is.True);
Assert.That(interactor.isSelectActive, Is.True);
// Release Grip
controllerState.selectInteractionState = new InteractionState {
active = false, deactivatedThisFrame = true
};
yield return(null);
Assert.That(controllerState.selectInteractionState.active, Is.False);
Assert.That(controllerState.selectInteractionState.deactivatedThisFrame, Is.True);
Assert.That(interactable.isHovered, Is.True);
switch (selectActionTrigger)
{
case XRBaseControllerInteractor.InputTriggerType.State:
case XRBaseControllerInteractor.InputTriggerType.StateChange:
Assert.That(interactable.isSelected, Is.False);
Assert.That(interactor.isSelectActive, Is.False);
break;
case XRBaseControllerInteractor.InputTriggerType.Toggle:
case XRBaseControllerInteractor.InputTriggerType.Sticky:
Assert.That(interactable.isSelected, Is.True);
Assert.That(interactor.isSelectActive, Is.True);
break;
}
// Press Grip again
controllerState.selectInteractionState = new InteractionState {
active = true, activatedThisFrame = true
};
yield return(null);
Assert.That(controllerState.selectInteractionState.active, Is.True);
Assert.That(controllerState.selectInteractionState.activatedThisFrame, Is.True);
Assert.That(interactable.isHovered, Is.True);
switch (selectActionTrigger)
{
case XRBaseControllerInteractor.InputTriggerType.State:
case XRBaseControllerInteractor.InputTriggerType.StateChange:
case XRBaseControllerInteractor.InputTriggerType.Sticky:
Assert.That(interactable.isSelected, Is.True);
Assert.That(interactor.isSelectActive, Is.True);
break;
case XRBaseControllerInteractor.InputTriggerType.Toggle:
Assert.That(interactable.isSelected, Is.False);
Assert.That(interactor.isSelectActive, Is.False);
break;
}
// Release Grip again
controllerState.selectInteractionState = new InteractionState {
active = false, deactivatedThisFrame = true
};
yield return(null);
Assert.That(controllerState.selectInteractionState.active, Is.False);
Assert.That(controllerState.selectInteractionState.deactivatedThisFrame, Is.True);
Assert.That(interactable.isHovered, Is.True);
Assert.That(interactable.isSelected, Is.False);
Assert.That(interactor.isSelectActive, Is.False);
}
public IEnumerator RayInteractorCanReleaseInteractableAfterHoverToSelectWhenGripping([ValueSource(nameof(s_SelectActionTriggers))] XRBaseControllerInteractor.InputTriggerType selectActionTrigger)
{
var manager = TestUtilities.CreateInteractionManager();
var interactor = TestUtilities.CreateRayInteractor();
interactor.transform.position = Vector3.zero;
interactor.transform.forward = Vector3.forward;
interactor.hoverToSelect = true;
interactor.hoverTimeToSelect = 0.2f;
interactor.selectActionTrigger = selectActionTrigger;
var interactable = TestUtilities.CreateSimpleInteractable();
interactable.transform.position = interactor.transform.position + interactor.transform.forward * 5.0f;
var controller = interactor.GetComponent <XRBaseController>();
var controllerState = new XRControllerState(0f, Vector3.zero, Quaternion.identity, false, false, false);
controller.SetControllerState(controllerState);
yield return(new WaitForSeconds(0.1f));
// Hasn't met duration threshold yet
Assert.That(controllerState.selectInteractionState.active, Is.False);
Assert.That(interactable.isHovered, Is.True);
Assert.That(interactable.isSelected, Is.False);
Assert.That(interactor.isSelectActive, Is.False);
yield return(new WaitForSeconds(0.2f));
// Hovered for long enough
Assert.That(controllerState.selectInteractionState.active, Is.False);
Assert.That(interactable.isHovered, Is.True);
Assert.That(interactable.isSelected, Is.True);
Assert.That(interactor.isSelectActive, Is.True);
// Press Grip
controllerState.selectInteractionState = new InteractionState {
active = true, activatedThisFrame = true
};
yield return(null);
Assert.That(controllerState.selectInteractionState.active, Is.True);
Assert.That(controllerState.selectInteractionState.activatedThisFrame, Is.True);
Assert.That(interactable.isHovered, Is.True);
Assert.That(interactable.isSelected, Is.True);
Assert.That(interactor.isSelectActive, Is.True);
interactor.hoverToSelect = false;
controllerState.selectInteractionState = new InteractionState {
active = true
};
yield return(null);
// This table summarizes what must be done by a user to drop the Interactable
// when hoverToSelect is disabled. It depends on whether the Select (i.e. Grip)
// is pressed after the Interactable is automatically selected from hoverToSelect.
// |Type |To drop when Grip is false|To drop when Grip is true after auto Select|
// |-----------|--------------------------|-------------------------------------------|
// |State |Nothing (will drop) |Release Grip |
// |StateChange|Press then Release Grip |Release Grip |
// |Toggle |Press Grip |Nothing (will drop since already toggled) |
// |Sticky |Press then Release Grip |Release Grip |
Assert.That(controllerState.selectInteractionState.active, Is.True);
Assert.That(interactable.isHovered, Is.True);
switch (selectActionTrigger)
{
case XRBaseControllerInteractor.InputTriggerType.State:
case XRBaseControllerInteractor.InputTriggerType.StateChange:
case XRBaseControllerInteractor.InputTriggerType.Sticky:
Assert.That(interactable.isSelected, Is.True);
Assert.That(interactor.isSelectActive, Is.True);
break;
case XRBaseControllerInteractor.InputTriggerType.Toggle:
Assert.That(interactable.isSelected, Is.False);
Assert.That(interactor.isSelectActive, Is.False);
break;
}
// Release Grip
controllerState.selectInteractionState = new InteractionState {
active = false, deactivatedThisFrame = true
};
yield return(null);
Assert.That(controllerState.selectInteractionState.active, Is.False);
Assert.That(controllerState.selectInteractionState.deactivatedThisFrame, Is.True);
Assert.That(interactable.isHovered, Is.True);
Assert.That(interactable.isSelected, Is.False);
Assert.That(interactor.isSelectActive, Is.False);
}
public unsafe override bool GatherInput(XRControllerState[] state_controllers, out int controllerCount, out bool leftSet, out int leftSetIndex, out bool rightSet, out int rightSetIndex, out SideToSet sideToSet)
{
// defaults
GatherInputDefaults(out controllerCount, out leftSet, out leftSetIndex, out rightSet, out rightSetIndex, out sideToSet);
// reset controllers
ResetControllers(state_controllers);
// validate OpenVR is avaliable
if (!isInit)
{
return(false);
}
if (system == null || !system.IsInputAvailable() || input.IsUsingLegacyInput())
{
return(false);
}
// get controller connection status and side
for (uint i = 0; i != OpenVR.k_unMaxTrackedDeviceCount; ++i)
{
if (!system.IsTrackedDeviceConnected(i))
{
continue;
}
if (system.GetTrackedDeviceClass(i) != ETrackedDeviceClass.Controller)
{
continue;
}
// get controller type
ETrackedPropertyError e = ETrackedPropertyError.TrackedProp_Success;
system.GetStringTrackedDeviceProperty(i, ETrackedDeviceProperty.Prop_ControllerType_String, OpenVR_Shared.propertyText, (uint)OpenVR_Shared.propertyText.Capacity, ref e);
if (e != ETrackedPropertyError.TrackedProp_Success)
{
continue;
}
// ignore gamepads
if (OpenVR_Shared.propertyText.Equals(OpenVR_Shared.propertyText_Gamepad))
{
continue;
}
// get controller
var controller = state_controllers[controllerCount];
controller.connected = true;
// get controller type
if (OpenVR_Shared.propertyText.Equals(OpenVR_Shared.propertyText_ViveController))
{
controller.type = XRInputControllerType.HTCVive;
}
else if (OpenVR_Shared.propertyText.Equals(OpenVR_Shared.propertyText_ViveCosmosController))
{
controller.type = XRInputControllerType.HTCViveCosmos;
}
else if (OpenVR_Shared.propertyText.Equals(OpenVR_Shared.propertyText_IndexController))
{
controller.type = XRInputControllerType.ValveIndex;
}
else if (OpenVR_Shared.propertyText.ToString().StartsWith(OpenVR_Shared.propertyText_Oculus.ToString()))
{
controller.type = XRInputControllerType.Oculus;
}
else if (OpenVR_Shared.propertyText.Equals(OpenVR_Shared.propertyText_WMR))
{
controller.type = XRInputControllerType.WMR;
}
else if (OpenVR_Shared.propertyText.Equals(OpenVR_Shared.propertyText_WMR_G2))
{
controller.type = XRInputControllerType.WMR_G2;
}
// update controller side
var role = system.GetControllerRoleForTrackedDeviceIndex(i);
switch (role)
{
case ETrackedControllerRole.LeftHand:
controller.side = XRControllerSide.Left;
leftSet = true;
leftSetIndex = controllerCount;
leftHand = (int)i;
break;
case ETrackedControllerRole.RightHand:
controller.side = XRControllerSide.Right;
rightSet = true;
rightSetIndex = controllerCount;
rightHand = (int)i;
break;
default: controller.side = XRControllerSide.Unknown; break;
}
state_controllers[controllerCount] = controller;
++controllerCount;
}
// pre-finish/pre-resolve unknown controller sides
GatherInputFinish(state_controllers, controllerCount, ref leftSet, ref leftSetIndex, ref rightSet, ref rightSetIndex, ref sideToSet);
// update inputs
var error = input.UpdateActionState(actionSets, (uint)Marshal.SizeOf <VRActiveActionSet_t>());
if (error != EVRInputError.None)
{
Debug.LogError("UpdateActionState: " + error.ToString());
}
// get hands
var controllerRight = new XRControllerState();
var controllerLeft = new XRControllerState();
if (rightSet)
{
controllerRight = state_controllers[rightSetIndex];
}
if (leftSet)
{
controllerLeft = state_controllers[leftSetIndex];
}
// update bumper buttons/touch
controllerRight.buttonBumper.Update(GetButtonState(viveAction_BumperButton, viveSource_RightHand));
controllerLeft.buttonBumper.Update(GetButtonState(viveAction_BumperButton, viveSource_LeftHand));
controllerRight.touchBumper.Update(GetButtonState(viveAction_BumperTouch, viveSource_RightHand));
controllerLeft.touchBumper.Update(GetButtonState(viveAction_BumperTouch, viveSource_LeftHand));
// update trigger buttons/touch
controllerRight.buttonTrigger.Update(GetButtonState(viveAction_TriggerButton, viveSource_RightHand));
controllerLeft.buttonTrigger.Update(GetButtonState(viveAction_TriggerButton, viveSource_LeftHand));
controllerRight.touchTrigger.Update(GetButtonState(viveAction_TriggerTouch, viveSource_RightHand));
controllerLeft.touchTrigger.Update(GetButtonState(viveAction_TriggerTouch, viveSource_LeftHand));
// update grip buttons/touch
controllerRight.buttonGrip.Update(GetButtonState(viveAction_GripButton, viveSource_RightHand));
controllerLeft.buttonGrip.Update(GetButtonState(viveAction_GripButton, viveSource_LeftHand));
controllerRight.touchGrip.Update(GetButtonState(viveAction_GripTouch, viveSource_RightHand));
controllerLeft.touchGrip.Update(GetButtonState(viveAction_GripTouch, viveSource_LeftHand));
// update menu buttons/touch
controllerRight.buttonMenu.Update(GetButtonState(viveAction_MenuButton, viveSource_RightHand));
controllerLeft.buttonMenu.Update(GetButtonState(viveAction_MenuButton, viveSource_LeftHand));
controllerRight.touchMenu.Update(GetButtonState(viveAction_MenuTouch, viveSource_RightHand));
controllerLeft.touchMenu.Update(GetButtonState(viveAction_MenuTouch, viveSource_LeftHand));
// update button/touch 1
controllerRight.button1.Update(GetButtonState(viveAction_Button1, viveSource_RightHand));
controllerLeft.button1.Update(GetButtonState(viveAction_Button1, viveSource_LeftHand));
controllerRight.touch1.Update(GetButtonState(viveAction_Touch1, viveSource_RightHand));
controllerLeft.touch1.Update(GetButtonState(viveAction_Touch1, viveSource_LeftHand));
// update button/touch 2
controllerRight.button2.Update(GetButtonState(viveAction_Button2, viveSource_RightHand));
controllerLeft.button2.Update(GetButtonState(viveAction_Button2, viveSource_LeftHand));
controllerRight.touch2.Update(GetButtonState(viveAction_Touch2, viveSource_RightHand));
controllerLeft.touch2.Update(GetButtonState(viveAction_Touch2, viveSource_LeftHand));
// update grip
if (controllerRight.type == XRInputControllerType.HTCVive || controllerRight.type == XRInputControllerType.WMR)
{
controllerRight.grip.Update(controllerRight.buttonGrip.on ? 1 : 0);// simulate analog state
}
else
{
controllerRight.grip.Update(GetAnalogState(viveAction_Grip, viveSource_RightHand).x);
}
if (controllerLeft.type == XRInputControllerType.HTCVive || controllerLeft.type == XRInputControllerType.WMR)
{
controllerLeft.grip.Update(controllerLeft.buttonGrip.on ? 1 : 0);// simulate analog state
}
else
{
controllerLeft.grip.Update(GetAnalogState(viveAction_Grip, viveSource_LeftHand).x);
}
// update triggers
controllerRight.trigger.Update(GetAnalogState(viveAction_Trigger, viveSource_RightHand).x);
controllerLeft.trigger.Update(GetAnalogState(viveAction_Trigger, viveSource_LeftHand).x);
// update trackpads / touch / button
if (controllerRight.type == XRInputControllerType.HTCVive)
{
controllerRight.joystick.Update(GetAnalogState(viveAction_Touchpad1, viveSource_RightHand));
controllerRight.buttonJoystick.Update(GetButtonState(viveAction_Touchpad1_Button, viveSource_RightHand));
}
else
{
controllerRight.joystick2.Update(GetAnalogState(viveAction_Touchpad1, viveSource_RightHand));
controllerRight.buttonJoystick2.Update(GetButtonState(viveAction_Touchpad1_Button, viveSource_RightHand));
}
if (controllerLeft.type == XRInputControllerType.HTCVive)
{
controllerLeft.joystick.Update(GetAnalogState(viveAction_Touchpad1, viveSource_LeftHand));
controllerLeft.buttonJoystick.Update(GetButtonState(viveAction_Touchpad1_Button, viveSource_LeftHand));
}
else
{
controllerLeft.joystick2.Update(GetAnalogState(viveAction_Touchpad1, viveSource_LeftHand));
controllerLeft.buttonJoystick2.Update(GetButtonState(viveAction_Touchpad1_Button, viveSource_LeftHand));
}
// update joysticks / touch / button
if (controllerRight.type != XRInputControllerType.HTCVive)
{
controllerRight.joystick.Update(GetAnalogState(viveAction_Joystick1, viveSource_RightHand));
controllerRight.touchJoystick.Update(GetButtonState(viveAction_Joystick1_Touch, viveSource_RightHand));
controllerRight.buttonJoystick.Update(GetButtonState(viveAction_Joystick1_Button, viveSource_RightHand));
}
if (controllerLeft.type != XRInputControllerType.HTCVive)
{
controllerLeft.joystick.Update(GetAnalogState(viveAction_Joystick1, viveSource_LeftHand));
controllerLeft.touchJoystick.Update(GetButtonState(viveAction_Joystick1_Touch, viveSource_LeftHand));
controllerLeft.buttonJoystick.Update(GetButtonState(viveAction_Joystick1_Button, viveSource_LeftHand));
}
// copy back hand updates
if (rightSet)
{
state_controllers[rightSetIndex] = controllerRight;
}
if (leftSet)
{
state_controllers[leftSetIndex] = controllerLeft;
}
return(true);
}
protected override void UpdateTrackingInput(XRControllerState controllerState)
{
// Get position from pose action
// Get rotation from position action
}
protected override void UpdateTrackingInput(XRControllerState controllerState)
{
base.UpdateTrackingInput(controllerState);
controllerState.poseDataFlags = PoseDataFlags.NoData;
}
public IEnumerator ObjectsCanRegisterDuringEvents()
{
var manager = TestUtilities.CreateInteractionManager();
var interactor = TestUtilities.CreateRayInteractor();
var interactable = TestUtilities.CreateSimpleInteractable();
interactable.transform.position = interactor.transform.position + interactor.transform.forward * 5f;
var otherInteractor = TestUtilities.CreateDirectInteractor();
var otherInteractable = TestUtilities.CreateSimpleInteractable();
otherInteractor.enabled = false;
otherInteractable.enabled = false;
// Don't let them get in the way, both are only used to test registration
otherInteractor.interactionLayerMask = 0;
otherInteractable.interactionLayerMask = 0;
// Upon Select, enable the other Interactor to have it register with the Interaction Manager during the update loop.
// Upon Deselect, disable the other Interactor to have it unregister from the Interaction Manager during the update loop.
interactor.selectEntered.AddListener(args =>
{
otherInteractor.enabled = true;
otherInteractable.enabled = true;
});
interactor.selectExited.AddListener(args =>
{
otherInteractor.enabled = false;
otherInteractable.enabled = false;
});
// Prepare controller state which will be used to cause a Select during the Interaction Manager update loop
var controller = interactor.GetComponent <XRBaseController>();
var controllerState = new XRControllerState(0f, Vector3.zero, Quaternion.identity, false, false, false);
controller.SetControllerState(controllerState);
var interactors = new List <XRBaseInteractor>();
var interactables = new List <XRBaseInteractable>();
manager.GetRegisteredInteractors(interactors);
manager.GetRegisteredInteractables(interactables);
Assert.That(interactors, Is.EqualTo(new[] { interactor }));
Assert.That(interactables, Is.EqualTo(new[] { interactable }));
// Wait for Physics update to ensure the Interactable can be detected by the Interactor
yield return(new WaitForFixedUpdate());
yield return(null);
Assert.That(interactable.isHovered, Is.True);
Assert.That(interactable.isSelected, Is.False);
// Press Grip
controllerState.selectInteractionState = new InteractionState {
active = true, activatedThisFrame = true
};
yield return(null);
Assert.That(interactable.isHovered, Is.True);
Assert.That(interactable.isSelected, Is.True);
manager.GetRegisteredInteractors(interactors);
manager.GetRegisteredInteractables(interactables);
Assert.That(interactors, Is.EqualTo(new XRBaseInteractor[] { interactor, otherInteractor }));
Assert.That(interactables, Is.EqualTo(new XRBaseInteractable[] { interactable, otherInteractable }));
// Release Grip
controllerState.selectInteractionState = new InteractionState {
active = false, deactivatedThisFrame = true
};
yield return(null);
Assert.That(interactable.isHovered, Is.True);
Assert.That(interactable.isSelected, Is.False);
manager.GetRegisteredInteractors(interactors);
manager.GetRegisteredInteractables(interactables);
Assert.That(interactors, Is.EqualTo(new[] { interactor }));
Assert.That(interactables, Is.EqualTo(new[] { interactable }));
}
