1 files changed, 40 insertions, 40 deletions

diff --git a/source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.cc b/source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.cc
index fcd9d26c3f0..a781b3ea1ed 100644
--- a/source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.cc
+++ b/source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.cc
@@ -24,65 +24,65 @@ namespace blender::compositor {
 
 ConvertDepthToRadiusOperation::ConvertDepthToRadiusOperation()
 {
-  this->addInputSocket(DataType::Value);
-  this->addOutputSocket(DataType::Value);
-  inputOperation_ = nullptr;
-  fStop_ = 128.0f;
-  cameraObject_ = nullptr;
-  maxRadius_ = 32.0f;
-  blurPostOperation_ = nullptr;
+  this->add_input_socket(DataType::Value);
+  this->add_output_socket(DataType::Value);
+  input_operation_ = nullptr;
+  f_stop_ = 128.0f;
+  camera_object_ = nullptr;
+  max_radius_ = 32.0f;
+  blur_post_operation_ = nullptr;
 }
 
-float ConvertDepthToRadiusOperation::determineFocalDistance()
+float ConvertDepthToRadiusOperation::determine_focal_distance()
 {
-  if (cameraObject_ && cameraObject_->type == OB_CAMERA) {
-    Camera *camera = (Camera *)cameraObject_->data;
+  if (camera_object_ && camera_object_->type == OB_CAMERA) {
+    Camera *camera = (Camera *)camera_object_->data;
     cam_lens_ = camera->lens;
-    return BKE_camera_object_dof_distance(cameraObject_);
+    return BKE_camera_object_dof_distance(camera_object_);
   }
 
   return 10.0f;
 }
 
-void ConvertDepthToRadiusOperation::initExecution()
+void ConvertDepthToRadiusOperation::init_execution()
 {
   float cam_sensor = DEFAULT_SENSOR_WIDTH;
   Camera *camera = nullptr;
 
-  if (cameraObject_ && cameraObject_->type == OB_CAMERA) {
-    camera = (Camera *)cameraObject_->data;
+  if (camera_object_ && camera_object_->type == OB_CAMERA) {
+    camera = (Camera *)camera_object_->data;
     cam_sensor = BKE_camera_sensor_size(camera->sensor_fit, camera->sensor_x, camera->sensor_y);
   }
 
-  inputOperation_ = this->getInputSocketReader(0);
-  float focalDistance = determineFocalDistance();
-  if (focalDistance == 0.0f) {
-    focalDistance = 1e10f; /* If the DOF is 0.0 then set it to be far away. */
+  input_operation_ = this->get_input_socket_reader(0);
+  float focal_distance = determine_focal_distance();
+  if (focal_distance == 0.0f) {
+    focal_distance = 1e10f; /* If the DOF is 0.0 then set it to be far away. */
   }
-  inverseFocalDistance_ = 1.0f / focalDistance;
-  aspect_ = (this->getWidth() > this->getHeight()) ?
-                (this->getHeight() / (float)this->getWidth()) :
-                (this->getWidth() / (float)this->getHeight());
-  aperture_ = 0.5f * (cam_lens_ / (aspect_ * cam_sensor)) / fStop_;
-  const float minsz = MIN2(getWidth(), getHeight());
+  inverse_focal_distance_ = 1.0f / focal_distance;
+  aspect_ = (this->get_width() > this->get_height()) ?
+                (this->get_height() / (float)this->get_width()) :
+                (this->get_width() / (float)this->get_height());
+  aperture_ = 0.5f * (cam_lens_ / (aspect_ * cam_sensor)) / f_stop_;
+  const float minsz = MIN2(get_width(), get_height());
   dof_sp_ = minsz / ((cam_sensor / 2.0f) /
                      cam_lens_); /* <- == `aspect * MIN2(img->x, img->y) / tan(0.5f * fov)` */
 
-  if (blurPostOperation_) {
-    blurPostOperation_->setSigma(MIN2(aperture_ * 128.0f, maxRadius_));
+  if (blur_post_operation_) {
+    blur_post_operation_->set_sigma(MIN2(aperture_ * 128.0f, max_radius_));
   }
 }
 
-void ConvertDepthToRadiusOperation::executePixelSampled(float output[4],
-                                                        float x,
-                                                        float y,
-                                                        PixelSampler sampler)
+void ConvertDepthToRadiusOperation::execute_pixel_sampled(float output[4],
+                                                          float x,
+                                                          float y,
+                                                          PixelSampler sampler)
 {
-  float inputValue[4];
+  float input_value[4];
   float z;
   float radius;
-  inputOperation_->readSampled(inputValue, x, y, sampler);
-  z = inputValue[0];
+  input_operation_->read_sampled(input_value, x, y, sampler);
+  z = input_value[0];
   if (z != 0.0f) {
     float iZ = (1.0f / z);
 
@@ -92,14 +92,14 @@ void ConvertDepthToRadiusOperation::executePixelSampled(float output[4],
     /* Scale crad back to original maximum and blend. */
     crad->rect[px] = bcrad + wts->rect[px] * (scf * crad->rect[px] - bcrad);
 #endif
-    radius = 0.5f * fabsf(aperture_ * (dof_sp_ * (inverseFocalDistance_ - iZ) - 1.0f));
+    radius = 0.5f * fabsf(aperture_ * (dof_sp_ * (inverse_focal_distance_ - iZ) - 1.0f));
     /* 'bug' T6615, limit minimum radius to 1 pixel,
      * not really a solution, but somewhat mitigates the problem. */
     if (radius < 0.0f) {
       radius = 0.0f;
     }
-    if (radius > maxRadius_) {
-      radius = maxRadius_;
+    if (radius > max_radius_) {
+      radius = max_radius_;
     }
     output[0] = radius;
   }
@@ -108,9 +108,9 @@ void ConvertDepthToRadiusOperation::executePixelSampled(float output[4],
   }
 }
 
-void ConvertDepthToRadiusOperation::deinitExecution()
+void ConvertDepthToRadiusOperation::deinit_execution()
 {
-  inputOperation_ = nullptr;
+  input_operation_ = nullptr;
 }
 
 void ConvertDepthToRadiusOperation::update_memory_buffer_partial(MemoryBuffer *output,
@@ -133,10 +133,10 @@ void ConvertDepthToRadiusOperation::update_memory_buffer_partial(MemoryBuffer *o
      * `crad->rect[px] = bcrad + wts->rect[px] * (scf * crad->rect[px] - bcrad);` */
 #endif
     const float radius = 0.5f *
-                         fabsf(aperture_ * (dof_sp_ * (inverseFocalDistance_ - inv_z) - 1.0f));
+                         fabsf(aperture_ * (dof_sp_ * (inverse_focal_distance_ - inv_z) - 1.0f));
     /* Bug T6615, limit minimum radius to 1 pixel,
      * not really a solution, but somewhat mitigates the problem. */
-    *it.out = CLAMPIS(radius, 0.0f, maxRadius_);
+    *it.out = CLAMPIS(radius, 0.0f, max_radius_);
   }
 }