public override void Process()
{
for (var j = 0; j < Pointers.Count; j++)
{
var pointer = Pointers[j];
if (!pointer || pointer.Camera == null || !pointer.isActiveAndEnabled)
{
continue;
}
pointer.CurrentUIElement = null;
for (var i = 0; i < UICanvases.Count; i++)
{
var canvas = UICanvases[i];
canvas.worldCamera = pointer.Camera;
}
pointer.Process();
eventSystem.RaycastAll(pointer.PointerEventData, m_RaycastResultCache);
pointer.PointerEventData.pointerCurrentRaycast = FindFirstRaycast(m_RaycastResultCache);
m_RaycastResultCache.Clear();
pointer.CurrentUIElement = pointer.PointerEventData.pointerCurrentRaycast.gameObject;
// Removed continue because it causes lingering hover after pointer moves off of raycast-able objects
//if (!pointer.PointerEventData.pointerCurrentRaycast.isValid)
// continue;
var screenPosition = (Vector2)pointer.Camera.WorldToScreenPoint(pointer.PointerEventData.pointerCurrentRaycast.worldPosition);
var delta = screenPosition - pointer.PointerEventData.position;
pointer.PointerEventData.position = screenPosition;
pointer.PointerEventData.delta = delta;
var buttonState = HVRController.GetButtonState(pointer.HandSide, PressButton);
ProcessMove(pointer.PointerEventData);
if (buttonState.JustActivated && pointer.PointerEventData.pointerCurrentRaycast.isValid)
{
ProcessPress(pointer);
}
else if (buttonState.Active && pointer.PointerEventData.pointerCurrentRaycast.isValid)
{
ProcessDrag(pointer.PointerEventData);
}
else if (buttonState.JustDeactivated)
{
ProcessRelease(pointer);
}
}
for (var i = 0; i < UICanvases.Count; i++)
{
var canvas = UICanvases[i];
canvas.worldCamera = null;
}
}
private void UpdateLeftController(InputDevice device)
{
// LeftHasTrackPad = false;
LeftFeatures.Clear();
var inputFeatures = new List <UnityEngine.XR.InputFeatureUsage>();
if (device.TryGetFeatureUsages(inputFeatures))
{
foreach (var feature in inputFeatures)
{
LeftFeatures.Add($"{feature.name}");
if (feature.name == "Secondary2DAxis")
{
// LeftHasTrackPad = true;
}
}
}
LeftXRInputSystem = GetController(LeftDevice.manufacturer?.ToLower(), LeftDevice.name?.ToLower());
LeftController = UpdateController(LeftXRInputSystem, device, HVRHandSide.Left);
if (device.isValid)
{
LeftControllerConnected.Invoke(LeftController);
}
}
private void ControllerConnected(HVRController controller)
{
switch (controller.ControllerType)
{
case HVRControllerType.Oculus:
CenterOfMass = Oculus;
break;
case HVRControllerType.WMRButtons:
case HVRControllerType.WMR:
CenterOfMass = WMR;
break;
case HVRControllerType.Vive:
CenterOfMass = Vive;
break;
case HVRControllerType.Knuckles:
CenterOfMass = Knuckles;
break;
default:
CenterOfMass = Fallback;
break;
}
if (!CenterOfMass)
{
CenterOfMass = Fallback;
}
if (!CenterOfMass)
{
CenterOfMass = transform;
}
}
protected virtual bool GetTeleportActivated()
{
if (HVRInputManager.Instance.RightController.ControllerType == HVRControllerType.Vive)
{
return(HVRController.GetButtonState(HVRHandSide.Right, HVRButtons.Menu).Active);
}
return(TeleportController.JoystickAxis.y < -.5f && Mathf.Abs(TeleportController.JoystickAxis.x) < .30);
}
protected virtual bool GetTeleportDeactivated()
{
if (HVRInputManager.Instance.RightController.ControllerType == HVRControllerType.Vive)
{
return(HVRController.GetButtonState(HVRHandSide.Right, HVRButtons.Menu).JustDeactivated);
}
return(TeleportController.JoystickAxis.y > -.25f);
}
protected override void CheckInput(HVRController controller)
{
if (controller.TrackpadButtonState.JustActivated)
{
Activated.Invoke();
}
else if (controller.TrackpadButtonState.JustDeactivated)
{
Deactivated.Invoke();
}
}
protected override void CheckInput(HVRController controller)
{
if (controller.TrackPadRight.JustActivated)
{
Activated.Invoke();
}
else if (controller.TrackPadRight.JustDeactivated)
{
Deactivated.Invoke();
}
}
protected override void CheckInput(HVRController controller)
{
if (controller.TriggerTouchState.JustActivated)
{
Activated.Invoke();
}
else if (controller.TriggerTouchState.JustDeactivated)
{
Deactivated.Invoke();
}
}
protected override void CheckInput(HVRController controller)
{
Value = controller.Trigger;
if (controller.TriggerButtonState.JustActivated)
{
Activated.Invoke();
}
else if (controller.TriggerButtonState.JustDeactivated)
{
Deactivated.Invoke();
}
}
private void ControllerConnected(HVRController controller)
{
if (controller.InputMap)
{
//Debug.Log($"offsetting based on {controller.InputMap.name},{controller.InputMap.ControllerRotationOffset},{controller.InputMap.ControllerPositionOffset}");
var angles = transform.localEulerAngles = controller.InputMap.ControllerRotationOffset;
transform.localPosition = controller.InputMap.ControllerPositionOffset;
if (HandSide == HVRHandSide.Left)
{
var position = transform.localPosition;
position.x *= -1;
transform.localPosition = position;
angles.y *= -1;
angles.z *= -1;
transform.localEulerAngles = angles;
}
}
}
private void UpdateBlend(HVRHandPoseBlend blend)
{
var blendTarget = 0f;
if (blend.Type == BlendType.Immediate)
{
blendTarget = 1f;
}
else if (blend.ButtonParameter)
{
var button = HVRController.GetButtonState(Hand.Side, blend.Button);
if (blend.Type == BlendType.BooleanParameter)
{
blendTarget = button.Active ? 1f : 0f;
}
else if (blend.Type == BlendType.FloatParameter)
{
blendTarget = button.Value;
}
}
else if (!string.IsNullOrWhiteSpace(blend.AnimationParameter) && blend.AnimationParameter != "None")
{
if (blend.Type == BlendType.BooleanParameter)
{
blendTarget = HVRAnimationParameters.GetBoolParameter(Hand.Side, blend.AnimationParameter) ? 1f : 0f;
}
else if (blend.Type == BlendType.FloatParameter)
{
blendTarget = HVRAnimationParameters.GetFloatParameter(Hand.Side, blend.AnimationParameter);
}
}
if (blend.Speed > .1f)
{
blend.Value = Mathf.Lerp(blend.Value, blendTarget, Time.deltaTime * blend.Speed);
}
else
{
blend.Value = blendTarget;
}
}
protected override void CheckInput(HVRController controller)
{
var release = false;
if (controller.ControllerType == HVRControllerType.WMR)
{
release = controller.Side == HVRHandSide.Right ? controller.TrackPadLeft.JustActivated : controller.TrackPadRight.JustActivated;
}
else if (controller.ControllerType == HVRControllerType.Vive)
{
release = HVRInputManager.Instance.RightController.TrackPadDown.JustActivated;
}
else
{
release = controller.PrimaryButtonState.JustActivated;
}
if (release)
{
HVRRayCastGun.ReleaseAmmo();
}
}
protected abstract void CheckInput(HVRController controller);
private HVRController UpdateController(XRInputSystem sdk, InputDevice device, HVRHandSide side)
{
HVRInputSettings inputMap = null;
Vector2 deadZone = Vector2.zero;
HVRControllerType controllerType;
//var hasTrackPad = side == HVRHandSide.Left ? LeftHasTrackPad : RightHasTrackPad;
var wasNone = CurrentSDK == InputSDK.None;
GetSDK();
if (CurrentSDK == InputSDK.Oculus)
{
#if !HVR_OCULUS
Debug.LogWarning($"OVRInputs cannot be used because HVR_OCULUS define symbol is missing. Oculus Asset and the Hurricane Oculus Integration is required to use OVRInputs." +
$"Falling back to XRInputs.");
CurrentSDK = InputSDK.XRInput;
#endif
}
if (wasNone && CurrentSDK != InputSDK.None)
{
Debug.Log($"InputSDK : {CurrentSDK}");
}
switch (sdk)
{
case XRInputSystem.WMROpenVR:
inputMap = WMROpenVRInputMap;
deadZone = WMRDeadzone;
controllerType = HVRControllerType.WMR;
break;
case XRInputSystem.ReverbG2:
deadZone = WMRDeadzone;
inputMap = WMRWithButtonsInputMap;
controllerType = HVRControllerType.WMRButtons;
break;
case XRInputSystem.WMR:
inputMap = WMRInputMap;
deadZone = WMRDeadzone;
controllerType = HVRControllerType.WMR;
break;
case XRInputSystem.OculusOpenVR:
inputMap = OculusOpenVRInputMap;
deadZone = OculusDeadzone;
controllerType = HVRControllerType.Oculus;
break;
case XRInputSystem.Oculus:
inputMap = OculusInputMap;
deadZone = OculusDeadzone;
controllerType = HVRControllerType.Oculus;
break;
case XRInputSystem.Vive:
deadZone = ViveDeadzone;
inputMap = ViveInputMap;
controllerType = HVRControllerType.Vive;
break;
case XRInputSystem.Knuckles:
deadZone = KnucklesDeadzone;
inputMap = KnucklesInputMap;
controllerType = HVRControllerType.Knuckles;
break;
case XRInputSystem.Cosmos:
inputMap = CosmosInputMap;
deadZone = CosmosDeadzone;
controllerType = HVRControllerType.Cosmos;
break;
case XRInputSystem.None:
inputMap = OculusInputMap;
controllerType = HVRControllerType.None;
break;
default:
inputMap = OculusInputMap;
deadZone = OculusDeadzone;
controllerType = HVRControllerType.Oculus;
break;
}
if (!inputMap)
{
inputMap = OculusInputMap;
}
HVRController controller = null;
if (side == HVRHandSide.Left)
{
if (LeftOculusController)
{
LeftOculusController.enabled = false;
}
if (LeftSteamController)
{
LeftSteamController.enabled = false;
}
if (LeftXRInputController)
{
LeftXRInputController.enabled = false;
}
if (LeftInputSystemController)
{
LeftInputSystemController.enabled = false;
}
}
else
{
if (RightOculusController)
{
RightOculusController.enabled = false;
}
if (RightSteamController)
{
RightSteamController.enabled = false;
}
if (RightXRInputController)
{
RightXRInputController.enabled = false;
}
if (RightInputSystemController)
{
RightInputSystemController.enabled = false;
}
}
switch (CurrentSDK)
{
case InputSDK.None:
case InputSDK.XRInput:
controller = side == HVRHandSide.Left ? LeftXRInputController : RightXRInputController;
HVRXRInputController xrController = controller as HVRXRInputController;
if (!controller)
{
xrController = gameObject.AddComponent <HVRXRInputController>();
controller = xrController;
if (side == HVRHandSide.Left)
{
LeftXRInputController = controller;
}
else
{
RightXRInputController = controller;
}
}
break;
case InputSDK.Oculus:
#if HVR_OCULUS
controller = side == HVRHandSide.Left ? LeftOculusController : RightOculusController;
if (!controller)
{
var oculusController = gameObject.AddComponent <HVROculusController>();
controller = oculusController;
oculusController.OVRHaptics = OVRHaptics;
if (side == HVRHandSide.Left)
{
LeftOculusController = controller;
}
else
{
RightOculusController = controller;
}
}
#endif
break;
case InputSDK.SteamVR:
#if HVR_STEAMVR
controller = side == HVRHandSide.Left ? LeftSteamController : RightSteamController;
if (!controller)
{
var steamController = gameObject.AddComponent <HVRSteamVRController>();
controller = steamController;
if (side == HVRHandSide.Left)
{
LeftSteamController = steamController;
}
else
{
RightSteamController = steamController;
}
}
#endif
break;
case InputSDK.InputSystem:
#if ENABLE_INPUT_SYSTEM
controller = side == HVRHandSide.Left ? LeftInputSystemController : RightInputSystemController;
if (!controller)
{
var inputSystemController = gameObject.AddComponent <HVRInputSystemController>();
controller = inputSystemController;
if (side == HVRHandSide.Left)
{
LeftInputSystemController = inputSystemController;
}
else
{
RightInputSystemController = inputSystemController;
}
}
#endif
break;
default:
throw new ArgumentOutOfRangeException();
}
if (OverrideDeadzone)
{
deadZone = DeadzoneOverride;
}
if (controller != null)
{
controller.XRNode = side == HVRHandSide.Left ? XRNode.LeftHand : XRNode.RightHand;
controller.ThumbstickDeadZone = deadZone;
controller.Side = side;
controller.InputMap = inputMap;
controller.enabled = true;
controller.ControllerType = controllerType;
}
controller.FingerSettings = FingerSettings;
return(controller);
}
