121 lines
3.7 KiB
C++
121 lines
3.7 KiB
C++
#pragma once
|
|
#include "rtt.h"
|
|
|
|
NS_START
|
|
|
|
class Brush
|
|
{
|
|
public:
|
|
int id;
|
|
std::string m_name;
|
|
uint16_t m_tex_id;
|
|
glm::vec4 m_tip_color;
|
|
float m_tip_size;
|
|
float m_tip_spacing;
|
|
float m_tip_flow;
|
|
float m_tip_angle;
|
|
float m_jitter_scale;
|
|
float m_jitter_angle;
|
|
float m_jitter_spread;
|
|
float m_jitter_flow;
|
|
};
|
|
|
|
class Stroke
|
|
{
|
|
public:
|
|
struct Sample
|
|
{
|
|
glm::vec2 pos;
|
|
float size;
|
|
float flow;
|
|
float angle;
|
|
};
|
|
struct Keypoint
|
|
{
|
|
glm::vec2 pos;
|
|
float pressure;
|
|
float dist;
|
|
};
|
|
int m_layer;
|
|
float m_dist;
|
|
float m_step;
|
|
ui::Brush m_brush;
|
|
std::vector<Keypoint> m_keypoints;
|
|
std::vector<Sample> m_samples;
|
|
int m_last_kp;
|
|
std::minstd_rand prng;
|
|
void start(glm::vec2 pos, float pressure, const ui::Brush& brush)
|
|
{
|
|
m_last_kp = 0;
|
|
m_dist = 0.f;
|
|
m_step = glm::max(brush.m_tip_spacing * brush.m_tip_size * 30, 0.1f);
|
|
m_brush = brush;
|
|
add_point(pos, pressure);
|
|
}
|
|
void 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;
|
|
}
|
|
bool has_sample()
|
|
{
|
|
return m_keypoints.empty() ? false : // no keypoints
|
|
(m_keypoints.back().dist > (m_dist + m_step)); // check if next kp is closer than spacing
|
|
}
|
|
std::vector<Sample> compute_samples()
|
|
{
|
|
int nsamples = (int)glm::floor((m_keypoints.back().dist - m_dist) / m_step);
|
|
std::vector<Sample> samples;
|
|
samples.reserve(nsamples); // preallocate the estimate number of samples
|
|
while (m_keypoints.back().dist > (m_dist + m_step))
|
|
{
|
|
m_dist += m_step;
|
|
while (m_dist > m_keypoints[m_last_kp + 1].dist)
|
|
m_last_kp++;
|
|
const auto& A = m_keypoints[m_last_kp];
|
|
const auto& B = m_keypoints[m_last_kp + 1]; // 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);
|
|
auto s = randomize_sample(pos, pressure);
|
|
samples.push_back(s);
|
|
}
|
|
return std::move(samples);
|
|
}
|
|
Sample randomize_sample(const glm::vec2& pos, float pressure)
|
|
{
|
|
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]
|
|
auto rnd_rad = [&] { return float((double)prng() / (double)prng.max() * M_PI * 2.0); }; // normalized [0, 2pi]
|
|
auto rnd_vec = [&] { float rad = rnd_rad(); return glm::vec2(cosf(rad), sinf(rad)); }; // normalized direction vector
|
|
|
|
Sample s;
|
|
s.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 = 100.f * m_brush.m_tip_size * (1.f - rnd_nor() * m_brush.m_jitter_scale);
|
|
s.flow = m_brush.m_tip_flow * (1.f - rnd_nor() * m_brush.m_jitter_flow);
|
|
return s;
|
|
}
|
|
};
|
|
|
|
class Layer
|
|
{
|
|
public:
|
|
RTT m_rtt;
|
|
bool m_visible = true;
|
|
bool m_locked = false;
|
|
float m_alpha = 1.f;
|
|
std::string m_name;
|
|
bool create(int width, int height, std::string name)
|
|
{
|
|
m_rtt.create(width, height);
|
|
return true;
|
|
}
|
|
};
|
|
|
|
NS_END
|