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

cleanup code

Browse Source
This commit is contained in:
omigamedev
2019-11-26 10:06:30 +01:00
parent 2e4561c32a
commit 9eafcecde9
2 changed files with 3 additions and 112 deletions
Download Patch File Download Diff File Expand all files Collapse all files

103
src/brush.cpp
View File

@@ -108,101 +108,6 @@ std::vector<StrokeSample> Stroke::compute_samples()
return samples; return samples;
} }
std::vector<StrokeSample> Stroke::compute_samples_old()
{
if (m_keypoints.size() < 2) return {};
int nsamples = (int)glm::floor((m_keypoints.back().dist - m_dist) / m_step);
std::vector<StrokeSample> samples;
samples.reserve(nsamples); // preallocate the estimate number of samples
while (m_keypoints.back().dist > (m_dist + m_step))
{
m_dist += m_step;
m_dir_dist += m_step;
int old_kp = m_last_kp;
while (m_dist > m_keypoints[m_last_kp + 1].dist && m_last_kp < m_keypoints.size())
m_last_kp++;
const auto& A = m_keypoints[old_kp];
const auto& B = m_keypoints[m_last_kp == old_kp ? m_last_kp + 1 : m_last_kp]; // NOTE: this should be true when while is true
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);
if (m_dir_dist > m_dir_step)
{
int next_kp = m_last_kp == m_dir_kp ? m_last_kp + 1 : m_dir_kp;
glm::vec2 v = glm::normalize(m_keypoints[m_last_kp].pos - m_keypoints[next_kp].pos);
m_dir_angle = -glm::orientedAngle(v, m_dir_ref);
LOG("DIR ANGLE %f PT (%f,%f)(%f,%f)", m_dir_angle,
m_keypoints[m_last_kp].pos.x, m_keypoints[m_last_kp].pos.y,
m_keypoints[next_kp].pos.x, m_keypoints[next_kp].pos.y);
if (m_brush->m_tip_angle_smooth > 0 && (glm::abs(m_dir_angle) > glm::radians(30.f) || !m_dir_valid))
{
if (glm::abs(m_dir_angle) > glm::radians(100.f))
{
LOG("BIG ANGLE");
m_direction.clear();
}
auto old_dir = m_dir_ref;
m_dir_ref = v;
m_dir_ref_angle = -glm::orientedAngle(m_dir_ref, { 1, 0 });
m_dir_angle = 0;
auto angle_diff = -glm::orientedAngle(m_dir_ref, old_dir);
for (int i = 0; i < m_direction.m_count; i++)
m_direction.m_vec[i] -= angle_diff;
LOG("REF ANGLE %f", m_dir_ref_angle);
}
m_dir_kp = m_last_kp;
m_dir_dist = 0;
if (!m_dir_valid)
{
m_dir_init = m_dir_angle + m_dir_ref_angle;
m_dir_valid = true;
LOG("DIR INVALID");
}
}
bool need_dir = false;
need_dir |= m_brush->m_tip_angle_follow;
need_dir |= m_brush->m_tip_angle_init;
need_dir |= m_brush->m_jitter_angle > 0;
// angle is not ready yet
if (need_dir && !m_dir_valid)
continue;
auto s = randomize_sample(pos, pressure, m_dir_angle + m_dir_ref_angle);
if (s.valid())
{
if (m_brush->m_tip_angle_follow)
{
m_direction.add(m_dir_angle);
s.angle += m_dir_angle /*m_direction.average()*/ + m_dir_ref_angle;
}
else if (m_brush->m_tip_angle_init)
{
s.angle += m_dir_init;
}
LOG("angle %f", s.angle);
m_prev_sample = s;
samples.push_back(s);
}
else
{
static bool invalid_logged = false;
if (!invalid_logged)
{
for (auto const& p : m_keypoints)
LOG("point dist %f pos %f %f %f", p.dist, p.pos.x, p.pos.y, p.pos.z);
invalid_logged = true;
}
LOG("A.dist %f B.dist %f", A.dist, B.dist);
LOG("Invalid sample");
}
}
return samples;
}
bool Stroke::has_sample() bool Stroke::has_sample()
{ {
return m_interp_main.ready() && (m_interp_dir.ready_first || !need_dir()); return m_interp_main.ready() && (m_interp_dir.ready_first || !need_dir());
@@ -217,12 +122,8 @@ bool Stroke::need_dir() const noexcept
void Stroke::reset(bool clear_keypoints /*= false*/) void Stroke::reset(bool clear_keypoints /*= false*/)
{ {
m_dir_kp = 0;
m_dir_angle = 0; m_dir_angle = 0;
m_dir_valid = false; m_dir_valid = false;
m_dir_dist = 0;
m_last_kp = 0;
m_dist = 0.f;
if (clear_keypoints) if (clear_keypoints)
m_keypoints.clear(); m_keypoints.clear();
m_interp_main.reset(clear_keypoints); m_interp_main.reset(clear_keypoints);
@@ -271,12 +172,8 @@ void Stroke::start(const std::shared_ptr<Brush>& brush)
m_direction.clear(); m_direction.clear();
m_pressure_buff.clear(); m_pressure_buff.clear();
m_hsv_jitter.clear(); m_hsv_jitter.clear();
m_last_kp = 0;
m_dist = 0.f;
m_dir_kp = 0;
m_dir_angle = 0; m_dir_angle = 0;
m_dir_valid = false; m_dir_valid = false;
m_dir_dist = 0;
m_brush = brush; m_brush = brush;
float aspect_width = glm::min(1.f, glm::clamp(m_brush->m_tip_aspect, .1f, .9f) * 2.f); float aspect_width = glm::min(1.f, glm::clamp(m_brush->m_tip_aspect, .1f, .9f) * 2.f);

12
src/brush.h
View File

@@ -170,17 +170,12 @@ public:
void reset(bool clear_keypoints) noexcept; void reset(bool clear_keypoints) noexcept;
std::vector<Keypoint> compute() noexcept; std::vector<Keypoint> compute() noexcept;
}; };
int m_layer = 0;
int m_dir_kp = 0;
bool m_dir_valid = false; bool m_dir_valid = false;
glm::vec2 m_dir_ref = { 1, 0 }; glm::vec2 m_dir_ref = { 1, 0 };
float m_dir_ref_angle = 0; float m_dir_ref_angle = 0;
float m_dir_dist = 0;
float m_dir_step = 10;
float m_dir_angle = 0; float m_dir_angle = 0;
float m_dir_init = 0; float m_dir_init = 0;
float m_curve = 0; float m_curve = 0;
float m_dist = 0;
float m_step = 0; float m_step = 0;
float m_max_size = FLT_MAX; float m_max_size = FLT_MAX;
bool m_filter_points = true; bool m_filter_points = true;
@@ -194,18 +189,17 @@ public:
std::vector<Keypoint> m_keypoints; std::vector<Keypoint> m_keypoints;
std::vector<std::pair<glm::vec3, float>> m_hold_points; std::vector<std::pair<glm::vec3, float>> m_hold_points;
std::vector<StrokeSample> m_samples; std::vector<StrokeSample> m_samples;
int m_last_kp;
std::mt19937 prng; std::mt19937 prng;
SamplesInterpolator m_interp_main;
SamplesInterpolator m_interp_dir;
void start(const std::shared_ptr<Brush>& brush); void start(const std::shared_ptr<Brush>& brush);
void add_point(glm::vec3 pos, float pressure); void add_point(glm::vec3 pos, float pressure);
void reset(bool clear_keypoints = false); void reset(bool clear_keypoints = false);
bool has_sample(); bool has_sample();
bool need_dir() const noexcept; bool need_dir() const noexcept;
std::vector<StrokeSample> compute_samples(); std::vector<StrokeSample> compute_samples();
std::vector<StrokeSample> compute_samples_old();
StrokeSample randomize_sample(const glm::vec3& pos, float pressure, float curve_angle); StrokeSample randomize_sample(const glm::vec3& pos, float pressure, float curve_angle);
SamplesInterpolator m_interp_main;
SamplesInterpolator m_interp_dir;
void randomize_prng(); void randomize_prng();
float rnd_nor() { return float((double)prng() / (double)prng.max()); }; // normalized [0, +1] float rnd_nor() { return float((double)prng() / (double)prng.max()); }; // normalized [0, +1]