public SetTargetPosition ( |
||
target | The new target position to for the transform. | |
return | void |
// Update is called once per frame private void Update() { if (Manipulating) { // First step is to figure out the delta between the initial manipulation position and the current manipulation position Vector3 localManipulationPosition = Camera.main.transform.InverseTransformPoint(gestureManager.ManipulationPosition); Vector3 initialToCurrentPosition = localManipulationPosition - initialManipulationPosition; // When performing a manipulation gesture, the manipulation generally only translates a relatively small amount. // If we move the object only as much as the input source itself moves, users can only make small adjustments before // the source is lost and the gesture completes. To improve the usability of the gesture we scale each // axis of movement by some amount (camera relative). This value can be changed in the editor or // at runtime based on the needs of individual movement scenarios. Vector3 scaledLocalPositionDelta = Vector3.Scale(initialToCurrentPosition, PositionScale); // Once we've figured out how much the object should move relative to the camera we apply that to the initial // camera relative position. This ensures that the object remains in the appropriate location relative to the camera // and the input source as the camera moves. The allows users to use both gaze and gesture to move objects. Once they // begin manipulating an object they can rotate their head or walk around and the object will move with them // as long as they maintain the gesture, while still allowing adjustment via input movement. Vector3 localObjectPosition = initialObjectPosition + scaledLocalPositionDelta; Vector3 worldObjectPosition = Camera.main.transform.TransformPoint(localObjectPosition); // If the object has an interpolator we should use it, otherwise just move the transform directly if (targetInterpolator != null) { targetInterpolator.SetTargetPosition(worldObjectPosition); } else { transform.position = worldObjectPosition; } } }
protected virtual void Update() { // Retrieve the frustum planes from the camera. frustumPlanes = GeometryUtility.CalculateFrustumPlanes(TagAlongView); // Determine if the Tagalong needs to move based on whether its // BoxCollider is in or out of the camera's view frustum. Vector3 tagalongTargetPosition; if (CalculateTagalongTargetPosition(transform.position, out tagalongTargetPosition)) { // Derived classes will use the same Interpolator and may have // adjusted its PositionUpdateSpeed for some other purpose. // Restore the value we care about and tell the Interpolator // to move the Tagalong to its new target position. interpolator.PositionPerSecond = PositionUpdateSpeed; interpolator.SetTargetPosition(tagalongTargetPosition); } else if (!interpolator.Running && EnforceDistance) { // If the Tagalong is inside the camera's view frustum, and it is // supposed to stay a fixed distance from the camera, force the // tagalong to that location (without using the Interpolator). Ray ray = new Ray(TagAlongView.transform.position, transform.position - TagAlongView.transform.position); transform.position = ray.GetPoint(TagalongDistance); } }
// Update is called once per frame private void Update() { if (Navigating) { // First step is to figure out the delta between the initial navigation position and the current navigation position // commented out as turning head affected the rotation of the ColorWheel. Will evaluate with user testing //Vector3 localNavigationPosition = Camera.main.transform.InverseTransformPoint(gestureManager.ManipulationPosition); //Vector3 initialToCurrentPosition = gestureManager.ManipulationPosition - initialNavigationPosition; //Vector3 localManipulationPosition = Camera.main.transform.InverseTransformPoint(gestureManager.ManipulationPosition); //Vector3 initialToCurrentPosition = localManipulationPosition - initialManipulationPosition; //// When performing a navigation gesture, the navigation generally only translates a relatively small amount. //// If we rotate the object only as much as the input source itself moves, users can only make small adjustments before //// the source is lost and the gesture completes. To improve the usability of the gesture we scale each //// axis of movement by some amount (camera relative). This value can be changed in the editor or //// at runtime based on the needs of individual movement scenarios. //// If PositionScale is set high to increase sensitivity, unfortunately it also increases the minimum travel distance //// needed to begin triggering movement. To fix this, a dynamicSensitivity var is used to counter the minimum travel ////Vector3 scaledLocalPositionDelta; ////if (dynamicSensitivity < PositionScale.y) ////{ //// scaledLocalPositionDelta = Vector3.Scale(initialToCurrentPosition, new Vector3(PositionScale.x, dynamicSensitivity, PositionScale.z)); //// dynamicSensitivity += 0.2f; ////} ////else ////{ //// scaledLocalPositionDelta = Vector3.Scale(initialToCurrentPosition, PositionScale); ////} //Vector3 scaledLocalPositionDelta = Vector3.Scale(initialToCurrentPosition, PositionScale); //// Once we've figured out how much the object should rotate relative to the camera we apply that to the initial //// camera relative position. This ensures that the object remains in the appropriate location relative to the camera //// and the input source as the camera moves. The allows users to use both gaze and gesture to move objects. Once they //// begin navigating an object they can rotate their head or walk around and the object will move with them //// as long as they maintain the gesture, while still allowing adjustment via input movement. //Vector3 localObjectPosition = initialObjectPosition + scaledLocalPositionDelta; //Vector3 worldObjectPosition = Camera.main.transform.TransformPoint(localObjectPosition); //// If the object has an interpolator we should use it, otherwise just move the transform directly //if (targetInterpolator != null) //{ // targetInterpolator.SetTargetPosition(localObjectPosition); //} //else //{ // navigatorActions.ActionController(localObjectPosition); //} //initialObjectPosition = initialToCurrentPosition; // First step is to figure out the delta between the initial manipulation position and the current manipulation position Vector3 localManipulationPosition = Camera.main.transform.InverseTransformPoint(gestureManager.ManipulationPosition); Vector3 initialToCurrentPosition = localManipulationPosition - initialNavigationPosition; // When performing a manipulation gesture, the manipulation generally only translates a relatively small amount. // If we move the object only as much as the input source itself moves, users can only make small adjustments before // the source is lost and the gesture completes. To improve the usability of the gesture we scale each // axis of movement by some amount (camera relative). This value can be changed in the editor or // at runtime based on the needs of individual movement scenarios. Vector3 scaledLocalPositionDelta = Vector3.Scale(initialToCurrentPosition, PositionScale); // Once we've figured out how much the object should move relative to the camera we apply that to the initial // camera relative position. This ensures that the object remains in the appropriate location relative to the camera // and the input source as the camera moves. The allows users to use both gaze and gesture to move objects. Once they // begin manipulating an object they can rotate their head or walk around and the object will move with them // as long as they maintain the gesture, while still allowing adjustment via input movement. Vector3 localObjectPosition = initialObjectPosition + scaledLocalPositionDelta; Vector3 worldObjectPosition = Camera.main.transform.TransformPoint(localObjectPosition); // If the object has an interpolator we should use it, otherwise just move the transform directly if (targetInterpolator != null) { targetInterpolator.SetTargetPosition(localObjectPosition); } else { navigatorActions.ActionController(localObjectPosition); //transform.position = worldObjectPosition; } } }