diff --git a/src/brush.cpp b/src/brush.cpp
index f6a05d1..74f08d4 100644
--- a/src/brush.cpp
+++ b/src/brush.cpp
@@ -108,101 +108,6 @@ std::vector<StrokeSample> Stroke::compute_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()
 {
     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*/)
 {
-    m_dir_kp = 0;
     m_dir_angle = 0;
     m_dir_valid = false;
-    m_dir_dist = 0;
-    m_last_kp = 0;
-    m_dist = 0.f;
     if (clear_keypoints)
         m_keypoints.clear();
     m_interp_main.reset(clear_keypoints);
@@ -271,12 +172,8 @@ void Stroke::start(const std::shared_ptr<Brush>& brush)
     m_direction.clear();
     m_pressure_buff.clear();
     m_hsv_jitter.clear();
-    m_last_kp = 0;
-    m_dist = 0.f;
-    m_dir_kp = 0;
     m_dir_angle = 0;
     m_dir_valid = false;
-    m_dir_dist = 0;
     m_brush = brush;
     
     float aspect_width = glm::min(1.f, glm::clamp(m_brush->m_tip_aspect, .1f, .9f) * 2.f);
diff --git a/src/brush.h b/src/brush.h
index e08440c..846804b 100644
--- a/src/brush.h
+++ b/src/brush.h
@@ -170,17 +170,12 @@ public:
         void reset(bool clear_keypoints) noexcept;
         std::vector<Keypoint> compute() noexcept;
     };
-    int m_layer = 0;
-    int m_dir_kp = 0;
     bool m_dir_valid = false;
     glm::vec2 m_dir_ref = { 1, 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_init = 0;
     float m_curve = 0;
-    float m_dist = 0;
     float m_step = 0;
     float m_max_size = FLT_MAX;
     bool m_filter_points = true;
@@ -194,18 +189,17 @@ public:
     std::vector<Keypoint> m_keypoints;
     std::vector<std::pair<glm::vec3, float>> m_hold_points;
     std::vector<StrokeSample> m_samples;
-    int m_last_kp;
     std::mt19937 prng;
+    SamplesInterpolator m_interp_main;
+    SamplesInterpolator m_interp_dir;
+
     void start(const std::shared_ptr<Brush>& brush);
     void add_point(glm::vec3 pos, float pressure);
     void reset(bool clear_keypoints = false);
     bool has_sample();
     bool need_dir() const noexcept;
     std::vector<StrokeSample> compute_samples();
-    std::vector<StrokeSample> compute_samples_old();
     StrokeSample randomize_sample(const glm::vec3& pos, float pressure, float curve_angle);
-    SamplesInterpolator m_interp_main;
-    SamplesInterpolator m_interp_dir;
 
     void randomize_prng();
     float rnd_nor() { return float((double)prng() / (double)prng.max()); };                     // normalized [0, +1]