multiple selection for free mask

data/shaders/texture-mask.glsl

@@ -0,0 +1,44 @@
+[[vertex]]
+
+uniform mat4 mvp;
+
+in vec4 pos;
+in vec2 uvs;
+out vec2 uv;
+
+void main()
+{
+    uv = uvs;
+    gl_Position = mvp * vec4(pos.xyz, 1.0);
+}
+
+[[fragment]]
+
+uniform sampler2D tex;
+
+in mediump vec2 uv;
+out mediump vec4 frag;
+
+void main()
+{
+    mediump float stroke = 1.0 - texture(tex, uv).r;
+
+    int zero_count = 0;
+    if (textureOffset(tex, uv, ivec2(-1, -1)).r > 0.99) zero_count++;
+    if (textureOffset(tex, uv, ivec2(-1,  0)).r > 0.99) zero_count++;
+    if (textureOffset(tex, uv, ivec2(-1, +1)).r > 0.99) zero_count++;
+    if (textureOffset(tex, uv, ivec2( 0, -1)).r > 0.99) zero_count++;
+    if (textureOffset(tex, uv, ivec2( 0,  0)).r > 0.99) zero_count++;
+    if (textureOffset(tex, uv, ivec2( 0, +1)).r > 0.99) zero_count++;
+    if (textureOffset(tex, uv, ivec2(+1, -1)).r > 0.99) zero_count++;
+    if (textureOffset(tex, uv, ivec2(+1,  0)).r > 0.99) zero_count++;
+    if (textureOffset(tex, uv, ivec2(+1, +1)).r > 0.99) zero_count++;
+    mediump float edge = (zero_count > 1 && zero_count < 8) ? 1.0 : 0.0;
+
+    const mediump vec4 c1 = vec4(1.0, 1.0, 1.0, 1.0);
+    const mediump vec4 c2 = vec4(0.9, 0.9, 0.9, 1.0);
+    mediump vec2 c = floor(fract(uv * 50.0) * 2.0);
+    mediump float alpha = mix(c.x, 1.0 - c.x, c.y);
+
+    frag = vec4(vec3(edge * alpha), edge);
+}

src/app_shaders.cpp

@@ -27,6 +27,8 @@ void App::initShaders()
         LOG("Failed to create shader Texture");
     if (!ShaderManager::load(kShader::TextureAlpha, "data/shaders/texture-alpha.glsl"))
         LOG("Failed to create shader TextureAlpha");
+    if (!ShaderManager::load(kShader::TextureMask, "data/shaders/texture-mask.glsl"))
+        LOG("Failed to create shader TextureMask");
     if (!ShaderManager::load(kShader::TextureAlphaSep, "data/shaders/texture-alpha-sep.glsl"))
         LOG("Failed to create shader TextureAlphaSep");
     if (!ShaderManager::load(kShader::TextureColorize, "data/shaders/texture-colorize.glsl"))

src/canvas_modes.cpp

@@ -560,7 +560,8 @@ void CanvasModeMaskFree::on_MouseEvent(MouseEvent* me, glm::vec2& loc)
         m_points2d.push_back(loc);
         m_points.push_back(vert);
         m_points.push_back(vert);
-        Canvas::I->m_smask.clear({0, 0, 0, 0});
+        if (!(App::I.keys[(int)kKey::KeyShift] || App::I.keys[(int)kKey::KeyCtrl]))
+            Canvas::I->m_smask.clear({0, 0, 0, 0});
         Canvas::I->m_smask_active = true;
         Canvas::I->m_smask_mode = 1;
         break;
@@ -579,7 +580,8 @@ void CanvasModeMaskFree::on_MouseEvent(MouseEvent* me, glm::vec2& loc)
                     glDisable(GL_DEPTH_TEST);
                     ShaderManager::use(kShader::Color);
                     ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera);
-                    ShaderManager::u_vec4(kShaderUniform::Col, {1, 1, 1, 1});
+                    ShaderManager::u_vec4(kShaderUniform::Col,
+                        App::I.keys[(int)kKey::KeyCtrl] ? glm::vec4(0, 0, 0, 1) : glm::vec4(1, 1, 1, 1));
                     m_shape.draw_fill();
                 };
                 // use m_shape to render the mask polygon
@@ -665,13 +667,13 @@ void CanvasModeMaskFree::on_Draw(const glm::mat4& ortho, const glm::mat4& proj,
             //m_dragging ? m_shape.draw_stroke() : m_shape.draw_fill();
             m_shape.draw_stroke();
         }
-        else
+        //else
-        {
+        //{
-            ShaderManager::use(kShader::Color);
+        //    ShaderManager::use(kShader::Color);
-            ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera);
+        //    ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera);
-            ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
+        //    ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
-            m_shape.draw_stroke();
+        //    m_shape.draw_stroke();
-        }
+        //}
     }
     if (depth) glEnable(GL_DEPTH_TEST);
 }

src/node_canvas.cpp

@@ -443,10 +443,31 @@ void NodeCanvas::draw()
     glDisable(GL_DEPTH_TEST);
     if (m_canvas->m_smask_active || m_canvas->m_current_mode == kCanvasMode::Copy || m_canvas->m_current_mode == kCanvasMode::Cut)
     {
-        if (m_canvas->m_smask_mode == 1)
+//         if (m_canvas->m_smask_mode == 1)
-            m_canvas->modes[(int)kCanvasMode::MaskFree][0]->on_Draw(ortho_proj, proj, camera);
+//             m_canvas->modes[(int)kCanvasMode::MaskFree][0]->on_Draw(ortho_proj, proj, camera);
-        else if (m_canvas->m_smask_mode == 2)
+//         else if (m_canvas->m_smask_mode == 2)
-            m_canvas->modes[(int)kCanvasMode::MaskLine][0]->on_Draw(ortho_proj, proj, camera);
+//             m_canvas->modes[(int)kCanvasMode::MaskLine][0]->on_Draw(ortho_proj, proj, camera);
+
+        ShaderManager::use(kShader::TextureMask);
+        ShaderManager::u_int(kShaderUniform::Tex, 0);
+        glActiveTexture(GL_TEXTURE0);
+        glEnable(GL_BLEND);
+
+        //draw the cube faces
+        for (int plane_index = 0; plane_index < 6; plane_index++)
+        {
+            auto plane_mvp = proj * camera *
+                glm::scale(glm::vec3(m_canvas->m_order.size() + 500.f)) *
+                m_canvas->m_plane_transform[plane_index] *
+                glm::translate(glm::vec3(0, 0, -1.f));
+
+            ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp);
+            m_canvas->m_smask.m_rtt[plane_index].bindTexture();
+            m_face_plane.draw_fill();
+            m_canvas->m_smask.m_rtt[plane_index].unbindTexture();
+        }
+
+
     }
     
     // keep drawing the grids

src/shader.h

@@ -57,6 +57,7 @@ enum class kShader : uint16_t
     ColorTri    = const_hash("color-tri"),
     ColorHue    = const_hash("color-hue"),
     Texture     = const_hash("texture"),
+    TextureMask = const_hash("texture-mask"),
     TextureColorize = const_hash("texture-colorize"),
     TextureAlpha= const_hash("texture-alpha"),
     TextureAlphaSep= const_hash("texture-alpha-sep"),