multicam: finished usable implementation

2022-09-25 20:26:10 -07:00
parent e4c2f37adc
commit a6b8b7ccbc
13 changed files with 263 additions and 37 deletions
@@ -1,13 +1,53 @@
 #include "multicamwidget.h"
+#include "widget/nodeparamview/nodeparamviewundo.h"

 namespace olive {

 #define super ViewerWidget

 MulticamWidget::MulticamWidget(QWidget *parent) :
-  super{parent}
+  super{parent},
+  node_(nullptr)
 {
+  auto_cacher()->SetMulticamMode(true);

+  connect(display_widget(), &ViewerDisplayWidget::DragStarted, this, &MulticamWidget::DisplayClicked);
+}
+
+RenderTicketPtr MulticamWidget::GetSingleFrame(const rational &t, bool dry)
+{
+  if (node_) {
+    return auto_cacher()->GetSingleFrame(node_, t, dry);
+  } else {
+    return super::GetSingleFrame(t, dry);
+  }
+}
+
+void MulticamWidget::DisplayClicked(const QPoint &p)
+{
+  if (!node_) {
+    return;
+  }
+
+  QPointF click = display_widget()->ScreenToScenePoint(p);
+  int width = display_widget()->GetVideoParams().width();
+  int height = display_widget()->GetVideoParams().height();
+
+  if (click.x() < 0 || click.y() < 0 || click.x() >= width || click.y() >= height) {
+    return;
+  }
+
+  int rows, cols;
+  node_->GetRowsAndColumns(&rows, &cols);
+
+  int multi = std::max(cols, rows);
+
+  int c = click.x() / (width/multi);
+  int r = click.y() / (height/multi);
+
+  MultiUndoCommand *command = new MultiUndoCommand();
+  command->add_child(new NodeParamSetStandardValueCommand(NodeKeyframeTrackReference(NodeInput(node_, node_->kCurrentInput)), node_->RowsColsToIndex(r, c, rows, cols)));
+  Core::instance()->undo_stack()->push(command);
 }

 }
@@ -13,8 +13,19 @@ class MulticamWidget : public ViewerWidget
 public:
  explicit MulticamWidget(QWidget *parent = nullptr);

+  void SetMulticamNode(MultiCamNode *n)
+  {
+    node_ = n;
+  }
+
+protected:
+  virtual RenderTicketPtr GetSingleFrame(const rational &t, bool dry = false) override;
+
 private:
-  //MultiCamNode *node_;
+  MultiCamNode *node_;
+
+private slots:
+  void DisplayClicked(const QPoint &p);

 };

@@ -580,7 +580,7 @@ void ViewerWidget::RequestNextDryRun()
      } else {
        RenderTicketWatcher *watcher = new RenderTicketWatcher(this);
        connect(watcher, &RenderTicketWatcher::Finished, this, &ViewerWidget::DryRunFinished);
-        watcher->SetTicket(auto_cacher_->GetSingleFrame(next_time, true));
+        watcher->SetTicket(GetSingleFrame(next_time, true));
        dry_run_next_frame_ += playback_speed_;
        dry_run_watchers_.append(watcher);
      }
@@ -1033,7 +1033,7 @@ RenderTicketPtr ViewerWidget::GetFrame(const rational &t)

  if (!QFileInfo::exists(cache_fn)) {
    // Frame hasn't been cached, start render job
-    return auto_cacher_->GetSingleFrame(t);
+    return GetSingleFrame(t);
  } else {
    // Frame has been cached, grab the frame
    RenderTicketPtr ticket = std::make_shared<RenderTicket>();
@@ -184,6 +184,13 @@ protected:
    ignore_scrub_++;
  }

+  virtual RenderTicketPtr GetSingleFrame(const rational &t, bool dry = false)
+  {
+    return auto_cacher_->GetSingleFrame(t, dry);
+  }
+
+  PreviewAutoCacher *auto_cacher() const { return auto_cacher_; }
+
 private:
  int64_t GetTimestamp() const
  {
@@ -431,17 +431,13 @@ void ViewerDisplayWidget::OnPaint()

  // Draw gizmos if we have any
  if (gizmos_) {
-    NodeTraverser gt;
-    gt.SetCacheVideoParams(gizmo_params_);
-
-    TimeRange range = GenerateGizmoTime();
-    gizmo_db_ = gt.GenerateRow(gizmos_, range);
-
    QPainter p(paint_device());
-    gizmo_last_draw_transform_ = GenerateGizmoTransform(gt, range);
+
+    GenerateGizmoTransforms();
+
    p.setWorldTransform(gizmo_last_draw_transform_);

-    gizmos_->UpdateGizmoPositions(gizmo_db_, NodeTraverser::GenerateGlobals(gizmo_params_, range));
+    gizmos_->UpdateGizmoPositions(gizmo_db_, NodeTraverser::GenerateGlobals(gizmo_params_, gizmo_draw_time_));
    foreach (NodeGizmo *gizmo, gizmos_->GetGizmos()) {
      if (gizmo->IsVisible()) {
        gizmo->Draw(&p);
@@ -812,8 +808,7 @@ bool ViewerDisplayWidget::OnMousePress(QMouseEvent *event)
      add_band_ = true;

    } else if (gizmos_
-               && (gizmo_last_draw_transform_inverted_ = gizmo_last_draw_transform_.inverted(),
-                   current_gizmo_ = TryGizmoPress(gizmo_db_, gizmo_last_draw_transform_inverted_.map(event->pos())))) {
+               && (current_gizmo_ = TryGizmoPress(gizmo_db_, gizmo_last_draw_transform_inverted_.map(event->pos())))) {

      // Handle gizmo click
      gizmo_start_drag_ = event->pos();
@@ -823,7 +818,7 @@ bool ViewerDisplayWidget::OnMousePress(QMouseEvent *event)
    } else {

      // Handle standard drag
-      emit DragStarted();
+      emit DragStarted(event->pos());

    }

@@ -871,7 +866,7 @@ bool ViewerDisplayWidget::OnMouseMove(QMouseEvent *event)
    // Signal movement
    if (DraggableGizmo *draggable = dynamic_cast<DraggableGizmo*>(current_gizmo_)) {
      if (!gizmo_drag_started_) {
-        QPointF start = gizmo_start_drag_ * gizmo_last_draw_transform_inverted_;
+        QPointF start = ScreenToScenePoint(gizmo_start_drag_);

        rational gizmo_time = GetGizmoTime();
        NodeTraverser t;
@@ -882,17 +877,17 @@ bool ViewerDisplayWidget::OnMouseMove(QMouseEvent *event)
        gizmo_drag_started_ = true;
      }

-      QPointF v = event->pos() * gizmo_last_draw_transform_inverted_;
+      QPointF v = ScreenToScenePoint(event->pos());
      switch (draggable->GetDragValueBehavior()) {
      case DraggableGizmo::kAbsolute:
        // Above value is correct
        break;
      case DraggableGizmo::kDeltaFromPrevious:
-        v -= gizmo_last_drag_ * gizmo_last_draw_transform_inverted_;
+        v -= ScreenToScenePoint(gizmo_last_drag_);
        gizmo_last_drag_ = event->pos();
        break;
      case DraggableGizmo::kDeltaFromStart:
-        v -= gizmo_start_drag_ * gizmo_last_draw_transform_inverted_;
+        v -= ScreenToScenePoint(gizmo_start_drag_);
        break;
      }

@@ -1182,6 +1177,21 @@ void ViewerDisplayWidget::CloseTextEditor()
  text_edit_ = nullptr;
 }

+void ViewerDisplayWidget::GenerateGizmoTransforms()
+{
+  NodeTraverser gt;
+  gt.SetCacheVideoParams(gizmo_params_);
+
+  gizmo_draw_time_ = GenerateGizmoTime();
+
+  if (gizmos_) {
+    gizmo_db_ = gt.GenerateRow(gizmos_, gizmo_draw_time_);
+  }
+
+  gizmo_last_draw_transform_ = GenerateGizmoTransform(gt, gizmo_draw_time_);
+  gizmo_last_draw_transform_inverted_ = gizmo_last_draw_transform_.inverted();
+}
+
 void ViewerDisplayWidget::SetShowFPS(bool e)
 {
  show_fps_ = e;
@@ -1221,6 +1231,15 @@ void ViewerDisplayWidget::Pause()
  queue_starved_ = false;
 }

+QPointF ViewerDisplayWidget::ScreenToScenePoint(const QPoint &p)
+{
+  if (gizmo_last_draw_transform_.isIdentity()) {
+    GenerateGizmoTransforms();
+  }
+
+  return p * gizmo_last_draw_transform_inverted_;
+}
+
 void ViewerDisplayWidget::UpdateFromQueue()
 {
  int64_t t = timer_.GetTimestampNow();
@@ -74,6 +74,7 @@ public:
  void SetSafeMargins(const ViewerSafeMarginInfo& safe_margin);

  void SetGizmos(Node* node);
+  const VideoParams &GetVideoParams() const { return gizmo_params_; }
  void SetVideoParams(const VideoParams &params);
  void SetTime(const rational& time);
  void SetSubtitleTracks(Sequence *list);
@@ -131,6 +132,8 @@ public:
    return &timer_;
  }

+  QPointF ScreenToScenePoint(const QPoint &p);
+
  virtual bool eventFilter(QObject *o, QEvent *e) override;

 public slots:
@@ -182,7 +185,7 @@ signals:
  /**
   * @brief Signal emitted when the user starts dragging from the viewer
   */
-  void DragStarted();
+  void DragStarted(const QPoint &p);

  /**
   * @brief Signal emitted when a hand drag starts
@@ -290,6 +293,8 @@ private:

  void CloseTextEditor();

+  void GenerateGizmoTransforms();
+
  /**
   * @brief Internal reference to the OpenGL texture to draw. Set in SetTexture() and used in paintGL().
   */
@@ -340,6 +345,7 @@ private:
  VideoParams gizmo_params_;
  QPoint gizmo_start_drag_;
  QPoint gizmo_last_drag_;
+  TimeRange gizmo_draw_time_;
  NodeGizmo *current_gizmo_;
  bool gizmo_drag_started_;
  QTransform gizmo_last_draw_transform_;