From abca1d5162a0e8a277c2d093d9f8f9ea925c4cfb Mon Sep 17 00:00:00 2001 From: omigamedev Date: Mon, 25 Feb 2019 01:31:32 +0100 Subject: [PATCH] opacity pressure and jitter, initial direction --- data/layout.xml | 30 ++++++++++++++++++++++-------- src/abr.cpp | 7 +++---- src/brush.cpp | 10 +++++++--- src/brush.h | 9 ++++++++- src/canvas.cpp | 12 ++++++------ src/canvas.h | 3 ++- src/node_panel_brush.cpp | 18 ++++++++++++++++-- src/node_panel_brush.h | 9 ++++++++- src/node_panel_stroke.cpp | 11 ++++++++--- src/node_panel_stroke.h | 5 ++++- src/node_stroke_preview.cpp | 15 ++++++++------- src/node_stroke_preview.h | 3 ++- 12 files changed, 94 insertions(+), 38 deletions(-) diff --git a/data/layout.xml b/data/layout.xml index 605f3f2..15faf10 100644 --- a/data/layout.xml +++ b/data/layout.xml @@ -226,8 +226,12 @@ - - + + + + + + @@ -249,11 +253,11 @@ - + - + @@ -268,15 +272,19 @@ - + + + + + - + - + @@ -559,6 +567,9 @@ + + + @@ -585,9 +596,12 @@ - + + + + diff --git a/src/abr.cpp b/src/abr.cpp index b195095..713635b 100644 --- a/src/abr.cpp +++ b/src/abr.cpp @@ -126,7 +126,7 @@ std::vector> ABR::compute_brushes(const std::string& path b->m_tip_aspect = (1.f - samp->value("Rndn") * 0.01) * 0.5f + 0.5f; b->m_tip_size = samp->value("Dmtr"); b->m_tip_spacing = samp->value("Spcn") * 0.01f; - b->m_tip_angle = samp->value("Angl") / 360.f; // [-180, 180] -> [0, 1] + b->m_tip_angle = -samp->value("Angl") / 360.f; // [0, 360] -> [0, 1] b->m_tip_flipx = samp->value("flipX"); b->m_tip_flipy = samp->value("flipY"); @@ -186,8 +186,7 @@ std::vector> ABR::compute_brushes(const std::string& path else if (mode == 6) { b->m_jitter_angle = jitter_angle->value("jitter") * 0.01f; - b->m_tip_angle_follow = true; // temporary use full direction - // TODO: implement initial direction only + b->m_tip_angle_init = true; } } @@ -290,7 +289,7 @@ std::vector> ABR::compute_brushes(const std::string& path if (db->value("useScatter")) { auto scatter = db->get("scatterDynamics"); - b->m_dual_scatter = scatter->value("jitter") * 0.001f; + b->m_dual_scatter = scatter->value("jitter") * 0.01f; } // brush sample diff --git a/src/brush.cpp b/src/brush.cpp index 9307813..157c4c8 100644 --- a/src/brush.cpp +++ b/src/brush.cpp @@ -136,6 +136,7 @@ StrokeSample Stroke::randomize_sample(const glm::vec3& pos, float pressure, floa float size_dyn = m_brush->m_tip_size_pressure ? pressure : 1.f; float flow_dyn = m_brush->m_tip_flow_pressure ? pressure : 1.f; + float opacity_dyn = m_brush->m_tip_opacity_pressure ? pressure : 1.f; float size = glm::min(m_brush->m_tip_size / glm::tan(glm::radians(m_camera.fov * 0.5f)), m_max_size); float randflipx = m_brush->m_tip_randflipx ? rnd_bneg() : 1.f; float randflipy = m_brush->m_tip_randflipy ? rnd_bneg() : 1.f; @@ -150,6 +151,7 @@ StrokeSample Stroke::randomize_sample(const glm::vec3& pos, float pressure, floa s.size = size * (1.f - rnd_nor() * m_brush->m_jitter_scale) * size_dyn; s.pos = pos + (rnd_vec() * m_brush->m_jitter_spread * s.size); s.flow = m_brush->m_tip_flow * (1.f - rnd_nor() * m_brush->m_jitter_flow) * flow_dyn; + s.opacity = m_brush->m_tip_opacity * (1.f - rnd_nor() * m_brush->m_jitter_opacity) * opacity_dyn; auto hsv = convert_rgb2hsv(m_brush->m_tip_color); hsv.x = glm::clamp(glm::mix(hsv.x, (pressure - 0.5f) * 2.0f, m_brush->m_tip_hue) + (rnd_nor() - 0.5f) * m_brush->m_jitter_hue, 0.f, 1.f); hsv.y = glm::clamp(glm::mix(hsv.y, (1.f - pressure - 0.5f) * 2.0f, m_brush->m_tip_sat) + (rnd_nor() - 0.5f) * m_brush->m_jitter_sat, 0.f, 1.f); @@ -180,13 +182,13 @@ std::vector Stroke::compute_samples() auto s = randomize_sample(pos, pressure, 0); if (s.valid()) { - if (m_brush->m_tip_angle_follow) + if (m_brush->m_tip_angle_follow || (!m_dir_valid && m_brush->m_tip_angle_init)) { if (m_dir_dist > m_dir_step && m_last_kp != m_dir_kp) { glm::vec2 v = glm::normalize(m_keypoints[m_last_kp].pos - m_keypoints[m_dir_kp].pos); m_dir_angle = -glm::orientedAngle(v, m_dir_ref); - if (m_brush->m_tip_angle_delay > 0 && (glm::abs(m_dir_angle) > glm::pi() / 2.f || !m_dir_valid)) + if (m_brush->m_tip_angle_smooth > 0 && (glm::abs(m_dir_angle) > glm::pi() / 2.f || !m_dir_valid)) { //if (glm::abs(m_dir_angle) > glm::radians(110.f)) // LOG("BIG ANGLE"); @@ -214,6 +216,8 @@ std::vector Stroke::compute_samples() } else { + if (m_brush->m_tip_angle_init) + s.angle += m_direction.average() + m_dir_ref_angle; m_prev_sample = s; samples.push_back(s); } @@ -319,7 +323,7 @@ void Stroke::start(const std::shared_ptr& brush) else m_step = m_brush->m_tip_spacing * size; - m_direction.resize(std::max(1, m_brush->m_tip_angle_delay * 200.f / m_step)); + m_direction.resize(std::max(1, m_brush->m_tip_angle_smooth * 200.f / m_step)); prng.seed(0); } diff --git a/src/brush.h b/src/brush.h index 6852879..a3486b4 100644 --- a/src/brush.h +++ b/src/brush.h @@ -29,20 +29,23 @@ public: float m_tip_flow = 1.f; float m_tip_opacity = 1.f; float m_tip_angle = 0; - float m_tip_angle_delay = 0.01; + float m_tip_angle_smooth = 0.01; float m_tip_mix = 0; float m_tip_wet = 0; float m_tip_noise = 0; float m_tip_hue = 0; float m_tip_sat = 0; float m_tip_val = 0; + bool m_tip_angle_init = false; bool m_tip_angle_follow = false; bool m_tip_flow_pressure = false; + bool m_tip_opacity_pressure = false; bool m_tip_size_pressure = false; float m_jitter_scale = 0; float m_jitter_angle = 0; float m_jitter_spread = 0; float m_jitter_flow = 0; + float m_jitter_opacity = 0; float m_jitter_hue = 0; float m_jitter_sat = 0; float m_jitter_val = 0; @@ -68,6 +71,9 @@ public: float m_dual_flow = .75f; float m_dual_opacity = 1.f; float m_dual_rotate = .25f; + float m_dual_angle = 0; + int m_dual_count = 1; + glm::vec2 m_dual_scale = { 1.f, 1.f }; int m_pattern_blend_mode = 1; bool m_pattern_eachsample = false; @@ -94,6 +100,7 @@ struct StrokeSample glm::vec2 scale = { 1, 1 }; float size = 0; float flow = 0; + float opacity = 0; float angle = 0; bool valid() const { diff --git a/src/canvas.cpp b/src/canvas.cpp index 82ca0da..5a595df 100644 --- a/src/canvas.cpp +++ b/src/canvas.cpp @@ -447,7 +447,8 @@ std::vector Canvas::stroke_draw_compute(Stroke& stroke) con f.m_mixer_rect = { glm::floor(mixer_bb_min), glm::ceil(mixer_bb_max - mixer_bb_min) }; f.col = glm::vec4(s.col, 1); - f.pressure = s.flow; + f.flow = s.flow; + f.opacity = s.opacity; f.shapes = stroke_draw_project(B); prev = s; @@ -528,8 +529,8 @@ void Canvas::stroke_draw() ShaderManager::use(kShader::Stroke); ShaderManager::u_vec4(kShaderUniform::Col, f.col); - ShaderManager::u_float(kShaderUniform::Alpha, f.pressure); - //ShaderManager::u_float(kShaderUniform::Opacity, f.opacity); // per-tip opacity + ShaderManager::u_float(kShaderUniform::Alpha, f.flow); + ShaderManager::u_float(kShaderUniform::Opacity, f.opacity); for (int i = 0; i < 6; i++) { auto& P = f.shapes[i]; @@ -552,7 +553,6 @@ void Canvas::stroke_draw() if (brush->m_dual_enabled) { ShaderManager::u_int(kShaderUniform::UsePattern, false); - ShaderManager::u_float(kShaderUniform::Opacity, brush->m_dual_opacity); ShaderManager::u_float(kShaderUniform::MixAlpha, 0); ShaderManager::u_float(kShaderUniform::Wet, 0); ShaderManager::u_float(kShaderUniform::Noise, 0); @@ -564,8 +564,8 @@ void Canvas::stroke_draw() { ShaderManager::use(kShader::Stroke); ShaderManager::u_vec4(kShaderUniform::Col, f.col); - ShaderManager::u_float(kShaderUniform::Alpha, f.pressure); - //ShaderManager::u_float(kShaderUniform::Opacity, f.opacity); // per-tip opacity + ShaderManager::u_float(kShaderUniform::Alpha, f.flow); + ShaderManager::u_float(kShaderUniform::Opacity, f.opacity); for (int i = 0; i < 6; i++) { auto& P = f.shapes[i]; diff --git a/src/canvas.h b/src/canvas.h index 1b02569..551b0b5 100644 --- a/src/canvas.h +++ b/src/canvas.h @@ -131,7 +131,8 @@ class Canvas struct StrokeFrame { glm::vec4 col; - float pressure; + float flow; + float opacity; std::array, 6> shapes; glm::vec4 m_mixer_rect; }; diff --git a/src/node_panel_brush.cpp b/src/node_panel_brush.cpp index 7c23c93..774084b 100644 --- a/src/node_panel_brush.cpp +++ b/src/node_panel_brush.cpp @@ -485,25 +485,29 @@ bool NodePanelBrushPreset::save() i.m_stencil_path_len = b->m_pattern_path.size(); i.m_stencil_thumb_path_len = b->m_pattern_thumb_path.size(); i.m_tip_color = b->m_tip_color; + i.m_tip_scale = b->m_tip_scale; i.m_tip_size = b->m_tip_size; i.m_tip_spacing = b->m_tip_spacing; i.m_tip_flow = b->m_tip_flow; i.m_tip_opacity = b->m_tip_opacity; i.m_tip_angle = b->m_tip_angle; - i.m_tip_angle_delay = b->m_tip_angle_delay; + i.m_tip_angle_smooth = b->m_tip_angle_smooth; i.m_tip_mix = b->m_tip_mix; i.m_tip_wet = b->m_tip_wet; i.m_tip_noise = b->m_tip_noise; i.m_tip_hue = b->m_tip_hue; i.m_tip_sat = b->m_tip_sat; i.m_tip_val = b->m_tip_val; + i.m_tip_angle_init = b->m_tip_angle_init; i.m_tip_angle_follow = b->m_tip_angle_follow; i.m_tip_flow_pressure = b->m_tip_flow_pressure; + i.m_tip_opacity_pressure= b->m_tip_opacity_pressure; i.m_tip_size_pressure = b->m_tip_size_pressure; i.m_jitter_scale = b->m_jitter_scale; i.m_jitter_angle = b->m_jitter_angle; i.m_jitter_spread = b->m_jitter_spread; i.m_jitter_flow = b->m_jitter_flow; + i.m_jitter_opacity = b->m_jitter_opacity; i.m_jitter_hue = b->m_jitter_hue; i.m_jitter_sat = b->m_jitter_sat; i.m_jitter_val = b->m_jitter_val; @@ -529,6 +533,9 @@ bool NodePanelBrushPreset::save() i.m_dual_flow = b->m_dual_flow; i.m_dual_opacity = b->m_dual_opacity; i.m_dual_rotate = b->m_dual_rotate; + i.m_dual_angle = b->m_dual_angle; + i.m_dual_count = b->m_dual_count; + i.m_dual_scale = b->m_dual_scale; i.m_pattern_eachsample = b->m_pattern_eachsample; i.m_pattern_invert = b->m_pattern_invert; @@ -581,25 +588,29 @@ bool NodePanelBrushPreset::restore() fread(&i, sizeof(i), 1, fp); auto b = std::make_shared(); b->m_tip_color = i.m_tip_color; + b->m_tip_scale = i.m_tip_scale; b->m_tip_size = i.m_tip_size; b->m_tip_spacing = i.m_tip_spacing; b->m_tip_flow = i.m_tip_flow; b->m_tip_opacity = i.m_tip_opacity; b->m_tip_angle = i.m_tip_angle; - b->m_tip_angle_delay = i.m_tip_angle_delay; + b->m_tip_angle_smooth = i.m_tip_angle_smooth; b->m_tip_mix = i.m_tip_mix; b->m_tip_wet = i.m_tip_wet; b->m_tip_noise = i.m_tip_noise; b->m_tip_hue = i.m_tip_hue; b->m_tip_sat = i.m_tip_sat; b->m_tip_val = i.m_tip_val; + b->m_tip_angle_init = i.m_tip_angle_init; b->m_tip_angle_follow = i.m_tip_angle_follow; b->m_tip_flow_pressure = i.m_tip_flow_pressure; + b->m_tip_opacity_pressure = i.m_tip_opacity_pressure; b->m_tip_size_pressure = i.m_tip_size_pressure; b->m_jitter_scale = i.m_jitter_scale; b->m_jitter_angle = i.m_jitter_angle; b->m_jitter_spread = i.m_jitter_spread; b->m_jitter_flow = i.m_jitter_flow; + b->m_jitter_opacity = i.m_jitter_opacity; b->m_jitter_hue = i.m_jitter_hue; b->m_jitter_sat = i.m_jitter_sat; b->m_jitter_val = i.m_jitter_val; @@ -623,6 +634,9 @@ bool NodePanelBrushPreset::restore() b->m_dual_flow = i.m_dual_flow; b->m_dual_opacity = i.m_dual_opacity; b->m_dual_rotate = i.m_dual_rotate; + b->m_dual_angle = i.m_dual_angle; + b->m_dual_count = i.m_dual_count; + b->m_dual_scale = i.m_dual_scale; b->m_pattern_eachsample = i.m_pattern_eachsample; b->m_pattern_invert = i.m_pattern_invert; diff --git a/src/node_panel_brush.h b/src/node_panel_brush.h index aeb3c42..a00ca44 100644 --- a/src/node_panel_brush.h +++ b/src/node_panel_brush.h @@ -104,26 +104,30 @@ class NodePanelBrushPreset : public Node int m_stencil_thumb_path_len = 0; glm::vec4 m_tip_color{ 0, 0, 0, 1 }; + glm::vec2 m_tip_scale = { 1.f, 1.f }; float m_tip_width = 1.f; float m_tip_size = 0; float m_tip_spacing = 0; float m_tip_flow = 0; float m_tip_opacity = 0; float m_tip_angle = 0; - float m_tip_angle_delay = 0; + float m_tip_angle_smooth = 0; float m_tip_mix = 0; float m_tip_wet = 0; float m_tip_noise = 0; float m_tip_hue = 0; float m_tip_sat = 0; float m_tip_val = 0; + bool m_tip_angle_init = false; bool m_tip_angle_follow = false; bool m_tip_flow_pressure = false; + bool m_tip_opacity_pressure = false; bool m_tip_size_pressure = false; float m_jitter_scale = 0; float m_jitter_angle = 0; float m_jitter_spread = 0; float m_jitter_flow = 0; + float m_jitter_opacity = 0; float m_jitter_hue = 0; float m_jitter_sat = 0; float m_jitter_val = 0; @@ -149,6 +153,9 @@ class NodePanelBrushPreset : public Node float m_dual_flow = .75f; float m_dual_opacity = 1.f; float m_dual_rotate = .25f; + float m_dual_angle = 0; + int m_dual_count = 1; + glm::vec2 m_dual_scale = { 1.f, 1.f }; bool m_pattern_eachsample = false; bool m_pattern_invert = false; diff --git a/src/node_panel_stroke.cpp b/src/node_panel_stroke.cpp index d601bc9..d2273e0 100644 --- a/src/node_panel_stroke.cpp +++ b/src/node_panel_stroke.cpp @@ -155,13 +155,14 @@ void NodePanelStroke::update_controls() 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_delay->m_value.x = b->m_tip_angle_delay; + 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_spread->m_value.x = b->m_jitter_spread; 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; @@ -185,7 +186,7 @@ void NodePanelStroke::update_controls() 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 = b->m_dual_scatter; + 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; @@ -434,7 +435,7 @@ void NodePanelStroke::init_controls() init_slider(m_tip_flow, "tip-flow", &Brush::m_tip_flow); init_slider(m_tip_opacity, "tip-opacity", &Brush::m_tip_opacity); init_slider(m_tip_angle, "tip-angle", &Brush::m_tip_angle); - init_slider(m_tip_angle_delay, "tip-angle-delay", &Brush::m_tip_angle_delay); + init_slider(m_tip_angle_smooth, "tip-angle-smooth", &Brush::m_tip_angle_smooth); init_slider(m_tip_mix, "tip-mix", &Brush::m_tip_mix); init_slider(m_tip_wet, "tip-wet", &Brush::m_tip_wet); init_slider(m_tip_noise, "tip-noise", &Brush::m_tip_noise); @@ -445,12 +446,15 @@ void NodePanelStroke::init_controls() init_slider(m_jitter_angle, "jitter-angle", &Brush::m_jitter_angle); init_slider(m_jitter_spread, "jitter-spread", &Brush::m_jitter_spread); init_slider(m_jitter_flow, "jitter-flow", &Brush::m_jitter_flow); + init_slider(m_jitter_opacity, "jitter-opacity", &Brush::m_jitter_opacity); init_slider(m_jitter_hue, "jitter-hue", &Brush::m_jitter_hue); init_slider(m_jitter_sat, "jitter-sat", &Brush::m_jitter_sat); init_slider(m_jitter_val, "jitter-val", &Brush::m_jitter_val); + init_checkbox(m_tip_angle_init, "tip-angle-init", &Brush::m_tip_angle_init); init_checkbox(m_tip_angle_follow, "tip-angle-follow", &Brush::m_tip_angle_follow); init_checkbox(m_tip_flow_pressure, "tip-flow-pressure", &Brush::m_tip_flow_pressure); + init_checkbox(m_tip_opacity_pressure, "tip-opacity-pressure", &Brush::m_tip_opacity_pressure); init_checkbox(m_tip_size_pressure, "tip-size-pressure", &Brush::m_tip_size_pressure); init_checkbox(m_tip_invert, "tip-invert", &Brush::m_tip_invert); @@ -538,6 +542,7 @@ void NodePanelStroke::init_controls() m_curves[m_tip_flow] = curve_quad; m_curves[m_dual_size] = curve_size1k_perc; m_curves[m_dual_spacing] = curve_size1k_perc; + m_curves[m_dual_scatter] = curve_size1k_perc; m_curves[m_dual_flow] = curve_quad; m_curves[m_pattern_scale] = curve_size1k_perc; diff --git a/src/node_panel_stroke.h b/src/node_panel_stroke.h index 25dfe63..a11d592 100644 --- a/src/node_panel_stroke.h +++ b/src/node_panel_stroke.h @@ -19,7 +19,7 @@ public: NodeSliderH* m_tip_flow; NodeSliderH* m_tip_opacity; NodeSliderH* m_tip_angle; - NodeSliderH* m_tip_angle_delay; + NodeSliderH* m_tip_angle_smooth; NodeSliderH* m_tip_mix; NodeSliderH* m_tip_wet; NodeSliderH* m_tip_noise; @@ -30,11 +30,14 @@ public: NodeSliderH* m_jitter_angle; NodeSliderH* m_jitter_spread; NodeSliderH* m_jitter_flow; + NodeSliderH* m_jitter_opacity; NodeSliderH* m_jitter_hue; NodeSliderH* m_jitter_sat; NodeSliderH* m_jitter_val; + NodeCheckBox* m_tip_angle_init; NodeCheckBox* m_tip_angle_follow; NodeCheckBox* m_tip_flow_pressure; + NodeCheckBox* m_tip_opacity_pressure; NodeCheckBox* m_tip_size_pressure; NodeButtonCustom* m_brush_button; NodeButtonCustom* m_dual_brush_button; diff --git a/src/node_stroke_preview.cpp b/src/node_stroke_preview.cpp index c04b1f8..c950949 100644 --- a/src/node_stroke_preview.cpp +++ b/src/node_stroke_preview.cpp @@ -214,7 +214,8 @@ std::vector NodeStrokePreview::stroke_draw_compu f.m_mixer_rect = { glm::floor(mixer_bb_min), glm::ceil(mixer_bb_max - mixer_bb_min) }; f.col = glm::vec4(s.col, 1); - f.pressure = s.flow; + f.flow = s.flow; + f.opacity = s.opacity; f.shapes = B; prev = s; @@ -251,6 +252,8 @@ void NodeStrokePreview::draw_stroke() m_stroke.start(b); auto dual_brush = std::make_shared(); + dual_brush->m_tip_scale = b->m_dual_scale; + dual_brush->m_tip_angle = b->m_dual_angle; dual_brush->m_tip_flow = b->m_dual_flow; dual_brush->m_tip_opacity = b->m_dual_opacity; dual_brush->m_tip_flipx = b->m_dual_flipx; @@ -319,7 +322,6 @@ void NodeStrokePreview::draw_stroke() m_rtt.clear(); ShaderManager::use(kShader::Stroke); ShaderManager::u_int(kShaderUniform::UsePattern, false); - ShaderManager::u_float(kShaderUniform::Opacity, b->m_dual_opacity); ShaderManager::u_float(kShaderUniform::MixAlpha, 0); ShaderManager::u_float(kShaderUniform::Wet, 0); ShaderManager::u_float(kShaderUniform::Noise, 0); @@ -329,8 +331,8 @@ void NodeStrokePreview::draw_stroke() for (auto& f : frames_dual) { ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 }); - ShaderManager::u_float(kShaderUniform::Alpha, f.pressure); - //ShaderManager::u_float(kShaderUniform::Opacity, f.opacity); // per sample opacity + ShaderManager::u_float(kShaderUniform::Alpha, f.flow); + ShaderManager::u_float(kShaderUniform::Opacity, f.opacity); auto rect = stroke_draw_samples(f.shapes, m_tex_dual); } glActiveTexture(GL_TEXTURE0); @@ -345,7 +347,6 @@ void NodeStrokePreview::draw_stroke() // DRAW MAIN BRUSH ShaderManager::use(kShader::Stroke); - ShaderManager::u_float(kShaderUniform::Opacity, b->m_tip_opacity); ShaderManager::u_float(kShaderUniform::MixAlpha, b->m_tip_mix); ShaderManager::u_float(kShaderUniform::Wet, b->m_tip_wet); ShaderManager::u_float(kShaderUniform::Noise, b->m_tip_noise); @@ -370,8 +371,8 @@ void NodeStrokePreview::draw_stroke() ShaderManager::use(kShader::Stroke); ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 } /*f.col*/); - ShaderManager::u_float(kShaderUniform::Alpha, glm::max(f.pressure, m_min_flow)); - //ShaderManager::u_float(kShaderUniform::Opacity, f.opacity); // per sample opacity + ShaderManager::u_float(kShaderUniform::Alpha, glm::max(f.flow, m_min_flow)); + ShaderManager::u_float(kShaderUniform::Opacity, f.opacity); auto rect = stroke_draw_samples(f.shapes, m_tex); } glActiveTexture(GL_TEXTURE3); diff --git a/src/node_stroke_preview.h b/src/node_stroke_preview.h index c6be585..32908a2 100644 --- a/src/node_stroke_preview.h +++ b/src/node_stroke_preview.h @@ -9,7 +9,8 @@ class NodeStrokePreview : public NodeBorder struct StrokeFrame { glm::vec4 col; - float pressure; + float flow; + float opacity; std::array shapes; glm::vec4 m_mixer_rect; };