use mutex to avoid window destroy deadlock, fix vertical slider to increase value upward

src/app_layout.cpp

@@ -128,6 +128,7 @@ void App::init_sidebar()
     };
     color->on_color_changed = [this](Node* target, glm::vec4 color) {
         Canvas::I->m_current_brush->m_tip_color = color;
+        quick->set_color(color);
     };
 
     stroke->on_brush_changed = [this](Node* target, const std::string& path, const std::string& thumb) {
@@ -147,8 +148,9 @@ void App::init_sidebar()
         quick->m_slider_size->set_value(stroke->m_tip_size->get_value());
     };
 
-    quick->on_color_change = [this](Node*, glm::vec3 color) {
+    quick->on_color_change = [this](Node*, glm::vec3 c) {
-        Canvas::I->m_current_brush->m_tip_color = glm::vec4(color, 1.f);
+        Canvas::I->m_current_brush->m_tip_color = glm::vec4(c, 1.f);
+        color->set_color(c);
     };
     quick->on_flow_change = [this](Node*, float value) {
         stroke->set_flow(value, true, true);
@@ -735,6 +737,8 @@ void App::brush_update()
 //     brushes->select_brush(canvas->m_brush->id);
 //     stroke->set_params(canvas->m_brush);
     stroke->update_controls();
+    quick->m_slider_flow->set_value(stroke->m_tip_flow->get_value());
+    quick->m_slider_size->set_value(stroke->m_tip_size->get_value());
 }
 
 void App::init_menu_layer()

src/main.cpp

@@ -33,6 +33,7 @@ std::thread hmd_renderer;
 std::thread renderer;
 int running = -1;
 std::mutex render_mutex;
+std::mutex wnd_mutex;
 std::condition_variable render_cv;
 
 int gl_count = 0;
@@ -646,8 +647,13 @@ int main(int argc, char** argv)
             {
                 static wchar_t title_fps[512];
                 swprintf_s(title_fps, L"%s - %d fps", window_title, frames);
-                if (running)
+
+                // lock if 
+                if (wnd_mutex.try_lock())
+                {
                     SetWindowText(hWnd, title_fps);
+                    wnd_mutex.unlock();
+                }
                 one_sec = 0;
                 frames = 0;
             }
@@ -806,10 +812,18 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wp, LPARAM lp)
         {
             running = 0;
             render_cv.notify_all();
-            if (renderer.joinable())
+
-                renderer.join();
+            {
-            if (hmd_renderer.joinable())
+                // avoid deadlock
-                hmd_renderer.join();
+                // nobody should call windows API on this window at this time
+                std::lock_guard<std::mutex> lock(wnd_mutex);
+
+                if (renderer.joinable())
+                    renderer.join();
+                if (hmd_renderer.joinable())
+                    hmd_renderer.join();
+            }
+
             App::I.terminate();
         }
         break;

src/node_dialog_picker.cpp

@@ -27,12 +27,12 @@ void NodeColorPicker::draw()
     NodeBorder::draw();
 //    glm::vec3 rgb = glm::vec3(Canvas::I->m_current_brush.m_tip_color);
 //    glm::vec3 hsv = convert_rgb2hsv(rgb);
-//    m_slider_h->m_value.x = hsv.x;
+//    m_slider_h->m_values = hsv.x;
-//    m_slider_s->m_value.x = hsv.y;
+//    m_slider_s->m_values = hsv.y;
-//    m_slider_v->m_value.x = hsv.z;
+//    m_slider_v->m_values = hsv.z;
-//    m_slider_r->m_value.x = rgb.x;
+//    m_slider_r->m_values = rgb.x;
-//    m_slider_g->m_value.x = rgb.y;
+//    m_slider_g->m_values = rgb.y;
-//    m_slider_b->m_value.x = rgb.z;
+//    m_slider_b->m_values = rgb.z;
 //    m_wheel->m_hsv = hsv;
 }
 
@@ -83,9 +83,9 @@ void NodeColorPicker::init_controls()
 
     m_wheel->on_value_changed = [this](Node*, glm::vec3 hsv)
     {
-        m_slider_h->m_value.x = hsv.x;
+        m_slider_h->m_value = hsv.x;
-        m_slider_s->m_value.x = hsv.y;
+        m_slider_s->m_value = hsv.y;
-        m_slider_v->m_value.x = hsv.z;
+        m_slider_v->m_value = hsv.z;
         glm::vec3 rgb = convert_hsv2rgb(hsv);
         m_slider_h->set_value(hsv.x);
         m_slider_s->set_value(hsv.y);
@@ -100,9 +100,9 @@ void NodeColorPicker::init_controls()
         m_wheel->m_hsv = hsv;
         glm::vec3 rgb = convert_hsv2rgb(hsv);
         m_color_cur->m_color = { rgb, 1 };
-        m_slider_r->m_value.x = rgb.x;
+        m_slider_r->m_value = rgb.x;
-        m_slider_g->m_value.x = rgb.y;
+        m_slider_g->m_value = rgb.y;
-        m_slider_b->m_value.x = rgb.z;
+        m_slider_b->m_value = rgb.z;
         if (on_color_change)
             on_color_change(this, rgb);
     };

src/node_panel_color.cpp

@@ -46,7 +46,7 @@ void NodePanelColor::init_controls()
 void NodePanelColor::set_color(glm::vec3 rgb)
 {
     auto hsv = convert_rgb2hsv(rgb);
-    m_hue->m_value.y = hsv.x;
+    m_hue->m_value = hsv.x;
     m_quad->m_value = glm::vec2(hsv.y, 1.f - hsv.z);
     m_quad->m_color = glm::vec4(rgb, 1);
     m_cursor = m_quad->m_value;

src/node_panel_quick.cpp

@@ -22,6 +22,11 @@ void NodePanelQuick::init()
     init_controls();
 }
 
+void NodePanelQuick::set_color(glm::vec3 color)
+{
+    static_cast<NodeBorder*>(m_button_color_current->m_children[0].get())->m_color = glm::vec4(color, 1.f);
+}
+
 void NodePanelQuick::init_controls()
 {
     auto s = find<NodeStrokePreview>("quick-brush1");

src/node_panel_quick.h

@@ -23,6 +23,7 @@ public:
     virtual Node* clone_instantiate() const override;
     virtual void clone_finalize(Node* dest) const override;
     virtual void init() override;
+    void set_color(glm::vec3 color);
 private:
     void init_controls();
     void handle_button_color_click(Node* target);

src/node_panel_stroke.cpp

@@ -148,23 +148,23 @@ bool NodePanelStroke::import_abr(const std::string& path)
 void NodePanelStroke::update_controls()
 {
     const auto& b = Canvas::I->m_current_brush;
-    m_tip_size->m_value.x = m_curves[m_tip_size].to_slider(b->m_tip_size);
+    m_tip_size->m_value = m_curves[m_tip_size].to_slider(b->m_tip_size);
-    m_tip_spacing->m_value.x = m_curves[m_tip_spacing].to_slider(b->m_tip_spacing);
+    m_tip_spacing->m_value = m_curves[m_tip_spacing].to_slider(b->m_tip_spacing);
-    m_tip_flow->m_value.x = m_curves[m_tip_flow].to_slider(b->m_tip_flow);
+    m_tip_flow->m_value = m_curves[m_tip_flow].to_slider(b->m_tip_flow);
-    m_tip_opacity->m_value.x = b->m_tip_opacity;
+    m_tip_opacity->m_value = b->m_tip_opacity;
-    m_tip_angle->m_value.x = b->m_tip_angle;
+    m_tip_angle->m_value = b->m_tip_angle;
-    m_tip_angle_smooth->m_value.x = b->m_tip_angle_smooth;
+    m_tip_angle_smooth->m_value = b->m_tip_angle_smooth;
-    m_tip_wet->m_value.x = b->m_tip_wet;
+    m_tip_wet->m_value = b->m_tip_wet;
-    m_tip_noise->m_value.x = b->m_tip_noise;
+    m_tip_noise->m_value = b->m_tip_noise;
-    m_jitter_scale->m_value.x = b->m_jitter_scale;
+    m_jitter_scale->m_value = b->m_jitter_scale;
-    m_jitter_angle->m_value.x = b->m_jitter_angle;
+    m_jitter_angle->m_value = b->m_jitter_angle;
-    m_jitter_scatter->m_value.x = m_curves[m_jitter_scatter].to_slider(b->m_jitter_scatter);;
+    m_jitter_scatter->m_value = m_curves[m_jitter_scatter].to_slider(b->m_jitter_scatter);;
-    m_jitter_flow->m_value.x = b->m_jitter_flow;
+    m_jitter_flow->m_value = b->m_jitter_flow;
-    m_jitter_opacity->m_value.x = b->m_jitter_opacity;
+    m_jitter_opacity->m_value = b->m_jitter_opacity;
-    m_jitter_hue->m_value.x = b->m_jitter_hue;
+    m_jitter_hue->m_value = b->m_jitter_hue;
-    m_jitter_sat->m_value.x = b->m_jitter_sat;
+    m_jitter_sat->m_value = b->m_jitter_sat;
-    m_jitter_val->m_value.x = b->m_jitter_val;
+    m_jitter_val->m_value = b->m_jitter_val;
-    m_jitter_aspect->m_value.x = b->m_jitter_aspect;
+    m_jitter_aspect->m_value = b->m_jitter_aspect;
     m_tip_angle_follow->checked = b->m_tip_angle_follow;
     m_tip_angle_init->checked = b->m_tip_angle_init;
     m_tip_flow_pressure->checked = b->m_tip_flow_pressure;
@@ -185,23 +185,23 @@ void NodePanelStroke::update_controls()
     m_tip_randflipx->checked = b->m_tip_randflipx;
     m_tip_randflipy->checked = b->m_tip_randflipy;
    
-    m_dual_size->m_value.x = m_curves[m_dual_size].to_slider(b->m_dual_size);
+    m_dual_size->m_value = m_curves[m_dual_size].to_slider(b->m_dual_size);
-    m_dual_spacing->m_value.x = m_curves[m_dual_spacing].to_slider(b->m_dual_spacing);
+    m_dual_spacing->m_value = m_curves[m_dual_spacing].to_slider(b->m_dual_spacing);
-    m_dual_flow->m_value.x = m_curves[m_dual_flow].to_slider(b->m_dual_flow);
+    m_dual_flow->m_value = m_curves[m_dual_flow].to_slider(b->m_dual_flow);
-    m_dual_scatter->m_value.x = m_curves[m_dual_scatter].to_slider(b->m_dual_scatter);
+    m_dual_scatter->m_value = m_curves[m_dual_scatter].to_slider(b->m_dual_scatter);
-    m_tip_aspect->m_value.x = b->m_tip_aspect;
+    m_tip_aspect->m_value = b->m_tip_aspect;
-    m_dual_opacity->m_value.x = b->m_dual_opacity;
+    m_dual_opacity->m_value = b->m_dual_opacity;
-    m_dual_rotate->m_value.x = b->m_dual_rotate;
+    m_dual_rotate->m_value = b->m_dual_rotate;
 
     m_pattern_eachsample->checked = b->m_pattern_eachsample;
     m_pattern_invert->checked = b->m_pattern_invert;
     m_pattern_flipx->checked = b->m_pattern_flipx;
     m_pattern_flipy->checked = b->m_pattern_flipy;
     m_pattern_rand_offset->checked = b->m_pattern_rand_offset;
-    m_pattern_scale->m_value.x = m_curves[m_pattern_scale].to_slider(b->m_pattern_scale);
+    m_pattern_scale->m_value = m_curves[m_pattern_scale].to_slider(b->m_pattern_scale);
-    m_pattern_brightness->m_value.x = b->m_pattern_brightness;
+    m_pattern_brightness->m_value = b->m_pattern_brightness;
-    m_pattern_contrast->m_value.x = b->m_pattern_contrast;
+    m_pattern_contrast->m_value = b->m_pattern_contrast;
-    m_pattern_depth->m_value.x = b->m_pattern_depth;
+    m_pattern_depth->m_value = b->m_pattern_depth;
 
     m_blend_mode->set_index(b->m_blend_mode);
     m_dual_blend_mode->set_index(b->m_dual_blend_mode);
@@ -634,7 +634,7 @@ void NodePanelStroke::init_slider(NodeSliderH*& target, const char* id, float Br
     target = find<NodeSliderH>(id);
     target->on_value_changed = std::bind(&NodePanelStroke::handle_slide,
         this, prop, std::placeholders::_1, std::placeholders::_2);
-    //m_canvas->m_brush->*prop = target->m_value.x;
+    //m_canvas->m_brush->*prop = target->m_values;
 }
 
 void NodePanelStroke::handle_slide(float Brush::* prop, Node* target, float value)

src/node_slider.cpp

@@ -28,9 +28,13 @@ void NodeSliderH::draw()
     NodeBorder::draw();
 
     auto sz = GetSize();
-    glm::vec2 cur_size = sz * (1.f - m_mask) + m_mask * glm::vec2(10);
+    glm::vec2 cur_size = sz;
+    cur_size[m_comp] = 10;
     glm::mat4 scale = glm::scale(glm::vec3(cur_size, 1.f));
-    glm::mat4 pos = glm::translate(glm::vec3(m_value * m_mask * sz + m_pos + sz * .5f * (1.f - m_mask), 0));
+    glm::vec2 cur_pos = m_pos;
+    cur_pos[m_comp] += (m_comp == 0 ? m_value : 1.f - m_value) * sz[m_comp];
+    cur_pos[1 - m_comp] += sz[1 - m_comp] * 0.5f;
+    glm::mat4 pos = glm::translate(glm::vec3(cur_pos , 0));
     auto mvp = m_proj * pos * scale;
 
     ShaderManager::use(kShader::Color);
@@ -44,14 +48,14 @@ void NodeSliderH::set_value(float value, bool propagate)
     // don't accept external values while user interaction
     if (dragging)
         return;
-    m_value = glm::vec2(value) * m_mask;
+    m_value = value;
     if (propagate && on_value_changed)
-        on_value_changed(this, glm::length(m_value));
+        on_value_changed(this, m_value);
 }
 
 float NodeSliderH::get_value()
 {
-    return glm::length(m_value * m_mask);
+    return m_value;
 }
 
 void NodeSliderH::parse_attributes(kAttribute ka, const tinyxml2::XMLAttribute* attr)
@@ -60,7 +64,7 @@ void NodeSliderH::parse_attributes(kAttribute ka, const tinyxml2::XMLAttribute*
     switch (ka)
     {
     case kAttribute::Value:
-        m_value = glm::vec2(attr->FloatValue());
+        m_value = attr->FloatValue();
         break;
     default:
         break;
@@ -78,26 +82,30 @@ kEventResult NodeSliderH::handle_event(Event* e)
         {
             m_old_value = m_value;
             auto sz = GetSize();
-            auto pos = glm::clamp(((MouseEvent*)e)->m_pos - m_pos, { 0, 0 }, sz) * m_mask;
+            auto pos = glm::clamp(((MouseEvent*)e)->m_pos - m_pos, { 0, 0 }, sz);
-            m_value = pos / glm::max({ 1, 1 }, sz);
+            m_value = m_comp == 0 ? 
+                pos[m_comp] / glm::max(1.f, sz[m_comp]) :
+                1.f - pos[m_comp] / glm::max(1.f, sz[m_comp]);
             if (on_value_changed)
-                on_value_changed(this, glm::length(m_value));
+                on_value_changed(this, m_value);
         }
         break;
     case kEventType::MouseUpL:
         mouse_release();
         if (dragging && on_value_final)
-            on_value_final(this, glm::length(m_value * m_mask));
+            on_value_final(this, m_value);
         dragging = false;
         break;
     case kEventType::MouseMove:
         if (dragging)
         {
             auto sz = GetSize();
-            auto pos = glm::clamp(((MouseEvent*)e)->m_pos - m_pos, { 0, 0 }, sz) * m_mask;
+            auto pos = glm::clamp(((MouseEvent*)e)->m_pos - m_pos, { 0, 0 }, sz);
-            m_value = pos / glm::max({ 1, 1 }, sz);
+            m_value = m_comp == 0 ?
+                pos[m_comp] / glm::max(1.f, sz[m_comp]) :
+                1.f - pos[m_comp] / glm::max(1.f, sz[m_comp]);
             if (on_value_changed)
-                on_value_changed(this, glm::length(m_value * m_mask));
+                on_value_changed(this, m_value);
         }
         break;
     case kEventType::MouseCancel:
@@ -105,9 +113,9 @@ kEventResult NodeSliderH::handle_event(Event* e)
         if (dragging)
         {
             m_value = m_old_value;
-            set_value(glm::length(m_value));
+            set_value(m_value);
             if (on_value_changed)
-                on_value_changed(this, glm::length(m_value * m_mask));
+                on_value_changed(this, m_value);
         }
         dragging = false;
         break;
@@ -147,16 +155,16 @@ void NodeSliderHue::init_controls()
 
 glm::vec4 NodeSliderHue::get_hue()
 {
-    m_color = glm::vec4(convert_hsv2rgb({ glm::length(m_value * m_mask), 1, 1 }), 1);
+    m_color = glm::vec4(convert_hsv2rgb({ m_value, 1, 1 }), 1);
     return m_color;
 }
 
 void NodeSliderHue::draw()
 {
     ShaderManager::use(kShader::ColorHue);
-    ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp);
+    ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp * glm::scale(glm::vec3(1, -1, 1)));
     //ShaderManager::u_vec4(kShaderUniform::Col, m_color);
-    ShaderManager::u_int(kShaderUniform::Direction, 1); // set vertical
+    ShaderManager::u_int(kShaderUniform::Direction, m_comp); // set vertical
     m_plane.draw_fill();
     NodeBorder::m_color = glm::vec4(0);
     NodeSliderH::draw();

src/node_slider.h

@@ -5,9 +5,9 @@ class NodeSliderH : public NodeBorder
 {
     bool dragging = false;
 public:
-    glm::vec2 m_mask{ 1, 0 };
+    int m_comp = 0;
-    glm::vec2 m_value{0};
+    float m_value = 0;
-    glm::vec2 m_old_value;
+    float m_old_value = 0;
     std::function<void(Node* target, float value)> on_value_changed;
     std::function<void(Node* target, float value)> on_value_final;
     virtual Node* clone_instantiate() const override;
@@ -24,7 +24,7 @@ class NodeSliderV : public NodeSliderH
 {
 public:
     virtual Node* clone_instantiate() const override { return new NodeSliderV(); }
-    NodeSliderV() { m_mask = { 0, 1 }; }
+    NodeSliderV() { m_comp = 1; }
 };
 
 class NodeSliderHue : public NodeSliderV