private bool IsNeutral(OVRHand hand, OVRSkeleton handSkeleton)
{
return(!hand.GetFingerIsPinching(OVRHand.HandFinger.Index) &&
!hand.GetFingerIsPinching(OVRHand.HandFinger.Middle) &&
!IsFistClosed(handSkeleton) &&
!IsPalmFlatWhileThumbIsUp(handSkeleton));
}
// 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>();
}
void Update()
{
try
{
if (m_Hand == null || !m_Hand.IsTracked || !m_Hand.IsDataHighConfidence)
{
ChangePinchStateToTrue(TherapyData.PinchType.None);
return;
}
OVRPlugin.GetHandState(OVRPlugin.Step.Physics, whichHand, ref state);
//LateralTestsAndPinchDebuging();
if (m_Hand.GetFingerIsPinching(OVRHand.HandFinger.Index))
{
OVRPlugin.Quatf index = state.BoneRotations[(int)OVRSkeleton.BoneId.Hand_Index3];
OVRPlugin.Quatf thumb = state.BoneRotations[(int)OVRSkeleton.BoneId.Hand_Thumb3];
float angle = Vector3.Angle(new Vector3(index.x, index.y, index.z), new Vector3(thumb.x, thumb.y, thumb.z));
if (angle < 70) // Tip Pinch
{
if (m_Hand.GetFingerIsPinching(OVRHand.HandFinger.Middle)) // 3 finger are pinching
{
ChangePinchStateToTrue(TherapyData.PinchType.Tip3);
}
else
{
ChangePinchStateToTrue(TherapyData.PinchType.Tip2);
}
}
else if (angle > 70) // Pad Pinch
{
if (m_Hand.GetFingerIsPinching(OVRHand.HandFinger.Middle)) // 3 finger are pinching
{
ChangePinchStateToTrue(TherapyData.PinchType.Pad3);
}
else
{
ChangePinchStateToTrue(TherapyData.PinchType.Pad2);
}
}
}
else// Not pinching at all
{
ChangePinchStateToTrue(TherapyData.PinchType.None);
}
}
catch (Exception e)
{
MainController.PrintToLog(e.ToString(), MainController.LogType.Error);
//m_debugText.text = e.ToString();
}
}
/// <summary>
/// 掴もうとしているか？
/// </summary>
/// <returns></returns>
private (bool isPinching, Vector3 position) isPinchingHand(OVRHand hand)
{
Vector3 position = Vector3.zero;
bool isPinching = false;
if (hand.GetFingerIsPinching(OVRHand.HandFinger.Index) ||
hand.GetFingerIsPinching(OVRHand.HandFinger.Middle) ||
hand.GetFingerIsPinching(OVRHand.HandFinger.Ring))
{
position = hand.PointerPose.position;
isPinching = true;
}
return(isPinching, position);
}
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;
}
}
private void CheckPinchState()
{
bool isIndexFingerPinching = ovrHand.GetFingerIsPinching(OVRHand.HandFinger.Index);
float indexFingerPinchStrength = ovrHand.GetFingerPinchStrength(OVRHand.HandFinger.Index);
if (ovrHand.GetFingerConfidence(OVRHand.HandFinger.Index) != OVRHand.TrackingConfidence.High)
{
return;
}
// finger pinch down
if (isIndexFingerPinching && indexFingerPinchStrength >= minFingerPinchDownStrength)
{
UpdateLine();
IsPinchingReleased = true;
return;
}
// finger pinch up
if (IsPinchingReleased)
{
AddNewLineRenderer();
IsPinchingReleased = false;
}
}
// Update is called once per frame
void Update()
{
if (ovrhand.GetFingerIsPinching(OVRHand.HandFinger.Index))
{
Vector3 handPos = ovrhand.transform.position;
if (ovrhand.IsDataHighConfidence)
{
if (lastlocation != handPos)
{
positionDiff = handPos - lastlocation;
}
if (positionDiff.magnitude * 100 < 0.1f)
{
positionDiff = Vector3.zero;
}
Vector3 tempPos = positionDiff.normalized * moveSpeed * Time.deltaTime;
gameobject.transform.position = Vector3.Lerp(gameobject.transform.position, gameobject.transform.position + tempPos, Time.deltaTime);
lastlocation = handPos;
//gameobject.transform.SetParent(parent.transform, true);
releaseTime = 20;
}
}
else
{
if (releaseTime > 0)
{
releaseTime--;
//gameobject.transform.SetParent(null);
}
}
}
void isGrabbing()
{
// Ray ray;
Vector3 current = item.transform.position;
// Experiment with left and right hand pinch
l_isIndexFingerPinching = l_hand.GetFingerIsPinching(OVRHand.HandFinger.Index);
r_isIndexFingerPinching = r_hand.GetFingerIsPinching(OVRHand.HandFinger.Index);
if (r_isIndexFingerPinching)
{
item.transform.position = Vector3.Lerp(item.transform.position, r_finger.Bones[20].Transform.position, 50f * Time.deltaTime);
item.transform.rotation = Quaternion.Slerp(item.transform.rotation, r_hand.transform.rotation, 10f * Time.deltaTime);
}
if (!r_isIndexFingerPinching)
{
item.transform.position = Vector3.Lerp(item.transform.position, initial_position, 50f * Time.deltaTime);
item.transform.rotation = Quaternion.Slerp(item.transform.rotation, r_hand.transform.rotation, 10f * Time.deltaTime);
}
if (r_isIndexFingerPinching && l_isIndexFingerPinching)
{
RaycastHit hit;
if (Physics.Raycast(tip.transform.position, -tip.transform.up, out hit, .2f))
{
if (hit.collider.tag == "Board")
{
Instantiate(ink, hit.point - Vector3.forward * 0.01f, hit.transform.rotation);
}
}
}
}
// Update is called once per frame
void Update()
{
PitchingGesture_L = left.GetFingerIsPinching(HandFinger.Index);
PitchingGesture_R = right.GetFingerIsPinching(HandFinger.Index);
if (((PitchingGesture_L && PitchingGesture_R) || (PointingGesture_L && PointingGesture_R)) &&
canDetect)
{
leftIndexTipPos = leftIndexTip.Transform.position;
rightIndexTipPos = rightIndexTip.Transform.position;
// A is set to 0, B is set to -A
// (B-A)/2 will be median point assuming A is center
// But A is not center so (B-A)/2 has to me moved to A's position so: MedianPoint = A + (A-B)/2
tablePos.x = leftIndexTipPos.x + (rightIndexTipPos.x - leftIndexTipPos.x) / 2;
tablePos.y = leftIndexTipPos.y + (rightIndexTipPos.y - leftIndexTipPos.y) / 2;
tablePos.z = leftIndexTipPos.z + (rightIndexTipPos.z - leftIndexTipPos.z) / 2;
Vector3 v = rightIndexTipPos - leftIndexTipPos;
tableRot = Quaternion.FromToRotation(Vector3.right, v);
table.transform.position = tablePos;
table.transform.rotation = tableRot;
// Forced to stay in plane XZ
Vector3 r = table.transform.eulerAngles;
r.x = 0f;
r.z = 0f;
table.transform.eulerAngles = r;
}
}
private void UpdateDataPoses(SkeletonPoseData poseData)
{
_handDataAsset.HandScale = poseData.RootScale;
_handDataAsset.IsTracked = _ovrHand.IsTracked;
_handDataAsset.IsHighConfidence = poseData.IsDataHighConfidence;
_handDataAsset.IsDominantHand = _ovrHand.IsDominantHand;
_handDataAsset.RootPoseOrigin = _handDataAsset.IsTracked
? PoseOrigin.RawTrackedPose
: PoseOrigin.None;
for (var fingerIdx = 0; fingerIdx < Constants.NUM_FINGERS; fingerIdx++)
{
var ovrFingerIdx = (OVRHand.HandFinger)fingerIdx;
bool isPinching = _ovrHand.GetFingerIsPinching(ovrFingerIdx);
_handDataAsset.IsFingerPinching[fingerIdx] = isPinching;
bool isHighConfidence =
_ovrHand.GetFingerConfidence(ovrFingerIdx) == OVRHand.TrackingConfidence.High;
_handDataAsset.IsFingerHighConfidence[fingerIdx] = isHighConfidence;
float fingerPinchStrength = _ovrHand.GetFingerPinchStrength(ovrFingerIdx);
_handDataAsset.FingerPinchStrength[fingerIdx] = fingerPinchStrength;
}
// Read the poses directly from the poseData, so it isn't in conflict with
// any modifications that the application makes to OVRSkeleton
_handDataAsset.Root = new Pose()
{
position = poseData.RootPose.Position.FromFlippedZVector3f(),
rotation = poseData.RootPose.Orientation.FromFlippedZQuatf()
};
if (_ovrHand.IsPointerPoseValid)
{
_handDataAsset.PointerPoseOrigin = PoseOrigin.RawTrackedPose;
_handDataAsset.PointerPose = new Pose(_ovrHand.PointerPose.localPosition,
_ovrHand.PointerPose.localRotation);
}
else
{
_handDataAsset.PointerPoseOrigin = PoseOrigin.None;
}
// Hand joint rotations X axis needs flipping to get to Unity's coordinate system.
var bones = poseData.BoneRotations;
for (int i = 0; i < bones.Length; i++)
{
// When using Link in the Unity Editor, the first frame of hand data
// sometimes contains bad joint data.
_handDataAsset.Joints[i] = float.IsNaN(bones[i].w)
? Config.HandSkeleton.joints[i].pose.rotation
: bones[i].FromFlippedXQuatf();
}
_handDataAsset.Joints[0] = WristFixupRotation;
}
/// <summary>
/// Refactors duplicate code for each hand in the update loop used to check
/// whether a state change is needed this frame
/// </summary>
private void CheckForUpdates(bool right, ref HandGestureState current, ref HandGestureState previous, ref OVRHand hand, ref OVRSkeleton skeleton)
{
string handName = (right) ? "Right" : "Left";
previous = current;
if (!hand.IsTracked)
{
UpdateHandInput(true, handName + " not found", HandGestureState.Neutral);
}
else if (IsFistClosedThumbOut(skeleton))
{
UpdateHandInput(true, handName + " fist closed thumb out", HandGestureState.Stop);
}
else if (IsFistClosed(skeleton))
{
UpdateHandInput(true, handName + " fist closed", HandGestureState.SqueezeAll);
}
else if (hand.GetFingerIsPinching(OVRHand.HandFinger.Index))
{
UpdateHandInput(true, handName + " Index Finger is pinching", HandGestureState.Insert);
}
else if (hand.GetFingerIsPinching(OVRHand.HandFinger.Middle))
{
UpdateHandInput(true, handName + " Middle Finger is pinching", HandGestureState.DragSelection);
}
else if (IsPointingUpward(skeleton, true))
{
UpdateHandInput(true, handName + " pointing upward", HandGestureState.DeselectAll);
}
else if (IsPointingWithPalmDown(skeleton, true))
{
UpdateHandInput(true, handName + " hand pointing", HandGestureState.Deselection);
}
else if (IsPalmFlatDownThumbOut(skeleton, true))
{
UpdateHandInput(true, handName + " palm is flat and thumb is out", HandGestureState.Selection);
}
else
{
UpdateHandInput(true, handName + " neutral", HandGestureState.Neutral);
}
}
// Update is called once per frame
void Update()
{
if (Lovrhand.GetFingerIsPinching(OVRHand.HandFinger.Index) & Rovrhand.GetFingerIsPinching(OVRHand.HandFinger.Index))
{
if (isGrab)
{
disNew = (Lhand.transform.position - Rhand.transform.position).magnitude;
//scale = scale + disNew / dis;
if (Lovrhand.IsDataHighConfidence & Rovrhand.IsDataHighConfidence)
{
if (disNew - dis > 0)
{
gameobject.transform.localScale = gameobject.transform.localScale + Vector3.one * scaleSpeed * Time.deltaTime;
}
else
{
gameobject.transform.localScale = gameobject.transform.localScale - Vector3.one * scaleSpeed * Time.deltaTime;
}
dis = disNew;
}
}
else
{
isGrab = true;
dis = (Lhand.transform.position - Rhand.transform.position).sqrMagnitude;
releaseTime = 20;
}
}
else
{
if (releaseTime <= 0)
{
isGrab = false;
}
else
{
releaseTime--;
disNew = (Lhand.transform.position - Rhand.transform.position).magnitude;
//scale = scale + (disNew - dis) * 2f;
if (disNew - dis > 0)
{
gameobject.transform.localScale = gameobject.transform.localScale + Vector3.one * scaleSpeed * Time.deltaTime;
}
else
{
gameobject.transform.localScale = gameobject.transform.localScale - Vector3.one * scaleSpeed * Time.deltaTime;
}
dis = disNew;
}
}
}
/// <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
}
private void DetectPinch()
{
bool isPinching = OVRHand.GetFingerIsPinching(OVRHand.HandFinger.Index);
if (isPinching && !IsCurrentlyPinching)
{
IsCurrentlyPinching = true;
OnPinchStart.Invoke();
}
else if (!isPinching && IsCurrentlyPinching)
{
IsCurrentlyPinching = false;
OnPinchEnd.Invoke();
}
}
protected void UpdateHandData(OVRHand ovrHand, OVRSkeleton ovrSkeleton)
{
if (ovrSkeleton != null)
{
var bones = ovrSkeleton.Bones;
foreach (var bone in bones)
{
UpdateBone(bone);
}
UpdatePalm(bones);
}
CoreServices.InputSystem?.RaiseHandJointsUpdated(InputSource, ControllerHandedness, jointPoses);
IsPinching = ovrHand.GetFingerIsPinching(OVRHand.HandFinger.Index);
}
private void CheckPinchState()
{
bool isIndexFingerPinching = ovrHand.GetFingerIsPinching(OVRHand.HandFinger.Index);
float indexFingerPinchStrength = ovrHand.GetFingerPinchStrength(OVRHand.HandFinger.Index);
if (ovrHand.GetFingerConfidence(OVRHand.HandFinger.Index) != OVRHand.TrackingConfidence.High)
{
return;
}
// finger pinch down
if (isIndexFingerPinching && indexFingerPinchStrength >= minFingerPinchDownStrength)
{
objectToMove.position = boneToTrack.Transform.position;
return;
}
}
// Update is called once per frame
void Update()
{
if (ovrhand.GetFingerIsPinching(OVRHand.HandFinger.Index))
{
if (ovrhand.IsDataHighConfidence)
{
//gameobject.transform.SetParent(parent.transform, true);
gameobject.transform.rotation = Quaternion.RotateTowards(gameobject.transform.rotation, ovrhand.transform.rotation, 1f);
Debug.Log("pinch");
releaseTime = 15;
}
}
else
{
if (releaseTime >= 0)
{
releaseTime--;
//gameobject.transform.SetParent(null);
}
}
}
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;
}
// Disable hand if not tracked
if (handRenderer != null)
{
handRenderer.enabled = ovrHand.IsTracked;
}
if (MRTKOculusConfig.Instance.UpdateMaterialPinchStrengthValue && handMaterial != null)
{
handMaterial.SetFloat(pinchStrengthProp, ovrHand.GetFingerPinchStrength(OVRHand.HandFinger.Index));
}
}
private void Update()
{
//入力なし
_inputData.InputState = HpInputState.NoInput;
//指定した手のした座標を構造体にぶち込む
_inputData.InputPosition = _ovrSkeleton.Bones[(int)_boneId].Transform.position;
Debug.Log(_inputData.InputPosition);
//PinchPoseできてるかどうか
float currentPinchStrength = _ovrHand.GetFingerPinchStrength(_handFingerType);
bool isPinching = _ovrHand.GetFingerIsPinching(_handFingerType);
bool isPinchPose = isPinching && currentPinchStrength >= _minPinchStrengthValue;
//入力中
if (isPinchPose && _isInput)
{
Debug.Log("入力中");
_isInput = true;
_inputData.InputState = HpInputState.Input;
}
//入力した瞬間
if (isPinchPose && _isInput == false)
{
Debug.Log("入力した瞬間");
_isInput = true;
_inputData.InputState = HpInputState.InputDown;
}
//ピンチポーズしてない
if (isPinchPose == false)
{
_isInput = false;
}
//構造体をのせてメッセージを発行
_inputDataSubject.OnNext(_inputData);
}
void AlignWithHand(OVRHand hand, OVRSkeleton skeleton)
{
if (pinching)
{
if (hand.GetFingerPinchStrength(OVRHand.HandFinger.Index) < 0.8f)
{
pinching = false;
}
}
else
{
if (hand.GetFingerIsPinching(OVRHand.HandFinger.Index))
{
if (GetComponent <Flashlight>())
{
GetComponent <Flashlight>().ToggleFlashlight();
}
pinching = true;
}
}
flashlightRoot.position = skeleton.Bones[6].Transform.position;
flashlightRoot.rotation = Quaternion.LookRotation(skeleton.Bones[6].Transform.position - skeleton.Bones[0].Transform.position);
}
void Update()
{
updateHandTracking();
if (IsHandTracking)
{
LeftHandConfidence = LeftHand.GetFingerConfidence(HandFinger.Index);
RightHandConfidence = RightHand.GetFingerConfidence(HandFinger.Index);
if (leftSkele != null && leftSkele.Bones != null)
{
leftIndexBone = leftSkele.Bones.FirstOrDefault(x => x.Id == OVRSkeleton.BoneId.Hand_IndexTip);
if (leftIndexBone != null)
{
LeftIndexPosition = leftIndexBone.Transform.position;
}
}
IsLeftIndexPinching = LeftHand.GetFingerIsPinching(HandFinger.Index) && LeftHandConfidence == TrackingConfidence.High;
LeftIndexPinchStrength = LeftHand.GetFingerPinchStrength(HandFinger.Index);
if (rightSkele && rightSkele.Bones != null)
{
rightIndexBone = rightSkele.Bones.FirstOrDefault(x => x.Id == OVRSkeleton.BoneId.Hand_IndexTip);
if (rightIndexBone != null)
{
RightIndexPosition = rightIndexBone.Transform.position;
}
}
IsRightIndexPinching = RightHand.GetFingerIsPinching(HandFinger.Index) && RightHandConfidence == TrackingConfidence.High;
RightIndexPinchStrength = RightHand.GetFingerPinchStrength(HandFinger.Index);
}
updateGrabbers();
}
public bool IsPinching(OVRHand.HandFinger finger)
{
return(_ovrHand.GetFingerIsPinching(finger));
}
private void Update()
{
//// right
//CheckForUpdates(true, ref currentRightHandGestureState, ref previousRightState, ref _rightHandState, ref _rightHandSkeleton);
previousRightState = currentRightHandGestureState;
if (!_rightHandState.IsTracked)
{
UpdateHandInput(true, "Right not found", HandGestureState.Neutral);
}
else if (IsFistClosedThumbOut(_rightHandSkeleton))
{
UpdateHandInput(true, "Right fist closed thumb out", HandGestureState.Stop);
}
else if (IsFistClosed(_rightHandSkeleton))
{
UpdateHandInput(true, "Right fist closed", HandGestureState.SqueezeAll);
}
else if (_rightHandState.GetFingerIsPinching(OVRHand.HandFinger.Index))
{
UpdateHandInput(true, "Right Index Finger is pinching", HandGestureState.Insert);
}
else if (_rightHandState.GetFingerIsPinching(OVRHand.HandFinger.Middle))
{
UpdateHandInput(true, "Right Middle Finger is pinching", HandGestureState.DragSelection);
}
else if (IsPointingUpward(_rightHandSkeleton, true))
{
UpdateHandInput(true, "Right pointing upward", HandGestureState.DeselectAll);
}
else if (IsPointingWithPalmDown(_rightHandSkeleton, true))
{
UpdateHandInput(true, "Right hand pointing", HandGestureState.Deselection);
}
else if (IsPalmFlatDownThumbOut(_rightHandSkeleton, true))
{
UpdateHandInput(true, "Right palm is flat and thumb is out", HandGestureState.Selection);
}
else
{
UpdateHandInput(true, "Right neutral", HandGestureState.Neutral);
}
//// left
//CheckForUpdates(false, ref currentLeftHandGestureState, ref previousLeftState, ref _leftHandState, ref _leftHandSkeleton);
previousLeftState = currentLeftHandGestureState;
if (!_leftHandState.IsTracked)
{
UpdateHandInput(false, "Left not found", HandGestureState.Neutral);
}
else if (IsFistClosedThumbOut(_leftHandSkeleton))
{
UpdateHandInput(false, "Left fist closed thumb out", HandGestureState.Stop);
string output = "Left fist closed thumb out ";
ILog(output + (_leftHandSkeleton.Bones[(int)BoneId.Hand_ThumbTip].Transform.position - _leftHandSkeleton.Bones[(int)BoneId.Hand_Index2].Transform.position).magnitude.ToString(), false);
}
else if (IsFistClosed(_leftHandSkeleton))
{
UpdateHandInput(false, "Left fist closed", HandGestureState.SqueezeAll);
}
else if (_leftHandState.GetFingerIsPinching(OVRHand.HandFinger.Index))
{
UpdateHandInput(false, "Left Index Finger is pinching", HandGestureState.Insert);
}
else if (_leftHandState.GetFingerIsPinching(OVRHand.HandFinger.Middle))
{
UpdateHandInput(false, "Left Middle Finger is pinching", HandGestureState.DragSelection);
}
else if (IsPointingUpward(_leftHandSkeleton, false))
{
UpdateHandInput(false, "Left pointing upward", HandGestureState.DeselectAll);
}
else if (IsPointingWithPalmDown(_leftHandSkeleton, false))
{
UpdateHandInput(false, "Left hand pointing", HandGestureState.Deselection);
}
else if (IsPalmFlatDownThumbOut(_leftHandSkeleton, false))
{
UpdateHandInput(false, "Left palm is flat and thumb is out", HandGestureState.Selection);
string output = "Left palm is flat and thumb is out ";
ILog(output +
(_leftHandSkeleton.Bones[(int)BoneId.Hand_IndexTip].Transform.position - _leftHandSkeleton.Bones[(int)BoneId.Hand_WristRoot].Transform.position).magnitude.ToString() + " " +
(_leftHandSkeleton.Bones[(int)BoneId.Hand_MiddleTip].Transform.position - _leftHandSkeleton.Bones[(int)BoneId.Hand_WristRoot].Transform.position).magnitude.ToString() + " " +
(_leftHandSkeleton.Bones[(int)BoneId.Hand_RingTip].Transform.position - _leftHandSkeleton.Bones[(int)BoneId.Hand_WristRoot].Transform.position).magnitude.ToString() + " " +
(_leftHandSkeleton.Bones[(int)BoneId.Hand_PinkyTip].Transform.position - _leftHandSkeleton.Bones[(int)BoneId.Hand_WristRoot].Transform.position).magnitude.ToString() + " " +
(_leftHandSkeleton.Bones[(int)BoneId.Hand_ThumbTip].Transform.position - _leftHandSkeleton.Bones[(int)BoneId.Hand_Index2].Transform.position).magnitude.ToString(), false);
}
else
{
UpdateHandInput(false, "Left neutral", HandGestureState.Neutral);
}
UpdateRotationState(true);
UpdateRotationState(false);
}
// Update is called once per frame
void Update()
{
bool isIndexFingerPinching = lefthand.GetFingerIsPinching(OVRHand.HandFinger.Index);
bool isMiddleFingerPinching = lefthand.GetFingerIsPinching(OVRHand.HandFinger.Middle);
bool isRingFingerPinching = lefthand.GetFingerIsPinching(OVRHand.HandFinger.Ring);
bool isPinkyFingerPinching = lefthand.GetFingerIsPinching(OVRHand.HandFinger.Pinky);
bool isRIndexFingerPinching = righthand.GetFingerIsPinching(OVRHand.HandFinger.Index);
bool isRMiddleFingerPinching = righthand.GetFingerIsPinching(OVRHand.HandFinger.Middle);
bool isRRingFingerPinching = righthand.GetFingerIsPinching(OVRHand.HandFinger.Ring);
bool isRPinkyFingerPinching = righthand.GetFingerIsPinching(OVRHand.HandFinger.Pinky);
if (boxtrigger)
{
if (state.state == 0)
{
if ((isIndexFingerPinching && !isRIndexFingerPinching) && eventtrigger)
{
cur = materials[1];
eventtrigger = false;
}
else if ((isMiddleFingerPinching && !isRMiddleFingerPinching) && eventtrigger)
{
cur = materials[2];
eventtrigger = false;
}
else if ((isRingFingerPinching && !isRRingFingerPinching) && eventtrigger)
{
cur = materials[3];
eventtrigger = false;
}
else if ((isPinkyFingerPinching && !isRPinkyFingerPinching) && eventtrigger)
{
cur = materials[4];
eventtrigger = false;
}
else if ((!isIndexFingerPinching && isRIndexFingerPinching) && eventtrigger)
{
cur = materials[5];
eventtrigger = false;
}
else if ((!isMiddleFingerPinching && isRMiddleFingerPinching) && eventtrigger)
{
cur = materials[6];
eventtrigger = false;
}
else if ((!isRingFingerPinching && isRRingFingerPinching) && eventtrigger)
{
cur = materials[7];
eventtrigger = false;
}
else if ((!isPinkyFingerPinching && isRPinkyFingerPinching) && eventtrigger)
{
cur = materials[8];
eventtrigger = false;
}
else if (!eventtrigger && !isIndexFingerPinching && !isMiddleFingerPinching && !isRingFingerPinching && !isPinkyFingerPinching &&
!isRIndexFingerPinching && !isRMiddleFingerPinching && !isRRingFingerPinching && !isRPinkyFingerPinching)
{
eventtrigger = true;
}
GetComponent <MeshRenderer>().material = cur;
}
else if (state.state == 1 && isIndexFingerPinching && !isRIndexFingerPinching)
{
this.gameObject.GetComponent <Transform>().localEulerAngles = leftanchor.GetComponent <Transform>().eulerAngles;
}
else if (state.state == 1 && isRIndexFingerPinching && !isIndexFingerPinching)
{
this.gameObject.GetComponent <Transform>().localEulerAngles = rightanchor.GetComponent <Transform>().eulerAngles;
}
else if (state.state == 1 && ((isMiddleFingerPinching && !isRMiddleFingerPinching) || (!isMiddleFingerPinching && isRMiddleFingerPinching)))
{
this.gameObject.GetComponent <Transform>().localScale = this.gameObject.GetComponent <Transform>().localScale - new Vector3(0.005f, 0.005f, 0.005f);
}
else if (state.state == 1 && ((isRingFingerPinching && !isRRingFingerPinching) || (!isRingFingerPinching && isRRingFingerPinching)))
{
this.gameObject.GetComponent <Transform>().localScale = this.gameObject.GetComponent <Transform>().localScale + new Vector3(0.005f, 0.005f, 0.005f);
}
else if (state.state == 2)
{
if (eventtrigger)
{
if (isIndexFingerPinching && !isRIndexFingerPinching)
{
Vector3 localchange = new Vector3(-leftanchor.GetComponent <Transform>().forward.z, leftanchor.GetComponent <Transform>().forward.y, leftanchor.GetComponent <Transform>().forward.x);
Vector3 temp = leftanchor.GetComponent <Transform>().position + localchange;
GameObject newObject = new GameObject();
Transform newTransform = newObject.transform;
newTransform.localPosition = temp;
Instantiate(this.gameObject, newTransform);
eventtrigger = false;
}
else if (isRIndexFingerPinching && !isIndexFingerPinching)
{
Vector3 localchange = new Vector3(-rightanchor.GetComponent <Transform>().forward.z, rightanchor.GetComponent <Transform>().forward.y, rightanchor.GetComponent <Transform>().forward.x);
Vector3 temp = rightanchor.GetComponent <Transform>().position + localchange;
GameObject newObject = new GameObject();
Transform newTransform = newObject.transform;
newTransform.localPosition = temp;
Instantiate(this.gameObject, newTransform);
eventtrigger = false;
}
}
if (!isIndexFingerPinching && !isRIndexFingerPinching)
{
eventtrigger = true;
}
}
else if (state.state == 3)
{
if (isRIndexFingerPinching && !isIndexFingerPinching)
{
this.gameObject.SetActive(false);
}
}
}
else
{
eventtrigger = true;
curleft = leftanchor.GetComponent <Transform>();
curright = rightanchor.GetComponent <Transform>();
}
}
public bool GetFingerIsPinching(FingerType fingerType)
{
OVRHand.HandFinger finger = ConvertFingerType(fingerType);
return(_hand.GetFingerIsPinching(finger));
}
public void UpdateController()
{
if (!Enabled)
{
return;
}
// hand pose
var lastState = TrackingState;
TrackingState = (hand.IsTracked) ? TrackingState.Tracked : TrackingState.NotTracked;
if (lastState != TrackingState)
{
CoreServices.InputSystem?.RaiseSourceTrackingStateChanged(InputSource, this, TrackingState);
}
if (TrackingState == TrackingState.Tracked)
{
var pose = new MixedRealityPose();
pose.Position = MixedRealityPlayspace.TransformPoint(hand.transform.position);
pose.Rotation = MixedRealityPlayspace.Rotation * hand.transform.rotation;
CoreServices.InputSystem?.RaiseSourcePoseChanged(InputSource, this, pose);
}
// hand interaction
if (Interactions == null)
{
Debug.LogError($"No interaction configuration for Oculus Quest Hand {ControllerHandedness} Source");
Enabled = false;
}
if (TrackingState == TrackingState.Tracked)
{
for (int i = 0; i < Interactions?.Length; i++)
{
var interaction = Interactions[i];
switch (interaction.InputType)
{
case DeviceInputType.None:
break;
case DeviceInputType.SpatialPointer:
// hand pointer
var pointer = new MixedRealityPose();
pointer.Position = MixedRealityPlayspace.TransformPoint(hand.PointerPose.position);
pointer.Rotation = MixedRealityPlayspace.Rotation * hand.PointerPose.rotation;
interaction.PoseData = pointer;
if (interaction.Changed)
{
CoreServices.InputSystem?.RaisePoseInputChanged(InputSource, ControllerHandedness, interaction.MixedRealityInputAction, pointer);
}
break;
case DeviceInputType.SpatialGrip:
if (interaction.AxisType == AxisType.SixDof)
{
var grip = new MixedRealityPose();
grip.Position = MixedRealityPlayspace.TransformPoint(hand.transform.position);
grip.Rotation = MixedRealityPlayspace.Rotation * hand.transform.rotation;
interaction.PoseData = grip;
if (interaction.Changed)
{
CoreServices.InputSystem?.RaisePoseInputChanged(InputSource, ControllerHandedness, interaction.MixedRealityInputAction, grip);
}
}
break;
case DeviceInputType.Select:
case DeviceInputType.TriggerPress:
interaction.BoolData = hand.GetFingerIsPinching(OVRHand.HandFinger.Index);
if (interaction.Changed)
{
if (interaction.BoolData)
{
CoreServices.InputSystem?.RaiseOnInputDown(InputSource, ControllerHandedness, interaction.MixedRealityInputAction);
}
else
{
CoreServices.InputSystem?.RaiseOnInputUp(InputSource, ControllerHandedness, interaction.MixedRealityInputAction);
}
}
break;
case DeviceInputType.IndexFinger:
if (jointPose.ContainsKey(TrackedHandJoint.IndexTip))
{
var indexFinger = jointPose[TrackedHandJoint.IndexTip];
interaction.PoseData = indexFinger;
if (interaction.Changed)
{
CoreServices.InputSystem?.RaisePoseInputChanged(InputSource, ControllerHandedness, interaction.MixedRealityInputAction, indexFinger);
}
}
break;
}
}
}
// hand joint
if (TrackingState == TrackingState.Tracked)
{
for (int i = 0; i < skeleton.Bones.Count; i++)
{
var bones = skeleton.Bones[i];
var handJoint = convertBoneIdToTrackedHandJoint(bones.Id);
var position = MixedRealityPlayspace.TransformPoint(bones.Transform.position);
var rotation = MixedRealityPlayspace.Rotation * bones.Transform.rotation;
if (jointPose.ContainsKey(handJoint))
{
jointPose[handJoint] = new MixedRealityPose(position, rotation);
}
else
{
jointPose.Add(handJoint, new MixedRealityPose(position, rotation));
}
}
CoreServices.InputSystem?.RaiseHandJointsUpdated(InputSource, ControllerHandedness, jointPose);
}
}
// Update is called once per frame
void Update()
{
bool lIndexPinch = lefthand.GetFingerIsPinching(OVRHand.HandFinger.Index);
bool lMiddlePinch = lefthand.GetFingerIsPinching(OVRHand.HandFinger.Middle);
bool lRingPinch = lefthand.GetFingerIsPinching(OVRHand.HandFinger.Ring);
bool lPinkyPinch = lefthand.GetFingerIsPinching(OVRHand.HandFinger.Pinky);
bool rIndexPinch = righthand.GetFingerIsPinching(OVRHand.HandFinger.Index);
bool rMiddlePinch = righthand.GetFingerIsPinching(OVRHand.HandFinger.Middle);
bool rRingPinch = righthand.GetFingerIsPinching(OVRHand.HandFinger.Ring);
bool rPinkyPinch = righthand.GetFingerIsPinching(OVRHand.HandFinger.Pinky);
/*if (lPinkyPinch && rPinkyPinch)
* {
* state++;
* if (state > 3)
* {
* state = 0;
* }
* cur = materials[state];
* GetComponent<MeshRenderer>().material = cur;
* }*/
if (lIndexPinch && rIndexPinch)
{
state = 1;
cur = materials[1];
GetComponent <MeshRenderer>().material = cur;
text.text = "Rotate/Scale Mode";
}
else if (lMiddlePinch && rMiddlePinch)
{
state = 2;
cur = materials[2];
GetComponent <MeshRenderer>().material = cur;
text.text = "Copy/Paste Mode";
}
else if (lRingPinch && rRingPinch)
{
state = 3;
cur = materials[3];
GetComponent <MeshRenderer>().material = cur;
text.text = "Create/Erase Mode";
}
else if (lPinkyPinch && rPinkyPinch)
{
state = 0;
cur = materials[0];
GetComponent <MeshRenderer>().material = cur;
text.text = "Color Mode";
}
if (state == 3 && lIndexPinch && !rIndexPinch && create)
{
Vector3 localchange = new Vector3(-leftanchor.GetComponent <Transform>().forward.z, leftanchor.GetComponent <Transform>().forward.y, leftanchor.GetComponent <Transform>().forward.x);
Vector3 temp = leftanchor.GetComponent <Transform>().position + localchange;
GameObject newObject = new GameObject();
Transform newTransform = newObject.transform;
newTransform.localPosition = temp;
//newTransform.localRotation = leftanchor.GetComponent<Transform>().rotation;
Instantiate(prefab, newTransform);
create = false;
}
if (state == 3 && !lIndexPinch)
{
create = true;
}
}
protected bool UpdateHandData(OVRHand ovrHand, OVRSkeleton ovrSkeleton)
{
bool isTracked = ovrHand.IsTracked;
if (ovrHand.HandConfidence == OVRHand.TrackingConfidence.High)
{
_lastHighConfidenceTime = Time.unscaledTime;
}
if (ovrHand.HandConfidence == OVRHand.TrackingConfidence.Low)
{
if (MRTKOculusConfig.Instance.MinimumHandConfidence == OVRHand.TrackingConfidence.High)
{
isTracked = false;
}
else
{
float lowConfidenceTime = Time.time - _lastHighConfidenceTime;
if (MRTKOculusConfig.Instance.LowConfidenceTimeThreshold > 0 &&
MRTKOculusConfig.Instance.LowConfidenceTimeThreshold < lowConfidenceTime)
{
isTracked = false;
}
}
}
if (ControllerHandedness == Handedness.Left)
{
MRTKOculusConfig.Instance.CurrentLeftHandTrackingConfidence = ovrHand.HandConfidence;
}
else
{
MRTKOculusConfig.Instance.CurrentRightHandTrackingConfidence = ovrHand.HandConfidence;
}
// Disable hand if not tracked
if (handRenderer != null)
{
handRenderer.enabled = isTracked;
}
if (ovrSkeleton != null)
{
var bones = ovrSkeleton.Bones;
foreach (var bone in bones)
{
UpdateBone(bone);
}
UpdatePalm();
}
CoreServices.InputSystem?.RaiseHandJointsUpdated(InputSource, ControllerHandedness, jointPoses);
// Note: After some testing, it seems when moving your hand fast, Oculus's pinch estimation data gets frozen, which leads to stuck pinches.
// To counter this, we perform a distance check between thumb and index to determine if we should force the pinch to a false state.
float pinchStrength;
if (AreIndexAndThumbFarApart())
{
pinchStrength = 0f;
IsPinching = false;
}
else
{
pinchStrength = ovrHand.GetFingerPinchStrength(OVRHand.HandFinger.Index);
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;
}
}
isIndexGrabbing = HandPoseUtils.IsIndexGrabbing(ControllerHandedness);
isMiddleGrabbing = HandPoseUtils.IsMiddleGrabbing(ControllerHandedness);
isThumbGrabbing = HandPoseUtils.IsThumbGrabbing(ControllerHandedness);
// Hand Curl Properties:
float indexFingerCurl = HandPoseUtils.IndexFingerCurl(ControllerHandedness);
float middleFingerCurl = HandPoseUtils.MiddleFingerCurl(ControllerHandedness);
float ringFingerCurl = HandPoseUtils.RingFingerCurl(ControllerHandedness);
float pinkyFingerCurl = HandPoseUtils.PinkyFingerCurl(ControllerHandedness);
// Pinch was also used as grab, we want to allow hand-curl grab not just pinch.
// Determine pinch and grab separately
if (isTracked)
{
IsGrabbing = isIndexGrabbing && isMiddleGrabbing;
}
if (MRTKOculusConfig.Instance.UpdateMaterialPinchStrengthValue && handMaterial != null)
{
float gripStrength = indexFingerCurl + middleFingerCurl + ringFingerCurl + pinkyFingerCurl;
gripStrength /= 4.0f;
gripStrength = gripStrength > 0.8f ? 1.0f : gripStrength;
pinchStrength = Mathf.Max(pinchStrength, gripStrength);
handMaterial.SetFloat(pinchStrengthProp, pinchStrength);
}
return(isTracked);
}
static private bool IsFingerPinched(OVRHand hand, OVRHand.HandFinger finger)
{
return(hand.GetFingerConfidence(finger) == OVRHand.TrackingConfidence.High && hand.GetFingerIsPinching(finger) && hand.GetFingerPinchStrength(finger) >= PinchMaxStrength);
}
void Update()
{
_isIndexPinching = ovrHand.GetFingerIsPinching(OVRHand.HandFinger.Index);
_isMiddlePinching = ovrHand.GetFingerIsPinching(OVRHand.HandFinger.Middle);
_isRingPinching = ovrHand.GetFingerIsPinching(OVRHand.HandFinger.Ring);
_isPinkyPinching = ovrHand.GetFingerIsPinching(OVRHand.HandFinger.Pinky);
_pinchingFingerNumber = 0;
if (_isIndexPinching)
{
_pinchingFingerNumber++;
}
if (_isMiddlePinching)
{
_pinchingFingerNumber++;
}
if (_isRingPinching)
{
_pinchingFingerNumber++;
}
if (_isPinkyPinching)
{
_pinchingFingerNumber++;
}
// 人差し指の先端位置を取得
Vector3 indexTipPos = skeleton.Bones[(int)OVRSkeleton.BoneId.Hand_IndexTip].Transform.position;
if (_isIndexPinching && _isMiddlePinching)
{
if (CurrentLineObject == null)
{
//PrefabからLineObjectを生成
CurrentLineObject = Instantiate(LineObjectPrefab, new Vector3(0, 0, 0), Quaternion.identity);
//生成したインスタンスをリストで持っておく
list_toggle_.Add(CurrentLineObject);
}
//ゲームオブジェクトからLineRendererコンポーネントを取得
LineRenderer render = CurrentLineObject.GetComponent <LineRenderer>();
//LineRendererからPositionsのサイズを取得
int NextPositionIndex = render.positionCount;
//LineRendererのPositionsのサイズを増やす
render.positionCount = NextPositionIndex + 1;
//LineRendererのPositionsに現在のコントローラーの位置情報を追加
render.SetPosition(NextPositionIndex, indexTipPos);
}
else
{
if (CurrentLineObject != null)
{
//現在描画中の線があったらnullにして次の線を描けるようにする。
CurrentLineObject = null;
}
}
if (_pinchingFingerNumber > 2)
{
//リストで保持しているインスタンスを削除
for (int i = 0; i < list_toggle_.Count; i++)
{
Destroy(list_toggle_[i]);
}
//リスト自体をキレイにする
list_toggle_.Clear();
}
}
