omar/panopainter
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
omigamedev
2019-03-04 19:32:43 +01:00
parent 6e73a9eee5
commit 801db87e06
9 changed files with 103 additions and 71 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/app_layout.cpp
View File

@@ -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) {
Canvas::I->m_current_brush->m_tip_color = glm::vec4(color, 1.f);
quick->on_color_change = [this](Node*, glm::vec3 c) {
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()

24
src/main.cpp
View File

@@ -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())
hmd_renderer.join();
{
// avoid deadlock
// 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;

24
src/node_dialog_picker.cpp
View File

@@ -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_s->m_value.x = hsv.y;
// m_slider_v->m_value.x = hsv.z;
// m_slider_r->m_value.x = rgb.x;
// m_slider_g->m_value.x = rgb.y;
// m_slider_b->m_value.x = rgb.z;
// m_slider_h->m_values = hsv.x;
// m_slider_s->m_values = hsv.y;
// m_slider_v->m_values = hsv.z;
// m_slider_r->m_values = rgb.x;
// m_slider_g->m_values = rgb.y;
// 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_s->m_value.x = hsv.y;
m_slider_v->m_value.x = hsv.z;
m_slider_h->m_value = hsv.x;
m_slider_s->m_value = hsv.y;
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_g->m_value.x = rgb.y;
m_slider_b->m_value.x = rgb.z;
m_slider_r->m_value = rgb.x;
m_slider_g->m_value = rgb.y;
m_slider_b->m_value = rgb.z;
if (on_color_change)
on_color_change(this, rgb);
};

2
src/node_panel_color.cpp
View File

@@ -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;

5
src/node_panel_quick.cpp
View File

@@ -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");

1
src/node_panel_quick.h
View File

@@ -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);

58
src/node_panel_stroke.cpp
View File

@@ -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_spacing->m_value.x = 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_opacity->m_value.x = b->m_tip_opacity;
m_tip_angle->m_value.x = b->m_tip_angle;
m_tip_angle_smooth->m_value.x = b->m_tip_angle_smooth;
m_tip_wet->m_value.x = b->m_tip_wet;
m_tip_noise->m_value.x = b->m_tip_noise;
m_jitter_scale->m_value.x = b->m_jitter_scale;
m_jitter_angle->m_value.x = b->m_jitter_angle;
m_jitter_scatter->m_value.x = m_curves[m_jitter_scatter].to_slider(b->m_jitter_scatter);;
m_jitter_flow->m_value.x = b->m_jitter_flow;
m_jitter_opacity->m_value.x = b->m_jitter_opacity;
m_jitter_hue->m_value.x = b->m_jitter_hue;
m_jitter_sat->m_value.x = b->m_jitter_sat;
m_jitter_val->m_value.x = b->m_jitter_val;
m_jitter_aspect->m_value.x = b->m_jitter_aspect;
m_tip_size->m_value = m_curves[m_tip_size].to_slider(b->m_tip_size);
m_tip_spacing->m_value = m_curves[m_tip_spacing].to_slider(b->m_tip_spacing);
m_tip_flow->m_value = m_curves[m_tip_flow].to_slider(b->m_tip_flow);
m_tip_opacity->m_value = b->m_tip_opacity;
m_tip_angle->m_value = b->m_tip_angle;
m_tip_angle_smooth->m_value = b->m_tip_angle_smooth;
m_tip_wet->m_value = b->m_tip_wet;
m_tip_noise->m_value = b->m_tip_noise;
m_jitter_scale->m_value = b->m_jitter_scale;
m_jitter_angle->m_value = b->m_jitter_angle;
m_jitter_scatter->m_value = m_curves[m_jitter_scatter].to_slider(b->m_jitter_scatter);;
m_jitter_flow->m_value = b->m_jitter_flow;
m_jitter_opacity->m_value = b->m_jitter_opacity;
m_jitter_hue->m_value = b->m_jitter_hue;
m_jitter_sat->m_value = b->m_jitter_sat;
m_jitter_val->m_value = b->m_jitter_val;
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_spacing->m_value.x = 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_scatter->m_value.x = m_curves[m_dual_scatter].to_slider(b->m_dual_scatter);
m_tip_aspect->m_value.x = b->m_tip_aspect;
m_dual_opacity->m_value.x = b->m_dual_opacity;
m_dual_rotate->m_value.x = b->m_dual_rotate;
m_dual_size->m_value = m_curves[m_dual_size].to_slider(b->m_dual_size);
m_dual_spacing->m_value = m_curves[m_dual_spacing].to_slider(b->m_dual_spacing);
m_dual_flow->m_value = m_curves[m_dual_flow].to_slider(b->m_dual_flow);
m_dual_scatter->m_value = m_curves[m_dual_scatter].to_slider(b->m_dual_scatter);
m_tip_aspect->m_value = b->m_tip_aspect;
m_dual_opacity->m_value = b->m_dual_opacity;
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_brightness->m_value.x = b->m_pattern_brightness;
m_pattern_contrast->m_value.x = b->m_pattern_contrast;
m_pattern_depth->m_value.x = b->m_pattern_depth;
m_pattern_scale->m_value = m_curves[m_pattern_scale].to_slider(b->m_pattern_scale);
m_pattern_brightness->m_value = b->m_pattern_brightness;
m_pattern_contrast->m_value = b->m_pattern_contrast;
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)

44
src/node_slider.cpp
View File

@@ -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;
m_value = pos / glm::max({ 1, 1 }, sz);
auto pos = glm::clamp(((MouseEvent*)e)->m_pos - m_pos, { 0, 0 }, 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;
m_value = pos / glm::max({ 1, 1 }, sz);
auto pos = glm::clamp(((MouseEvent*)e)->m_pos - m_pos, { 0, 0 }, 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();

8
src/node_slider.h
View File

@@ -5,9 +5,9 @@ class NodeSliderH : public NodeBorder
{
bool dragging = false;
public:
glm::vec2 m_mask{ 1, 0 };
glm::vec2 m_value{0};
glm::vec2 m_old_value;
int m_comp = 0;
float m_value = 0;
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