1 files changed, 49 insertions, 50 deletions

diff --git a/source/blender/compositor/operations/COM_MultilayerImageOperation.cc b/source/blender/compositor/operations/COM_MultilayerImageOperation.cc
index 3a5de944a00..5549cd1e937 100644
--- a/source/blender/compositor/operations/COM_MultilayerImageOperation.cc
+++ b/source/blender/compositor/operations/COM_MultilayerImageOperation.cc
@@ -19,7 +19,6 @@
 #include "COM_MultilayerImageOperation.h"
 
 #include "IMB_imbuf.h"
-#include "IMB_imbuf_types.h"
 
 namespace blender::compositor {
 
@@ -27,27 +26,27 @@ MultilayerBaseOperation::MultilayerBaseOperation(RenderLayer *render_layer,
                                                  RenderPass *render_pass,
                                                  int view)
 {
-  this->m_passId = BLI_findindex(&render_layer->passes, render_pass);
-  this->m_view = view;
-  this->m_renderLayer = render_layer;
-  this->m_renderPass = render_pass;
+  pass_id_ = BLI_findindex(&render_layer->passes, render_pass);
+  view_ = view;
+  render_layer_ = render_layer;
+  render_pass_ = render_pass;
 }
 
-ImBuf *MultilayerBaseOperation::getImBuf()
+ImBuf *MultilayerBaseOperation::get_im_buf()
 {
   /* temporarily changes the view to get the right ImBuf */
-  int view = this->m_imageUser->view;
+  int view = image_user_->view;
 
-  this->m_imageUser->view = this->m_view;
-  this->m_imageUser->pass = this->m_passId;
+  image_user_->view = view_;
+  image_user_->pass = pass_id_;
 
-  if (BKE_image_multilayer_index(this->m_image->rr, this->m_imageUser)) {
-    ImBuf *ibuf = BaseImageOperation::getImBuf();
-    this->m_imageUser->view = view;
+  if (BKE_image_multilayer_index(image_->rr, image_user_)) {
+    ImBuf *ibuf = BaseImageOperation::get_im_buf();
+    image_user_->view = view;
     return ibuf;
   }
 
-  this->m_imageUser->view = view;
+  image_user_->view = view;
   return nullptr;
 }
 
@@ -55,17 +54,17 @@ void MultilayerBaseOperation::update_memory_buffer_partial(MemoryBuffer *output,
                                                            const rcti &area,
                                                            Span<MemoryBuffer *> UNUSED(inputs))
 {
-  output->copy_from(m_buffer, area);
+  output->copy_from(buffer_, area);
 }
 
-std::unique_ptr<MetaData> MultilayerColorOperation::getMetaData()
+std::unique_ptr<MetaData> MultilayerColorOperation::get_meta_data()
 {
-  BLI_assert(this->m_buffer);
+  BLI_assert(buffer_);
   MetaDataExtractCallbackData callback_data = {nullptr};
-  RenderResult *render_result = this->m_image->rr;
+  RenderResult *render_result = image_->rr;
   if (render_result && render_result->stamp_data) {
-    RenderLayer *render_layer = this->m_renderLayer;
-    RenderPass *render_pass = this->m_renderPass;
+    RenderLayer *render_layer = render_layer_;
+    RenderPass *render_pass = render_pass_;
     std::string full_layer_name =
         std::string(render_layer->name,
                     BLI_strnlen(render_layer->name, sizeof(render_layer->name))) +
@@ -73,7 +72,7 @@ std::unique_ptr<MetaData> MultilayerColorOperation::getMetaData()
         std::string(render_pass->name, BLI_strnlen(render_pass->name, sizeof(render_pass->name)));
     blender::StringRef cryptomatte_layer_name =
         blender::bke::cryptomatte::BKE_cryptomatte_extract_layer_name(full_layer_name);
-    callback_data.setCryptomatteKeys(cryptomatte_layer_name);
+    callback_data.set_cryptomatte_keys(cryptomatte_layer_name);
 
     BKE_stamp_info_callback(&callback_data,
                             render_result->stamp_data,
@@ -84,83 +83,83 @@ std::unique_ptr<MetaData> MultilayerColorOperation::getMetaData()
   return std::move(callback_data.meta_data);
 }
 
-void MultilayerColorOperation::executePixelSampled(float output[4],
-                                                   float x,
-                                                   float y,
-                                                   PixelSampler sampler)
+void MultilayerColorOperation::execute_pixel_sampled(float output[4],
+                                                     float x,
+                                                     float y,
+                                                     PixelSampler sampler)
 {
-  if (this->m_imageFloatBuffer == nullptr) {
+  if (image_float_buffer_ == nullptr) {
     zero_v4(output);
   }
   else {
-    if (this->m_numberOfChannels == 4) {
+    if (number_of_channels_ == 4) {
       switch (sampler) {
         case PixelSampler::Nearest:
-          nearest_interpolation_color(this->m_buffer, nullptr, output, x, y);
+          nearest_interpolation_color(buffer_, nullptr, output, x, y);
           break;
         case PixelSampler::Bilinear:
-          bilinear_interpolation_color(this->m_buffer, nullptr, output, x, y);
+          bilinear_interpolation_color(buffer_, nullptr, output, x, y);
           break;
         case PixelSampler::Bicubic:
-          bicubic_interpolation_color(this->m_buffer, nullptr, output, x, y);
+          bicubic_interpolation_color(buffer_, nullptr, output, x, y);
           break;
       }
     }
     else {
       int yi = y;
       int xi = x;
-      if (xi < 0 || yi < 0 || (unsigned int)xi >= this->getWidth() ||
-          (unsigned int)yi >= this->getHeight()) {
+      if (xi < 0 || yi < 0 || (unsigned int)xi >= this->get_width() ||
+          (unsigned int)yi >= this->get_height()) {
         zero_v4(output);
       }
       else {
-        int offset = (yi * this->getWidth() + xi) * 3;
-        copy_v3_v3(output, &this->m_imageFloatBuffer[offset]);
+        int offset = (yi * this->get_width() + xi) * 3;
+        copy_v3_v3(output, &image_float_buffer_[offset]);
       }
     }
   }
 }
 
-void MultilayerValueOperation::executePixelSampled(float output[4],
-                                                   float x,
-                                                   float y,
-                                                   PixelSampler /*sampler*/)
+void MultilayerValueOperation::execute_pixel_sampled(float output[4],
+                                                     float x,
+                                                     float y,
+                                                     PixelSampler /*sampler*/)
 {
-  if (this->m_imageFloatBuffer == nullptr) {
+  if (image_float_buffer_ == nullptr) {
     output[0] = 0.0f;
   }
   else {
     int yi = y;
     int xi = x;
-    if (xi < 0 || yi < 0 || (unsigned int)xi >= this->getWidth() ||
-        (unsigned int)yi >= this->getHeight()) {
+    if (xi < 0 || yi < 0 || (unsigned int)xi >= this->get_width() ||
+        (unsigned int)yi >= this->get_height()) {
       output[0] = 0.0f;
     }
     else {
-      float result = this->m_imageFloatBuffer[yi * this->getWidth() + xi];
+      float result = image_float_buffer_[yi * this->get_width() + xi];
       output[0] = result;
     }
   }
 }
 
-void MultilayerVectorOperation::executePixelSampled(float output[4],
-                                                    float x,
-                                                    float y,
-                                                    PixelSampler /*sampler*/)
+void MultilayerVectorOperation::execute_pixel_sampled(float output[4],
+                                                      float x,
+                                                      float y,
+                                                      PixelSampler /*sampler*/)
 {
-  if (this->m_imageFloatBuffer == nullptr) {
+  if (image_float_buffer_ == nullptr) {
     output[0] = 0.0f;
   }
   else {
     int yi = y;
     int xi = x;
-    if (xi < 0 || yi < 0 || (unsigned int)xi >= this->getWidth() ||
-        (unsigned int)yi >= this->getHeight()) {
+    if (xi < 0 || yi < 0 || (unsigned int)xi >= this->get_width() ||
+        (unsigned int)yi >= this->get_height()) {
       output[0] = 0.0f;
     }
     else {
-      int offset = (yi * this->getWidth() + xi) * 3;
-      copy_v3_v3(output, &this->m_imageFloatBuffer[offset]);
+      int offset = (yi * this->get_width() + xi) * 3;
+      copy_v3_v3(output, &image_float_buffer_[offset]);
     }
   }
 }