Expand framebuffer by 32pix to allow objects on the edge of the canvas to be blurred as they are moved outside of the canvas

Author: alcomposer

Libraries/nanovg

@@ -607,6 +607,7 @@ void Canvas::performRender(NVGcontext* nvg, Rectangle<int> invalidRegion) {
     auto const halfSize = infiniteCanvasSize / 2;
     auto const zoom = getValue<float>(zoomScale);
     bool isLocked = getValue<bool>(locked);
+    auto cnvMargin = NVGSurface::cnvMargin;
     nvgSave(nvg);
 
     if (auto parentCnv = findParentComponentOfClass<Canvas>(); parentCnv && parentCnv->viewport && isQuickCanvas) {
@@ -615,19 +616,19 @@ void Canvas::performRender(NVGcontext* nvg, Rectangle<int> invalidRegion) {
             auto offset = quickCanvasOffset * zoom;
             nvgTranslate(nvg, -viewPos.x - offset.x, -viewPos.y - offset.y);
             nvgScale(nvg, zoom, zoom);
-            invalidRegion = invalidRegion.translated(viewPos.x + offset.x, viewPos.y + offset.y);
+            invalidRegion = invalidRegion.translated(viewPos.x + offset.x - cnvMargin, viewPos.y + offset.y - cnvMargin);
             invalidRegion /= zoom;
         }
     } else if (viewport) {
         nvgTranslate(nvg, -viewport->getViewPositionX(), -viewport->getViewPositionY());
         nvgScale(nvg, zoom, zoom);
-        invalidRegion = invalidRegion.translated(viewport->getViewPositionX(), viewport->getViewPositionY());
+        invalidRegion = invalidRegion.translated(viewport->getViewPositionX() - cnvMargin, viewport->getViewPositionY() - cnvMargin);
         invalidRegion /= zoom;
     }
     if (isQuickCanvas || viewport) {
         if (!isQuickCanvas) {
             nvgFillColor(nvg, canvasBackgroundCol);
-            nvgFillRect(nvg, invalidRegion.getX(), invalidRegion.getY(), invalidRegion.getWidth(), invalidRegion.getHeight());
+            nvgFillRect(nvg, 0, 0, infiniteCanvasSize, infiniteCanvasSize); // fill the whole thing (which will get cropped to visible anyway)
         }
         if (!isLocked) {
             nvgBeginPath(nvg);
@@ -1483,7 +1484,7 @@ void Canvas::mouseDrag(MouseEvent const& e)
         return;
     }
 
-    auto usedViewport = isQuickCanvas ? findParentComponentOfClass<Canvas>()->viewport.get() : viewport.get();
+    auto usedViewport = getActiveViewport();
 
     auto viewportEvent = e.getEventRelativeTo(usedViewport);
     if (usedViewport && !ObjectBase::isBeingEdited() && autoscroll(viewportEvent)) {
@@ -1497,9 +1498,14 @@ void Canvas::mouseDrag(MouseEvent const& e)
     }
 }
 
+Viewport* Canvas::getActiveViewport()
+{
+    return isQuickCanvas ? findParentComponentOfClass<Canvas>()->viewport.get() : viewport.get();
+}
+
 bool Canvas::autoscroll(MouseEvent const& e)
 {
-    auto usedViewport = isQuickCanvas ? findParentComponentOfClass<Canvas>()->viewport.get() : viewport.get();
+    auto usedViewport = getActiveViewport();
 
     if (!usedViewport)
         return false;
@@ -1944,7 +1950,7 @@ void Canvas::duplicateSelection()
     // Adjust the viewport position to ensure the duplicated objects are visible
 
     // Use the base canvas viewport (quick canvas uses base canvas viewport)
-    auto usedViewport = isQuickCanvas ? findParentComponentOfClass<Canvas>()->viewport.get() : viewport.get();
+    auto usedViewport = getActiveViewport();
 
     auto viewportPos = usedViewport->getViewPosition();
 

Source/Canvas.cpp

@@ -92,6 +92,8 @@ class Canvas : public Component
     void middleMouseChanged(bool isHeld) override;
     void altKeyChanged(bool isHeld) override;
 
+    Viewport* getActiveViewport();
+
     void settingsChanged(String const& name, var const& value) override;
 
     void focusGained(FocusChangeType cause) override;

Source/Canvas.h

@@ -992,11 +992,6 @@ class WelcomePanel : public Component
         Graphics g(*nvgContext);
         g.reduceClipRegion(editor->nvgSurface.getInvalidArea());
         paintEntireComponent(g, false);
-
-        auto gradient = nvgLinearGradient(nvg, 0, viewport.getY(), 0, viewport.getY() + 20, convertColour(findColour(PlugDataColour::panelBackgroundColourId)), nvgRGBA(255, 255, 255, 0));
-
-        nvgFillPaint(nvg, gradient);
-        nvgFillRect(nvg, viewport.getX() + 8, viewport.getY(), viewport.getWidth() - 16, 20);
     }
 
     void lookAndFeelChanged() override

Source/Components/WelcomePanel.h

@@ -202,8 +202,8 @@ void NVGSurface::detachContext()
 void NVGSurface::updateBufferSize()
 {
     float pixelScale = getRenderScale();
-    int scaledWidth = getWidth() * pixelScale;
-    int scaledHeight = getHeight() * pixelScale;
+    int scaledWidth = getWidth() * pixelScale + doubleCnvMargin;
+    int scaledHeight = getHeight() * pixelScale + doubleCnvMargin;
 
     if (fbWidth != scaledWidth || fbHeight != scaledHeight || !invalidFBO) {
         if (invalidFBO)
@@ -216,11 +216,12 @@ void NVGSurface::updateBufferSize()
 
         if (quickCanvasBlurFBO)
             nvgDeleteFramebuffer(quickCanvasBlurFBO);
+        // The blur frame buffer is Float16 RGB (no alpha) with two colour attachments for multi-pass optimized blurring
         quickCanvasBlurFBO = nvgCreateFramebuffer(nvg, scaledWidth, scaledHeight, NVG_IMAGE_PREMULTIPLIED | NVG_IMAGE_FLOAT | NVG_DOUBLE_COLOUR_ATTACH);
 
         fbWidth = scaledWidth;
         fbHeight = scaledHeight;
-        invalidArea = getLocalBounds();
+        invalidArea = getLocalBounds().expanded(32);
     }
 }
 
@@ -308,12 +309,12 @@ void NVGSurface::resized()
 
 void NVGSurface::invalidateAll()
 {
-    invalidArea = invalidArea.getUnion(getLocalBounds());
+    invalidArea = invalidArea.getUnion(getLocalBounds().expanded(cnvMargin).translated(cnvMargin, cnvMargin));
 }
 
 void NVGSurface::invalidateArea(Rectangle<int> area)
 {
-    invalidArea = invalidArea.getUnion(area);
+    invalidArea = invalidArea.getUnion(area.translated(cnvMargin, cnvMargin));
 }
 
 void NVGSurface::render()
@@ -368,15 +369,15 @@ void NVGSurface::render()
 
     updateBufferSize();
 
-    invalidArea = invalidArea.getIntersection(getLocalBounds());
+    invalidArea = invalidArea.getIntersection(getLocalBounds().translated(cnvMargin, cnvMargin).expanded(cnvMargin));
 
     if (auto* cnv = editor->getPluginModeCanvas()) {
-        cnv->updateFramebuffers(nvg, cnv->getLocalBounds());
+        cnv->updateFramebuffers(nvg, cnv->getLocalBounds().expanded(cnvMargin));
     } else {
         for (auto* cnv : editor->getTabComponent().getVisibleCanvases()) {
-            cnv->updateFramebuffers(nvg, cnv->getLocalBounds());
+            cnv->updateFramebuffers(nvg, cnv->getLocalBounds().expanded(cnvMargin));
             if (cnv->quickCanvas) {
-                cnv->quickCanvas->updateFramebuffers(nvg, cnv->getLocalBounds());
+                cnv->quickCanvas->updateFramebuffers(nvg, cnv->getLocalBounds().expanded(cnvMargin));
             }
         }
     }
@@ -386,48 +387,60 @@ void NVGSurface::render()
     if (!invalidArea.isEmpty()) {
         // Draw only the invalidated region on top of framebuffer
         nvgBindFramebuffer(invalidFBO);
-        nvgViewport(0, 0, viewWidth, viewHeight);
+        nvgViewport(0, 0, viewWidth + doubleCnvMargin, viewHeight + doubleCnvMargin);
 #if NANOVG_GL_IMPLEMENTATION
         glClear(GL_STENCIL_BUFFER_BIT);
 #endif
-        nvgBeginFrame(nvg, getWidth() * desktopScale, getHeight() * desktopScale, devicePixelScale);
+        nvgBeginFrame(nvg, getWidth() * desktopScale + doubleCnvMargin, getHeight() * desktopScale + doubleCnvMargin, devicePixelScale);
+        nvgTranslate(nvg, cnvMargin, cnvMargin);
         nvgScale(nvg, desktopScale, desktopScale);
         doQuickCanvasPass = editor->renderArea(nvg, invalidArea);
+
+//#define DEBUG_QUICKCANVAS_PAINT
+#ifdef DEBUG_QUICKCANVAS_PAINT
+        nvgTranslate(nvg, -cnvMargin, -cnvMargin);
+        Random random;
+        nvgBeginPath(nvg);
+        nvgFillColor(nvg, nvgRGBA(random.nextInt(256), random.nextInt(256), random.nextInt(256), 100));
+        nvgFillRect(nvg, invalidArea.getX() * pixelScale, invalidArea.getY() * pixelScale, invalidArea.getWidth() * pixelScale, invalidArea.getHeight() * pixelScale);
+#endif
         nvgGlobalScissor(nvg, invalidArea.getX() * pixelScale, invalidArea.getY() * pixelScale, invalidArea.getWidth() * pixelScale, invalidArea.getHeight() * pixelScale);
+
         nvgEndFrame(nvg);
 
 #if ENABLE_FPS_COUNT
         frameTimer->render(nvg, getWidth(), getHeight(), pixelScale);
 #endif
 
-        if (doQuickCanvasPass && !invalidArea.isEmpty()) {
+        if (doQuickCanvasPass) {
             for (auto cnv : editor->getTabComponent().getSplitCanvasesQuickCanvases()) {
+                auto sX = cnv->getActiveViewport()->getX();
+                auto sY = cnv->getActiveViewport()->getY() - 30; // height of tabbar
+                auto sW = cnv->getActiveViewport()->getWidth();
+                auto sH = cnv->getActiveViewport()->getHeight();
+                // Blur the current canvas invalidFBO
+                nvgBindFramebuffer(quickCanvasBlurFBO);
+                nvgBlitFramebuffer(nvg, invalidFBO, 0, 0, fbWidth, fbHeight, 0, 0, fbWidth, fbHeight);
+
+                //glScissor(sX, sY, sW, sH);
+                glDisable(GL_SCISSOR_TEST);
+                nvgBlurFramebuffer(nvg, quickCanvasBlurFBO, 0, 0, fbWidth, fbHeight, fbWidth, fbHeight, cnv->quickCanvasAlpha * getValue<float>(cnv->zoomScale));
+                glEnable(GL_SCISSOR_TEST);
 
                 nvgBindFramebuffer(quickCanvasFBO);
 
                 // Clear only the invalid region
                 glClearColor(0, 0, 0, 0);
                 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
 
-                nvgBeginFrame(nvg, getWidth() * desktopScale, getHeight() * desktopScale, devicePixelScale);
+                nvgBeginFrame(nvg, getWidth() * desktopScale + doubleCnvMargin, getHeight() * desktopScale + doubleCnvMargin, devicePixelScale);
+                nvgTranslate(nvg, cnvMargin, cnvMargin);
                 nvgScale(nvg, desktopScale, desktopScale);
                 editor->renderArea(nvg, invalidArea, true);
                 nvgGlobalScissor(nvg, invalidArea.getX() * pixelScale, invalidArea.getY() * pixelScale, invalidArea.getWidth() * pixelScale, invalidArea.getHeight() * pixelScale);
 
-//#define DEBUG_QUICKCANVAS_PAINT
-#ifdef DEBUG_QUICKCANVAS_PAINT
-                Random random;
-                nvgBeginPath(nvg);
-                nvgFillColor(nvg, nvgRGBA(random.nextInt(256), random.nextInt(256), random.nextInt(256), 100));
-                nvgFillRect(nvg, invalidArea.getX() * pixelScale, invalidArea.getY() * pixelScale, invalidArea.getWidth() * pixelScale, invalidArea.getHeight() * pixelScale);
-#endif
                 nvgEndFrame(nvg);
 
-                // Blur the current canvas invalidFBO
-                nvgBindFramebuffer(quickCanvasBlurFBO);
-                nvgBlitFramebuffer(nvg, invalidFBO, 0, 0, viewWidth, viewHeight, 0, 0, viewWidth, viewHeight);
-                nvgBlurFramebuffer(nvg, quickCanvasBlurFBO, fbWidth, fbHeight, cnv->quickCanvasAlpha * getValue<float>(cnv->zoomScale));
-
                 nvgBindFramebuffer(quickCanvasBlurFBO);
                 nvgViewport(0, 0, fbWidth, fbHeight);
                 nvgBeginFrame(nvg, fbWidth, fbHeight, 1);
@@ -451,10 +464,13 @@ void NVGSurface::render()
 
     if (needsBufferSwap) {
         nvgBindFramebuffer(nullptr);
+        glDisable(GL_SCISSOR_TEST);
         if (doQuickCanvasPass)
-            nvgBlitFramebuffer(nvg, quickCanvasBlurFBO, 0, 0, viewWidth, viewHeight, 0, 0, viewWidth, viewHeight);
+            nvgBlitFramebuffer(nvg, quickCanvasBlurFBO, cnvMargin, -cnvMargin, viewWidth, viewHeight + doubleCnvMargin, 0, 0, viewWidth, viewHeight + doubleCnvMargin);
         else
-            nvgBlitFramebuffer(nvg, invalidFBO, 0, 0, viewWidth, viewHeight, 0, 0, viewWidth, viewHeight);
+            nvgBlitFramebuffer(nvg, invalidFBO, cnvMargin, -cnvMargin, viewWidth, viewHeight + doubleCnvMargin, 0, 0, viewWidth, viewHeight + doubleCnvMargin);
+
+        glEnable(GL_SCISSOR_TEST);
 
 #ifdef NANOVG_GL_IMPLEMENTATION
         glContext->swapBuffers();

Source/NVGSurface.cpp

@@ -51,7 +51,7 @@ class NVGSurface :
 
     void lookAndFeelChanged() override;
 
-    Rectangle<int> getInvalidArea() { return invalidArea; }
+    Rectangle<int> getInvalidArea() { return invalidArea.translated(-cnvMargin, -cnvMargin); }
 
     float getRenderScale() const;
 
@@ -108,6 +108,9 @@ class NVGSurface :
 
     void renderFrameToImage(Image& image, Rectangle<int> area);
 
+    inline static int cnvMargin = 32;
+    inline static int doubleCnvMargin = cnvMargin * 2;
+
 private:
     float calculateRenderScale() const;
 

Source/NVGSurface.h

@@ -609,9 +609,12 @@ bool TabComponent::renderArea(NVGcontext* nvg, Rectangle<int> area, bool renderQ
 {
     bool isQuickCanvasShowing = false;
 
+    auto cnvMargin = NVGSurface::cnvMargin;
+    auto cnvDoubleMargin = NVGSurface::doubleCnvMargin;
+
     if (splits[0]) {
         NVGScopedState scopedState(nvg);
-        nvgScissor(nvg, 0, 0, splits[1] ? (splitSize - 3) : getWidth(), getHeight());
+        nvgScissor(nvg, -cnvMargin, -cnvMargin, splits[1] ? (splitSize - 3) : getWidth() + cnvDoubleMargin, getHeight() + cnvDoubleMargin);
         if (renderQuickCanvas && splits[0]->quickCanvas)
             splits[0]->quickCanvas->performRender(nvg, area);
         else