Draw text using JUCE paths, calculate path intersections

Author: timothyschoen

Libraries/nanovg

@@ -903,6 +903,7 @@ struct DraggableListNumber final : public DraggableNumber {
             }
             return;
         }
+        
 
         if (hoveredDecimal >= 0) {
             auto const highlightColour = outlineColour.withAlpha(isMouseButtonDown() ? 0.5f : 0.3f);

Source/Components/DraggableNumber.h

@@ -379,7 +379,7 @@ class NVGImage {
                 subImage.imageId = nvgCreateImageARGB(nvg, totalWidth, totalHeight, flags | NVG_IMAGE_PREMULTIPLIED, imageData.data);
             else if (image.isSingleChannel())
                 subImage.imageId = nvgCreateImageAlpha(nvg, totalWidth, totalHeight, flags, imageData.data);
-
+            
             deleteImage();
 
             subImage.bounds = image.getBounds();

Source/NVGSurface.h

@@ -296,6 +296,154 @@ void NanoVGGraphicsContext::setPath(juce::Path const& path, juce::AffineTransfor
     }
 }
 
+std::vector<juce::Path> splitIntoSubPaths(const juce::Path& original)
+{
+    std::vector<juce::Path> subPaths;
+    juce::Path currentSubPath;
+
+    juce::Path::Iterator it(original);
+    while (it.next()) {
+        switch (it.elementType) {
+            case juce::Path::Iterator::startNewSubPath:
+                if (!currentSubPath.isEmpty()) {
+                    subPaths.push_back(currentSubPath);
+                    currentSubPath.clear();
+                }
+                currentSubPath.startNewSubPath(it.x1, it.y1);
+                break;
+
+            case juce::Path::Iterator::lineTo:
+                currentSubPath.lineTo(it.x1, it.y1);
+                break;
+
+            case juce::Path::Iterator::quadraticTo:
+                currentSubPath.quadraticTo(it.x1, it.y1, it.x2, it.y2);
+                break;
+
+            case juce::Path::Iterator::cubicTo:
+                currentSubPath.cubicTo(it.x1, it.y1, it.x2, it.y2, it.x3, it.y3);
+                break;
+
+            case juce::Path::Iterator::closePath:
+                currentSubPath.closeSubPath();
+                break;
+        }
+    }
+
+    // Push the final path if it's not empty
+    if (!currentSubPath.isEmpty())
+        subPaths.push_back(currentSubPath);
+
+    return subPaths;
+}
+
+bool linesIntersect(juce::Point<float> a1, juce::Point<float> a2,
+                    juce::Point<float> b1, juce::Point<float> b2)
+{
+    auto cross = [](juce::Point<float> v1, juce::Point<float> v2) {
+        return v1.x * v2.y - v1.y * v2.x;
+    };
+
+    juce::Point<float> da = a2 - a1;
+    juce::Point<float> db = b2 - b1;
+    juce::Point<float> delta = b1 - a1;
+
+    float denom = cross(da, db);
+    if (std::abs(denom) < 1e-6f)
+        return false; // Lines are parallel
+
+    float t = cross(delta, db) / denom;
+    float u = cross(delta, da) / denom;
+
+    return (t >= 0.0f && t <= 1.0f && u >= 0.0f && u <= 1.0f);
+}
+
+void NanoVGGraphicsContext::setEvenOddPath(juce::Path const& path, juce::AffineTransform const& transform)
+{
+    juce::Path p(path);
+    p.applyTransform(transform);
+
+    nvgBeginPath(nvg);
+    nvgPathWinding(nvg, NVG_SOLID);
+    
+    auto subpaths = splitIntoSubPaths(p);
+    
+    for (auto& path : subpaths) {
+        int crossings = 0;
+        juce::Point<float> testPoint = path.getPointAlongPath(0); // point on current path
+        juce::Point<float> outsidePoint = path.getBounds().getTopLeft() - juce::Point<float>(10.0f, 10.0f); // outside point
+
+        for (auto& other : subpaths) {
+            if (other == path)
+                continue;
+
+            juce::Path::Iterator it(other);
+            juce::Point<float> p0;
+            
+            while (it.next()) {
+                switch (it.elementType) {
+                    case juce::Path::Iterator::startNewSubPath:
+                        p0 = { it.x1, it.y1 };
+                        break;
+
+                    case juce::Path::Iterator::lineTo: {
+                        juce::Point<float> p1 = { it.x1, it.y1 };
+                        if (linesIntersect(testPoint, outsidePoint, p0, p1))
+                            crossings++;
+                        p0 = p1;
+                        break;
+                    }
+
+                    case juce::Path::Iterator::quadraticTo: {
+                        juce::Point<float> p1 = { it.x2, it.y2 }; // end point
+                        if (linesIntersect(testPoint, outsidePoint, p0, p1))
+                            crossings++;
+                        p0 = p1;
+                        break;
+                    }
+
+                    case juce::Path::Iterator::cubicTo: {
+                        juce::Point<float> p1 = { it.x3, it.y3 }; // end point
+                        if (linesIntersect(testPoint, outsidePoint, p0, p1))
+                            crossings++;
+                        p0 = p1;
+                        break;
+                    }
+
+                    case juce::Path::Iterator::closePath:
+                        break;
+                }
+            }
+        }
+        
+        juce::Path::Iterator i(path);
+        while (i.next()) {
+            switch (i.elementType) {
+            case juce::Path::Iterator::startNewSubPath:
+                nvgMoveTo(nvg, i.x1, i.y1);
+                break;
+            case juce::Path::Iterator::lineTo:
+                nvgLineTo(nvg, i.x1, i.y1);
+                break;
+            case juce::Path::Iterator::quadraticTo:
+                nvgQuadTo(nvg, i.x1, i.y1, i.x2, i.y2);
+                break;
+            case juce::Path::Iterator::cubicTo:
+                nvgBezierTo(nvg, i.x1, i.y1, i.x2, i.y2, i.x3, i.y3);
+                break;
+            case juce::Path::Iterator::closePath:
+                nvgClosePath(nvg);
+                break;
+            default:
+                break;
+            }
+        }
+        
+        nvgPathWinding(nvg, (crossings % 2 == 1) ? NVG_HOLE : NVG_SOLID);
+
+    }
+}
+
 void NanoVGGraphicsContext::fillPath(juce::Path const& path, juce::AffineTransform const& transform)
 {
     setPath(path, transform);
@@ -449,12 +597,23 @@ void NanoVGGraphicsContext::drawGlyph(int const glyphNumber, juce::AffineTransfo
     utf8.write(wc);
     utf8.writeNull();
 
+    nvgSave(nvg);
+
+    juce::Path p;
+    auto f = getFont();
+    f.getTypefacePtr()->getOutlineForGlyph (glyphNumber, p);
+    setEvenOddPath(p, juce::AffineTransform::scale (f.getHeight() * f.getHorizontalScale(), f.getHeight())
+                .followedBy (transform));
+    nvgFill(nvg);
+    nvgRestore(nvg);
+ 
+    /*
     nvgSave(nvg);
     setFont(getFont());
     nvgTransform(nvg, transform.mat00, transform.mat10, transform.mat01, transform.mat11, transform.mat02, transform.mat12);
     nvgTextAlign(nvg, NVG_ALIGN_BASELINE | NVG_ALIGN_LEFT);
     nvgText(nvg, 0, 1, txt, &txt[1]);
-    nvgRestore(nvg);
+    nvgRestore(nvg);*/
 }
 
 bool NanoVGGraphicsContext::drawTextLayout(juce::AttributedString const& str, juce::Rectangle<float> const& rect)

Source/Utility/NanoVGGraphicsContext.cpp

@@ -51,7 +51,8 @@ class NanoVGGraphicsContext final : public juce::LowLevelGraphicsContext {
     void fillRectList(juce::RectangleList<float> const&) override;
 
     void setPath(juce::Path const& path, juce::AffineTransform const& transform);
-
+    void setEvenOddPath(const juce::Path& path, const juce::AffineTransform& transform);
+    
     void strokePath(juce::Path const&, juce::PathStrokeType const&, juce::AffineTransform const&);
     void fillPath(juce::Path const&, juce::AffineTransform const&) override;
     void drawImage(juce::Image const&, juce::AffineTransform const&) override;