layer highlight when selected

engine/app_layout.cpp

@@ -108,6 +108,10 @@ void App::initLayout()
             canvas->m_canvas->m_layers[canvas->m_canvas->m_order[idx]].m_alpha_locked = visible;
         };
 
+        layers->on_layer_highlight_changed = [this](Node*, int idx, bool highlight) {
+            canvas->m_canvas->m_layers[canvas->m_canvas->m_order[idx]].m_hightlight = highlight;
+        };
+
         canvas->m_canvas->layer_add("Default");
         layers->add_layer("Default");
 

engine/app_shaders.cpp

@@ -38,10 +38,14 @@ void App::initShaders()
         SHADER_VERSION
         "uniform sampler2D tex;\n"
         "uniform mediump float alpha;\n"
+        "uniform bool highlight;\n"
         "in mediump vec3 uv;\n"
         "out mediump vec4 frag;\n"
         "void main(){\n"
-        "   frag = texture(tex, uv.xy) * vec4(1,1,1,alpha);\n"
+        "   mediump vec4 c = texture(tex, uv.xy);\n"
+        "   frag = highlight ? \n"
+        "       vec4(clamp(vec3(.3)+c.rgb, vec3(0), vec3(1)), c.a) : \n"
+        "       texture(tex, uv.xy) * vec4(1,1,1,alpha);\n"
         "}\n";
     // TEXTURE COMP ERASE
     static const char* shader_comp_erase_f =

engine/canvas.cpp

@@ -1166,6 +1166,7 @@ ui::Image ui::Canvas::thumbnail_generate(int w, int h)
 
         ui::ShaderManager::use(kShader::TextureAlpha);
         ui::ShaderManager::u_int(kShaderUniform::Tex, 0);
+        ui::ShaderManager::u_int(kShaderUniform::Highlight, false);
         ui::ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp);
         for (auto layer_index : m_order)
         {

engine/canvas.h

@@ -18,6 +18,7 @@ public:
     bool m_visible = true;
     bool m_alpha_locked = false;
     float m_opacity = 1.f;
+    bool m_hightlight = false;
     std::string m_name;
     int w, h;
     struct Snapshot

engine/node_canvas.cpp

@@ -105,26 +105,7 @@ void NodeCanvas::draw()
                 ui::ShaderManager::u_int(kShaderUniform::TexStroke, 1);
                 ui::ShaderManager::u_float(kShaderUniform::Alpha, m_canvas->m_current_stroke->m_brush.m_tip_opacity);
                 ui::ShaderManager::u_int(kShaderUniform::Lock, m_canvas->m_layers[m_canvas->m_current_layer_idx].m_alpha_locked);
-            }
-            else if(m_canvas->m_show_tmp && m_canvas->m_current_layer_idx == layer_index)
-            {
-                ui::ShaderManager::use(kShader::CompDraw);
-                ui::ShaderManager::u_int(kShaderUniform::Tex, 0);
-                ui::ShaderManager::u_int(kShaderUniform::TexStroke, 1);
-                ui::ShaderManager::u_float(kShaderUniform::Alpha, m_canvas->m_current_stroke->m_brush.m_tip_opacity);
-                ui::ShaderManager::u_int(kShaderUniform::Lock, m_canvas->m_layers[m_canvas->m_current_layer_idx].m_alpha_locked);
-            }
-            else
-            {
-                ui::ShaderManager::use(kShader::TextureAlpha);
-                ui::ShaderManager::u_int(kShaderUniform::Tex, 0);
-                ui::ShaderManager::u_float(kShaderUniform::Alpha, m_canvas->m_layers[layer_index].m_opacity);
-            }
                 ui::ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z);
-
-//            if (!(m_canvas->m_state == ui::Canvas::kCanvasMode::Erase &&
-//                m_canvas->m_show_tmp && m_canvas->m_current_layer_idx == layer_index))
-            {
                 glActiveTexture(GL_TEXTURE0);
                 m_canvas->m_layers[layer_index].m_rtt[plane_index].bindTexture();
                 glActiveTexture(GL_TEXTURE1);
@@ -134,6 +115,36 @@ void NodeCanvas::draw()
                 glActiveTexture(GL_TEXTURE0);
                 m_canvas->m_layers[layer_index].m_rtt[plane_index].unbindTexture();
             }
+            else if(m_canvas->m_show_tmp && m_canvas->m_current_layer_idx == layer_index)
+            {
+                ui::ShaderManager::use(kShader::CompDraw);
+                ui::ShaderManager::u_int(kShaderUniform::Tex, 0);
+                ui::ShaderManager::u_int(kShaderUniform::TexStroke, 1);
+                ui::ShaderManager::u_float(kShaderUniform::Alpha, m_canvas->m_current_stroke->m_brush.m_tip_opacity);
+                ui::ShaderManager::u_int(kShaderUniform::Lock, m_canvas->m_layers[m_canvas->m_current_layer_idx].m_alpha_locked);
+                ui::ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z);
+                glActiveTexture(GL_TEXTURE0);
+                m_canvas->m_layers[layer_index].m_rtt[plane_index].bindTexture();
+                glActiveTexture(GL_TEXTURE1);
+                m_canvas->m_tmp[plane_index].bindTexture();
+                m_face_plane.draw_fill();
+                m_canvas->m_tmp[plane_index].unbindTexture();
+                glActiveTexture(GL_TEXTURE0);
+                m_canvas->m_layers[layer_index].m_rtt[plane_index].unbindTexture();
+            }
+            else
+            {
+                ui::ShaderManager::use(kShader::TextureAlpha);
+                ui::ShaderManager::u_int(kShaderUniform::Tex, 0);
+                ui::ShaderManager::u_float(kShaderUniform::Alpha, m_canvas->m_layers[layer_index].m_opacity);
+                ui::ShaderManager::u_int(kShaderUniform::Highlight, m_canvas->m_layers[layer_index].m_hightlight);
+                ui::ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z);
+                glActiveTexture(GL_TEXTURE0);
+                m_canvas->m_layers[layer_index].m_rtt[plane_index].bindTexture();
+                m_face_plane.draw_fill();
+                m_canvas->m_layers[layer_index].m_rtt[plane_index].unbindTexture();
+            }
+
 //            if (m_canvas->m_show_tmp && m_canvas->m_current_layer_idx == layer_index)
 //            {
 //                ui::ShaderManager::use(kShader::TextureAlpha);

engine/node_panel_layer.cpp

@@ -77,8 +77,14 @@ kEventResult NodeLayer::handle_event(Event* e)
         m_selected = true;
         if (on_selected)
             on_selected(this);
+        if (on_highlight)
+            on_highlight(this, true);
+        mouse_capture();
         break;
     case kEventType::MouseUpL:
+        if (on_highlight)
+            on_highlight(this, false);
+        mouse_release();
         break;
     default:
         return kEventResult::Available;
@@ -167,6 +173,7 @@ void NodePanelLayer::add_layer(const char* name)
     l->on_selected = std::bind(&NodePanelLayer::handle_layer_selected, this, std::placeholders::_1);
     l->on_opacity_changed = std::bind(&NodePanelLayer::handle_layer_opacity, this, std::placeholders::_1, std::placeholders::_2);
     l->on_visibility_changed = std::bind(&NodePanelLayer::handle_layer_visibility, this, std::placeholders::_1, std::placeholders::_2);
+    l->on_highlight = std::bind(&NodePanelLayer::handle_layer_highlight, this, std::placeholders::_1, std::placeholders::_2);
     if (m_current_layer)
         m_current_layer->m_selected = false;
     m_current_layer = l;
@@ -207,6 +214,12 @@ void NodePanelLayer::handle_layer_opacity(NodeLayer* target, float value)
         on_layer_opacity_changed(this, m_layers_container->get_child_index(target), value);
 }
 
+void NodePanelLayer::handle_layer_highlight(NodeLayer* target, bool highlight)
+{
+    if (on_layer_highlight_changed)
+        on_layer_highlight_changed(this, m_layers_container->get_child_index(target), highlight);
+}
+
 void NodePanelLayer::handle_layer_visibility(NodeLayer* target, bool visible)
 {
     if (on_layer_visibility_changed)

engine/node_panel_layer.h

@@ -11,6 +11,7 @@ public:
     std::function<void(NodeLayer* target)> on_selected;
     std::function<void(NodeLayer* target, float opacity)> on_opacity_changed;
     std::function<void(NodeLayer* target, bool visible)> on_visibility_changed;
+    std::function<void(NodeLayer* target, bool highlight)> on_highlight;
     bool m_selected = false;
     glm::vec4 m_color_normal = glm::vec4(.4, .4, .4, 1);
     glm::vec4 m_color_selected = glm::vec4(.3, .3, .3, 1);
@@ -41,6 +42,7 @@ public:
     std::function<void(Node* target, int old_idx, int new_idx)> on_layer_change;
     std::function<void(Node* target, int idx, float value)> on_layer_opacity_changed;
     std::function<void(Node* target, int idx, bool visible)> on_layer_visibility_changed;
+    std::function<void(Node* target, int idx, bool highlight)> on_layer_highlight_changed;
     std::function<void(Node* target, int index)> on_layer_delete;
     std::function<void(Node* target)> on_layer_add;
     std::function<void(Node* target, int old_idx, int new_idx)> on_layer_order;
@@ -55,6 +57,7 @@ public:
     void remove_layer(NodeLayer* layer);
     void handle_layer_opacity(NodeLayer* target, float value);
     void handle_layer_visibility(NodeLayer* target, bool visible);
+    void handle_layer_highlight(NodeLayer* target, bool highlight);
     void handle_layer_selected(NodeLayer* target);
     void clear();
 };

engine/shader.h

@@ -17,6 +17,7 @@ enum class kShaderUniform : uint16_t
     Tsz = const_hash("tsz"),
     Alpha = const_hash("alpha"),
     Resolution = const_hash("resolution"),
+    Highlight = const_hash("highlight"),
 };
 
 enum class kShader : uint16_t