private void Update()
{
if (!HandsManager.Instance || !HandsManager.Instance.IsInitialized() || !_isInitialized || _capsuleToTrack == null)
{
return;
}
OVRHand hand = IsRightHandedTool ? HandsManager.Instance.RightHand : HandsManager.Instance.LeftHand;
float currentScale = hand.HandScale;
// push tool into the tip based on how wide it is. so negate the direction
Transform capsuleTransform = _capsuleToTrack.CapsuleCollider.transform;
Vector3 capsuleDirection = capsuleTransform.right;
Vector3 trackedPosition = capsuleTransform.position + _capsuleToTrack.CapsuleCollider.height * 0.5f
* capsuleDirection;
Vector3 sphereRadiusOffset = currentScale * _fingerTipPokeToolView.SphereRadius *
capsuleDirection;
// push tool back so that it's centered on transform/bone
Vector3 toolPosition = trackedPosition + sphereRadiusOffset;
transform.position = toolPosition;
transform.rotation = capsuleTransform.rotation;
InteractionPosition = trackedPosition;
UpdateAverageVelocity();
CheckAndUpdateScale();
}
protected void UpdateHandData(OVRHand ovrHand, OVRSkeleton ovrSkeleton)
{
if (ovrSkeleton != null)
{
var bones = ovrSkeleton.Bones;
foreach (var bone in bones)
{
UpdateBone(bone);
}
UpdatePalm();
}
CoreServices.InputSystem?.RaiseHandJointsUpdated(InputSource, ControllerHandedness, jointPoses);
if (IsPinching)
{
// If we are already pinching, we make the pinch a bit sticky
IsPinching = ovrHand.GetFingerPinchStrength(OVRHand.HandFinger.Index) > 0.85f;
}
else
{
// If not yet pinching, only consider pinching if finger confidence is high
IsPinching = ovrHand.GetFingerIsPinching(OVRHand.HandFinger.Index) &&
ovrHand.GetFingerConfidence(OVRHand.HandFinger.Index) == OVRHand.TrackingConfidence.High;
}
}
public override void Enable()
{
base.Enable();
var ovrCameraRig = GameObject.FindObjectOfType <OVRCameraRig>();
var ovrHands = ovrCameraRig.GetComponentsInChildren <OVRHand>();
foreach (var ovrHand in ovrHands)
{
var skeltonDataProvider = ovrHand as OVRSkeleton.IOVRSkeletonDataProvider;
var skeltonType = skeltonDataProvider.GetSkeletonType();
var ovrSkelton = ovrHand.GetComponent <OVRSkeleton>();
if (ovrSkelton == null)
{
continue;
}
switch (skeltonType)
{
case OVRSkeleton.SkeletonType.HandLeft:
leftHand = ovrHand;
leftSkeleton = ovrSkelton;
break;
case OVRSkeleton.SkeletonType.HandRight:
rightHand = ovrHand;
rightSkeleton = ovrSkelton;
break;
}
}
}
public OculusQuestArticulatedHand(
TrackingState trackingState,
Handedness controllerHandedness,
IMixedRealityInputSource inputSource = null,
MixedRealityInteractionMapping[] interactions = null) : base(trackingState, controllerHandedness, inputSource, interactions)
{
var rigs = GameObject.FindObjectOfType <OVRCameraRig>();
var hands = rigs.GetComponentsInChildren <OVRHand>();
foreach (var item in hands)
{
switch (((OVRSkeleton.IOVRSkeletonDataProvider)item).GetSkeletonType())
{
case OVRSkeleton.SkeletonType.HandLeft:
if (controllerHandedness == Handedness.Left)
{
hand = item;
skeleton = item?.GetComponent <OVRSkeleton>();
}
break;
case OVRSkeleton.SkeletonType.HandRight:
if (controllerHandedness == Handedness.Right)
{
hand = item;
skeleton = item?.GetComponent <OVRSkeleton>();
}
break;
}
}
//var anchor = GameObject.Find((controllerHandedness == Handedness.Left) ? "LeftHandAnchor" : "RightHandAnchor");
//hand = anchor?.GetComponentInChildren<OVRHand>();
//skeleton = anchor?.GetComponentInChildren<OVRSkeleton>();
}
private void SetupInput()
{
cameraRig = GameObject.FindObjectOfType <OVRCameraRig>();
if (cameraRig == null)
{
var mainCamera = Camera.main;
Transform cameraParent = null;
if (mainCamera != null)
{
cameraParent = mainCamera.transform.parent;
// Destroy main camera
GameObject.Destroy(cameraParent.gameObject);
}
// Instantiate camera rig as a child of the MixedRealityPlayspace
cameraRig = GameObject.Instantiate(MRTKOculusConfig.Instance.OVRCameraRigPrefab);
}
bool useAvatarHands = MRTKOculusConfig.Instance.RenderAvatarHandsInsteadOfController;
// If using Avatar hands, de-activate ovr controller rendering
foreach (var controllerHelper in cameraRig.gameObject.GetComponentsInChildren <OVRControllerHelper>())
{
controllerHelper.gameObject.SetActive(!useAvatarHands);
}
if (useAvatarHands)
{
// Initialize the local avatar controller
GameObject.Instantiate(MRTKOculusConfig.Instance.LocalAvatarPrefab, cameraRig.trackingSpace);
}
var ovrHands = cameraRig.GetComponentsInChildren <OVRHand>();
foreach (var ovrHand in ovrHands)
{
var skeltonDataProvider = ovrHand as OVRSkeleton.IOVRSkeletonDataProvider;
var skeltonType = skeltonDataProvider.GetSkeletonType();
var ovrSkelton = ovrHand.GetComponent <OVRSkeleton>();
if (ovrSkelton == null)
{
continue;
}
switch (skeltonType)
{
case OVRSkeleton.SkeletonType.HandLeft:
leftHand = ovrHand;
leftSkeleton = ovrSkelton;
break;
case OVRSkeleton.SkeletonType.HandRight:
rightHand = ovrHand;
rightSkeleton = ovrSkelton;
break;
}
}
}
private OculusHand GetOrAddHand(Handedness handedness, OVRHand ovrHand)
{
if (trackedHands.ContainsKey(handedness))
{
return(trackedHands[handedness]);
}
// Add new hand
var pointers = RequestPointers(SupportedControllerType.ArticulatedHand, handedness);
var inputSourceType = InputSourceType.Hand;
IMixedRealityInputSystem inputSystem = Service as IMixedRealityInputSystem;
var inputSource = inputSystem?.RequestNewGenericInputSource($"Oculus Quest {handedness} Hand", pointers, inputSourceType);
OculusHand handController = new OculusHand(TrackingState.Tracked, handedness, inputSource);
handController.InitializeHand(ovrHand, MRTKOculusConfig.Instance.CustomHandMaterial);
for (int i = 0; i < handController.InputSource?.Pointers?.Length; i++)
{
handController.InputSource.Pointers[i].Controller = handController;
handController.UpdateHandMaterial(MRTKOculusConfig.Instance.CustomHandMaterial);
}
inputSystem?.RaiseSourceDetected(handController.InputSource, handController);
trackedHands.Add(handedness, handController);
return(handController);
}
internal void SetHand(string hand)
{
switch (hand.ToLower())
{
case "left":
if (rightGrabber != null && leftGrabber != null)
{
rightGrabber.enabled = false;
leftGrabber.enabled = true;
}
whichHand = OVRPlugin.Hand.HandLeft;
m_Hand = m_LeftHand;
break;
case "right":
if (rightGrabber != null && leftGrabber != null)
{
leftGrabber.enabled = false;
rightGrabber.enabled = true;
}
whichHand = OVRPlugin.Hand.HandRight;
m_Hand = m_RightHand;
break;
default:
MainController.PrintToLog("Hand wasn't set correctly.", MainController.LogType.Error);
SetHand("Right");
break;
}
}
private bool IsNeutral(OVRHand hand, OVRSkeleton handSkeleton)
{
return(!hand.GetFingerIsPinching(OVRHand.HandFinger.Index) &&
!hand.GetFingerIsPinching(OVRHand.HandFinger.Middle) &&
!IsFistClosed(handSkeleton) &&
!IsPalmFlatWhileThumbIsUp(handSkeleton));
}
private OculusHand GetOrAddHand(Handedness handedness, OVRHand ovrHand)
{
if (trackedHands.ContainsKey(handedness))
{
return(trackedHands[handedness]);
}
// Add new hand
var pointers = RequestPointers(SupportedControllerType.ArticulatedHand, handedness);
var inputSourceType = InputSourceType.Hand;
var inputSource = Service?.RequestNewGenericInputSource($"Oculus Quest {handedness} Hand", pointers, inputSourceType);
OculusHand handDevice = new OculusHand(TrackingState.Tracked, handedness, inputSource);
handDevice.InitializeHand(ovrHand, SettingsProfile);
for (int i = 0; i < handDevice.InputSource?.Pointers?.Length; i++)
{
handDevice.InputSource.Pointers[i].Controller = handDevice;
}
Service?.RaiseSourceDetected(handDevice.InputSource, handDevice);
trackedHands.Add(handedness, handDevice);
return(handDevice);
}
public void InjectInteractionOVRCameraRig(InteractionOVRCameraRig ovrCameraRig)
{
_ovrCameraRig = ovrCameraRig;
// Clear the cached values to force new values to be read on next access
_leftHand = null;
_rightHand = null;
}
// Start is called before the first frame update
protected override void Start()
{
base.Start();
hand = GetComponent <OVRHand>();
ske = GetComponent <OVRSkeleton>();
//ske.Freeze = false;
}
public void UpdateState(OVRHand hand, Interactable currFocusedInteractable)
{
float pinchStrength = hand.GetFingerPinchStrength(OVRHand.HandFinger.Index);
bool isPinching = Mathf.Abs(PINCH_STRENGTH_THRESHOLD - pinchStrength) < Mathf.Epsilon;
var oldPinchState = _currPinchState;
switch (oldPinchState)
{
case PinchState.PinchUp:
// can only be in pinch up for a single frame, so consider
// next frame carefully
if (isPinching)
{
_currPinchState = PinchState.PinchDown;
if (currFocusedInteractable != _firstFocusedInteractable)
{
_firstFocusedInteractable = null;
}
}
else
{
_currPinchState = PinchState.None;
_firstFocusedInteractable = null;
}
break;
case PinchState.PinchStay:
if (!isPinching)
{
_currPinchState = PinchState.PinchUp;
}
// if object is not focused anymore, then forget it
if (currFocusedInteractable != _firstFocusedInteractable)
{
_firstFocusedInteractable = null;
}
break;
// pinch down lasts for a max of 1 frame. either go to pinch stay or up
case PinchState.PinchDown:
_currPinchState = isPinching ? PinchState.PinchStay : PinchState.PinchUp;
// if the focused interactable changes, then the original one is now invalid
if (_firstFocusedInteractable != currFocusedInteractable)
{
_firstFocusedInteractable = null;
}
break;
default:
if (isPinching)
{
_currPinchState = PinchState.PinchDown;
// this is the interactable that must be focused through out the pinch up and down
// gesture.
_firstFocusedInteractable = currFocusedInteractable;
}
break;
}
}
public void InitializeHand(OVRHand ovrHand, OculusXRSDKDeviceManagerProfile deviceManagerSettings)
{
settingsProfile = deviceManagerSettings;
handRenderer = ovrHand.GetComponent <Renderer>();
UpdateHandMaterial(settingsProfile.CustomHandMaterial);
pinchStrengthProp = Shader.PropertyToID(settingsProfile.PinchStrengthMaterialProperty);
}
void OnTriggerExit(Collider other)
{
OVRHand hand = other.GetComponent <OVRHand>();
if (hand != null)
{
currHandCount--;
}
}
GestureSO CheckRecognition(OVRSkeleton skeleton, List <OVRBone> fingerBones, OVRHand hand)
{
if (fingerBones.Count == 0)
{
return(null);
}
if (!hand.IsTracked)
{
return(null);
}
if (!hand.IsDataHighConfidence && waitForHighConfidenceData)
{
return(null);
}
// fist gesture
float sumDistance = 0;
bool isDiscarded = false;
for (int i = 0; i < fingerBones.Count; i++)
{
Vector3 currentData = skeleton.transform.InverseTransformPoint(fingerBones[i].Transform.position);
float distance = Vector3.Distance(fistGesture.fingerPositions[i], currentData);
if (distance > recognitionThreshold)
{
isDiscarded = true;
break;
}
sumDistance = distance;
}
if (!isDiscarded)
{
return(fistGesture);
}
// palm gesture
sumDistance = 0;
isDiscarded = false;
for (int i = 0; i < fingerBones.Count; i++)
{
Vector3 currentData = skeleton.transform.InverseTransformPoint(fingerBones[i].Transform.position);
float distance = Vector3.Distance(palmGesture.fingerPositions[i], currentData);
if (distance > recognitionThreshold)
{
isDiscarded = true;
break;
}
sumDistance = distance;
}
if (!isDiscarded)
{
return(palmGesture);
}
return(null);
}
void OnTriggerEnter(Collider other)
{
OVRHand hand = other.GetComponent <OVRHand>();
if (hand != null)
{
currHandCount++;
}
lastScaleDelta = -1;
}
// Start is called before the first frame update
void Start()
{
skeleton = this.GetComponent <OVRSkeleton>();
hand = this.GetComponent <OVRHand>();
foreach (var bone in skeleton.Bones)
{
Debug.Log(bone.Id);
}
}
private void Awake()
{
controllerHand = GetComponent <SkeletalControllerHand>();
handAnimator = GetComponent <Animator>();
hand = controllerTransform.GetComponentInChildren <OVRHand>();
skeleton = hand.GetComponent <OVRSkeleton>();
GetControllerHashes();
}
private void Awake()
{
_rightRaycastViz = transform.GetChild(0).GetComponent <LineRenderer>();
_leftRaycastViz = transform.GetChild(1).GetComponent <LineRenderer>();
_rightHand = RightMarker.Instance.transform;
_leftHand = LeftMarker.Instance.transform;
_rightHandPoser = _rightHand.GetComponentInChildren <OVRHand>();
_leftHandPoser = _leftHand.GetComponentInChildren <OVRHand>();
_input = AtomicInput.Instance;
}
// Start is called before the first frame update
void Start()
{
l_hand = GetComponent <OVRHand>();
l_finger = GetComponent <OVRSkeleton>();
r_finger = r_hand.GetComponent <OVRSkeleton>();
r_isIndexFingerPinching = r_hand.GetFingerIsPinching(OVRHand.HandFinger.Index);
l_isIndexFingerPinching = l_hand.GetFingerIsPinching(OVRHand.HandFinger.Index);
initial_position = item.transform.position;
inkRenderer = ink.GetComponent <Renderer>();
}
protected void UpdateHand(OVRHand ovrHand, OVRSkeleton ovrSkeleton, Handedness handedness)
{
if (ovrHand.IsTracked)
{
var hand = GetOrAddHand(handedness, ovrHand);
hand.UpdateController(ovrHand, ovrSkeleton, cameraRig.trackingSpace);
}
else
{
RemoveHandDevice(handedness);
}
}
private void Awake()
{
_input = AtomicInput.Instance;
right = transform.name.Contains("Right");
_hand = (right)
? RightMarker.Instance.GetComponentInChildren <OVRHand>()
: LeftMarker.Instance.GetComponentInChildren <OVRHand>();
_skeleton = (right)
? RightMarker.Instance.GetComponentInChildren <OVRSkeleton>()
: LeftMarker.Instance.GetComponentInChildren <OVRSkeleton>();
vRenderer = GetComponent <MeshRenderer>();
}
/// <summary>
/// Get a float value the finger pinch strength based on the abstract input button
/// </summary>
/// <param name="h">Which hand is the axis on</param>
/// <param name="b">Which button is being pressed</param>
/// <returns>A float from 0-1 indicating how much the input has been pressed</returns>
public override float GetAxis(Hand h, Button b)
{
GameObject handObj = (h == Hand.Left) ? leftHand : rightHand;
OVRHand hand = handObj.GetComponent <OVRHand>();
HandFinger finger = FingerMap(b);
if (hand && hand.GetFingerConfidence(finger) == TrackingConfidence.High)
{
return(hand.GetFingerPinchStrength(finger));
}
return(0f);
}
public OVRHandReflection(OVRHand hand)
{
Hand = hand;
PointerPoseGo = typeof(OVRHand).CreateFieldAccess <OVRHand, GameObject>(Hand, "_pointerPoseGO");
PointerPose = typeof(OVRHand).CreateFieldAccess <OVRHand, Transform>(Hand, "PointerPose", true);
IsInitialized = typeof(OVRHand).CreateFieldAccess <OVRHand, bool>(Hand, "_isInitialized");
IsTracked = typeof(OVRHand).CreateFieldAccess <OVRHand, bool>(Hand, "IsTracked", true);
IsSystemGestureInProgress = typeof(OVRHand).CreateFieldAccess <OVRHand, bool>(Hand, "IsSystemGestureInProgress", true);
IsPointerPoseValid = typeof(OVRHand).CreateFieldAccess <OVRHand, bool>(Hand, "IsPointerPoseValid", true);
HandScale = typeof(OVRHand).CreateFieldAccess <OVRHand, float>(Hand, "HandScale", true);
HandConfidence = typeof(OVRHand).CreateFieldAccess <OVRHand, OVRHand.TrackingConfidence>(Hand, "HandConfidence", true);
HandState = typeof(OVRHand).CreateFieldAccess <OVRHand, OVRPlugin.HandState>(Hand, "_handState");
}
/// <summary>
/// Get whether the correct finger has been pinched based on the abstract input button
/// </summary>
/// <param name="h">Which hand is the button on</param>
/// <param name="b">Which button is being pressed</param>
/// <returns>A bool indicating whether the given button has been pressed</returns>
public override bool GetButton(Hand h, Button b)
{
var handObj = (h == Hand.Left) ? leftHand : rightHand;
OVRHand hand = handObj.ActualOvrHand;
HandFinger finger = FingerMap(b);
if (hand && hand.GetFingerConfidence(finger) == TrackingConfidence.High)
{
return(hand.GetFingerIsPinching(finger));
}
return(false); //null check for hand
}
/// <summary>
/// Get a float value the finger pinch strength based on the abstract input button
/// </summary>
/// <param name="h">Which hand is the axis on</param>
/// <param name="b">Which button is being pressed</param>
/// <returns>A float from 0-1 indicating how much the input has been pressed</returns>
public override float GetAxis(Hand h, Button b)
{
var handObj = (h == Hand.Left) ? leftHand : rightHand;
OVRHand hand = handObj.ActualOvrHand;
HandFinger finger = FingerMap(b);
if (hand && hand.GetFingerConfidence(finger) == TrackingConfidence.High)
{
return(hand.GetFingerPinchStrength(finger));
}
return(0f);
}
private OculusQuestHand GetOrAddHand(Handedness handedness, OVRHand ovrHand)
{
if (trackedHands.ContainsKey(handedness))
{
return(trackedHands[handedness]);
}
Material handMaterial = null;
if (handedness == Handedness.Right)
{
if (rightHandMaterial == null)
{
rightHandMaterial = new Material(MRTKOculusConfig.Instance.CustomHandMaterial);
}
handMaterial = rightHandMaterial;
}
else
{
if (leftHandMaterial == null)
{
leftHandMaterial = new Material(MRTKOculusConfig.Instance.CustomHandMaterial);
}
handMaterial = leftHandMaterial;
}
// Add new hand
var pointers = RequestPointers(SupportedControllerType.ArticulatedHand, handedness);
var inputSourceType = InputSourceType.Hand;
IMixedRealityInputSystem inputSystem = Service as IMixedRealityInputSystem;
var inputSource = inputSystem?.RequestNewGenericInputSource($"Oculus Quest {handedness} Hand", pointers, inputSourceType);
var controller = new OculusQuestHand(TrackingState.Tracked, handedness, ovrHand, handMaterial, inputSource);
// Code is obsolete later on, but older MRTK versions require it.
#pragma warning disable 618
controller.SetupConfiguration(typeof(OculusQuestHand));
#pragma warning restore 618
for (int i = 0; i < controller.InputSource?.Pointers?.Length; i++)
{
controller.InputSource.Pointers[i].Controller = controller;
}
inputSystem?.RaiseSourceDetected(controller.InputSource, controller);
trackedHands.Add(handedness, controller);
return(controller);
}
private void Awake()
{
if (!gameObject.activeInHierarchy)
{
return;
}
_rightColliders = transform.GetChild(0).GetComponentsInChildren <Collider>();
_leftColliders = transform.GetChild(1).GetComponentsInChildren <Collider>();
_input = AtomicInput.Instance;
_rightStartingPointRenderer = rightStartingPoint.GetComponentsInChildren <MeshRenderer>();
if (rightCurrentPositionMarker == null)
{
Debug.LogError("The TranslationToolController couldn't locate its right position marker. Please assign it in Inspector.");
}
else
{
_rightCurrentPositionRenderer = rightCurrentPositionMarker.GetComponent <MeshRenderer>();
}
rightLineRenderer = transform.GetComponentInChildren <LineRenderer>();
_leftStartingPointRenderer = leftStartingPoint.GetComponentsInChildren <MeshRenderer>();
if (leftCurrentPositionMarker == null)
{
Debug.LogError("The TranslationToolController couldn't locate its left position marker. Please assign it in Inspector.");
}
else
{
_leftCurrentPositionRenderer = leftCurrentPositionMarker.GetComponent <MeshRenderer>();
}
_rightControllerMarker = RightMarker.Instance;
_leftControllerMarker = LeftMarker.Instance;
_rightHandPoser = _rightControllerMarker.transform.GetComponentInChildren <OVRHand>();
_leftHandPoser = _leftControllerMarker.transform.GetComponentInChildren <OVRHand>();
_rightHandSkeleton = _rightControllerMarker.transform.GetComponentInChildren <OVRSkeleton>();
_leftHandSkeleton = _leftControllerMarker.transform.GetComponentInChildren <OVRSkeleton>();
_rightPreMarkerRenderer = _rightPreMarker.GetChild(0).GetComponent <MeshRenderer>();
_leftPreMarkerRenderer = _leftPreMarker.GetChild(0).GetComponent <MeshRenderer>();
ToggleTranslateToolVisibility(false, false);
ToggleTranslateToolVisibility(false, true);
ToggleTranslateToolColliders(false, false);
ToggleTranslateToolColliders(false, true);
}
protected override void Awake()
{
base.Awake();
hand = controllerTransform.GetComponentInChildren <OVRHand>();
skeleton = hand.GetComponent <OVRSkeleton>();
GetControllerHashes();
fingerBasis = new BoneBasis()
{
Forward = fingerForward, Up = fingerUp
};
}
private void Awake()
{
_input = AtomicInput.Instance;
_rightHandMarker = RightMarker.Instance;
_leftHandMarker = LeftMarker.Instance;
_rightHandSkeleton = _rightHandMarker.transform.GetComponentInChildren <OVRSkeleton>();
_leftHandSkeleton = _leftHandMarker.transform.GetComponentInChildren <OVRSkeleton>();
_rightHand = _rightHandMarker.transform.GetComponentInChildren <OVRHand>();
_leftHand = _leftHandMarker.transform.GetComponentInChildren <OVRHand>();
_rightHighlights = transform.GetChild(0).GetComponentsInChildren <TransformationModeHighlight>(true).ToList();
_leftHighlights = transform.GetChild(1).GetComponentsInChildren <TransformationModeHighlight>(true).ToList();
_rightColliders = transform.GetChild(0).GetComponentsInChildren <Collider>(true);
_leftColliders = transform.GetChild(1).GetComponentsInChildren <Collider>(true);
_rightMainRenderers = new List <MeshRenderer>();
_leftMainRenderers = new List <MeshRenderer>();
MeshRenderer[] allRightRenderers = transform.GetChild(0).GetComponentsInChildren <MeshRenderer>(true);
foreach (MeshRenderer renderer in allRightRenderers)
{
if (renderer.GetComponent <TransformationModeHighlight>() == null)
{
_rightMainRenderers.Add(renderer);
}
}
MeshRenderer[] allLeftRenderers = transform.GetChild(1).GetComponentsInChildren <MeshRenderer>(true);
foreach (MeshRenderer renderer in allLeftRenderers)
{
if (renderer.GetComponent <TransformationModeHighlight>() == null)
{
_leftMainRenderers.Add(renderer);
}
}
_rightTextObjects = transform.GetChild(0).GetComponentsInChildren <Text>();
_leftTextObjects = transform.GetChild(1).GetComponentsInChildren <Text>();
_rightLabelGroup = transform.GetChild(0).GetComponentInChildren <CanvasGroup>();
_leftLabelGroup = transform.GetChild(1).GetComponentInChildren <CanvasGroup>();
_rightPositionMarker = transform.GetChild(0);
_leftPositionMarker = transform.GetChild(1);
InitializeHighlightCapabilityOnBothCameras();
}
