RenderedTarget: Move rect union calculation to a separate method

Author: adazem009

src/renderedtarget.cpp

@@ -610,34 +610,10 @@ bool RenderedTarget::touchingClones(const std::vector<libscratchcpp::Sprite *> &
     if (myRect.isEmpty())
         return false;
 
-    QRectF united;
     std::vector<IRenderedTarget *> candidates;
 
     // Calculate the union of the bounding rectangle intersections
-    for (auto clone : clones) {
-        Q_ASSERT(clone);
-
-        if (!clone)
-            continue;
-
-        SpriteModel *model = static_cast<SpriteModel *>(clone->getInterface());
-        Q_ASSERT(model);
-
-        if (model) {
-            // Calculate the intersection of the bounding rectangles
-            IRenderedTarget *candidate = model->renderedTarget();
-            Q_ASSERT(candidate);
-            Rect scratchRect = candidate->getFastBounds();
-            // TODO: Use Rect::snapToInt()
-            QRect rect(QPoint(scratchRect.left(), scratchRect.bottom()), QPoint(scratchRect.right(), scratchRect.top()));
-            QRectF intersected = myRect.intersected(rect);
-
-            // Add it to the union
-            united = united.united(intersected);
-
-            candidates.push_back(candidate);
-        }
-    }
+    QRectF united = candidatesBounds(myRect, clones, candidates);
 
     if (united.isEmpty() || candidates.empty())
         return false;
@@ -813,6 +789,54 @@ QRectF RenderedTarget::touchingBounds() const
     return bounds;
 }
 
+QRectF RenderedTarget::candidatesBounds(const QRectF &targetRect, const std::vector<Target *> &candidates, std::vector<IRenderedTarget *> &dst)
+{
+    QRectF united;
+    dst.clear();
+
+    for (auto candidate : candidates) {
+        Q_ASSERT(candidate);
+
+        if (!candidate)
+            continue;
+
+        IRenderedTarget *target = nullptr;
+
+        if (candidate->isStage()) {
+            Stage *stage = static_cast<Stage *>(candidate);
+            StageModel *model = static_cast<StageModel *>(stage->getInterface());
+            Q_ASSERT(model);
+
+            if (model)
+                target = model->renderedTarget();
+        } else {
+            Sprite *sprite = static_cast<Sprite *>(candidate);
+            SpriteModel *model = static_cast<SpriteModel *>(sprite->getInterface());
+            Q_ASSERT(model);
+
+            if (model)
+                target = model->renderedTarget();
+        }
+
+        Q_ASSERT(target);
+
+        if (target) {
+            // Calculate the intersection of the bounding rectangles
+            Rect scratchRect = target->getFastBounds();
+            // TODO: Use Rect::snapToInt()
+            QRect rect(QPoint(scratchRect.left(), scratchRect.bottom()), QPoint(scratchRect.right(), scratchRect.top()));
+            QRectF intersected = targetRect.intersected(rect);
+
+            // Add it to the union
+            united = united.united(intersected);
+
+            dst.push_back(target);
+        }
+    }
+
+    return united;
+}
+
 void RenderedTarget::clampRect(Rect &rect, double left, double right, double bottom, double top)
 {
     // TODO: Use Rect::clamp()

src/renderedtarget.h

@@ -123,6 +123,7 @@ class RenderedTarget : public IRenderedTarget
         QPointF mapFromStageWithOriginPoint(const QPointF &scenePoint) const;
         CpuTextureManager *textureManager();
         QRectF touchingBounds() const;
+        static QRectF candidatesBounds(const QRectF &targetRect, const std::vector<libscratchcpp::Target *> &candidates, std::vector<IRenderedTarget *> &dst);
         static void clampRect(libscratchcpp::Rect &rect, double left, double right, double bottom, double top);
 
         libscratchcpp::IEngine *m_engine = nullptr;