Merge pull request #120 from scratchcpp/touching_color

Implement touching color

Author: adazem009

README.md

@@ -145,7 +145,7 @@ int main(int argc, char **argv) {
 - [x] Clones
 - [x] Sprite dragging
 - [x] Touching sprite block
-- [ ] Touching color blocks
+- [ ] Touching color blocks (color is touching color is not implemented yet)
 - [ ] Pen blocks (all blocks except the stamp block are implemented)
 - [x] Monitors
 - [ ] Graphics effects (color, brightness and ghost are implemented)

src/cputexturemanager.cpp

@@ -51,6 +51,21 @@ const std::vector<QPoint> &CpuTextureManager::getTextureConvexHullPoints(const T
         return it->second;
 }
 
+void CpuTextureManager::removeTexture(const Texture &texture)
+{
+    if (!texture.isValid())
+        return;
+
+    const GLuint handle = texture.handle();
+    auto it = m_textureData.find(handle);
+
+    if (it != m_textureData.cend()) {
+        delete it->second;
+        m_textureData.erase(it);
+        m_convexHullPoints.erase(handle);
+    }
+}
+
 bool CpuTextureManager::addTexture(const Texture &texture)
 {
     if (!texture.isValid())

src/cputexturemanager.h

@@ -20,6 +20,8 @@ class CpuTextureManager
         GLubyte *getTextureData(const Texture &texture);
         const std::vector<QPoint> &getTextureConvexHullPoints(const Texture &texture);
 
+        void removeTexture(const Texture &texture);
+
     private:
         bool addTexture(const Texture &texture);
 

src/ipenlayer.h

@@ -3,6 +3,7 @@
 #pragma once
 
 #include <qnanoquickitem.h>
+#include <scratchcpp/rect.h>
 
 namespace libscratchcpp
 {
@@ -37,6 +38,9 @@ class IPenLayer : public QNanoQuickItem
         virtual void drawLine(const PenAttributes &penAttributes, double x0, double y0, double x1, double y1) = 0;
 
         virtual QOpenGLFramebufferObject *framebufferObject() const = 0;
+        virtual QRgb colorAtScratchPoint(double x, double y) const = 0;
+
+        virtual const libscratchcpp::Rect &getBounds() const = 0;
 };
 
 } // namespace scratchcpprender

src/irenderedtarget.h

@@ -86,8 +86,10 @@ class IRenderedTarget : public QNanoQuickItem
         virtual const std::vector<QPoint> &hullPoints() const = 0;
 
         virtual bool containsScratchPoint(double x, double y) const = 0;
+        virtual QRgb colorAtScratchPoint(double x, double y) const = 0;
 
         virtual bool touchingClones(const std::vector<libscratchcpp::Sprite *> &clones) const = 0;
+        virtual bool touchingColor(const libscratchcpp::Value &color) const = 0;
 };
 
 } // namespace scratchcpprender

src/penlayer.cpp

@@ -76,6 +76,8 @@ void scratchcpprender::PenLayer::clear()
     m_glF->glEnable(GL_SCISSOR_TEST);
     m_fbo->release();
 
+    m_textureDirty = true;
+    m_boundsDirty = true;
     update();
 }
 
@@ -121,6 +123,8 @@ void scratchcpprender::PenLayer::drawLine(const PenAttributes &penAttributes, do
     painter.end();
     m_fbo->release();
 
+    m_textureDirty = true;
+    m_boundsDirty = true;
     update();
 }
 
@@ -129,6 +133,84 @@ QOpenGLFramebufferObject *PenLayer::framebufferObject() const
     return m_fbo.get();
 }
 
+QRgb PenLayer::colorAtScratchPoint(double x, double y) const
+{
+    if (m_textureDirty)
+        const_cast<PenLayer *>(this)->updateTexture();
+
+    if (!m_texture.isValid())
+        return qRgba(0, 0, 0, 0);
+
+    const double width = m_texture.width();
+    const double height = m_texture.height();
+
+    // Translate the coordinates
+    // TODO: Apply scale
+    x = std::floor(x + width / 2.0);
+    y = std::floor(-y + height / 2.0);
+
+    // If the point is outside the texture, return fully transparent color
+    if ((x < 0 || x >= width) || (y < 0 || y >= height))
+        return qRgba(0, 0, 0, 0);
+
+    GLubyte *data = m_textureManager.getTextureData(m_texture);
+    const int index = (y * width + x) * 4; // RGBA channels
+    Q_ASSERT(index >= 0 && index < width * height * 4);
+    return qRgba(data[index], data[index + 1], data[index + 2], data[index + 3]);
+}
+
+const libscratchcpp::Rect &PenLayer::getBounds() const
+{
+    if (m_textureDirty)
+        const_cast<PenLayer *>(this)->updateTexture();
+
+    if (m_boundsDirty) {
+        if (!m_texture.isValid()) {
+            m_bounds = libscratchcpp::Rect();
+            return m_bounds;
+        }
+
+        m_boundsDirty = false;
+        double left = std::numeric_limits<double>::infinity();
+        double top = -std::numeric_limits<double>::infinity();
+        double right = -std::numeric_limits<double>::infinity();
+        double bottom = std::numeric_limits<double>::infinity();
+        const double width = m_texture.width();
+        const double height = m_texture.height();
+        const std::vector<QPoint> &points = m_textureManager.getTextureConvexHullPoints(m_texture);
+
+        if (points.empty()) {
+            m_bounds = libscratchcpp::Rect();
+            return m_bounds;
+        }
+
+        for (const QPointF &point : points) {
+            // TODO: Apply scale
+            double x = point.x() - width / 2;
+            double y = -point.y() + height / 2;
+
+            if (x < left)
+                left = x;
+
+            if (x > right)
+                right = x;
+
+            if (y > top)
+                top = y;
+
+            if (y < bottom)
+                bottom = y;
+        }
+
+        m_bounds.setLeft(left);
+        m_bounds.setTop(top);
+        m_bounds.setRight(right + 1);
+        m_bounds.setBottom(bottom - 1);
+    }
+
+    return m_bounds;
+}
+
 IPenLayer *PenLayer::getProjectPenLayer(libscratchcpp::IEngine *engine)
 {
     auto it = m_projectPenLayers.find(engine);
@@ -148,3 +230,21 @@ QNanoQuickItemPainter *PenLayer::createItemPainter() const
 {
     return new PenLayerPainter;
 }
+
+void PenLayer::updateTexture()
+{
+    if (!m_fbo)
+        return;
+
+    m_textureDirty = false;
+    m_textureManager.removeTexture(m_texture);
+
+    if (!m_resolvedFbo || m_resolvedFbo->size() != m_fbo->size()) {
+        QOpenGLFramebufferObjectFormat format;
+        format.setAttachment(QOpenGLFramebufferObject::CombinedDepthStencil);
+        m_resolvedFbo = std::make_unique<QOpenGLFramebufferObject>(m_fbo->size(), format);
+    }
+
+    QOpenGLFramebufferObject::blitFramebuffer(m_resolvedFbo.get(), m_fbo.get());
+    m_texture = Texture(m_resolvedFbo->texture(), m_resolvedFbo->size());
+}

src/penlayer.h

@@ -2,13 +2,16 @@
 
 #pragma once
 
-#include <ipenlayer.h>
 #include <QOpenGLFramebufferObject>
 #include <QOpenGLPaintDevice>
 #include <QOpenGLFunctions>
 #include <QPainter>
 #include <scratchcpp/iengine.h>
 
+#include "ipenlayer.h"
+#include "texture.h"
+#include "cputexturemanager.h"
+
 namespace scratchcpprender
 {
 
@@ -33,6 +36,9 @@ class PenLayer : public IPenLayer
         void drawLine(const PenAttributes &penAttributes, double x0, double y0, double x1, double y1) override;
 
         QOpenGLFramebufferObject *framebufferObject() const override;
+        QRgb colorAtScratchPoint(double x, double y) const override;
+
+        const libscratchcpp::Rect &getBounds() const override;
 
         static IPenLayer *getProjectPenLayer(libscratchcpp::IEngine *engine);
         static void addPenLayer(libscratchcpp::IEngine *engine, IPenLayer *penLayer); // for tests
@@ -44,13 +50,21 @@ class PenLayer : public IPenLayer
         QNanoQuickItemPainter *createItemPainter() const override;
 
     private:
+        void updateTexture();
+
         static std::unordered_map<libscratchcpp::IEngine *, IPenLayer *> m_projectPenLayers;
         bool m_antialiasingEnabled = true;
         libscratchcpp::IEngine *m_engine = nullptr;
         std::unique_ptr<QOpenGLFramebufferObject> m_fbo;
+        std::unique_ptr<QOpenGLFramebufferObject> m_resolvedFbo;
         std::unique_ptr<QOpenGLPaintDevice> m_paintDevice;
         QOpenGLFramebufferObjectFormat m_fboFormat;
         std::unique_ptr<QOpenGLFunctions> m_glF;
+        Texture m_texture;
+        bool m_textureDirty = true;
+        mutable CpuTextureManager m_textureManager;
+        mutable bool m_boundsDirty = true;
+        mutable libscratchcpp::Rect m_bounds;
 };
 
 } // namespace scratchcpprender