add wet parameter, fix selection mask modes

engine/canvas.cpp

@@ -20,7 +20,7 @@ std::vector<CanvasMode*> ui::Canvas::modes[] = {
     { new CanvasModeGrid, new CanvasModeBasicCamera },
     { new CanvasModeFill, new CanvasModeBasicCamera },
     { new CanvasModeMaskFree, new CanvasModeBasicCamera },
-    { new CanvasModeMaskFree, new CanvasModeBasicCamera },
+    { new CanvasModeMaskLine, new CanvasModeBasicCamera },
 };
 glm::vec3 ui::Canvas::m_plane_origin[6] = {
     { 0, 0,-1}, // front
@@ -246,6 +246,7 @@ void ui::Canvas::stroke_draw()
             ShaderManager::u_vec2(kShaderUniform::Resolution, { m_width, m_height });
             //ShaderManager::u_vec2(kShaderUniform::StencilOffset, glm::vec2((rand()%1000)*0.001f, (rand()%1000)*0.001f));
             ShaderManager::u_float(kShaderUniform::StencilAlpha, m_brush.m_tip_stencil);
+            ShaderManager::u_float(kShaderUniform::Wet, m_brush.m_tip_wet);
             for (const auto& s : samples)
             {
                 glm::vec2 dx(s.size * 0.5f, 0), dy(0, s.size * 0.5f);
@@ -1458,6 +1459,140 @@ void ui::Canvas::draw_objects(std::function<void(const glm::mat4& camera, const
     draw_objects(observer, m_layers[m_current_layer_idx]);
 }
 
+void ui::Canvas::project2Dpoints(std::vector<ui::Shape::vertex_t>& vertices)
+{
+    for (auto& p : vertices)
+    {
+        glm::vec3 ro, rd, hit_o, hit_d;
+        glm::vec2 hit_fb;
+        int plane_id;
+        if (point_trace(p.pos, ro, rd, hit_o, hit_fb, hit_d, plane_id))
+            p.pos = glm::vec4(hit_o, 1);
+    }
+}
+
+std::vector<ui::Shape::vertex_t> ui::Canvas::triangulate(const std::vector<std::shared_ptr<p2t::Point>>& points)
+{
+    struct Segment
+    {
+        std::shared_ptr<p2t::Point> a = nullptr;
+        std::shared_ptr<p2t::Point> b = nullptr;
+        Segment* prev = nullptr;
+        std::shared_ptr<Segment> next = nullptr;
+        bool end = false;
+    };
+    
+    std::shared_ptr<Segment> root = std::make_shared<Segment>();
+    std::shared_ptr<Segment> node = root;
+    for (int i = 0; i < points.size(); i++)
+    {
+        node->a = points[i];
+        if (i == points.size() - 1)
+        {
+            node->b = points[0];
+            node->next = root;
+            node->end = true;
+            root->prev = node.get();
+        }
+        else
+        {
+            node->b = points[i + 1];
+            node->next = std::make_shared<Segment>();
+            node->next->prev = node.get();
+        }
+        node = node->next;
+    }
+
+    node = root;
+    std::stack<std::shared_ptr<Segment>> todo;
+    std::vector<std::shared_ptr<Segment>> polys;
+    todo.push(root);
+    while (!todo.empty())
+    {
+        node = todo.top();
+        todo.pop();
+        polys.push_back(node);
+        while (node)
+        {
+            std::shared_ptr<Segment> other = node->next;
+            while (other)
+            {
+                if (*node->a == *other->a || *node->a == *other->b ||
+                    *node->b == *other->a || *node->b == *other->b)
+                {
+                    other = other->end ? nullptr : other->next;
+                    continue;
+                }
+                glm::vec2 s0a(node->a->x, node->a->y);
+                glm::vec2 s0b(node->b->x, node->b->y);
+                glm::vec2 s1a(other->a->x, other->a->y);
+                glm::vec2 s1b(other->b->x, other->b->y);
+                glm::vec2 is;
+                if (segments_intersect(s0a, s0b, s1a, s1b, is))
+                {
+                    auto p = std::make_shared<p2t::Point>(is.x, is.y);
+                    auto poly_root = std::make_shared<Segment>();
+                    poly_root->a = p;
+                    poly_root->b = node->b;
+                    poly_root->next = node->next;
+                    todo.push(poly_root);
+                    other->a = p;
+                    node->b = p;
+                    auto poly_end = std::make_shared<Segment>();
+                    poly_end->a = other->prev->b;
+                    poly_end->b = p;
+                    poly_end->end = true;
+                    poly_end->prev = other->prev;
+                    other->prev->next = poly_end;
+                    other->prev = node.get();
+                    node->next = other;
+                    break;
+                }
+                other = other->end ? nullptr : other->next;
+            }
+            node = node->end ? nullptr : node->next;
+        }
+    }
+
+    std::vector<ui::Shape::vertex_t> vertices;
+    for (auto poly : polys)
+    {
+        std::vector<p2t::Point*> outline;
+        node = poly;
+        while (node)
+        {
+            outline.push_back(new p2t::Point(*node->a));
+            auto current = node;
+            node = node->end ? nullptr : node->next;
+            current->next = nullptr;
+        }
+        LOG("poly %ld", outline.size());
+
+        if (outline.size() > 2)
+        {
+            p2t::CDT* cdt = new p2t::CDT(outline);
+            cdt->Triangulate();
+            auto tr = cdt->GetTriangles();
+            for (auto t : tr)
+            {
+                ui::Shape::vertex_t vertex;
+                for (int i = 0; i < 3; i++)
+                {
+                    auto p = t->GetPoint(i);
+                    vertex.pos = glm::vec4(p->x, p->y, 0, 1);
+                    vertices.push_back(vertex);
+                }
+            }
+
+            delete cdt;
+        }
+        for (auto p : outline)
+            delete p;
+    }
+
+    return vertices;
+}
+
 ///////////////////////////////////////////////////////////////////////////////////////////
 
 void ui::Layer::destroy()