public void HighlightEntirePath() {
   CameraPathTinter t = WidgetManager.m_Instance.PathTinter;
   for (int i = 0; i < Path.PositionKnots.Count; ++i) {
     CameraPathPositionKnot pk = Path.PositionKnots[i];
     pk.RegisterHighlight(0, true);
     t.TintKnot(pk);
   }
   for (int i = 0; i < Path.RotationKnots.Count; ++i) {
     CameraPathRotationKnot rk = Path.RotationKnots[i];
     rk.RegisterHighlight(0, true);
     t.TintKnot(rk);
   }
   for (int i = 0; i < Path.SpeedKnots.Count; ++i) {
     CameraPathSpeedKnot sk = Path.SpeedKnots[i];
     sk.RegisterHighlight(0, true);
     t.TintKnot(sk);
   }
   for (int i = 0; i < Path.FovKnots.Count; ++i) {
     CameraPathFovKnot fk = Path.FovKnots[i];
     fk.RegisterHighlight(0, true);
     t.TintKnot(fk);
   }
   for (int i = 0; i < Path.Segments.Count; ++i) {
     t.TintSegment(m_Path.Segments[i]);
   }
 }
  override protected void OnUserEndInteracting() {
    base.OnUserEndInteracting();

    if (!m_EatInteractingInput) {
      // Finalize our move commands with the current state of whatever's being actively modified.
      switch (m_ActiveKnot.knot.KnotType) {
      case CameraPathKnot.Type.Position:
        if (m_ActiveKnot.control == 0) {
          SketchMemoryScript.m_Instance.PerformAndRecordCommand(
              new MovePositionKnotCommand(m_Path, m_ActiveKnot,
                TrTransform.FromTransform(m_ActiveKnot.knot.transform), true));
        } else {
          CameraPathPositionKnot pk = m_ActiveKnot.knot as CameraPathPositionKnot;
          Vector3 knotFwd = m_ActiveKnot.knot.transform.forward;
          SketchMemoryScript.m_Instance.PerformAndRecordCommand(
              new ModifyPositionKnotCommand(
                m_Path, m_ActiveKnot, pk.TangentMagnitude, knotFwd, final:true));
        }
        break;
      case CameraPathKnot.Type.Rotation:
      case CameraPathKnot.Type.Speed:
      case CameraPathKnot.Type.Fov:
        // Reset any PreviewWidget overrides.
        m_ActiveKnot.knot.gameObject.SetActive(true);
        InputManager.Wand.Geometry.PreviewKnotHint.Activate(false);
        InputManager.Brush.Geometry.PreviewKnotHint.Activate(false);
        SketchControlsScript.m_Instance.CameraPathCaptureRig.OverridePreviewWidgetPathT(null);

        if (m_ActiveKnot.control == 0) {
          SketchMemoryScript.m_Instance.PerformAndRecordCommand(
              new MoveConstrainedKnotCommand(m_Path, m_ActiveKnot,
                m_ActiveKnot.knot.transform.rotation, final:true));
        } else {
          if (m_ActiveKnot.knot.KnotType == CameraPathKnot.Type.Speed) {
            CameraPathSpeedKnot sk = m_ActiveKnot.knot as CameraPathSpeedKnot;
            SketchMemoryScript.m_Instance.PerformAndRecordCommand(
                new ModifySpeedKnotCommand(sk, sk.SpeedValue));
          } else if (m_ActiveKnot.knot.KnotType == CameraPathKnot.Type.Fov) {
            CameraPathFovKnot fk = m_ActiveKnot.knot as CameraPathFovKnot;
            SketchMemoryScript.m_Instance.PerformAndRecordCommand(
                new ModifyFovKnotCommand(fk, fk.FovValue));
          }
        }
        break;
      }
    }

    m_KnotEditingLastInputXf = null;
    m_ActiveKnot = null;
  }
示例#3
0
        protected override void OnRedo()
        {
            // The scale of path widgets is arbitrary.  However, the scale should be one at knot creation
            // time so newly added knots have appropriate mesh scales.
            m_Widget.transform.localScale = Vector3.one;
            if (m_CreatedKnot == null)
            {
                switch (m_KnotType)
                {
                case CameraPathKnot.Type.Position:
                    m_CreatedKnot = m_Widget.Path.CreatePositionKnot(m_SpawnXf.translation);
                    break;

                case CameraPathKnot.Type.Rotation:
                    m_CreatedKnot = m_Widget.Path.CreateRotationKnot(m_PathT, m_SpawnXf.rotation);
                    break;

                case CameraPathKnot.Type.Speed:
                    m_CreatedKnot = m_Widget.Path.CreateSpeedKnot(m_PathT);
                    break;

                case CameraPathKnot.Type.Fov:
                    m_CreatedKnot = m_Widget.Path.CreateFovKnot(m_PathT);
                    break;

                default:
                    Debug.Log("CreatePathKnotCommand knot type unsupported.");
                    break;
                }
            }

            switch (m_KnotType)
            {
            case CameraPathKnot.Type.Position:
                int knotIndex = m_PathT.Floor();
                // If we're inserting a point and it's at the head, take on the characteristics of
                // the head knot.  This will cause InsertPositionKnot to register the path as looping,
                // which is what we want.
                if (m_Widget.Path.IsPositionNearHead(m_CreatedKnot.transform.position) &&
                    knotIndex == m_Widget.Path.NumPositionKnots)
                {
                    CameraPathPositionKnot cppkCreated = (CameraPathPositionKnot)m_CreatedKnot;
                    CameraPathPositionKnot cppkHead    = m_Widget.Path.PositionKnots[0];
                    cppkCreated.transform.rotation = cppkHead.transform.rotation;
                    cppkCreated.TangentMagnitude   = cppkHead.TangentMagnitude;
                }
                m_Widget.Path.InsertPositionKnot((CameraPathPositionKnot)m_CreatedKnot, knotIndex);
                break;

            case CameraPathKnot.Type.Rotation:
                m_Widget.Path.AddRotationKnot((CameraPathRotationKnot)m_CreatedKnot, m_PathT);
                break;

            case CameraPathKnot.Type.Speed:
                m_Widget.Path.AddSpeedKnot((CameraPathSpeedKnot)m_CreatedKnot, m_PathT);
                break;

            case CameraPathKnot.Type.Fov:
                m_Widget.Path.AddFovKnot((CameraPathFovKnot)m_CreatedKnot, m_PathT);
                break;

            default:
                Debug.Log("CreatePathKnotCommand knot type unsupported.");
                break;
            }

            m_CreatedKnot.gameObject.SetActive(true);
            App.Switchboard.TriggerCameraPathKnotChanged();
            WidgetManager.m_Instance.CameraPathsVisible = true;
        }
示例#4
0
        override public void UpdateTool()
        {
            base.UpdateTool();

            // If we're in the recording state, just look for cancel and get out.
            if (CurrentMode == Mode.Recording)
            {
                if (InputManager.m_Instance.GetCommandDown(InputManager.SketchCommands.MenuContextClick))
                {
                    SketchControlsScript.m_Instance.CameraPathCaptureRig.StopRecordingPath(false);
                }
                return;
            }

            var       widgets      = WidgetManager.m_Instance.CameraPathWidgets;
            Transform toolAttachXf = InputManager.Brush.Geometry.ToolAttachPoint;

            bool input     = InputManager.m_Instance.GetCommand(InputManager.SketchCommands.Activate);
            bool inputDown = InputManager.m_Instance.GetCommandDown(InputManager.SketchCommands.Activate);

            // Tint any path we're intersecting with.
            if (!input && m_LastValidPath != null && m_Mode != Mode.RemoveKnot)
            {
                m_LastValidPath.TintSegments(m_LastValidPosition);
            }

            // Initiating input.
            if (inputDown)
            {
                // We clicked, but the path we clicked on isn't the active path.  In that case,
                // switch it to the active path and eat up this input.
                // Don't do this for removing knots.  That input should be explicit.
                if (m_Mode != Mode.RemoveKnot && m_LastValidPath != null)
                {
                    GrabWidgetData data = WidgetManager.m_Instance.GetCurrentCameraPath();
                    bool           lastValidIsCurrent = (data == null) ? false : data.m_WidgetScript == m_LastValidPath;
                    if (!lastValidIsCurrent)
                    {
                        WidgetManager.m_Instance.SetCurrentCameraPath(m_LastValidPath);
                        return;
                    }
                }

                switch (m_Mode)
                {
                case Mode.AddPositionKnot:
                    // Create a new path if none exists or if we're trying to add a position point
                    // in a place where we're not extending an existing path.
                    if (!WidgetManager.m_Instance.AnyCameraPathWidgetsActive ||
                        (m_LastValidPath == null && m_ExtendPath == null))
                    {
                        m_ExtendPath     = WidgetManager.m_Instance.CreatePathWidget();
                        m_ExtendPathType = ExtendPathType.ExtendAtHead;
                        WidgetManager.m_Instance.SetCurrentCameraPath(m_ExtendPath);
                    }

                    if (m_LastValidPath != null)
                    {
                        m_LastValidPath.AddPathConstrainedKnot(
                            CameraPathKnot.Type.Position, m_LastValidPosition, toolAttachXf.rotation);
                        m_LastPlacedKnot     = m_LastValidPath.Path.LastPlacedKnotInfo;
                        m_LastPlacedKnotPath = m_LastValidPath;
                    }
                    else if (m_ExtendPath != null)
                    {
                        // Manipulation of a path we wish to extend.
                        m_ExtendPath.ExtendPath(toolAttachXf.position, m_ExtendPathType);

                        // Remember the index of the path we just added to, so we can manipulate it
                        // while input is held.
                        // Don't record this if we just made our path loop.
                        if (!m_ExtendPath.Path.PathLoops)
                        {
                            m_LastPlacedKnot     = m_ExtendPath.Path.LastPlacedKnotInfo;
                            m_LastPlacedKnotPath = m_ExtendPath;
                        }
                    }
                    break;

                case Mode.AddRotationKnot:
                    if (m_LastValidPath != null)
                    {
                        m_LastValidPath.AddPathConstrainedKnot(
                            CameraPathKnot.Type.Rotation, m_LastValidPosition, toolAttachXf.rotation);
                        m_LastPlacedKnot     = m_LastValidPath.Path.LastPlacedKnotInfo;
                        m_LastPlacedKnotPath = m_LastValidPath;
                    }
                    break;

                case Mode.AddSpeedKnot:
                    if (m_LastValidPath != null)
                    {
                        m_LastValidPath.AddPathConstrainedKnot(
                            CameraPathKnot.Type.Speed, m_LastValidPosition, toolAttachXf.rotation);
                        m_LastPlacedKnot     = m_LastValidPath.Path.LastPlacedKnotInfo;
                        m_LastPlacedKnotPath = m_LastValidPath;
                    }
                    break;

                case Mode.AddFovKnot:
                    if (m_LastValidPath != null)
                    {
                        m_LastValidPath.AddPathConstrainedKnot(
                            CameraPathKnot.Type.Fov, m_LastValidPosition, toolAttachXf.rotation);
                        m_LastPlacedKnot     = m_LastValidPath.Path.LastPlacedKnotInfo;
                        m_LastPlacedKnotPath = m_LastValidPath;
                    }
                    break;

                case Mode.RemoveKnot:
                    CheckToRemoveKnot(toolAttachXf.position);
                    break;
                }

                // Remember what our controller looked like so we can manipulate this knot.
                if (m_LastPlacedKnot != null)
                {
                    Transform   controller  = InputManager.Brush.Transform;
                    Transform   knotXf      = m_LastPlacedKnot.knot.transform;
                    TrTransform newWidgetXf = Coords.AsGlobal[knotXf];
                    m_LastPlacedKnotXf_LS = Coords.AsGlobal[controller].inverse * newWidgetXf;
                    HideAllMeshes();
                }
            }
            else if (input)
            {
                if (m_Mode == Mode.RemoveKnot)
                {
                    CheckToRemoveKnot(toolAttachXf.position);
                }
                else if (m_LastPlacedKnot != null)
                {
                    // Holding input from last frame can allow us to manipulate a just placed position knot.
                    WidgetManager.m_Instance.PathTinter.TintKnot(m_LastPlacedKnot.knot);

                    TrTransform controllerXf = Coords.AsGlobal[InputManager.Brush.Transform];
                    TrTransform inputXf      = controllerXf * m_LastPlacedKnotXf_LS;

                    switch (m_LastPlacedKnot.knot.KnotType)
                    {
                    case CameraPathKnot.Type.Position:
                        if (m_LastPlacedKnot.control != 0)
                        {
                            CameraPathPositionKnot pk = m_LastPlacedKnot.knot as CameraPathPositionKnot;
                            float   tangentMag        = pk.GetTangentMagnitudeFromControlXf(inputXf);
                            Vector3 knotFwd           =
                                (inputXf.translation - m_LastPlacedKnot.knot.transform.position).normalized;
                            if ((CameraPathPositionKnot.ControlType)m_LastPlacedKnot.control ==
                                CameraPathPositionKnot.ControlType.TangentControlBack)
                            {
                                knotFwd *= -1.0f;
                            }

                            SketchMemoryScript.m_Instance.PerformAndRecordCommand(
                                new ModifyPositionKnotCommand(
                                    m_LastPlacedKnotPath.Path, m_LastPlacedKnot, tangentMag, knotFwd,
                                    mergesWithCreateCommand: true));
                        }
                        break;

                    case CameraPathKnot.Type.Rotation:
                        // Rotation knots hide when we grab them, and in their place, we set the preview widget.
                        m_LastPlacedKnot.knot.gameObject.SetActive(false);
                        SketchControlsScript.m_Instance.CameraPathCaptureRig.OverridePreviewWidgetPathT(
                            m_LastPlacedKnot.knot.PathT);
                        SketchMemoryScript.m_Instance.PerformAndRecordCommand(
                            new MoveConstrainedKnotCommand(m_LastPlacedKnotPath.Path, m_LastPlacedKnot,
                                                           inputXf.rotation, mergesWithCreateCommand: true));
                        break;

                    case CameraPathKnot.Type.Speed:
                        CameraPathSpeedKnot sk = m_LastPlacedKnot.knot as CameraPathSpeedKnot;
                        float speed            = sk.GetSpeedValueFromY(
                            InputManager.Brush.Behavior.PointerAttachPoint.transform.position.y);
                        SketchMemoryScript.m_Instance.PerformAndRecordCommand(
                            new ModifySpeedKnotCommand(sk, speed, mergesWithCreateCommand: true));
                        break;

                    case CameraPathKnot.Type.Fov:
                        CameraPathFovKnot fk  = m_LastPlacedKnot.knot as CameraPathFovKnot;
                        float             fov = fk.GetFovValueFromY(
                            InputManager.Brush.Behavior.PointerAttachPoint.transform.position.y);
                        SketchMemoryScript.m_Instance.PerformAndRecordCommand(
                            new ModifyFovKnotCommand(fk, fov, mergesWithCreateCommand: true));
                        break;
                    }
                }
            }
            else
            {
                // No input to work with.  Forget we had anything and make sure our meshes are showing.
                if (m_LastPlacedKnot != null)
                {
                    RefreshMeshVisibility();

                    // Rotation knots hide when we grab them, make sure it's enabled.
                    if (m_LastPlacedKnot.knot.KnotType == CameraPathKnot.Type.Rotation)
                    {
                        m_LastPlacedKnot.knot.gameObject.SetActive(true);
                        SketchControlsScript.m_Instance.CameraPathCaptureRig.OverridePreviewWidgetPathT(null);
                    }
                }
                m_LastPlacedKnot     = null;
                m_LastPlacedKnotPath = null;
            }
        }
  static public void CreateFromSaveData(CameraPathMetadata cameraPath) {
    // Create a new widget.
    CameraPathWidget widget = Instantiate<CameraPathWidget>(
        WidgetManager.m_Instance.CameraPathWidgetPrefab);
    widget.transform.parent = App.Scene.MainCanvas.transform;

    // The scale of path widgets is arbitrary.  However, the scale should be one at creation
    // time so the knots added below have appropriate mesh scales.
    widget.transform.localScale = Vector3.one;
    widget.transform.localPosition = Vector3.zero;
    widget.transform.localRotation = Quaternion.identity;

    // Add the path knots and set their tangent speed.
    for (int i = 0; i < cameraPath.PathKnots.Length; ++i) {
      GameObject go = Instantiate<GameObject>(
          WidgetManager.m_Instance.CameraPathPositionKnotPrefab);
      go.transform.position = cameraPath.PathKnots[i].Xf.translation;
      go.transform.rotation = cameraPath.PathKnots[i].Xf.rotation;
      go.transform.parent = widget.transform;

      CameraPathPositionKnot knot = go.GetComponent<CameraPathPositionKnot>();
      knot.TangentMagnitude = cameraPath.PathKnots[i].TangentMagnitude;

      widget.m_Path.PositionKnots.Add(knot);
      widget.m_Path.AllKnots.Add(knot);

      if (i > 0) {
        widget.m_Path.Segments.Add(CameraPath.CreateSegment(widget.transform));
      }
    }

    // Refresh the path so the segment curves are correct.
    for (int i = 0; i < cameraPath.PathKnots.Length - 1; ++i) {
      widget.m_Path.RefreshSegment(i);
    }

    // Add the rotation knots.  Note this list is ordered, and they're serialized in order,
    // so we need to make sure they're created in order.
    for (int i = 0; i < cameraPath.RotationKnots.Length; ++i) {
      GameObject go = Instantiate<GameObject>(
          WidgetManager.m_Instance.CameraPathRotationKnotPrefab);
      go.transform.position = cameraPath.RotationKnots[i].Xf.translation;
      go.transform.rotation = cameraPath.RotationKnots[i].Xf.rotation;
      go.transform.parent = widget.transform;

      CameraPathRotationKnot knot = go.GetComponent<CameraPathRotationKnot>();
      knot.PathT = new PathT(cameraPath.RotationKnots[i].PathTValue);
      knot.DistanceAlongSegment = widget.m_Path.GetSegmentDistanceToT(knot.PathT);

      widget.m_Path.RotationKnots.Add(knot);
      widget.m_Path.AllKnots.Add(knot);
    }
    // Align quaternions on all rotation knots so we don't have unexpected camera flips
    // when calculating rotation as we walk the path.
    widget.m_Path.RefreshRotationKnotPolarities();

    // Add the speed knots.  Note this list is ordered, and they're serialized in order,
    // so we need to make sure they're created in order.
    for (int i = 0; i < cameraPath.SpeedKnots.Length; ++i) {
      GameObject go = Instantiate<GameObject>(
          WidgetManager.m_Instance.CameraPathSpeedKnotPrefab);
      go.transform.position = cameraPath.SpeedKnots[i].Xf.translation;
      go.transform.rotation = cameraPath.SpeedKnots[i].Xf.rotation;
      go.transform.parent = widget.transform;

      CameraPathSpeedKnot knot = go.GetComponent<CameraPathSpeedKnot>();

      knot.PathT = new PathT(cameraPath.SpeedKnots[i].PathTValue);
      knot.DistanceAlongSegment = widget.m_Path.GetSegmentDistanceToT(knot.PathT);
      knot.SpeedValue = cameraPath.SpeedKnots[i].Speed;

      widget.m_Path.SpeedKnots.Add(knot);
      widget.m_Path.AllKnots.Add(knot);
    }

    // Add the fov knots.  Note this list is ordered, and they're serialized in order,
    // so we need to make sure they're created in order.
    for (int i = 0; i < cameraPath.FovKnots.Length; ++i) {
      GameObject go = Instantiate<GameObject>(
          WidgetManager.m_Instance.CameraPathFovKnotPrefab);
      go.transform.position = cameraPath.FovKnots[i].Xf.translation;
      go.transform.rotation = cameraPath.FovKnots[i].Xf.rotation;
      go.transform.parent = widget.transform;

      CameraPathFovKnot knot = go.GetComponent<CameraPathFovKnot>();

      knot.PathT = new PathT(cameraPath.FovKnots[i].PathTValue);
      knot.DistanceAlongSegment = widget.m_Path.GetSegmentDistanceToT(knot.PathT);
      knot.FovValue = cameraPath.FovKnots[i].Fov;

      widget.m_Path.FovKnots.Add(knot);
      widget.m_Path.AllKnots.Add(knot);
    }

    // Refresh visuals on the whole path.
    for (int i = 0; i < widget.m_Path.AllKnots.Count; ++i) {
      widget.m_Path.AllKnots[i].RefreshVisuals();
      widget.m_Path.AllKnots[i].ActivateTint(false);
      widget.m_Path.AllKnots[i].SetActivePathVisuals(false);
    }

    // And turn them off.
    widget.m_Path.ValidatePathLooping();
    widget.m_Path.SetKnotsActive(false);
    App.Switchboard.TriggerCameraPathCreated();
  }
  override public float GetActivationScore(Vector3 point, InputManager.ControllerName name) {
    float nearestKnotScore = -1.0f;
    KnotDescriptor nearestResult = new KnotDescriptor();

    if (VideoRecorderUtils.ActiveVideoRecording == null &&
        !WidgetManager.m_Instance.WidgetsDormant &&
        !InputManager.m_Instance.GetCommand(InputManager.SketchCommands.Activate)) {
      // Check against all knots and put our results in storage bins.
      // Note that we're walking along the sorted lists instead of using m_Path.m_AllKnots.
      // This ensures the knotIndex stored in KnotCollisionResult is correct.
      for (int i = 0; i < m_Path.PositionKnots.Count; ++i) {
        int control = -1;
        CameraPathPositionKnot pk = m_Path.PositionKnots[i];
        float knotScore = pk.gameObject.activeSelf ?
            pk.CollisionWithPoint(point, out control) : -1.0f;
        if (knotScore > nearestKnotScore) {
          nearestResult.Set(pk, control, i, null);
          nearestKnotScore = knotScore;
        }
      }
      for (int i = 0; i < m_Path.RotationKnots.Count; ++i) {
        int control = -1;
        CameraPathRotationKnot rk = m_Path.RotationKnots[i];
        float knotScore = rk.CollisionWithPoint(point, out control);
        if (knotScore > nearestKnotScore) {
          nearestResult.Set(rk, control, null, rk.PathT);
          nearestKnotScore = knotScore;
        }
      }
      for (int i = 0; i < m_Path.SpeedKnots.Count; ++i) {
        int control = -1;
        CameraPathSpeedKnot sk = m_Path.SpeedKnots[i];
        float knotScore = sk.CollisionWithPoint(point, out control);
        if (knotScore > nearestKnotScore) {
          nearestResult.Set(sk, control, null, sk.PathT);
          nearestKnotScore = knotScore;
        }
      }
      for (int i = 0; i < m_Path.FovKnots.Count; ++i) {
        int control = -1;
        CameraPathFovKnot fk = m_Path.FovKnots[i];
        float knotScore = fk.CollisionWithPoint(point, out control);
        if (knotScore > nearestKnotScore) {
          nearestResult.Set(fk, control, null, fk.PathT);
          nearestKnotScore = knotScore;
        }
      }
    }

    bool brushOrWand = (name == InputManager.ControllerName.Brush) ||
        (name == InputManager.ControllerName.Wand);
    if (!m_UserInteracting) {
      if (brushOrWand) {
        m_LastCollisionResults[(int)name].Set(nearestResult);
        if ((nearestResult.knot != null) && (nearestResult.control != -1)) {
          m_LastValidCollisionResults[(int)name].Set(nearestResult);
        }
      }
    } else if (m_InteractingController != name && brushOrWand) {
      m_LastCollisionResults[(int)name].Set(null, CameraPathKnot.kDefaultControl, null, null);
    }
    return nearestKnotScore;
  }
  override public void RecordAndSetPosRot(TrTransform inputXf) {
    // Don't manipulate anything if we're eating input.
    if (m_EatInteractingInput) {
      return;
    }

    SnapEnabled = (m_ActiveKnot.knot.KnotType == CameraPathKnot.Type.Rotation ||
                   m_ActiveKnot.knot.KnotType == CameraPathKnot.Type.Position) &&
                  InputManager.Controllers[(int)m_InteractingController].GetCommand(
                      InputManager.SketchCommands.MenuContextClick);
    inputXf = GetDesiredTransform(inputXf);

    if (m_ActiveKnot.knot.KnotType == CameraPathKnot.Type.Position) {
      // Move the base knot.
      if (m_ActiveKnot.control == 0) {
        // If this knot is the tail or the head and we're within snapping distance of the other
        // end, snap to the transform.
        TrTransform snappedXf = inputXf;
        int positionKnot = m_ActiveKnot.positionKnotIndex.Value;
        if (positionKnot == 0 || positionKnot == Path.NumPositionKnots - 1) {
          int otherIndex = positionKnot == 0 ? Path.NumPositionKnots - 1 : 0;
          float distToOther = Vector3.Distance(inputXf.translation,
              Path.PositionKnots[otherIndex].KnotXf.position);
          if (distToOther < m_KnotSnapDistanceToEnd) {
            snappedXf.translation = Path.PositionKnots[otherIndex].KnotXf.position;
            snappedXf.rotation = Path.PositionKnots[otherIndex].KnotXf.rotation;
          }
        }

        SketchMemoryScript.m_Instance.PerformAndRecordCommand(
            new MovePositionKnotCommand(m_Path, m_ActiveKnot, snappedXf));
      } else {
        // Modify the knot tangents.
        CameraPathPositionKnot pk = m_ActiveKnot.knot as CameraPathPositionKnot;
        if (SnapEnabled) {
          Vector3 snappedTranslation = inputXf.translation;
          snappedTranslation.y = pk.transform.position.y;
          inputXf.translation = snappedTranslation;
        }
        float tangentMag = pk.GetTangentMagnitudeFromControlXf(inputXf);
        Vector3 knotFwd = (inputXf.translation - m_ActiveKnot.knot.transform.position).normalized;
        if ((CameraPathPositionKnot.ControlType)m_ActiveKnot.control ==
            CameraPathPositionKnot.ControlType.TangentControlBack) {
          knotFwd *= -1.0f;
        }
        SketchMemoryScript.m_Instance.PerformAndRecordCommand(
            new ModifyPositionKnotCommand(m_Path, m_ActiveKnot, tangentMag, knotFwd));
      }
      return;
    }

    // Constrain rotation and speed knots to the path.
    // Instead of testing the raw value that comes in from the controller position, test our
    // last valid path position plus any translation that's happened the past frame.  This
    // method keeps the test positions near the path, allowing continuous movement when the
    // user has moved beyond the intersection distance to the path.
    Vector3 positionToProject = inputXf.translation;
    if (m_KnotEditingLastInputXf.HasValue) {
      Vector3 translationDiff = inputXf.translation - m_KnotEditingLastInputXf.Value;
      positionToProject = m_ActiveKnot.knot.KnotXf.position + translationDiff;
    }
    m_KnotEditingLastInputXf = inputXf.translation;

    // Project transform on to the path to get t.
    Vector3 error = Vector3.zero;
    if (m_Path.ProjectPositionOnToPath(positionToProject, out PathT pathT, out error)) {
      // Move the base knot.
      if (m_ActiveKnot.control == 0) {
        // Path constrained knots are a little sticky on the ends of the path.  Knots very
        // near the ends *probably* want to be on the ends, and when there are small deltas
        // near the ends, it causes unwanted erratic curves.
        m_ActiveKnot.pathT = m_Path.MaybeSnapPathTToEnd(pathT, m_KnotSnapDistanceToEnd);

        // Rotation knots allow the user to place the preview widget at their position
        // for live preview.
        if (m_ActiveKnot.knot.KnotType == CameraPathKnot.Type.Rotation) {
          CheckForPreviewWidgetOverride(pathT);
        }

        SketchMemoryScript.m_Instance.PerformAndRecordCommand(
            new MoveConstrainedKnotCommand(m_Path, m_ActiveKnot, inputXf.rotation));
      } else {
        // Alternate controls.
        BaseControllerBehavior b = InputManager.Controllers[(int)m_InteractingController].Behavior;
        float controllerY = b.PointerAttachPoint.transform.position.y;

        if (m_ActiveKnot.knot.KnotType == CameraPathKnot.Type.Speed) {
          CameraPathSpeedKnot sk = m_ActiveKnot.knot as CameraPathSpeedKnot;
          float speed = sk.GetSpeedValueFromY(controllerY - m_GrabControlInitialYDiff);
          SketchMemoryScript.m_Instance.PerformAndRecordCommand(
              new ModifySpeedKnotCommand(sk, speed));
        } else if (m_ActiveKnot.knot.KnotType == CameraPathKnot.Type.Fov) {
          CameraPathFovKnot fk = m_ActiveKnot.knot as CameraPathFovKnot;
          float fov = fk.GetFovValueFromY(controllerY - m_GrabControlInitialYDiff);
          CheckForPreviewWidgetOverride(fk.PathT);
          SketchMemoryScript.m_Instance.PerformAndRecordCommand(
              new ModifyFovKnotCommand(fk, fov));
        }
      }
    }
    m_KnotEditingLastInputXf -= error;
  }