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

opacity pressure and jitter, initial direction

Browse Source
This commit is contained in:
omigamedev
2019-02-25 01:31:32 +01:00
parent bfaff312f8
commit abca1d5162
12 changed files with 94 additions and 38 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
data/layout.xml
View File

@@ -226,8 +226,12 @@
<text text="flow pressure"/>
</node>
</node>
<node height="20" pad="1" width="100%">
<slider-h id="tip-opacity" value="1"/>
<node height="40" pad="1" width="100%" dir="col">
<slider-h id="tip-opacity" height="19" value="1"/>
<node align="center" dir="row">
<checkbox id="tip-opacity-pressure" width="20" height="19"/>
<text text="opacity pressure"/>
</node>
</node>
</node>
</node>
@@ -249,11 +253,11 @@
<node height="20" justify="center">
<text text="Spacing"/>
</node>
<node height="20" justify="center" margin="0 0 20 0">
<node height="20" justify="center" margin="0 0 40 0">
<text text="Angle"/>
</node>
<node height="20" justify="center">
<text text="Delay"/>
<text text="Smoothing"/>
</node>
</node>
<node dir="col" align="center" grow="1" width="1">
@@ -268,15 +272,19 @@
<node height="20" pad="1" width="100%">
<slider-h id="tip-spacing" value=".25"/>
</node>
<node height="40" pad="1" width="100%" dir="col">
<node height="60" pad="1" width="100%" dir="col">
<slider-h id="tip-angle" height="19"/>
<node align="center" dir="row">
<checkbox id="tip-angle-init" width="20" height="19"/>
<text text="initial direction"/>
</node>
<node align="center" dir="row">
<checkbox id="tip-angle-follow" width="20" height="19"/>
<text text="direction"/>
<text text="follow direction"/>
</node>
</node>
<node height="20" pad="1" width="100%">
<slider-h id="tip-angle-delay" value="0"/>
<slider-h id="tip-angle-smooth" value="0"/>
</node>
</node>
</node>
@@ -559,6 +567,9 @@
<node height="20" justify="center" margin="0 0 5 0">
<text text="Flow"/>
</node>
<node height="20" justify="center" margin="0 0 5 0">
<text text="Opacity"/>
</node>
<node height="20" justify="center">
<text text="Hue"/>
</node>
@@ -585,9 +596,12 @@
<node height="20" pad="1" width="100%" margin="0 0 5 0">
<slider-h id="jitter-spread"/>
</node>
<node height="20" pad="1" width="100%" margin="0 0 5 0">
<node height="20" pad="1" width="100%">
<slider-h id="jitter-flow"/>
</node>
<node height="20" pad="1" width="100%" margin="0 0 5 0">
<slider-h id="jitter-opacity"/>
</node>
<node height="20" pad="1" width="100%">
<slider-h id="jitter-hue"/>
</node>

7
src/abr.cpp
View File

@@ -126,7 +126,7 @@ std::vector<std::shared_ptr<Brush>> ABR::compute_brushes(const std::string& path
b->m_tip_aspect = (1.f - samp->value<UnitFloat>("Rndn") * 0.01) * 0.5f + 0.5f;
b->m_tip_size = samp->value<UnitFloat>("Dmtr");
b->m_tip_spacing = samp->value<UnitFloat>("Spcn") * 0.01f;
b->m_tip_angle = samp->value<UnitFloat>("Angl") / 360.f; // [-180, 180] -> [0, 1]
b->m_tip_angle = -samp->value<UnitFloat>("Angl") / 360.f; // [0, 360] -> [0, 1]
b->m_tip_flipx = samp->value<Boolean>("flipX");
b->m_tip_flipy = samp->value<Boolean>("flipY");
@@ -186,8 +186,7 @@ std::vector<std::shared_ptr<Brush>> ABR::compute_brushes(const std::string& path
else if (mode == 6)
{
b->m_jitter_angle = jitter_angle->value<UnitFloat>("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<std::shared_ptr<Brush>> ABR::compute_brushes(const std::string& path
if (db->value<Boolean>("useScatter"))
{
auto scatter = db->get<Descriptor>("scatterDynamics");
b->m_dual_scatter = scatter->value<UnitFloat>("jitter") * 0.001f;
b->m_dual_scatter = scatter->value<UnitFloat>("jitter") * 0.01f;
}
// brush sample

10
src/brush.cpp
View File

@@ -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<StrokeSample> 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<float>() / 2.f || !m_dir_valid))
if (m_brush->m_tip_angle_smooth > 0 && (glm::abs(m_dir_angle) > glm::pi<float>() / 2.f || !m_dir_valid))
{
//if (glm::abs(m_dir_angle) > glm::radians(110.f))
// LOG("BIG ANGLE");
@@ -214,6 +216,8 @@ std::vector<StrokeSample> 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>& brush)
else
m_step = m_brush->m_tip_spacing * size;
m_direction.resize(std::max<int>(1, m_brush->m_tip_angle_delay * 200.f / m_step));
m_direction.resize(std::max<int>(1, m_brush->m_tip_angle_smooth * 200.f / m_step));
prng.seed(0);
}

9
src/brush.h
View File

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

12
src/canvas.cpp
View File

@@ -447,7 +447,8 @@ std::vector<Canvas::StrokeFrame> 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];

3
src/canvas.h
View File

@@ -131,7 +131,8 @@ class Canvas
struct StrokeFrame
{
glm::vec4 col;
float pressure;
float flow;
float opacity;
std::array<std::vector<vertex_t>, 6> shapes;
glm::vec4 m_mixer_rect;
};

18
src/node_panel_brush.cpp
View File

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

9
src/node_panel_brush.h
View File

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

11
src/node_panel_stroke.cpp
View File

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

5
src/node_panel_stroke.h
View File

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

15
src/node_stroke_preview.cpp
View File

@@ -214,7 +214,8 @@ std::vector<NodeStrokePreview::StrokeFrame> 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<Brush>();
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);

3
src/node_stroke_preview.h
View File

@@ -9,7 +9,8 @@ class NodeStrokePreview : public NodeBorder
struct StrokeFrame
{
glm::vec4 col;
float pressure;
float flow;
float opacity;
std::array<vertex_t, 4> shapes;
glm::vec4 m_mixer_rect;
};