1 files changed, 24 insertions, 24 deletions

diff --git a/source/blender/compositor/operations/COM_ProjectorLensDistortionOperation.cc b/source/blender/compositor/operations/COM_ProjectorLensDistortionOperation.cc
index d2d5581deb2..8e6aa7e8db8 100644
--- a/source/blender/compositor/operations/COM_ProjectorLensDistortionOperation.cc
+++ b/source/blender/compositor/operations/COM_ProjectorLensDistortionOperation.cc
@@ -27,9 +27,9 @@ ProjectorLensDistortionOperation::ProjectorLensDistortionOperation()
   this->addInputSocket(DataType::Value);
   this->addOutputSocket(DataType::Color);
   this->flags.complex = true;
-  m_inputProgram = nullptr;
-  m_dispersionAvailable = false;
-  m_dispersion = 0.0f;
+  inputProgram_ = nullptr;
+  dispersionAvailable_ = false;
+  dispersion_ = 0.0f;
 }
 
 void ProjectorLensDistortionOperation::init_data()
@@ -37,23 +37,23 @@ void ProjectorLensDistortionOperation::init_data()
   if (execution_model_ == eExecutionModel::FullFrame) {
     NodeOperation *dispersion_input = get_input_operation(1);
     if (dispersion_input->get_flags().is_constant_operation) {
-      m_dispersion = static_cast<ConstantOperation *>(dispersion_input)->get_constant_elem()[0];
+      dispersion_ = static_cast<ConstantOperation *>(dispersion_input)->get_constant_elem()[0];
     }
-    m_kr = 0.25f * max_ff(min_ff(m_dispersion, 1.0f), 0.0f);
-    m_kr2 = m_kr * 20;
+    kr_ = 0.25f * max_ff(min_ff(dispersion_, 1.0f), 0.0f);
+    kr2_ = kr_ * 20;
   }
 }
 
 void ProjectorLensDistortionOperation::initExecution()
 {
   this->initMutex();
-  m_inputProgram = this->getInputSocketReader(0);
+  inputProgram_ = this->getInputSocketReader(0);
 }
 
 void *ProjectorLensDistortionOperation::initializeTileData(rcti * /*rect*/)
 {
   updateDispersion();
-  void *buffer = m_inputProgram->initializeTileData(nullptr);
+  void *buffer = inputProgram_->initializeTileData(nullptr);
   return buffer;
 }
 
@@ -65,11 +65,11 @@ void ProjectorLensDistortionOperation::executePixel(float output[4], int x, int
   const float v = (y + 0.5f) / height;
   const float u = (x + 0.5f) / width;
   MemoryBuffer *inputBuffer = (MemoryBuffer *)data;
-  inputBuffer->readBilinear(inputValue, (u * width + m_kr2) - 0.5f, v * height - 0.5f);
+  inputBuffer->readBilinear(inputValue, (u * width + kr2_) - 0.5f, v * height - 0.5f);
   output[0] = inputValue[0];
   inputBuffer->read(inputValue, x, y);
   output[1] = inputValue[1];
-  inputBuffer->readBilinear(inputValue, (u * width - m_kr2) - 0.5f, v * height - 0.5f);
+  inputBuffer->readBilinear(inputValue, (u * width - kr2_) - 0.5f, v * height - 0.5f);
   output[2] = inputValue[2];
   output[3] = 1.0f;
 }
@@ -77,18 +77,18 @@ void ProjectorLensDistortionOperation::executePixel(float output[4], int x, int
 void ProjectorLensDistortionOperation::deinitExecution()
 {
   this->deinitMutex();
-  m_inputProgram = nullptr;
+  inputProgram_ = nullptr;
 }
 
 bool ProjectorLensDistortionOperation::determineDependingAreaOfInterest(
     rcti *input, ReadBufferOperation *readOperation, rcti *output)
 {
   rcti newInput;
-  if (m_dispersionAvailable) {
+  if (dispersionAvailable_) {
     newInput.ymax = input->ymax;
     newInput.ymin = input->ymin;
-    newInput.xmin = input->xmin - m_kr2 - 2;
-    newInput.xmax = input->xmax + m_kr2 + 2;
+    newInput.xmin = input->xmin - kr2_ - 2;
+    newInput.xmax = input->xmax + kr2_ + 2;
   }
   else {
     rcti dispInput;
@@ -112,17 +112,17 @@ bool ProjectorLensDistortionOperation::determineDependingAreaOfInterest(
 /* TODO(manzanilla): to be removed with tiled implementation. */
 void ProjectorLensDistortionOperation::updateDispersion()
 {
-  if (m_dispersionAvailable) {
+  if (dispersionAvailable_) {
     return;
   }
   this->lockMutex();
-  if (!m_dispersionAvailable) {
+  if (!dispersionAvailable_) {
     float result[4];
     this->getInputSocketReader(1)->readSampled(result, 1, 1, PixelSampler::Nearest);
-    m_dispersion = result[0];
-    m_kr = 0.25f * max_ff(min_ff(m_dispersion, 1.0f), 0.0f);
-    m_kr2 = m_kr * 20;
-    m_dispersionAvailable = true;
+    dispersion_ = result[0];
+    kr_ = 0.25f * max_ff(min_ff(dispersion_, 1.0f), 0.0f);
+    kr2_ = kr_ * 20;
+    dispersionAvailable_ = true;
   }
   this->unlockMutex();
 }
@@ -156,8 +156,8 @@ void ProjectorLensDistortionOperation::get_area_of_interest(const int input_idx,
 
   r_input_area.ymax = output_area.ymax;
   r_input_area.ymin = output_area.ymin;
-  r_input_area.xmin = output_area.xmin - m_kr2 - 2;
-  r_input_area.xmax = output_area.xmax + m_kr2 + 2;
+  r_input_area.xmin = output_area.xmin - kr2_ - 2;
+  r_input_area.xmax = output_area.xmax + kr2_ + 2;
 }
 
 void ProjectorLensDistortionOperation::update_memory_buffer_partial(MemoryBuffer *output,
@@ -171,11 +171,11 @@ void ProjectorLensDistortionOperation::update_memory_buffer_partial(MemoryBuffer
   for (BuffersIterator<float> it = output->iterate_with({}, area); !it.is_end(); ++it) {
     const float v = (it.y + 0.5f) / height;
     const float u = (it.x + 0.5f) / width;
-    input_image->read_elem_bilinear((u * width + m_kr2) - 0.5f, v * height - 0.5f, color);
+    input_image->read_elem_bilinear((u * width + kr2_) - 0.5f, v * height - 0.5f, color);
     it.out[0] = color[0];
     input_image->read_elem(it.x, it.y, color);
     it.out[1] = color[1];
-    input_image->read_elem_bilinear((u * width - m_kr2) - 0.5f, v * height - 0.5f, color);
+    input_image->read_elem_bilinear((u * width - kr2_) - 0.5f, v * height - 0.5f, color);
     it.out[2] = color[2];
     it.out[3] = 1.0f;
   }