1 files changed, 43 insertions, 44 deletions

diff --git a/source/blender/compositor/operations/COM_BilateralBlurOperation.cc b/source/blender/compositor/operations/COM_BilateralBlurOperation.cc
index 7368dcf0cad..5f7d2432f05 100644
--- a/source/blender/compositor/operations/COM_BilateralBlurOperation.cc
+++ b/source/blender/compositor/operations/COM_BilateralBlurOperation.cc
@@ -22,65 +22,65 @@ namespace blender::compositor {
 
 BilateralBlurOperation::BilateralBlurOperation()
 {
-  this->addInputSocket(DataType::Color);
-  this->addInputSocket(DataType::Color);
-  this->addOutputSocket(DataType::Color);
+  this->add_input_socket(DataType::Color);
+  this->add_input_socket(DataType::Color);
+  this->add_output_socket(DataType::Color);
   this->flags.complex = true;
 
-  inputColorProgram_ = nullptr;
-  inputDeterminatorProgram_ = nullptr;
+  input_color_program_ = nullptr;
+  input_determinator_program_ = nullptr;
 }
 
-void BilateralBlurOperation::initExecution()
+void BilateralBlurOperation::init_execution()
 {
-  inputColorProgram_ = getInputSocketReader(0);
-  inputDeterminatorProgram_ = getInputSocketReader(1);
-  QualityStepHelper::initExecution(COM_QH_INCREASE);
+  input_color_program_ = get_input_socket_reader(0);
+  input_determinator_program_ = get_input_socket_reader(1);
+  QualityStepHelper::init_execution(COM_QH_INCREASE);
 }
 
-void BilateralBlurOperation::executePixel(float output[4], int x, int y, void *data)
+void BilateralBlurOperation::execute_pixel(float output[4], int x, int y, void *data)
 {
   /* Read the determinator color at x, y,
    * this will be used as the reference color for the determinator. */
-  float determinatorReferenceColor[4];
+  float determinator_reference_color[4];
   float determinator[4];
-  float tempColor[4];
-  float blurColor[4];
-  float blurDivider;
+  float temp_color[4];
+  float blur_color[4];
+  float blur_divider;
   float space = space_;
   float sigmacolor = data_->sigma_color;
   int minx = floor(x - space);
   int maxx = ceil(x + space);
   int miny = floor(y - space);
   int maxy = ceil(y + space);
-  float deltaColor;
-  inputDeterminatorProgram_->read(determinatorReferenceColor, x, y, data);
+  float delta_color;
+  input_determinator_program_->read(determinator_reference_color, x, y, data);
 
-  zero_v4(blurColor);
-  blurDivider = 0.0f;
+  zero_v4(blur_color);
+  blur_divider = 0.0f;
   /* TODO(sergey): This isn't really good bilateral filter, it should be
    * using gaussian bell for weights. Also sigma_color doesn't seem to be
    * used correct at all.
    */
-  for (int yi = miny; yi < maxy; yi += QualityStepHelper::getStep()) {
-    for (int xi = minx; xi < maxx; xi += QualityStepHelper::getStep()) {
+  for (int yi = miny; yi < maxy; yi += QualityStepHelper::get_step()) {
+    for (int xi = minx; xi < maxx; xi += QualityStepHelper::get_step()) {
       /* Read determinator. */
-      inputDeterminatorProgram_->read(determinator, xi, yi, data);
-      deltaColor = (fabsf(determinatorReferenceColor[0] - determinator[0]) +
-                    fabsf(determinatorReferenceColor[1] - determinator[1]) +
-                    /* Do not take the alpha channel into account. */
-                    fabsf(determinatorReferenceColor[2] - determinator[2]));
-      if (deltaColor < sigmacolor) {
+      input_determinator_program_->read(determinator, xi, yi, data);
+      delta_color = (fabsf(determinator_reference_color[0] - determinator[0]) +
+                     fabsf(determinator_reference_color[1] - determinator[1]) +
+                     /* Do not take the alpha channel into account. */
+                     fabsf(determinator_reference_color[2] - determinator[2]));
+      if (delta_color < sigmacolor) {
         /* Add this to the blur. */
-        inputColorProgram_->read(tempColor, xi, yi, data);
-        add_v4_v4(blurColor, tempColor);
-        blurDivider += 1.0f;
+        input_color_program_->read(temp_color, xi, yi, data);
+        add_v4_v4(blur_color, temp_color);
+        blur_divider += 1.0f;
       }
     }
   }
 
-  if (blurDivider > 0.0f) {
-    mul_v4_v4fl(output, blurColor, 1.0f / blurDivider);
+  if (blur_divider > 0.0f) {
+    mul_v4_v4fl(output, blur_color, 1.0f / blur_divider);
   }
   else {
     output[0] = 0.0f;
@@ -90,25 +90,24 @@ void BilateralBlurOperation::executePixel(float output[4], int x, int y, void *d
   }
 }
 
-void BilateralBlurOperation::deinitExecution()
+void BilateralBlurOperation::deinit_execution()
 {
-  inputColorProgram_ = nullptr;
-  inputDeterminatorProgram_ = nullptr;
+  input_color_program_ = nullptr;
+  input_determinator_program_ = nullptr;
 }
 
-bool BilateralBlurOperation::determineDependingAreaOfInterest(rcti *input,
-                                                              ReadBufferOperation *readOperation,
-                                                              rcti *output)
+bool BilateralBlurOperation::determine_depending_area_of_interest(
+    rcti *input, ReadBufferOperation *read_operation, rcti *output)
 {
-  rcti newInput;
+  rcti new_input;
   int add = ceil(space_) + 1;
 
-  newInput.xmax = input->xmax + (add);
-  newInput.xmin = input->xmin - (add);
-  newInput.ymax = input->ymax + (add);
-  newInput.ymin = input->ymin - (add);
+  new_input.xmax = input->xmax + (add);
+  new_input.xmin = input->xmin - (add);
+  new_input.ymax = input->ymax + (add);
+  new_input.ymin = input->ymin - (add);
 
-  return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output);
+  return NodeOperation::determine_depending_area_of_interest(&new_input, read_operation, output);
 }
 
 void BilateralBlurOperation::get_area_of_interest(const int UNUSED(input_idx),
@@ -173,7 +172,7 @@ void BilateralBlurOperation::update_memory_buffer_partial(MemoryBuffer *output,
                                                           Span<MemoryBuffer *> inputs)
 {
   PixelCursor p = {};
-  p.step = QualityStepHelper::getStep();
+  p.step = QualityStepHelper::get_step();
   p.sigma_color = data_->sigma_color;
   p.input_color = inputs[0];
   p.input_determinator = inputs[1];