Merge pull request #53 from scratchcpp/contains_method

Implement the RenderedTarget::contains() method

Author: adazem009

ScratchCPPGui/irenderedtarget.h

@@ -63,6 +63,9 @@ class IRenderedTarget : public QNanoQuickItem
 
         virtual bool isSvg() const = 0;
         virtual void paintSvg(QNanoPainter *painter) = 0;
+
+        virtual void updateHullPoints(QOpenGLFramebufferObject *fbo) = 0;
+        virtual const std::vector<QPointF> &hullPoints() const = 0;
 };
 
 } // namespace scratchcppgui

ScratchCPPGui/renderedtarget.cpp

@@ -303,6 +303,79 @@ void RenderedTarget::paintSvg(QNanoPainter *painter)
     context->makeCurrent(oldSurface);
 }
 
+void RenderedTarget::updateHullPoints(QOpenGLFramebufferObject *fbo)
+{
+    if (m_stageModel)
+        return; // hull points are useless for the stage
+
+    Q_ASSERT(fbo);
+    int width = fbo->width();
+    int height = fbo->height();
+    m_hullPoints.clear();
+    m_hullPoints.reserve(width * height);
+
+    // Blit multisampled FBO to a custom FBO
+    QOpenGLFramebufferObject customFbo(fbo->size());
+    glBindFramebuffer(GL_READ_FRAMEBUFFER_EXT, fbo->handle());
+    glBindFramebuffer(GL_DRAW_FRAMEBUFFER_EXT, customFbo.handle());
+    glBlitFramebuffer(0, 0, width, height, 0, 0, width, height, GL_COLOR_BUFFER_BIT, GL_NEAREST);
+    glBindFramebuffer(GL_FRAMEBUFFER_EXT, customFbo.handle());
+
+    // Read pixels from framebuffer
+    size_t size = width * height * 4;
+    GLubyte *pixelData = new GLubyte[size];
+    glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixelData);
+    glBindFramebuffer(GL_FRAMEBUFFER_EXT, 0);
+    fbo->bind();
+
+    // Flip vertically
+    int rowSize = width * 4;
+    GLubyte *tempRow = new GLubyte[rowSize];
+
+    for (size_t i = 0; i < height / 2; ++i) {
+        size_t topRowIndex = i * rowSize;
+        size_t bottomRowIndex = (height - 1 - i) * rowSize;
+
+        // Swap rows
+        memcpy(tempRow, &pixelData[topRowIndex], rowSize);
+        memcpy(&pixelData[topRowIndex], &pixelData[bottomRowIndex], rowSize);
+        memcpy(&pixelData[bottomRowIndex], tempRow, rowSize);
+    }
+
+    delete[] tempRow;
+
+    // Fill hull points vector
+    for (int y = 0; y < height; y++) {
+        for (int x = 0; x < width; x++) {
+            int index = (y * width + x) * 4; // RGBA channels
+
+            // Check alpha channel
+            if (pixelData[index + 3] > 0)
+                m_hullPoints.push_back(QPointF(x, y));
+        }
+    }
+
+    delete[] pixelData;
+}
+
+const std::vector<QPointF> &RenderedTarget::hullPoints() const
+{
+    return m_hullPoints;
+}
+
+bool RenderedTarget::contains(const QPointF &point) const
+{
+    if (m_stageModel)
+        return true; // the stage contains any point within the scene
+
+    for (const auto &hullPoint : m_hullPoints) {
+        if (point.toPoint() == hullPoint.toPoint())
+            return true;
+    }
+
+    return false;
+}
+
 void RenderedTarget::calculateSize(Target *target, double costumeWidth, double costumeHeight)
 {
     if (m_costume) {

ScratchCPPGui/renderedtarget.h

@@ -59,6 +59,11 @@ class RenderedTarget : public IRenderedTarget
         bool isSvg() const override;
         void paintSvg(QNanoPainter *painter) override;
 
+        void updateHullPoints(QOpenGLFramebufferObject *fbo) override;
+        const std::vector<QPointF> &hullPoints() const override;
+
+        Q_INVOKABLE bool contains(const QPointF &point) const override;
+
     signals:
         void engineChanged();
         void stageModelChanged();
@@ -101,6 +106,7 @@ class RenderedTarget : public IRenderedTarget
         double m_originY = 0;
         qreal m_maximumWidth = std::numeric_limits<double>::infinity();
         qreal m_maximumHeight = std::numeric_limits<double>::infinity();
+        std::vector<QPointF> m_hullPoints;
 };
 
 } // namespace scratchcppgui

ScratchCPPGui/targetpainter.cpp

@@ -26,10 +26,30 @@ void TargetPainter::paint(QNanoPainter *painter)
     if (m_target->isSvg())
         m_target->paintSvg(painter);
     else {
+        QOpenGLContext *context = QOpenGLContext::currentContext();
+        Q_ASSERT(context);
+
+        if (!context)
+            return;
+
+        QOffscreenSurface surface;
+        surface.setFormat(context->format());
+        surface.create();
+        Q_ASSERT(surface.isValid());
+
+        QSurface *oldSurface = context->surface();
+        context->makeCurrent(&surface);
+
+        painter->beginFrame(width, height);
         QNanoImage image = QNanoImage::fromCache(painter, m_target->bitmapBuffer(), m_target->bitmapUniqueKey());
         painter->drawImage(image, 0, 0, width, height);
+        painter->endFrame();
+
+        context->doneCurrent();
+        context->makeCurrent(oldSurface);
     }
 
+    m_target->updateHullPoints(framebufferObject());
     m_target->unlockCostume();
 }
 

test/mocks/renderedtargetmock.h

@@ -44,6 +44,10 @@ class RenderedTargetMock : public IRenderedTarget
         MOCK_METHOD(bool, isSvg, (), (const, override));
         MOCK_METHOD(void, paintSvg, (QNanoPainter *), (override));
 
+        MOCK_METHOD(void, updateHullPoints, (QOpenGLFramebufferObject *), (override));
+        MOCK_METHOD(const std::vector<QPointF> &, hullPoints, (), (const, override));
+
+        MOCK_METHOD(bool, contains, (const QPointF &), (const, override));
         MOCK_METHOD(QNanoQuickItemPainter *, createItemPainter, (), (const, override));
 };
 

test/renderedtarget/renderedtarget_test.cpp

@@ -468,6 +468,82 @@ TEST_F(RenderedTargetTest, PaintSvg)
     context.doneCurrent();
 }
 
+TEST_F(RenderedTargetTest, HullPoints)
+{
+    EngineMock engine;
+    Sprite sprite;
+    SpriteModel model;
+    model.init(&sprite);
+
+    RenderedTarget target;
+    target.setEngine(&engine);
+    target.setSpriteModel(&model);
+
+    // Create OpenGL context
+    QOpenGLContext context;
+    QOffscreenSurface surface;
+    createContextAndSurface(&context, &surface);
+
+    // Create a painter
+    QNanoPainter painter;
+
+    QOpenGLFramebufferObjectFormat format;
+    format.setAttachment(QOpenGLFramebufferObject::CombinedDepthStencil);
+
+    // Begin painting
+    QOpenGLFramebufferObject fbo(4, 6, format);
+    fbo.bind();
+    painter.beginFrame(fbo.width(), fbo.height());
+
+    // Paint
+    QNanoImage image = QNanoImage::fromCache(&painter, "image.png");
+    painter.drawImage(image, 0, 0);
+    painter.endFrame();
+
+    // Test hull points
+    target.updateHullPoints(&fbo);
+    ASSERT_EQ(target.hullPoints(), std::vector<QPointF>({ { 1, 1 }, { 2, 1 }, { 3, 1 }, { 1, 2 }, { 3, 2 }, { 1, 3 }, { 2, 3 }, { 3, 3 } }));
+
+    // Begin painting (multisampled)
+    format.setSamples(16);
+    QOpenGLFramebufferObject fboMultiSampled(4, 6, format);
+    fboMultiSampled.bind();
+    painter.beginFrame(fboMultiSampled.width(), fboMultiSampled.height());
+
+    // Paint (multisampled)
+    painter.drawImage(image, 0, 0);
+    painter.endFrame();
+
+    // Test hull points (this is undefined with multisampling, so we just check if there are any hull points)
+    ASSERT_FALSE(target.hullPoints().empty());
+
+    // Release
+    fbo.release();
+    context.doneCurrent();
+
+    // Test contains()
+    ASSERT_FALSE(target.contains({ 0, 0 }));
+    ASSERT_FALSE(target.contains({ 1, 0 }));
+    ASSERT_FALSE(target.contains({ 2, 0 }));
+    ASSERT_FALSE(target.contains({ 3, 0 }));
+
+    ASSERT_FALSE(target.contains({ 0, 1 }));
+    ASSERT_TRUE(target.contains({ 1, 1 }));
+    ASSERT_TRUE(target.contains({ 1.4, 1.25 }));
+    ASSERT_TRUE(target.contains({ 2, 1 }));
+    ASSERT_TRUE(target.contains({ 3, 1 }));
+
+    ASSERT_TRUE(target.contains({ 1, 2 }));
+    ASSERT_FALSE(target.contains({ 2, 2 }));
+    ASSERT_TRUE(target.contains({ 3, 2 }));
+    ASSERT_FALSE(target.contains({ 3.5, 2.1 }));
+
+    ASSERT_TRUE(target.contains({ 1, 3 }));
+    ASSERT_TRUE(target.contains({ 2, 3 }));
+    ASSERT_TRUE(target.contains({ 3, 3 }));
+    ASSERT_FALSE(target.contains({ 3.3, 3.5 }));
+}
+
 TEST_F(RenderedTargetTest, Engine)
 {
     RenderedTarget target;

test/targetpainter/targetpainter_test.cpp

@@ -57,7 +57,7 @@ TEST_F(TargetPainterTest, PaintBitmap)
 
         // Begin painting reference
         QNanoPainter refPainter;
-        QOpenGLFramebufferObject refFbo(100, 100, format);
+        QOpenGLFramebufferObject refFbo(40, 60, format);
         refFbo.bind();
         refPainter.beginFrame(refFbo.width(), refFbo.height());
 
@@ -67,7 +67,7 @@ TEST_F(TargetPainterTest, PaintBitmap)
         refPainter.endFrame();
 
         // Begin painting
-        QOpenGLFramebufferObject fbo(100, 100, format);
+        QOpenGLFramebufferObject fbo(40, 60, format);
         fbo.bind();
         painter.beginFrame(fbo.width(), fbo.height());
 
@@ -79,6 +79,7 @@ TEST_F(TargetPainterTest, PaintBitmap)
         EXPECT_CALL(target, bitmapBuffer()).WillOnce(Return(&buffer));
         static const QString uniqueKey("abc");
         EXPECT_CALL(target, bitmapUniqueKey()).WillOnce(ReturnRef(uniqueKey));
+        EXPECT_CALL(target, updateHullPoints);
         EXPECT_CALL(target, unlockCostume());
         targetPainter.paint(&painter);
         painter.endFrame();
@@ -110,6 +111,7 @@ TEST_F(TargetPainterTest, PaintSvg)
     EXPECT_CALL(target, height()).WillOnce(Return(60));
     EXPECT_CALL(target, isSvg()).WillOnce(Return(true));
     EXPECT_CALL(target, paintSvg(&painter));
+    EXPECT_CALL(target, updateHullPoints);
     EXPECT_CALL(target, unlockCostume());
     targetPainter.paint(&painter);