diff --git a/toonz/sources/tnztools/toonzrasterbrushtool.cpp b/toonz/sources/tnztools/toonzrasterbrushtool.cpp
index 563b59b..09dc759 100644
--- a/toonz/sources/tnztools/toonzrasterbrushtool.cpp
+++ b/toonz/sources/tnztools/toonzrasterbrushtool.cpp
@@ -880,7 +880,6 @@ ToonzRasterBrushTool::ToonzRasterBrushTool(std::string name, int targetType)
     , m_modifierSize("ModifierSize", -3, 3, 0, true)
     , m_modifierLockAlpha("Lock Alpha", false)
     , m_targetType(targetType)
-    , m_bluredBrush(0)
     , m_enabled(false)
     , m_isPrompting(false)
     , m_firstTime(true)
@@ -1386,28 +1385,26 @@ void ToonzRasterBrushTool::leftButtonDown(const TPointD &pos,
         m_smoothStroke.getSmoothPoints(pts);
       }
     } else {
-      m_points.clear();
+      m_painting.blured.points.clear();
       TThickPoint point(centeredPos + rasCenter, thickness);
-      m_points.push_back(point);
-      m_bluredBrush = new BluredBrush(m_workRas, maxThick, m_brushPad, false);
+      m_painting.blured.points.push_back(point);
+      m_painting.blured.bluredBrush = new BluredBrush(m_workRas, maxThick, m_brushPad, false);
 
       if (drawOrder == PaletteOrder)
-        m_bluredBrush->setAboveStyleIds(aboveStyleIds);
+        m_painting.blured.bluredBrush->setAboveStyleIds(aboveStyleIds);
 
-      TRect strokeRect = m_bluredBrush->getBoundFromPoints(m_points);
+      TRect strokeRect = m_painting.blured.bluredBrush->getBoundFromPoints( m_painting.blured.points );
       updateWorkAndBackupRasters(strokeRect);
       m_painting.tileSaver->save(strokeRect);
-      m_bluredBrush->addPoint(point, 1);
+      m_painting.blured.bluredBrush->addPoint(point, 1);
       if (!m_painting.straight.isStraight)
-        m_bluredBrush->updateDrawing(ri->getRaster(), m_backupRas, strokeRect,
-                                     m_painting.styleId, drawOrder,
-                                     m_modifierLockAlpha.getValue());
+        m_painting.blured.bluredBrush->updateDrawing( ri->getRaster(), m_backupRas, strokeRect,
+                                                      m_painting.styleId, drawOrder,
+                                                      m_modifierLockAlpha.getValue() );
       m_painting.lastRect = strokeRect;
 
-      std::vector<TThickPoint> pts;
-      if (m_smooth.getValue() == 0) {
-        pts.push_back(point);
-      } else {
+      if (m_smooth.getValue()) {
+        std::vector<TThickPoint> pts;
         m_smoothStroke.beginStroke(m_smooth.getValue());
         m_smoothStroke.addPoint(point);
         m_smoothStroke.getSmoothPoints(pts);
@@ -1554,41 +1551,41 @@ void ToonzRasterBrushTool::leftButtonDrag(const TPointD &pos,
       m_smoothStroke.getSmoothPoints(pts);
     }
     for (size_t i = 0; i < pts.size(); ++i) {
-      TThickPoint old = m_points.back();
+      TThickPoint old = m_painting.blured.points.back();
 
       const TThickPoint &point = pts[i];
       TThickPoint mid((old + point) * 0.5, (point.thick + old.thick) * 0.5);
-      m_points.push_back(mid);
-      m_points.push_back(point);
+      m_painting.blured.points.push_back(mid);
+      m_painting.blured.points.push_back(point);
 
       TRect bbox;
-      int m = (int)m_points.size();
+      int m = (int)m_painting.blured.points.size();
       std::vector<TThickPoint> points;
       if (m == 3) {
         // ho appena cominciato. devo disegnare un segmento
-        TThickPoint pa = m_points.front();
+        TThickPoint pa = m_painting.blured.points.front();
         points.push_back(pa);
         points.push_back(mid);
-        bbox = m_bluredBrush->getBoundFromPoints(points);
+        bbox = m_painting.blured.bluredBrush->getBoundFromPoints(points);
         updateWorkAndBackupRasters(bbox + m_painting.lastRect);
         m_painting.tileSaver->save(bbox);
-        m_bluredBrush->addArc(pa, (mid + pa) * 0.5, mid, 1, 1);
+        m_painting.blured.bluredBrush->addArc(pa, (mid + pa) * 0.5, mid, 1, 1);
         m_painting.lastRect += bbox;
       } else {
-        points.push_back(m_points[m - 4]);
+        points.push_back(m_painting.blured.points[m - 4]);
         points.push_back(old);
         points.push_back(mid);
-        bbox = m_bluredBrush->getBoundFromPoints(points);
+        bbox = m_painting.blured.bluredBrush->getBoundFromPoints(points);
         updateWorkAndBackupRasters(bbox + m_painting.lastRect);
         m_painting.tileSaver->save(bbox);
-        m_bluredBrush->addArc(m_points[m - 4], old, mid, 1, 1);
+        m_painting.blured.bluredBrush->addArc( m_painting.blured.points[m - 4], old, mid, 1, 1 );
         m_painting.lastRect += bbox;
       }
       invalidateRect += ToolUtils::getBounds(points, maxThickness) - rasCenter;
 
-      m_bluredBrush->updateDrawing(ti->getRaster(), m_backupRas, bbox,
-                                   m_painting.styleId, m_drawOrder.getIndex(),
-                                   m_modifierLockAlpha.getValue());
+      m_painting.blured.bluredBrush->updateDrawing( ti->getRaster(), m_backupRas, bbox,
+                                                    m_painting.styleId, m_drawOrder.getIndex(),
+                                                    m_modifierLockAlpha.getValue() );
     }
   }
 
@@ -1772,71 +1769,71 @@ void ToonzRasterBrushTool::finishRasterBrush(const TPointD &pos,
     if (pts.size() > 0) {
       // this doesn't get run for a straight line
       for (size_t i = 0; i < pts.size() - 1; ++i) {
-        TThickPoint old = m_points.back();
+        TThickPoint old = m_painting.blured.points.back();
 
         const TThickPoint &point = pts[i];
         TThickPoint mid((old + point) * 0.5, (point.thick + old.thick) * 0.5);
-        m_points.push_back(mid);
-        m_points.push_back(point);
+        m_painting.blured.points.push_back(mid);
+        m_painting.blured.points.push_back(point);
 
         TRect bbox;
-        int m = (int)m_points.size();
+        int m = (int)m_painting.blured.points.size();
         std::vector<TThickPoint> points;
         if (m == 3) {
           // ho appena cominciato. devo disegnare un segmento
-          TThickPoint pa = m_points.front();
+          TThickPoint pa = m_painting.blured.points.front();
           points.push_back(pa);
           points.push_back(mid);
-          bbox = m_bluredBrush->getBoundFromPoints(points);
+          bbox = m_painting.blured.bluredBrush->getBoundFromPoints(points);
           updateWorkAndBackupRasters(bbox + m_painting.lastRect);
           m_painting.tileSaver->save(bbox);
-          m_bluredBrush->addArc(pa, (mid + pa) * 0.5, mid, 1, 1);
+          m_painting.blured.bluredBrush->addArc(pa, (mid + pa) * 0.5, mid, 1, 1);
           m_painting.lastRect += bbox;
         } else {
-          points.push_back(m_points[m - 4]);
+          points.push_back(m_painting.blured.points[m - 4]);
           points.push_back(old);
           points.push_back(mid);
-          bbox = m_bluredBrush->getBoundFromPoints(points);
+          bbox = m_painting.blured.bluredBrush->getBoundFromPoints(points);
           updateWorkAndBackupRasters(bbox + m_painting.lastRect);
           m_painting.tileSaver->save(bbox);
-          m_bluredBrush->addArc(m_points[m - 4], old, mid, 1, 1);
+          m_painting.blured.bluredBrush->addArc(m_painting.blured.points[m - 4], old, mid, 1, 1);
           m_painting.lastRect += bbox;
         }
 
         invalidateRect +=
             ToolUtils::getBounds(points, maxThickness) - rasCenter;
 
-        m_bluredBrush->updateDrawing(ti->getRaster(), m_backupRas, bbox,
-                                     m_painting.styleId, m_drawOrder.getIndex(),
-                                     m_modifierLockAlpha.getValue());
+        m_painting.blured.bluredBrush->updateDrawing( ti->getRaster(), m_backupRas, bbox,
+                                                      m_painting.styleId, m_drawOrder.getIndex(),
+                                                      m_modifierLockAlpha.getValue() );
       }
-      if (!m_painting.straight.isStraight && m_points.size() > 1) {
+      if (!m_painting.straight.isStraight && m_painting.blured.points.size() > 1) {
         TThickPoint point = pts.back();
-        m_points.push_back(point);
+        m_painting.blured.points.push_back(point);
       }
-      int m = m_points.size();
+      int m = m_painting.blured.points.size();
       std::vector<TThickPoint> points;
-      if (!m_painting.straight.isStraight && m_points.size() > 1) {
-        points.push_back(m_points[m - 3]);
-        points.push_back(m_points[m - 2]);
-        points.push_back(m_points[m - 1]);
+      if (!m_painting.straight.isStraight && m_painting.blured.points.size() > 1) {
+        points.push_back( m_painting.blured.points[m - 3] );
+        points.push_back( m_painting.blured.points[m - 2] );
+        points.push_back( m_painting.blured.points[m - 1] );
       } else {
-        const TThickPoint point = m_points[0];
+        const TThickPoint point = m_painting.blured.points[0];
         TThickPoint mid((thickPoint + point) * 0.5,
                         (point.thick + thickPoint.thick) * 0.5);
-        m_points.push_back(mid);
-        m_points.push_back(thickPoint);
-        points.push_back(m_points[0]);
-        points.push_back(m_points[1]);
-        points.push_back(m_points[2]);
+        m_painting.blured.points.push_back(mid);
+        m_painting.blured.points.push_back(thickPoint);
+        points.push_back( m_painting.blured.points[0] );
+        points.push_back( m_painting.blured.points[1] );
+        points.push_back( m_painting.blured.points[2] );
       }
-      TRect bbox = m_bluredBrush->getBoundFromPoints(points);
+      TRect bbox = m_painting.blured.bluredBrush->getBoundFromPoints(points);
       updateWorkAndBackupRasters(bbox);
       m_painting.tileSaver->save(bbox);
-      m_bluredBrush->addArc(points[0], points[1], points[2], 1, 1);
-      m_bluredBrush->updateDrawing(ti->getRaster(), m_backupRas, bbox,
-                                   m_painting.styleId, m_drawOrder.getIndex(),
-                                   m_modifierLockAlpha.getValue());
+      m_painting.blured.bluredBrush->addArc( points[0], points[1], points[2], 1, 1 );
+      m_painting.blured.bluredBrush->updateDrawing( ti->getRaster(), m_backupRas, bbox,
+                                                    m_painting.styleId, m_drawOrder.getIndex(),
+                                                    m_modifierLockAlpha.getValue() );
 
       invalidateRect += ToolUtils::getBounds(points, maxThickness) - rasCenter;
 
@@ -1845,12 +1842,12 @@ void ToonzRasterBrushTool::finishRasterBrush(const TPointD &pos,
     if (!invalidateRect.isEmpty()) invalidate(invalidateRect.enlarge(2));
     m_painting.lastRect.empty();
 
-    delete m_bluredBrush;
-    m_bluredBrush = 0;
+    delete m_painting.blured.bluredBrush;
+    m_painting.blured.bluredBrush = nullptr;
 
     if (m_painting.tileSet->getTileCount() > 0) {
       TUndoManager::manager()->add(new RasterBluredBrushUndo(
-          m_painting.tileSet, m_points, m_painting.styleId, (DrawOrder)m_drawOrder.getIndex(),
+          m_painting.tileSet, m_painting.blured.points, m_painting.styleId, (DrawOrder)m_drawOrder.getIndex(),
           m_modifierLockAlpha.getValue(), simLevel.getPointer(), frameId,
           m_rasThickness.getValue().second, m_hardness.getValue() * 0.01,
           m_isFrameCreated, m_isLevelCreated, m_painting.straight.isStraight));
diff --git a/toonz/sources/tnztools/toonzrasterbrushtool.h b/toonz/sources/tnztools/toonzrasterbrushtool.h
index 01c5685..af8504f 100644
--- a/toonz/sources/tnztools/toonzrasterbrushtool.h
+++ b/toonz/sources/tnztools/toonzrasterbrushtool.h
@@ -190,6 +190,11 @@ protected:
       RasterStrokeGenerator *rasterTrack = nullptr;
     } pencil;
     
+    struct Blured {
+      std::vector<TThickPoint> points;
+      BluredBrush *bluredBrush;
+    } blured;
+    
     struct MyPaint {
       MyPaintToonzBrush *brush = nullptr;
       TRect strokeRect;
@@ -224,14 +229,11 @@ protected:
       m_mousePos,  //!< Current mouse position, in world coordinates.
       m_brushPos;  //!< World position the brush will be painted at.
 
-  BluredBrush *m_bluredBrush;
   QRadialGradient m_brushPad;
 
   TRasterCM32P m_backupRas;
   TRaster32P m_workRas;
 
-  std::vector<TThickPoint> m_points;
-
   SmoothStroke m_smoothStroke;
 
   BrushPresetManager