private bool IsPointingWholeHandUpward(OVRSkeleton hand, bool right)
{
Vector3 middleDirection = (hand.Bones[(int)BoneId.Hand_MiddleTip].Transform.position - hand.Bones[(int)BoneId.Hand_Middle1].Transform.position).normalized;
Vector3 ringDirection = (hand.Bones[(int)BoneId.Hand_RingTip].Transform.position - hand.Bones[(int)BoneId.Hand_Ring1].Transform.position).normalized;
return(Vector3.Dot(Vector3.up, middleDirection) > 0.7f && Vector3.Dot(Vector3.up, ringDirection) > 0.7f);
}
private IEnumerator Start()
{
while (!HandsManager.Instance || !HandsManager.Instance.IsInitialized())
{
yield return(null);
}
_handManager = HandsManager.Instance;
_handSkeleton = GetComponentInParent <OVRSkeleton>();
_hand = GetComponentInParent <OVRHand>();
if (!_handSkeleton || !_hand)
{
yield break;
}
switch (fingerToFollow)
{
case OVRPlugin.HandFinger.Thumb:
_boneId = OVRSkeleton.BoneId.Hand_Thumb3;
break;
case OVRPlugin.HandFinger.Index:
_boneId = OVRSkeleton.BoneId.Hand_Index3;
break;
case OVRPlugin.HandFinger.Middle:
_boneId = OVRSkeleton.BoneId.Hand_Middle3;
break;
case OVRPlugin.HandFinger.Ring:
_boneId = OVRSkeleton.BoneId.Hand_Ring3;
break;
case OVRPlugin.HandFinger.Pinky:
_boneId = OVRSkeleton.BoneId.Hand_Pinky3;
break;
default:
_boneId = OVRSkeleton.BoneId.Hand_Index3;
break;
}
// var capsuleTriggers = new List<BoneCapsuleTriggerLogic>();
var boneCapsules = HandsManager.GetCapsulesPerBone(_handSkeleton, _boneId);
// foreach (var capsule in boneCapsules)
// {
// var capsuleTrigger = capsule.CapsuleRigidbody.gameObject.AddComponent<BoneCapsuleTriggerLogic>();
// capsule.CapsuleCollider.isTrigger = true;
// capsuleTriggers.Add(capsuleTrigger);
// }
if (boneCapsules.Count > 0)
{
_capsuleToTrack = boneCapsules[0];
}
_isInitialized = true;
}
// Start is called before the first frame update
protected override void Start()
{
base.Start();
hand = GetComponent <OVRHand>();
ske = GetComponent <OVRSkeleton>();
//ske.Freeze = false;
}
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;
}
}
void UpdateHandSkeletonBones(bool isLeftHand)
{
OVRSkeleton skeleton = isLeftHand ? _LeftHandOVRSkelton : _RightHandOVRSkelton;
Dictionary <HumanBodyBones, OVRSkeleton.BoneId> handBoneIdMap;
handBoneIdMap = isLeftHand ? _LeftHandBoneIdMap : _RightHandBoneIdMap;
foreach (HumanBodyBones boneKey in handBoneIdMap.Keys)
{
OVRSkeleton.BoneId ovrBoneId = handBoneIdMap[boneKey];
if ((int)ovrBoneId < skeleton.Bones.Count)
{
Transform skeletonBone = skeleton.Bones[(int)ovrBoneId].Transform;
Quaternion localRotation = skeletonBone.localRotation;
// Local pose composition
if ((ovrBoneId == OVRSkeleton.BoneId.Hand_Thumb2) || (ovrBoneId == OVRSkeleton.BoneId.Hand_Pinky1))
{
short parentBoneIndex = skeleton.Bones[(int)ovrBoneId].ParentBoneIndex;
Transform parentBone = skeleton.Bones[parentBoneIndex].Transform;
localRotation = parentBone.localRotation * localRotation;
}
_Skeleton[boneKey].localRotation = localRotation;
}
}
}
public override void OnInspectorGUI()
{
DrawPropertiesExcluding(serializedObject, new string[] { "_customBones" });
serializedObject.ApplyModifiedProperties();
OVRCustomSkeleton skeleton = (OVRCustomSkeleton)target;
OVRSkeleton.SkeletonType skeletonType = skeleton.GetSkeletonType();
if (skeletonType == OVRSkeleton.SkeletonType.None)
{
EditorGUILayout.HelpBox("Please select a SkeletonType.", MessageType.Warning);
}
else
{
if (GUILayout.Button("Auto Map Bones"))
{
skeleton.TryAutoMapBonesByName();
EditorUtility.SetDirty(skeleton);
EditorSceneManager.MarkSceneDirty(skeleton.gameObject.scene);
}
EditorGUILayout.LabelField("Bones", EditorStyles.boldLabel);
BoneId start = skeleton.GetCurrentStartBoneId();
BoneId end = skeleton.GetCurrentEndBoneId();
if (start != BoneId.Invalid && end != BoneId.Invalid)
{
for (int i = (int)start; i < (int)end; ++i)
{
string boneName = OVRSkeleton.BoneLabelFromBoneId(skeletonType, (BoneId)i);
skeleton.CustomBones[i] = (Transform)EditorGUILayout.ObjectField(boneName, skeleton.CustomBones[i], typeof(Transform), true);
}
}
}
}
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>();
}
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;
}
}
}
private bool IsNeutral(OVRHand hand, OVRSkeleton handSkeleton)
{
return(!hand.GetFingerIsPinching(OVRHand.HandFinger.Index) &&
!hand.GetFingerIsPinching(OVRHand.HandFinger.Middle) &&
!IsFistClosed(handSkeleton) &&
!IsPalmFlatWhileThumbIsUp(handSkeleton));
}
private void Awake()
{
skeleton = GetComponent <OVRSkeleton>();
#if !UNITY_EDITOR
hand.gameObject.SetActive(false);
#endif
}
private void Initialize()
{
_boneVisualizations = new List <BoneVisualization>();
_ovrSkeleton = GetComponent <OVRSkeleton>();
_skeletonGO = new GameObject("SkeletonRenderer");
_skeletonGO.transform.SetParent(transform, false);
if (_skeletonMaterial == null)
{
_skeletonMaterial = new Material(Shader.Find("Diffuse"));
}
for (int i = 0; i < _ovrSkeleton.Bones.Count; i++)
{
var boneVis = new BoneVisualization(
_skeletonGO,
_skeletonMaterial,
_scale,
_ovrSkeleton.Bones[i].Transform,
_ovrSkeleton.Bones[i].Transform.parent);
_boneVisualizations.Add(boneVis);
}
_isInitialized = true;
}
void Initialize()
{
if (detector == null)
{
this.enabled = false;
return;
}
_ovrSkelton = detector.GetComponent <OVRSkeleton>();
lockOn = FindObjectOfType <LockOn>();
if (_ovrSkelton == null)
{
return;
}
IndexTip = _ovrSkelton.Bones[(int)OVRSkeleton.BoneId.Hand_IndexTip].Transform;
Index3 = _ovrSkelton.Bones[(int)OVRSkeleton.BoneId.Hand_Index3].Transform;
StartCoroutine(ShotLoop());
Addressables.InstantiateAsync(GunCircle).Completed += op =>
{
op.Result.transform.parent = transform;
op.Result.transform.position = IndexTip.position;
Circle = op.Result;
};
}
void AddHandSkeletonBones(SkeletonBuilder skeletonBuilder, bool isLeftHand)
{
OVRSkeleton skeleton = isLeftHand ? _LeftHandOVRSkelton : _RightHandOVRSkelton;
Dictionary <HumanBodyBones, OVRSkeleton.BoneId> handBoneIdMap;
handBoneIdMap = isLeftHand ? _LeftHandBoneIdMap : _RightHandBoneIdMap;
foreach (HumanBodyBones boneKey in handBoneIdMap.Keys)
{
OVRSkeleton.BoneId ovrBoneId = handBoneIdMap[boneKey];
if ((int)ovrBoneId < skeleton.Bones.Count)
{
Transform skeletonBone = skeleton.BindPoses[(int)ovrBoneId].Transform;
Vector3 localPosition = skeletonBone.localPosition;
Quaternion localRotation = skeletonBone.localRotation;
// Local pose composition
if ((ovrBoneId == OVRSkeleton.BoneId.Hand_Thumb2) || (ovrBoneId == OVRSkeleton.BoneId.Hand_Pinky1))
{
short parentBoneIndex = skeleton.Bones[(int)ovrBoneId].ParentBoneIndex;
Transform parentBone = skeleton.Bones[parentBoneIndex].Transform;
localPosition = parentBone.localPosition + parentBone.localRotation * localPosition;
localRotation = parentBone.localRotation * localRotation;
}
skeletonBuilder.Add(boneKey, _HandBoneParent[boneKey], localPosition, localRotation);
}
}
}
private void Initialize()
{
_boneVisualizations = new List <BoneVisualization>();
_capsuleVisualizations = new List <CapsuleVisualization>();
_ovrSkeleton = GetComponent <OVRSkeleton>();
_skeletonGO = new GameObject("SkeletonRenderer");
_skeletonGO.transform.SetParent(transform, false);
if (_skeletonMaterial == null)
{
_skeletonDefaultMaterial = new Material(Shader.Find("Diffuse"));
_skeletonMaterial = _skeletonDefaultMaterial;
}
if (_capsuleMaterial == null)
{
_capsuleDefaultMaterial = new Material(Shader.Find("Diffuse"));
_capsuleMaterial = _capsuleDefaultMaterial;
}
if (_systemGestureMaterial == null)
{
_systemGestureDefaultMaterial = new Material(Shader.Find("Diffuse"));
_systemGestureDefaultMaterial.color = Color.blue;
_systemGestureMaterial = _systemGestureDefaultMaterial;
}
if (_ovrSkeleton.IsInitialized)
{
for (int i = 0; i < _ovrSkeleton.Bones.Count; i++)
{
var boneVis = new BoneVisualization(
_skeletonGO,
_skeletonMaterial,
_systemGestureMaterial,
_scale,
_ovrSkeleton.Bones[i].Transform,
_ovrSkeleton.Bones[i].Transform.parent);
_boneVisualizations.Add(boneVis);
}
if (_renderPhysicsCapsules && _ovrSkeleton.Capsules != null)
{
for (int i = 0; i < _ovrSkeleton.Capsules.Count; i++)
{
var capsuleVis = new CapsuleVisualization(
_skeletonGO,
_capsuleMaterial,
_systemGestureMaterial,
_scale,
_ovrSkeleton.Capsules[i]);
_capsuleVisualizations.Add(capsuleVis);
}
}
IsInitialized = true;
}
}
private void Initialize()
{
_boneDots = new List <BoneDot>();
_fingerDots = new List <FingerDot>();
_ovrSkeleton = GetComponent <OVRSkeleton>();
for (int i = 0; i < BoneDirectionIndex.Length / 3; i++)
{
var boneVis = new BoneDot(
_ovrSkeleton.Bones[BoneDirectionIndex[i, 0]].Transform,
_ovrSkeleton.Bones[BoneDirectionIndex[i, 1]].Transform,
_ovrSkeleton.Bones[BoneDirectionIndex[i, 2]].Transform);
_boneDots.Add(boneVis);
}
for (int i = 0; i < Enum.GetNames(typeof(FingerIndex)).Length; i++)
{
FingerDot Fing;
if (i == 0)
{
Fing = new FingerDot(_boneDots[0], _boneDots[1]);
}
else
{
Fing = new FingerDot(_boneDots[2 + 3 * (i - 1)], _boneDots[3 + 3 * (i - 1)], _boneDots[4 + 3 * (i - 1)]);
}
_fingerDots.Add(Fing);
}
_isInitialized = true;
}
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 void Awake()
{
if (_ovrSkeleton == null)
{
_ovrSkeleton = GetComponent <OVRSkeleton>();
}
}
private float CalculateFingerDistance(OVRSkeleton skeleton, HandPoseData handPose)
{
var sumDistance = 0f;
var discard = false;
var i = 0;
var fingerBones = skeleton.Bones;
while (!discard && i < fingerBones.Count)
{
var currentData =
fingerSkeleton.transform.InverseTransformPoint(fingerBones[i].Transform.position);
var distance = Vector3.Distance(currentData, handPose.fingerDatas[i]);
discard = (distance > sensitivity);
if (discard)
{
sumDistance = Mathf.Infinity;
}
else
{
i++;
sumDistance += distance;
}
}
return(sumDistance);
}
private void UpdateHand(HandTrackingFingerMap h, OVRSkeleton s)
{
if (s == null || s.Bones.Count == 0)
{
return;
}
SetProperties(h.Hand_Index1, s.Bones[(int)bid.Hand_Index1].Transform);
SetProperties(h.Hand_Index2, s.Bones[(int)bid.Hand_Index2].Transform);
SetProperties(h.Hand_Index3, s.Bones[(int)bid.Hand_Index3].Transform);
SetProperties(h.Hand_Middle1, s.Bones[(int)bid.Hand_Middle1].Transform);
SetProperties(h.Hand_Middle2, s.Bones[(int)bid.Hand_Middle2].Transform);
SetProperties(h.Hand_Middle3, s.Bones[(int)bid.Hand_Middle3].Transform);
SetProperties(h.Hand_Ring1, s.Bones[(int)bid.Hand_Ring1].Transform);
SetProperties(h.Hand_Ring2, s.Bones[(int)bid.Hand_Ring2].Transform);
SetProperties(h.Hand_Ring3, s.Bones[(int)bid.Hand_Ring3].Transform);
//SetProperties(h.Hand_Pinky0, s.Bones[(int)bid.Hand_Pinky0].Transform);
SetProperties(h.Hand_Pinky1, s.Bones[(int)bid.Hand_Pinky1].Transform);
SetProperties(h.Hand_Pinky2, s.Bones[(int)bid.Hand_Pinky2].Transform);
SetProperties(h.Hand_Pinky3, s.Bones[(int)bid.Hand_Pinky3].Transform);
//SetProperties(h.Hand_Thumb0, s.Bones[(int)bid.Hand_Thumb0].Transform);
SetProperties(h.Hand_Thumb1, s.Bones[(int)bid.Hand_Thumb1].Transform);
SetProperties(h.Hand_Thumb2, s.Bones[(int)bid.Hand_Thumb2].Transform);
SetProperties(h.Hand_Thumb3, s.Bones[(int)bid.Hand_Thumb3].Transform);
}
private IEnumerator AttachToolsToHands(Transform[] toolObjects, bool isRightHand)
{
HandsManager handsManagerObj = null;
while ((handsManagerObj = HandsManager.Instance) == null || !handsManagerObj.IsInitialized())
{
yield return(null);
}
// create set of tools per hand to be safe
HashSet <Transform> toolObjectSet = new HashSet <Transform>();
foreach (Transform toolTransform in toolObjects)
{
toolObjectSet.Add(toolTransform.transform);
}
foreach (Transform toolObject in toolObjectSet)
{
OVRSkeleton handSkeletonToAttachTo =
isRightHand ? handsManagerObj.RightHandSkeleton : handsManagerObj.LeftHandSkeleton;
while (handSkeletonToAttachTo == null || handSkeletonToAttachTo.Bones == null)
{
yield return(null);
}
AttachToolToHandTransform(toolObject, isRightHand);
}
}
private void InitializeAxis(OVRSkeleton skeleton)
{
axises = new Transform[skeleton.Bones.Count];
for (int i = 0; i < skeleton.Bones.Count; i++)
{
axises[i] = Instantiate <Transform>(axisPrototype, this.transform);
}
}
private bool IsPointingUpward(OVRSkeleton hand, bool right)
{
Vector3 indexDirection = (hand.Bones[(int)BoneId.Hand_IndexTip].Transform.position - hand.Bones[(int)BoneId.Hand_Index1].Transform.position).normalized;
Vector3 middleDirection = (hand.Bones[(int)BoneId.Hand_MiddleTip].Transform.position - hand.Bones[(int)BoneId.Hand_Middle1].Transform.position).normalized;
float indexMiddleComparison = Vector3.Dot(indexDirection, middleDirection);
return(indexMiddleComparison < 0 && Vector3.Dot(indexDirection, Vector3.up) > 0.7f);
}
void Start()
{
if (detector == null)
{
this.enabled = false;
}
_ovrSkelton = detector.gameObject.GetComponent <OVRSkeleton>();
}
private IEnumerator AttachTriggerLogic()
{
while (!HandsManager.Instance || !HandsManager.Instance.IsInitialized())
{
yield return(null);
}
OVRSkeleton handSkeleton = IsRightHandedTool ? HandsManager.Instance.RightHandSkeleton : HandsManager.Instance.LeftHandSkeleton;
OVRSkeleton.BoneId boneToTestCollisions = OVRSkeleton.BoneId.Hand_Pinky3;
switch (_fingerToFollow)
{
case OVRPlugin.HandFinger.Thumb:
boneToTestCollisions = OVRSkeleton.BoneId.Hand_Thumb3;
break;
case OVRPlugin.HandFinger.Index:
boneToTestCollisions = OVRSkeleton.BoneId.Hand_Index3;
break;
case OVRPlugin.HandFinger.Middle:
boneToTestCollisions = OVRSkeleton.BoneId.Hand_Middle3;
break;
case OVRPlugin.HandFinger.Ring:
boneToTestCollisions = OVRSkeleton.BoneId.Hand_Ring3;
break;
case OVRPlugin.HandFinger.Pinky:
boneToTestCollisions = OVRSkeleton.BoneId.Hand_Pinky3;
break;
default:
boneToTestCollisions = OVRSkeleton.BoneId.Hand_Index3;
break;
}
List <BoneCapsuleTriggerLogic> boneCapsuleTriggerLogic = new List <BoneCapsuleTriggerLogic>();
List <OVRBoneCapsule> boneCapsules = HandsManager.GetCapsulesPerBone(handSkeleton, boneToTestCollisions);
foreach (var ovrCapsuleInfo in boneCapsules)
{
var boneCapsuleTrigger = ovrCapsuleInfo.CapsuleRigidbody.gameObject.AddComponent <BoneCapsuleTriggerLogic>();
ovrCapsuleInfo.CapsuleCollider.isTrigger = true;
boneCapsuleTrigger.ToolTags = ToolTags;
boneCapsuleTriggerLogic.Add(boneCapsuleTrigger);
}
_boneCapsuleTriggerLogic = boneCapsuleTriggerLogic.ToArray();
// finger tip should have only one capsule
if (boneCapsules.Count > 0)
{
_capsuleToTrack = boneCapsules[0];
}
_isInitialized = true;
}
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);
}
private void Awake()
{
controllerHand = GetComponent <SkeletalControllerHand>();
handAnimator = GetComponent <Animator>();
hand = controllerTransform.GetComponentInChildren <OVRHand>();
skeleton = hand.GetComponent <OVRSkeleton>();
GetControllerHashes();
}
private void InitializeBones(ref Dictionary <BoneId, Transform> bones, OVRSkeleton ovrSkeleton)
{
foreach (var bone in ovrSkeleton.Bones)
{
if (OVRToPosingIDs.TryGetValue(bone.Id, out BoneId id))
{
bones.Add(id, bone.Transform);
}
}
}
// 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);
}
}
// 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>();
}
public void UpdateFinger(OVRSkeleton s)
{
if (s == null || s.Bones.Count == 0)
{
return;
}
Transform tracking = s.Bones[(int)boneMapping[name]].Transform;
SetProperties(transform, tracking);
}
