1 files changed, 42 insertions, 47 deletions

diff --git a/source/blender/compositor/operations/COM_MaskOperation.cc b/source/blender/compositor/operations/COM_MaskOperation.cc
index aa7b693554f..d02d23445b6 100644
--- a/source/blender/compositor/operations/COM_MaskOperation.cc
+++ b/source/blender/compositor/operations/COM_MaskOperation.cc
@@ -26,34 +26,34 @@ namespace blender::compositor {
 MaskOperation::MaskOperation()
 {
   this->addOutputSocket(DataType::Value);
-  m_mask = nullptr;
-  m_maskWidth = 0;
-  m_maskHeight = 0;
-  m_maskWidthInv = 0.0f;
-  m_maskHeightInv = 0.0f;
-  m_frame_shutter = 0.0f;
-  m_frame_number = 0;
-  m_rasterMaskHandleTot = 1;
-  memset(m_rasterMaskHandles, 0, sizeof(m_rasterMaskHandles));
+  mask_ = nullptr;
+  maskWidth_ = 0;
+  maskHeight_ = 0;
+  maskWidthInv_ = 0.0f;
+  maskHeightInv_ = 0.0f;
+  frame_shutter_ = 0.0f;
+  frame_number_ = 0;
+  rasterMaskHandleTot_ = 1;
+  memset(rasterMaskHandles_, 0, sizeof(rasterMaskHandles_));
 }
 
 void MaskOperation::initExecution()
 {
-  if (m_mask && m_rasterMaskHandles[0] == nullptr) {
-    if (m_rasterMaskHandleTot == 1) {
-      m_rasterMaskHandles[0] = BKE_maskrasterize_handle_new();
+  if (mask_ && rasterMaskHandles_[0] == nullptr) {
+    if (rasterMaskHandleTot_ == 1) {
+      rasterMaskHandles_[0] = BKE_maskrasterize_handle_new();
 
       BKE_maskrasterize_handle_init(
-          m_rasterMaskHandles[0], m_mask, m_maskWidth, m_maskHeight, true, true, m_do_feather);
+          rasterMaskHandles_[0], mask_, maskWidth_, maskHeight_, true, true, do_feather_);
     }
     else {
       /* make a throw away copy of the mask */
-      const float frame = (float)m_frame_number - m_frame_shutter;
-      const float frame_step = (m_frame_shutter * 2.0f) / m_rasterMaskHandleTot;
+      const float frame = (float)frame_number_ - frame_shutter_;
+      const float frame_step = (frame_shutter_ * 2.0f) / rasterMaskHandleTot_;
       float frame_iter = frame;
 
       Mask *mask_temp = (Mask *)BKE_id_copy_ex(
-          nullptr, &m_mask->id, nullptr, LIB_ID_COPY_LOCALIZE | LIB_ID_COPY_NO_ANIMDATA);
+          nullptr, &mask_->id, nullptr, LIB_ID_COPY_LOCALIZE | LIB_ID_COPY_NO_ANIMDATA);
 
       /* trick so we can get unkeyed edits to display */
       {
@@ -62,24 +62,19 @@ void MaskOperation::initExecution()
 
         for (masklay = (MaskLayer *)mask_temp->masklayers.first; masklay;
              masklay = masklay->next) {
-          masklay_shape = BKE_mask_layer_shape_verify_frame(masklay, m_frame_number);
+          masklay_shape = BKE_mask_layer_shape_verify_frame(masklay, frame_number_);
           BKE_mask_layer_shape_from_mask(masklay, masklay_shape);
         }
       }
 
-      for (unsigned int i = 0; i < m_rasterMaskHandleTot; i++) {
-        m_rasterMaskHandles[i] = BKE_maskrasterize_handle_new();
+      for (unsigned int i = 0; i < rasterMaskHandleTot_; i++) {
+        rasterMaskHandles_[i] = BKE_maskrasterize_handle_new();
 
         /* re-eval frame info */
         BKE_mask_evaluate(mask_temp, frame_iter, true);
 
-        BKE_maskrasterize_handle_init(m_rasterMaskHandles[i],
-                                      mask_temp,
-                                      m_maskWidth,
-                                      m_maskHeight,
-                                      true,
-                                      true,
-                                      m_do_feather);
+        BKE_maskrasterize_handle_init(
+            rasterMaskHandles_[i], mask_temp, maskWidth_, maskHeight_, true, true, do_feather_);
 
         frame_iter += frame_step;
       }
@@ -91,23 +86,23 @@ void MaskOperation::initExecution()
 
 void MaskOperation::deinitExecution()
 {
-  for (unsigned int i = 0; i < m_rasterMaskHandleTot; i++) {
-    if (m_rasterMaskHandles[i]) {
-      BKE_maskrasterize_handle_free(m_rasterMaskHandles[i]);
-      m_rasterMaskHandles[i] = nullptr;
+  for (unsigned int i = 0; i < rasterMaskHandleTot_; i++) {
+    if (rasterMaskHandles_[i]) {
+      BKE_maskrasterize_handle_free(rasterMaskHandles_[i]);
+      rasterMaskHandles_[i] = nullptr;
     }
   }
 }
 
 void MaskOperation::determine_canvas(const rcti &preferred_area, rcti &r_area)
 {
-  if (m_maskWidth == 0 || m_maskHeight == 0) {
+  if (maskWidth_ == 0 || maskHeight_ == 0) {
     r_area = COM_AREA_NONE;
   }
   else {
     r_area = preferred_area;
-    r_area.xmax = r_area.xmin + m_maskWidth;
-    r_area.ymax = r_area.ymin + m_maskHeight;
+    r_area.xmax = r_area.xmin + maskWidth_;
+    r_area.ymax = r_area.ymin + maskHeight_;
   }
 }
 
@@ -117,13 +112,13 @@ void MaskOperation::executePixelSampled(float output[4],
                                         PixelSampler /*sampler*/)
 {
   const float xy[2] = {
-      (x * m_maskWidthInv) + m_mask_px_ofs[0],
-      (y * m_maskHeightInv) + m_mask_px_ofs[1],
+      (x * maskWidthInv_) + mask_px_ofs_[0],
+      (y * maskHeightInv_) + mask_px_ofs_[1],
   };
 
-  if (m_rasterMaskHandleTot == 1) {
-    if (m_rasterMaskHandles[0]) {
-      output[0] = BKE_maskrasterize_handle_sample(m_rasterMaskHandles[0], xy);
+  if (rasterMaskHandleTot_ == 1) {
+    if (rasterMaskHandles_[0]) {
+      output[0] = BKE_maskrasterize_handle_sample(rasterMaskHandles_[0], xy);
     }
     else {
       output[0] = 0.0f;
@@ -133,14 +128,14 @@ void MaskOperation::executePixelSampled(float output[4],
     /* In case loop below fails. */
     output[0] = 0.0f;
 
-    for (unsigned int i = 0; i < m_rasterMaskHandleTot; i++) {
-      if (m_rasterMaskHandles[i]) {
-        output[0] += BKE_maskrasterize_handle_sample(m_rasterMaskHandles[i], xy);
+    for (unsigned int i = 0; i < rasterMaskHandleTot_; i++) {
+      if (rasterMaskHandles_[i]) {
+        output[0] += BKE_maskrasterize_handle_sample(rasterMaskHandles_[i], xy);
       }
     }
 
     /* until we get better falloff */
-    output[0] /= m_rasterMaskHandleTot;
+    output[0] /= rasterMaskHandleTot_;
   }
 }
 
@@ -156,23 +151,23 @@ void MaskOperation::update_memory_buffer_partial(MemoryBuffer *output,
 
   float xy[2];
   for (BuffersIterator<float> it = output->iterate_with({}, area); !it.is_end(); ++it) {
-    xy[0] = it.x * m_maskWidthInv + m_mask_px_ofs[0];
-    xy[1] = it.y * m_maskHeightInv + m_mask_px_ofs[1];
+    xy[0] = it.x * maskWidthInv_ + mask_px_ofs_[0];
+    xy[1] = it.y * maskHeightInv_ + mask_px_ofs_[1];
     *it.out = 0.0f;
     for (MaskRasterHandle *handle : handles) {
       *it.out += BKE_maskrasterize_handle_sample(handle, xy);
     }
 
     /* Until we get better falloff. */
-    *it.out /= m_rasterMaskHandleTot;
+    *it.out /= rasterMaskHandleTot_;
   }
 }
 
 Vector<MaskRasterHandle *> MaskOperation::get_non_null_handles() const
 {
   Vector<MaskRasterHandle *> handles;
-  for (int i = 0; i < m_rasterMaskHandleTot; i++) {
-    MaskRasterHandle *handle = m_rasterMaskHandles[i];
+  for (int i = 0; i < rasterMaskHandleTot_; i++) {
+    MaskRasterHandle *handle = rasterMaskHandles_[i];
     if (handle == nullptr) {
       continue;
     }