multicam: finished usable implementation

app/widget/viewer/viewer.cpp

@@ -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>();

app/widget/viewer/viewer.h

@@ -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
   {

app/widget/viewer/viewerdisplay.cpp

@@ -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();

app/widget/viewer/viewerdisplay.h

@@ -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_;