/// <summary> /// Called by Handles when they are released. /// </summary> public void NotifyHandleDeactivated(TransformHandle handle) { if (handle is TransformTranslationHandle) { _activeTranslationAxes.Remove(((TransformTranslationHandle)handle).axis); } _activeHandles.Remove(handle); switch (_toolState) { case ToolState.Idle: Debug.LogWarning("Warning: Handle was deactived while Tool was already idle."); break; default: if (_activeHandles.Count == 0) { _toolState = ToolState.Idle; } break; } }
/// <summary> /// Called by handles when they are grasped. /// </summary> /// <param name="handle"></param> public void NotifyHandleActivated(TransformHandle handle) { switch (_toolState) { case ToolState.Idle: _activeHandles.Add(handle); if (handle is TransformTranslationHandle) { _toolState = ToolState.Translating; _activeTranslationAxes.Add(((TransformTranslationHandle)handle).axis); } else { _toolState = ToolState.Rotating; } break; case ToolState.Translating: if (handle is TransformRotationHandle) { Debug.LogError("Error: Can't rotate a transform while it is already being " + "translated."); } else { _activeHandles.Add(handle); _activeTranslationAxes.Add(((TransformTranslationHandle)handle).axis); } break; case ToolState.Rotating: Debug.LogError("Error: Only one handle can be active while a transform is being " + "rotated."); break; } }
// Checks to see if object is being scaled + sets the intialScaling variable of object private void ScalingSetup() { if (_activeHandles.Count == 2) { float xCount = 0; float yCount = 0; float zCount = 0; foreach (TransformHandle handle in _activeHandles) { if (handle.name == "Translate Pos X" || handle.name == "Translate Neg X") { xCount += 1; if (xCount == 1) { HandleOne = handle; } if (xCount == 2) { HandleTwo = handle; ChosenAxis = ScaleAxis.x; _toolState = ToolState.Scaling; } } if (handle.name == "Translate Pos Y" || handle.name == "Translate Neg Y") { yCount += 1; if (yCount == 1) { HandleOne = handle; } if (yCount == 2) { HandleTwo = handle; ChosenAxis = ScaleAxis.y; _toolState = ToolState.Scaling; } } if (handle.name == "Translate Pos Z" || handle.name == "Translate Neg Y") { zCount += 1; if (zCount == 1) { HandleOne = handle; } if (zCount == 2) { HandleTwo = handle; ChosenAxis = ScaleAxis.z; _toolState = ToolState.Scaling; } } } if (xCount == 2 || yCount == 2 || zCount == 2) { if (!initialScaled) { Vector3 leftPosition = new Vector3(hands[0].PalmPosition.x * 1 / 1000, hands[0].PalmPosition.y * 1 / 1000, hands[0].PalmPosition.z * 1 / 1000); Vector3 rightPosition = new Vector3(hands[1].PalmPosition.x * 1 / 1000, hands[1].PalmPosition.y * 1 / 1000, hands[1].PalmPosition.z * 1 / 1000); initialScaling = target.transform.localScale; initialHandDistance = Vector3.Distance(leftPosition, rightPosition); initialScaled = true; InitialHandleOnePosition = HandleOne.transform.position; InitialHandleTwoPosition = HandleTwo.transform.position; InitialHandOnePosition = leftPosition; InitialHandTwoPosition = rightPosition; } } } // To reset values if we're done/not scaling. if (_activeHandles.Count != 2) { initialScaled = false; } }
private void updateHandles() { switch (_toolState) { case ToolState.Idle: // Find the closest handle to any InteractionHand. TransformHandle closestHandleToAnyHand = null; float closestHandleDist = float.PositiveInfinity; foreach (var intController in interactionManager.interactionControllers .Query() .Where(controller => controller.isTracked)) { if (!intController.isPrimaryHovering) { continue; } TransformHandle testHandle = intController.primaryHoveredObject .gameObject .GetComponent <TransformHandle>(); if (testHandle == null || !_transformHandles.Contains(testHandle)) { continue; } float testDist = intController.primaryHoverDistance; if (testDist < closestHandleDist) { closestHandleToAnyHand = testHandle; closestHandleDist = testDist; } } // While idle, only show the closest handle to any hand, hide other handles. foreach (var handle in _transformHandles) { if (closestHandleToAnyHand != null && handle == closestHandleToAnyHand) { handle.EnsureVisible(); } else { handle.EnsureHidden(); } } break; case ToolState.Translating: // While translating, show all translation handles except the other handle // on the same axis, and hide rotation handles. foreach (var handle in _transformHandles) { if (handle is TransformTranslationHandle) { var translateHandle = handle as TransformTranslationHandle; if (!_activeHandles.Contains(translateHandle) && _activeTranslationAxes.Contains(translateHandle.axis)) { handle.EnsureHidden(); } else { handle.EnsureVisible(); } } else { handle.EnsureHidden(); } } break; case ToolState.Rotating: // While rotating, only show the active rotating handle. foreach (var handle in _transformHandles) { if (_activeHandles.Contains(handle)) { handle.EnsureVisible(); } else { handle.EnsureHidden(); } } break; } }
private void updateHandles() { switch (_toolState) { case ToolState.Idle: // Find the closest handle to any InteractionHand. TransformHandle closestHandleToAnyHand = null; float closestHandleDist = float.PositiveInfinity; foreach (var intController in interactionManager.interactionControllers .Query() .Where(controller => controller.isTracked)) { if (!intController.isPrimaryHovering) { continue; } TransformHandle testHandle = intController.primaryHoveredObject .gameObject .GetComponent <TransformHandle>(); if (testHandle == null || !_transformHandles.Contains(testHandle)) { continue; } float testDist = intController.primaryHoverDistance; if (testDist < closestHandleDist) { closestHandleToAnyHand = testHandle; closestHandleDist = testDist; } } // While idle, only show the closest handle to any hand, hide other handles. foreach (var handle in _transformHandles) { if (closestHandleToAnyHand != null && handle == closestHandleToAnyHand) { // Check if rotation should be restricted (aka is it connected?) if (ObjectConnected) { // If it's a Link, then shouldn't be able to rotate it (but should be able to translate the parent using it) if (target.GetComponent <ObjectJoint>() == null) { if (closestHandleToAnyHand is TransformTranslationHandle) { handle.EnsureVisible(); } else { handle.EnsureHidden(); } } // If it's a Joint, then we want to be able to rotate around the designated axis. else { if (rotateHandleNames.Contains(closestHandleToAnyHand.name) || closestHandleToAnyHand is TransformTranslationHandle) { handle.EnsureVisible(); } else { handle.EnsureHidden(); } } } // If rotation shouldn't be restricted, then just show any handle. else { handle.EnsureVisible(); } } else { handle.EnsureHidden(); } } break; case ToolState.Translating: // ***************** TODO: How about if we make others not visible and only axis visible? ************************ // While translating, show all translation handles except the other handle // on the same axis, and hide rotation handles. foreach (var handle in _transformHandles) { if (handle is TransformTranslationHandle) { var translateHandle = handle as TransformTranslationHandle; if (!_activeHandles.Contains(translateHandle) && _activeTranslationAxes.Contains(translateHandle.axis)) { handle.EnsureVisible(); } else { handle.EnsureVisible(); } } else { handle.EnsureHidden(); } } break; case ToolState.Rotating: // While rotating, only show the active rotating handle. foreach (var handle in _transformHandles) { if (_activeHandles.Contains(handle)) { handle.EnsureVisible(); } else { handle.EnsureHidden(); } } break; } }