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

add brush follow-orientation flag to stroke settings and fix stroke preview

Browse Source
This commit is contained in:
omigamedev
2017-08-20 16:01:49 +01:00
parent eee574085b
commit 506923de69
8 changed files with 77 additions and 14 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
data/layout.xml
View File

@@ -123,7 +123,12 @@
<node height="20" pad="1" width="100%"><slider-h id="tip-flow" value=".5"/></node>
<node height="20" pad="1" width="100%"><slider-h id="tip-opacity" value="1"/></node>
<node height="20" pad="1" width="100%"><slider-h id="tip-spacing" value=".25"/></node>
<node height="20" pad="1" width="100%"><slider-h id="tip-angle"/></node>
<node height="20" pad="1" width="100%" dir="row">
<slider-h id="tip-angle" width="1" grow="1"/>
<node width="20" pad="0" margin="0 0 0 2">
<checkbox id="tip-angle-follow"></checkbox>
</node>
</node>
<node height="20" pad="1" width="100%"><slider-h id="tip-mix"/></node>
</border>
</node>

36
engine/brush.cpp
View File

@@ -154,7 +154,7 @@ bool ui::BrushMesh::create()
return true;
}
ui::StrokeSample ui::Stroke::randomize_sample(const glm::vec2& pos, float pressure)
ui::StrokeSample ui::Stroke::randomize_sample(const glm::vec2& pos, float pressure, float curve_angle)
{
auto rnd_nor = [&] { return float((double)prng() / (double)prng.max()); }; // normalized [0, +1]
//auto rnd_neg = [&] { return float((double)prng() / (double)prng.max() * 2.0 - 1.0); }; // normalized [-1, +1]
@@ -162,7 +162,8 @@ ui::StrokeSample ui::Stroke::randomize_sample(const glm::vec2& pos, float pressu
auto rnd_vec = [&] { float rad = rnd_rad(); return glm::vec2(cosf(rad), sinf(rad)); }; // normalized direction vector
StrokeSample s;
s.angle = (m_brush.m_tip_angle + rnd_nor() * m_brush.m_jitter_angle) * (float)(M_PI * 2.0);
s.origin = pos;
s.angle = -curve_angle + (m_brush.m_tip_angle + rnd_nor() * m_brush.m_jitter_angle) * (float)(M_PI * 2.0);
s.pos = pos + (rnd_vec() * m_brush.m_jitter_spread * 100.f);
s.size = 800.f * glm::pow(m_brush.m_tip_size, 3.f) * (1.f - rnd_nor() * m_brush.m_jitter_scale);
s.flow = glm::pow(m_brush.m_tip_flow, 2.f) * (1.f - rnd_nor() * m_brush.m_jitter_flow) * pressure;
@@ -176,6 +177,7 @@ std::vector<ui::StrokeSample> ui::Stroke::compute_samples()
samples.reserve(nsamples); // preallocate the estimate number of samples
while (m_keypoints.back().dist > (m_dist + m_step))
{
bool is_first = m_last_kp == 0;
m_dist += m_step;
while (m_dist > m_keypoints[m_last_kp + 1].dist)
m_last_kp++;
@@ -184,7 +186,21 @@ std::vector<ui::StrokeSample> ui::Stroke::compute_samples()
float t = (m_dist - A.dist) / (B.dist - A.dist); // NOTE: must be A != B
auto pos = glm::lerp(A.pos, B.pos, t);
float pressure = glm::lerp(A.pressure, B.pressure, t);
auto s = randomize_sample(pos, pressure);
auto s = randomize_sample(pos, pressure, 0);
if (m_brush.m_tip_angle_follow)
{
auto& pre = m_prev_sample;
glm::vec2 v = glm::normalize(s.origin - pre.origin);
float curve_angle = -glm::orientedAngle(v, glm::vec2(1, 0));
// NOTE: average angles need correction for 0-360 discontinuity
//m_curve_angles.add(curve_angle);
//float avg = m_curve_angles.average();
s.angle += curve_angle;
}
m_prev_sample = s;
samples.push_back(s);
}
return std::move(samples);
@@ -205,16 +221,20 @@ void ui::Stroke::add_point(glm::vec2 pos, float pressure)
{
float dist = m_keypoints.empty() ? 0.f :
m_keypoints.back().dist + glm::distance(m_keypoints.back().pos, pos);
m_keypoints.emplace_back();
m_keypoints.back().pos = pos;
m_keypoints.back().pressure = pressure;
m_keypoints.back().dist = dist;
if (m_keypoints.empty())
m_prev_sample.origin = pos;
Keypoint kp;
kp.pos = pos;
kp.pressure = pressure;
kp.dist = dist;
m_keypoints.push_back(kp);
}
void ui::Stroke::start(const ui::Brush& brush)
{
m_curve_angles.clear();
m_last_kp = 0;
m_dist = 0.f;
m_step = glm::max(brush.m_tip_spacing * brush.m_tip_size * 100, 1.f);
m_brush = brush;
prng.seed(0);
}
}

6
engine/brush.h
View File

@@ -16,6 +16,7 @@ public:
float m_tip_flow;
float m_tip_opacity;
float m_tip_angle;
bool m_tip_angle_follow = false;
float m_jitter_scale;
float m_jitter_angle;
float m_jitter_spread;
@@ -25,6 +26,7 @@ public:
struct StrokeSample
{
glm::vec2 pos;
glm::vec2 origin;
float size;
float flow;
float angle;
@@ -64,6 +66,8 @@ public:
float m_step;
Camera m_camera;
ui::Brush m_brush;
cbuffer<float, 3> m_curve_angles;
StrokeSample m_prev_sample;
std::vector<Keypoint> m_keypoints;
std::vector<StrokeSample> m_samples;
int m_last_kp;
@@ -73,7 +77,7 @@ public:
void reset(bool clear_keypoints = false);
bool has_sample();
std::vector<StrokeSample> compute_samples();
StrokeSample randomize_sample(const glm::vec2& pos, float pressure);
StrokeSample randomize_sample(const glm::vec2& pos, float pressure, float curve_angle);
};
NS_END

27
engine/node_panel_stroke.cpp
View File

@@ -32,15 +32,18 @@ void NodePanelStroke::init_controls()
init_slider(m_jitter_angle, "jitter-angle", &ui::Brush::m_jitter_angle);
init_slider(m_jitter_spread, "jitter-spread", &ui::Brush::m_jitter_spread);
init_slider(m_jitter_flow, "jitter-flow", &ui::Brush::m_jitter_flow);
init_checkbox(m_tip_angle_follow, "tip-angle-follow", &ui::Brush::m_tip_angle_follow);
//m_canvas->draw_stroke();
}
void NodePanelStroke::init_slider(NodeSliderH*& slider, const char* id, float ui::Brush::* prop)
void NodePanelStroke::init_slider(NodeSliderH*& target, const char* id, float ui::Brush::* prop)
{
slider = find<NodeSliderH>(id);
slider->on_value_changed = std::bind(&NodePanelStroke::handle_slide,
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 = slider->m_value.x;
m_canvas->m_brush.*prop = target->m_value.x;
}
void NodePanelStroke::handle_slide(float ui::Brush::* prop, Node* target, float value)
@@ -50,3 +53,19 @@ void NodePanelStroke::handle_slide(float ui::Brush::* prop, Node* target, float
if (on_stroke_change)
on_stroke_change(this);
}
void NodePanelStroke::init_checkbox(NodeCheckBox*& target, const char* id, bool ui::Brush::* prop)
{
target = find<NodeCheckBox>(id);
target->on_value_changed = std::bind(&NodePanelStroke::handle_checkbox,
this, prop, std::placeholders::_1, std::placeholders::_2);
m_canvas->m_brush.*prop = target->checked;
}
void NodePanelStroke::handle_checkbox(bool ui::Brush::* prop, Node *target, bool value)
{
m_canvas->m_brush.*prop = value;
m_canvas->draw_stroke();
if (on_stroke_change)
on_stroke_change(this);
}

6
engine/node_panel_stroke.h
View File

@@ -3,6 +3,7 @@
#include "node_stroke_preview.h"
#include "node_slider.h"
#include "brush.h"
#include "node_checkbox.h"
class NodePanelStroke : public Node
{
@@ -17,11 +18,16 @@ public:
NodeSliderH* m_jitter_angle;
NodeSliderH* m_jitter_spread;
NodeSliderH* m_jitter_flow;
NodeCheckBox* m_tip_angle_follow;
std::function<void(Node* target)> on_stroke_change;
virtual Node* clone_instantiate() const override;
virtual void clone_finalize(Node* dest) const override;
virtual void init() override;
void init_controls();
void init_slider(NodeSliderH*& slider, const char* id, float ui::Brush::* prop);
void handle_slide(float ui::Brush::* prop, Node* target, float value);
void init_checkbox(NodeCheckBox*& slider, const char* id, bool ui::Brush::* prop);
void handle_checkbox(bool ui::Brush::* prop, Node* target, bool value);
};

3
engine/node_stroke_preview.cpp
View File

@@ -69,6 +69,8 @@ void NodeStrokePreview::draw_stroke()
b.m_tip_size *= .7f; // reduce the size in the preview
m_stroke.reset();
m_stroke.start(b);
if (!m_stroke.m_keypoints.empty())
m_stroke.m_prev_sample.origin = m_stroke.m_keypoints[0].pos;
auto samples = m_stroke.compute_samples();
auto& tex = TextureManager::get(m_brush.m_tex_id);
tex.bind();
@@ -127,6 +129,7 @@ void NodeStrokePreview::handle_resize(glm::vec2 old_size, glm::vec2 new_size)
float w = new_size.x;
float h = new_size.y;
std::vector<glm::vec2> kp = { { pad, pad },{ pad, h - pad },{ w - pad, pad },{ w - pad, h - pad } };
m_stroke.reset();
m_stroke.start(m_brush);
for (int i = 0; i < 20; i++)
m_stroke.add_point(BezierCurve::Bezier2D(kp, i / 20.f), 1.f);

1
engine/pch.h
View File

@@ -100,6 +100,7 @@
#include <glm/gtc/type_ptr.hpp>
#include <glm/gtx/rotate_vector.hpp>
#include <glm/gtx/euler_angles.hpp>
#include <glm/gtx/vector_angle.hpp>
#include <tinyxml2.h>
#include <jpge.h>

5
engine/util.h
View File

@@ -30,6 +30,11 @@ template<typename T, int N> struct cbuffer
m_index = 0;
m_count = 0;
}
void clear()
{
m_index = 0;
m_count = 0;
}
T& head()
{
return m_index == 0 ? m_vec[m_count - 1] : m_vec[m_index - 1];