void updateColorSelectionBar() { if (hue && hue.activeSelf) { hue.transform.position = leftHandModel.GetPalmPosition() + leftHandModel.GetPalmNormal() * 0.15f; hue.transform.rotation = leftHandModel.GetPalmRotation(); } }
protected void UpdateTracker() { //get the 1st hand in the frame if (handController.GetAllGraphicsHands().Length != 0) { handModel = handController.GetAllGraphicsHands()[0]; handModel.transform.GetComponentInChildren <SkinnedMeshRenderer>().enabled = visibleHand; hand = handModel.GetLeapHand(); Position = handModel.GetPalmPosition(); Rotation = handModel.GetPalmRotation(); float grabStrength = handModel.GetLeapHand().GrabStrength; if (grabStrength >= 0.9) { Grab = true; } else if (grabStrength <= 0.75) { Grab = false; } } //mask/display the graphical hand on key down if (Input.GetKeyDown(visibleHandKey)) { var smr = handModel.transform.GetComponentInChildren <SkinnedMeshRenderer>(); visibleHand = !visibleHand; } }
protected void UpdatePalmRotation() { HandModel hand_model = GetComponent <HandModel>(); palm_rotation_ = Quaternion.Slerp(palm_rotation_, hand_model.GetPalmRotation(), 1.0f - rotationFiltering); }
protected void UpdatePalmRotation() { HandModel handModel = this.GetComponent <HandModel>(); // apply some smoothing to avoid abrupt changes this.PalmRotation = Quaternion.Slerp(this.PalmRotation, handModel.GetPalmRotation(), 1.0f - this.RotationFiltering); }
IEnumerator Fire(HandModel currentHand) { canFire = false; //Debug.Log (canFire); GameObject justFired = Instantiate (ammo, currentHand.transform.position + currentHand.GetPalmNormal() * offset , currentHand.GetPalmRotation()) as GameObject; justFired.GetComponent<moveProjectile> ().target = target; //justFired.GetComponent<moveProjectile> ().force = Quaternion.LookRotation( handController.transform.forward, Vector3.down).eulerAngles; yield return new WaitForSeconds (delay); canFire = true; }
// Update is called once per frame void Update() { hand = transform.GetComponent <HandModel> (); //Somente deve funcionar na mão escolhida, direita ou esquerda if (maoCerta) { for (int i = 0; i < 2; i++) { dedos [i] = hand.fingers [i + 1].GetBoneCenter(3); distancias [i] = (dedos [i] - hand.GetPalmPosition()).magnitude; //distâncias dos dedos à palma da mão } //Verifica se a mão está fechada e próxima da base ou se o usuário quer ter que alcançar a seringa para pega-la if (pegando()) { if ((hand.GetPalmPosition() - baseSeringaPosition).magnitude < distBaseSeringa || !GetComponentInParent <escolherMao> ().alcançarSeringa) { pegou = true; } } //"Prende" a seringa à palma da mão, utilizando sua posição e rotação + ajustes if (pegou) { seringa.transform.position = hand.GetPalmPosition() + hand.GetPalmNormal() * distSeringa.x + Vector3.Cross(hand.GetPalmDirection(), hand.GetPalmNormal()).normalized *distSeringa.y + hand.GetPalmDirection() * distSeringa.z; seringa.transform.rotation = hand.GetPalmRotation() * rotSeringa; GetComponentInParent <escolherMao> ().Congelar(); } //Solta a seringa de volta a base else { seringa.transform.position = baseSeringaPosition; seringa.transform.rotation = baseSeringaRotation; } //Verifica se a mão está aberta e próxima da base da seringa ou se o usuário quer soltar a seringa a qualquer momento if (soltando()) { if ((hand.GetPalmPosition() - baseSeringaPosition).magnitude < distBaseSeringa || !GetComponentInParent <escolherMao> ().alcançarSeringa) { pegou = false; } } } }
protected void StartPinch(Vector3 pinch_position) { HandModel hand_model = GetComponent <HandModel>(); if (active_object_ != null) { IgnoreCollisions(active_object_.gameObject, true); palm_rotation_ = hand_model.GetPalmRotation(); rotation_from_palm_ = Quaternion.Inverse(palm_rotation_) * active_object_.transform.rotation; current_pinch_ = active_object_.transform.position; GrabbableObject grabbable = active_object_.GetComponent <GrabbableObject>(); if (grabbable == null || grabbable.rotateQuickly) { last_max_angular_velocity_ = active_object_.rigidbody.maxAngularVelocity; active_object_.rigidbody.maxAngularVelocity = Mathf.Infinity; } if (grabbable != null) { grabbable.OnGrab(); if (grabbable.preferredOrientation) { Vector3 palm_vector = grabbable.palmOrientation; if (hand_model.GetLeapHand().IsLeft) { palm_vector = Vector3.Scale(palm_vector, new Vector3(-1, 1, 1)); } Quaternion relative_rotation = Quaternion.Inverse(palm_rotation_) * active_object_.transform.rotation; Vector3 axis_in_palm = relative_rotation * grabbable.objectOrientation; Quaternion axis_correction = Quaternion.FromToRotation(axis_in_palm, palm_vector); if (Vector3.Dot(axis_in_palm, palm_vector) < 0) { axis_correction = Quaternion.FromToRotation(axis_in_palm, -palm_vector); } rotation_from_palm_ = axis_correction * relative_rotation; } } } }
public void FixedUpdate() { if (graphicsEnabled) { UpdateHandRepresentations(); if (ikActive) { if (leftActive && leftHand != null) { RiggedHand l = leftHand as RiggedHand; vrIK.solver.leftArm.IKPosition = leftHand.GetPalmPosition(); vrIK.solver.leftArm.IKRotation = leftHand.GetPalmRotation() * l.Reorientation(); vrIK.solver.leftArm.positionWeight = 1.0f; vrIK.solver.leftArm.rotationWeight = 0.0f; leftTransform.Enabled = true; } else { vrIK.solver.leftArm.positionWeight = 0.0f; vrIK.solver.leftArm.rotationWeight = 0.0f; leftTransform.Enabled = false; } if (rightActive && rightHand != null) { RiggedHand r = rightHand as RiggedHand; vrIK.solver.rightArm.IKPosition = rightHand.GetPalmPosition(); vrIK.solver.rightArm.IKRotation = rightHand.GetPalmRotation() * r.Reorientation(); vrIK.solver.rightArm.positionWeight = 1.0f; vrIK.solver.rightArm.rotationWeight = 0.0f; rightTransform.Enabled = true; } else { vrIK.solver.rightArm.positionWeight = 0.0f; vrIK.solver.rightArm.rotationWeight = 0.0f; rightTransform.Enabled = false; } } } }
void Update() { if (leap_hand == null) { return; } Vector3 centroid = GetCentroidFingers(); if (command == CommandGesture.NULL) { if (isComandGrab(centroid, JoyConfig.Config.DistanceGrab)) { command = CommandGesture.Grab; } } else { switch (command) { case CommandGesture.Grab: if (!isComandGrab(centroid, JoyConfig.Config.DistanceRelease)) { command = CommandGesture.NULL; MoveTool.MoveHome(); } else { Tool.transform.rotation = hand_model.GetPalmRotation(); FingerModel midle = hand_model.fingers[2]; MoveTool.MoveTo(midle.GetJointPosition(1)); } break; default: break; } } }
private void OnPinch(Vector3 pinch_position) { pinching_ = true; // Check if we pinched a movable object and grab the closest one that's not part of the hand. Collider[] close_things = Physics.OverlapSphere(pinch_position, grabDistance); Vector3 distance = new Vector3(grabDistance, 0.0f, 0.0f); HandModel hand_model = GetComponent <HandModel>(); for (int j = 0; j < close_things.Length; ++j) { Vector3 new_distance = pinch_position - close_things[j].transform.position; if (close_things[j].GetComponent <Rigidbody>() != null && new_distance.magnitude < distance.magnitude && !close_things[j].transform.IsChildOf(transform)) { grabbed_ = close_things[j]; distance = new_distance; } } if (grabbed_ != null) { grabbed_.GetComponent <Rigidbody>().maxAngularVelocity = Mathf.Infinity; grabbed_.GetComponent <Rigidbody>().detectCollisions = false; palm_rotation_ = hand_model.GetPalmRotation(); palm_position_ = hand_model.GetPalmPosition(); start_rotation_ = grabbed_.transform.rotation * Quaternion.Inverse(palm_rotation_); start_position_ = Quaternion.Inverse(palm_rotation_) * (grabbed_.transform.position - palm_position_); Grabbable grabbable = grabbed_.GetComponent <Grabbable>(); if (grabbable != null) { grabbable.OnGrab(); } } }
protected void StartPinch() { // Only pinch if we're hovering over an object. if (active_object_ == null) { return; } HandModel hand_model = GetComponent <HandModel>(); Debug.Log("Start pinch"); Leap.Utils.IgnoreCollisions(gameObject, active_object_.gameObject, true); GrabbableObject grabbable = active_object_.GetComponent <GrabbableObject>(); // Setup initial position and rotation conditions. palm_rotation_ = hand_model.GetPalmRotation(); object_pinch_offset_ = Vector3.zero; // If we don't center the object, find the closest point in the collider for our grab point. if (grabbable == null || !grabbable.centerGrabbedObject) { Vector3 delta_position = active_object_.transform.position - current_pinch_position_; Ray pinch_ray = new Ray(current_pinch_position_, delta_position); RaycastHit pinch_hit; // If we raycast hits the object, we're outside the collider so grab the hit point. // If not, we're inside the collider so just use the pinch position. if (active_object_.Raycast(pinch_ray, out pinch_hit, grabObjectDistance)) { object_pinch_offset_ = active_object_.transform.position - pinch_hit.point; } else { object_pinch_offset_ = active_object_.transform.position - current_pinch_position_; } } filtered_pinch_position_ = active_object_.transform.position - object_pinch_offset_; object_pinch_offset_ = Quaternion.Inverse(active_object_.transform.rotation) * object_pinch_offset_; rotation_from_palm_ = Quaternion.Inverse(palm_rotation_) * active_object_.transform.rotation; // If we can rotate the object quickly, increase max angular velocity for now. if (grabbable == null || grabbable.rotateQuickly) { last_max_angular_velocity_ = active_object_.rigidbody.maxAngularVelocity; active_object_.rigidbody.maxAngularVelocity = Mathf.Infinity; } if (grabbable != null) { // Notify grabbable object that it was grabbed. grabbable.OnGrab(); if (grabbable.useAxisAlignment) { // If this option is enabled we only want to align the object axis with the palm axis // so we'll cancel out any rotation about the aligned axis. Vector3 palm_vector = grabbable.rightHandAxis; if (hand_model.GetLeapHand().IsLeft) { palm_vector = Vector3.Scale(palm_vector, new Vector3(-1, 1, 1)); } Vector3 axis_in_palm = rotation_from_palm_ * grabbable.objectAxis; Quaternion axis_correction = Quaternion.FromToRotation(axis_in_palm, palm_vector); if (Vector3.Dot(axis_in_palm, palm_vector) < 0) { axis_correction = Quaternion.FromToRotation(axis_in_palm, -palm_vector); } rotation_from_palm_ = axis_correction * rotation_from_palm_; } } }
void Update() { bool trigger_pinch = false; HandModel hand_model = GetComponent <HandModel>(); Hand leap_hand = hand_model.GetLeapHand(); if (leap_hand == null) { return; } // Scale trigger distance by thumb proximal bone length. Vector leap_thumb_tip = leap_hand.Fingers[0].TipPosition; float proximal_length = leap_hand.Fingers[0].Bone(Bone.BoneType.TYPE_PROXIMAL).Length; float trigger_distance = proximal_length * TRIGGER_DISTANCE_RATIO; // Check thumb tip distance to joints on all other fingers. // If it's close enough, start pinching. for (int i = 1; i < HandModel.NUM_FINGERS && !trigger_pinch; ++i) { Finger finger = leap_hand.Fingers[i]; for (int j = 0; j < FingerModel.NUM_BONES && !trigger_pinch; ++j) { Vector leap_joint_position = finger.Bone((Bone.BoneType)j).NextJoint; if (leap_joint_position.DistanceTo(leap_thumb_tip) < trigger_distance) { trigger_pinch = true; } } } Vector3 pinch_position = 0.5f * (hand_model.fingers[0].GetTipPosition() + hand_model.fingers[1].GetTipPosition()); // Only change state if it's different. if (leap_hand.Confidence >= minConfidence && leap_hand.PalmVelocity.ToUnityScaled().magnitude <= maxVelocity) { if (trigger_pinch && !pinching_) { OnPinch(pinch_position); } else if (!trigger_pinch && pinching_) { OnRelease(); } } // Accelerate what we are grabbing toward the pinch. if (grabbed_ != null) { Grabbable grabbable = grabbed_.GetComponent <Grabbable>(); palm_rotation_ = Quaternion.Slerp(palm_rotation_, hand_model.GetPalmRotation(), 1.0f - filtering); Vector3 delta_palm_position = hand_model.GetPalmPosition() - palm_position_; palm_position_ += (1 - filtering) * delta_palm_position; Vector3 target_position = pinch_position; Quaternion target_rotation = palm_rotation_ * start_rotation_; if (grabbable != null) { if (grabbable.keepDistanceWhenGrabbed) { target_position = palm_position_ + palm_rotation_ * start_position_; } if (grabbable.preferredOrientation) { Quaternion relativeToPalm = Quaternion.FromToRotation(grabbable.objectOrientation, grabbable.palmOrientation); target_rotation = palm_rotation_ * relativeToPalm; } } Vector3 velocity = (target_position - grabbed_.transform.position) / Time.fixedDeltaTime; grabbed_.GetComponent <Rigidbody>().velocity = velocity; Quaternion delta_rotation = target_rotation * Quaternion.Inverse(grabbed_.transform.rotation); float angle = 0.0f; Vector3 axis = Vector3.zero; delta_rotation.ToAngleAxis(out angle, out axis); if (angle >= 180) { angle = 360 - angle; axis = -axis; } if (angle != 0) { grabbed_.GetComponent <Rigidbody>().angularVelocity = angle * axis; } } }
void updateLeftHand() { Vector3 upCam = mainCamera.transform.up; float difference = Vector3.Angle(leftHandModel.GetPalmNormal(), upCam); if (difference < MAX_ANGLE_DIFFERENCE_FOR_INTERFACE && leftHand.activeSelf) { if (leftHandInterfaceActive) { //Update the position, rotation, and color if (hue && hue.activeSelf) { hue.transform.position = leftHandModel.GetPalmPosition() + leftHandModel.GetPalmNormal() * 0.15f; hue.transform.rotation = leftHandModel.GetPalmRotation(); } if (alpha && alpha.activeSelf) { alpha.transform.position = leftHandModel.GetPalmPosition() + leftHandModel.GetPalmNormal() * 0.15f; alpha.transform.rotation = leftHandModel.GetPalmRotation(); } if (saturation && saturation.activeSelf) { saturation.transform.position = leftHandModel.GetPalmPosition() + leftHandModel.GetPalmNormal() * 0.15f; saturation.transform.rotation = leftHandModel.GetPalmRotation(); } } else { //Spawn in the light, 3 selectors, and sphere. //update each position, rotation, and color if (hue) { hue.transform.position = leftHandModel.GetPalmPosition() + leftHandModel.GetPalmNormal() * 0.15f; hue.transform.rotation = leftHandModel.GetPalmRotation(); hue.SetActive(true); } else if (huePrefab) { hue = (GameObject)Instantiate(huePrefab, leftHandModel.GetPalmPosition() + leftHandModel.GetPalmNormal() * 0.15f, leftHandModel.GetPalmRotation()); hueSliderHeightPercentage = 0.5f; updateColorSelected(); } if (alpha) { alpha.SetActive(true); } else if (alphaPrefab) { alpha = (GameObject)Instantiate(alphaPrefab, leftHandModel.GetPalmPosition() + leftHandModel.GetPalmNormal() * 0.15f, leftHandModel.GetPalmRotation()); } if (saturation) { saturation.SetActive(true); } else if (saturationPrefab) { saturation = (GameObject)Instantiate(saturationPrefab, leftHandModel.GetPalmPosition() + leftHandModel.GetPalmNormal() * 0.15f, leftHandModel.GetPalmRotation()); } leftHandInterfaceActive = true; } } else { if (leftHandInterfaceActive) { if (!leftHand.activeSelf || difference >= MAX_ANGLE_DIFFERENCE_FOR_INTERFACE) { if (hue) { hue.SetActive(false); } if (saturation) { saturation.SetActive(false); } if (alpha) { alpha.SetActive(false); } leftHandInterfaceActive = false; } } } }
void selector() { Debug.Log(hand.palm.localEulerAngles); float difference = Vector3.Angle(hand.palm.localEulerAngles, FACING_CAMERA); if (difference < 8.0f && leftHand.activeSelf) { if (selectorsMade) { //Update the position, rotation, and color if (hue) { hue.transform.position = hand.GetPalmPosition() + hand.GetPalmNormal() * 0.15f; hue.transform.rotation = hand.GetPalmRotation(); } if (alpha) { alpha.transform.position = hand.GetPalmPosition() + hand.GetPalmNormal() * 0.15f; alpha.transform.rotation = hand.GetPalmRotation(); } if (saturation) { saturation.transform.position = hand.GetPalmPosition() + hand.GetPalmNormal() * 0.15f; saturation.transform.rotation = hand.GetPalmRotation(); } } else { //Spawn in the light, 3 selectors, and sphere. //update each position, rotation, and color if (huePrefab) { hue = (GameObject)Instantiate(huePrefab, hand.GetPalmPosition() + hand.GetPalmNormal() * 0.15f, hand.GetPalmRotation()); } if (alphaPrefab) { alpha = (GameObject)Instantiate(alphaPrefab); } if (saturationPrefab) { saturation = (GameObject)Instantiate(saturationPrefab); } selectorsMade = true; lhc.BroadcastMessage("setInterface", true); } } else { if (selectorsMade) { if (!leftHand.activeSelf || difference >= 8.0f) { if (hue) { Destroy(hue); } if (saturation) { Destroy(saturation); } if (alpha) { Destroy(alpha); } selectorsMade = false; } lhc.BroadcastMessage("setInterface", false); } } }
public void juego_oculus() { //moverseOculus(); moverse2Oculus(); if (Mano_derecha.IsTracked) { /* * CALCULAR ACELERACION MANO */ if (tiempo_cal_ac < 0) { Vector3 posicion_actual = Mano_derecha.GetPalmPosition(); Vector3 aceleracion_actual = posicion_actual - pos_mano; pos_mano = posicion_actual; tiempo_cal_ac = 0.2f; if (aceleraciones.Count > 4) { aceleraciones.Remove(aceleraciones[0]); } aceleraciones.Add(aceleracion_actual); Vector3 aceleracion_media = new Vector3(0, 0, 0); for (int i = 0; i < aceleraciones.Count; i++) { aceleracion_media += aceleraciones[i]; } aceleracion_leap = aceleracion_media / aceleraciones.Count; } else { tiempo_cal_ac -= Time.deltaTime; } /* * SI TENEMOS UN OBJETO COGIDO / LANZAMIENTO / SOLTAR * */ if (seleccionado) { Debug.Log("cogido"); if (Mano_derecha.GetLeapHand().PinchStrength <= 0.5 && tiempo > 1f) { seleccionado = false; temp_transform.transform.position = Mano_derecha.GetPalmPosition(); temp_transform.transform.rotation = Mano_derecha.GetPalmRotation(); GameObject aux_aceleracion = new GameObject(); /*aux_aceleracion.transform.position = aceleracion_leap;*/ aux_aceleracion.transform.position = Mano_derecha.GetLeapHand().PalmVelocity.ToVector3(); interactuable.GetComponent <Interactuable>().suelta(temp_transform.transform, aux_aceleracion.transform); Destroy(aux_aceleracion); interactuable = null; } else { temp_transform.transform.position = Mano_derecha.GetPalmPosition(); temp_transform.transform.rotation = Mano_derecha.GetPalmRotation(); interactuable.GetComponent <Interactuable>().mueve(temp_transform.transform); } } else { /* * RECOGER OBJETO DE LIBRE USO * */ objeto_mover_oculus(); boton_oculus(); } } else { /*no tenemos mano detectada */ if (seleccionado) { Debug.Log("mano no detectada"); seleccionado = false; GameObject aux_aceleracion = new GameObject(); aceleracion_leap = new Vector3(0, 0, 0); aux_aceleracion.transform.position = aceleracion_leap; interactuable.GetComponent <Interactuable>().suelta(temp_transform.transform, aux_aceleracion.transform); Destroy(aux_aceleracion); interactuable = null; } } }
private void onHandEvent(object sender, LMWidgets.EventArg <HandData> e) { if (!e.CurrentValue.HasHand) { if (m_activeObject != null) { m_activeObject.GetComponent <Renderer>().enabled = false; } return; } else { if (m_activeObject != null) { m_activeObject.GetComponent <Renderer>().enabled = true; } } HandModel hand = e.CurrentValue.HandModel; transform.rotation = hand.GetPalmRotation(); transform.position = hand.GetPalmPosition() + (transform.up * IconOffsetDistance); // Transition logic below here. if (ModalityManager.Instance.HasActiveItem()) { if (ModalityManager.Instance.ActiveItemName == "ARMHUD" && m_activeObject != null || ModalityManager.Instance.ActiveItemName == "Joyball" && m_activeObject != null) { m_activeObject = null; //Debug.Log("Go None"); StopAllCoroutines(); StartCoroutine(transitionOut(switchToNone)); } return; } bool aboveHorizon = !m_raycastEmitter.RayCheck(hand.GetPalmPosition()); if (aboveHorizon && !m_wasAboveHorizon || (aboveHorizon && m_activeObject == null)) { if (m_activeObject == null) { m_activeObject = m_constellationIcon; } StopAllCoroutines(); StartCoroutine(transitionOut(switchToConstellation)); } // else if (!aboveHorizon && m_wasAboveHorizon || (!aboveHorizon && m_activeObject == null) ) { else if (!aboveHorizon && m_wasAboveHorizon) { if (m_activeObject == null) { m_activeObject = null; } StopAllCoroutines(); // DECISION: Joyball icon is NOT needed due to the affordance presented by the JoyBall itself // StartCoroutine(transitionOut(switchToJoyball)); StartCoroutine(transitionOut(switchToNone)); // StartCoroutine(transitionOut(switchToGrabCycle)); } m_wasAboveHorizon = aboveHorizon; }
protected void StartGrasp() { // Only grasp if we're hovering over an object. if (this.ActiveObject == null) { return; } HandModel handModel = this.GetComponent <HandModel>(); GraspableObject graspable = this.ActiveObject.GetComponent <GraspableObject>(); Leap.Utils.IgnoreCollisions(this.gameObject, this.ActiveObject.gameObject, true); // Setup initial position and rotation conditions. this.PalmRotation = handModel.GetPalmRotation(); this.GraspOffset = Vector3.zero; // If we don't center the object, find the closest point in the collider for our grab point. if (graspable == null || !graspable.CenterGraspedObject) { Vector3 deltaPosition = ActiveObject.transform.position - this.CurrentGraspCenter; Ray graspRay = new Ray(this.CurrentGraspCenter, deltaPosition); RaycastHit graspHit; // If the raycast hits the object, we are outside the collider so grab the hit point. // If not, we are inside the collider so just use the grasp position. if (ActiveObject.Raycast(graspRay, out graspHit, GraspObjectDistance)) { this.GraspOffset = this.ActiveObject.transform.position - graspHit.point; } else { this.GraspOffset = this.ActiveObject.transform.position - CurrentGraspCenter; } } this.SmoothedGraspPosition = this.ActiveObject.transform.position - this.GraspOffset; this.GraspOffset = Quaternion.Inverse(this.ActiveObject.transform.rotation) * GraspOffset; this.RotationFromPalm = Quaternion.Inverse(this.PalmRotation) * this.ActiveObject.transform.rotation; // If we can rotate the object quickly, increase max angular velocity for now. if (graspable == null || graspable.RotateQuickly) { this.ObjectMaxAngularVelocity = this.ActiveObject.GetComponent <Rigidbody>().maxAngularVelocity; this.ActiveObject.GetComponent <Rigidbody>().maxAngularVelocity = Mathf.Infinity; } if (graspable != null) { // Notify grabbable object that it was grabbed. if (graspable.GetResponseTime() < 0L) { if (handModel != null) { Vector3 normal = handModel.GetPalmNormal(); float angleLeft = Vector3.Angle(normal, Vector3.left); float angleRight = Vector3.Angle(normal, Vector3.right); if (GraspController.Verbose) { Debug.LogWarning("hand normal: " + normal + ", to right: " + angleRight + ", to left: " + angleLeft); } if (angleLeft < angleRight) { graspable.setGraspDirection(GraspableObject.GraspDirection.UPRIGHT); } else { graspable.setGraspDirection(GraspableObject.GraspDirection.ROTATED); } } else { if (GraspController.Verbose) { Debug.LogWarning("no hand found..."); } } } graspable.OnGrasp(this.gameObject); if (graspable.UseAxisAlignment) { // If this option is enabled we only want to align the object axis with the palm axis, // hence we cancel out any rotation about the aligned axis. Vector3 palmVector = graspable.RightHandAxis; if (handModel.GetLeapHand().IsLeft) { palmVector = Vector3.Scale(palmVector, new Vector3(-1, 1, 1)); } Vector3 axisInPalm = this.RotationFromPalm * graspable.ObjectAxis; Quaternion axisCorrection = Quaternion.FromToRotation(axisInPalm, palmVector); if (Vector3.Dot(axisInPalm, palmVector) < 0) { axisCorrection = Quaternion.FromToRotation(axisInPalm, -palmVector); } this.RotationFromPalm = axisCorrection * this.RotationFromPalm; } } }