Cleanup: use snake case.

2 files changed, 60 insertions, 61 deletions

diff --git a/source/blender/compositor/intern/COM_ExecutionGroup.cpp b/source/blender/compositor/intern/COM_ExecutionGroup.cpp
index 1286a07c4d0..37623228183 100644
--- a/source/blender/compositor/intern/COM_ExecutionGroup.cpp
+++ b/source/blender/compositor/intern/COM_ExecutionGroup.cpp
@@ -43,19 +43,19 @@
 
 ExecutionGroup::ExecutionGroup()
 {
-  this->m_isOutput = false;
+  this->m_is_output = false;
   this->m_complex = false;
   this->m_bTree = nullptr;
   this->m_height = 0;
   this->m_width = 0;
   this->m_max_read_buffer_offset = 0;
-  this->m_numberOfXChunks = 0;
-  this->m_numberOfYChunks = 0;
-  this->m_numberOfChunks = 0;
+  this->m_x_chunks_len = 0;
+  this->m_y_chunks_len = 0;
+  this->m_chunks_len = 0;
   this->m_initialized = false;
   this->m_openCL = false;
   this->m_singleThreaded = false;
-  this->m_chunksFinished = 0;
+  this->m_chunks_finished = 0;
   BLI_rcti_init(&this->m_viewerBorder, 0, 0, 0, 0);
   this->m_executionStartTime = 0;
 }
@@ -123,9 +123,9 @@ void ExecutionGroup::initExecution()
   m_chunk_execution_states.clear();
   determineNumberOfChunks();
 
-  if (this->m_numberOfChunks != 0) {
-    m_chunk_execution_states.resize(this->m_numberOfChunks);
-    for (int index = 0; index < this->m_numberOfChunks; index++) {
+  if (this->m_chunks_len != 0) {
+    m_chunk_execution_states.resize(this->m_chunks_len);
+    for (int index = 0; index < this->m_chunks_len; index++) {
       m_chunk_execution_states[index] = eChunkExecutionState::NOT_SCHEDULED;
     }
   }
@@ -146,9 +146,9 @@ void ExecutionGroup::initExecution()
 void ExecutionGroup::deinitExecution()
 {
   m_chunk_execution_states.clear();
-  this->m_numberOfChunks = 0;
-  this->m_numberOfXChunks = 0;
-  this->m_numberOfYChunks = 0;
+  this->m_chunks_len = 0;
+  this->m_x_chunks_len = 0;
+  this->m_y_chunks_len = 0;
   this->m_read_operations.clear();
   this->m_bTree = nullptr;
 }
@@ -164,17 +164,17 @@ void ExecutionGroup::determineResolution(unsigned int resolution[2])
 void ExecutionGroup::determineNumberOfChunks()
 {
   if (this->m_singleThreaded) {
-    this->m_numberOfXChunks = 1;
-    this->m_numberOfYChunks = 1;
-    this->m_numberOfChunks = 1;
+    this->m_x_chunks_len = 1;
+    this->m_y_chunks_len = 1;
+    this->m_chunks_len = 1;
   }
   else {
     const float chunkSizef = this->m_chunkSize;
     const int border_width = BLI_rcti_size_x(&this->m_viewerBorder);
     const int border_height = BLI_rcti_size_y(&this->m_viewerBorder);
-    this->m_numberOfXChunks = ceil(border_width / chunkSizef);
-    this->m_numberOfYChunks = ceil(border_height / chunkSizef);
-    this->m_numberOfChunks = this->m_numberOfXChunks * this->m_numberOfYChunks;
+    this->m_x_chunks_len = ceil(border_width / chunkSizef);
+    this->m_y_chunks_len = ceil(border_height / chunkSizef);
+    this->m_chunks_len = this->m_x_chunks_len * this->m_y_chunks_len;
   }
 }
 
@@ -192,20 +192,20 @@ void ExecutionGroup::execute(ExecutionSystem *graph)
   if (bTree->test_break && bTree->test_break(bTree->tbh)) {
     return;
   } /** \note Early break out for blur and preview nodes. */
-  if (this->m_numberOfChunks == 0) {
+  if (this->m_chunks_len == 0) {
     return;
   } /** \note Early break out. */
   unsigned int chunkNumber;
 
   this->m_executionStartTime = PIL_check_seconds_timer();
 
-  this->m_chunksFinished = 0;
+  this->m_chunks_finished = 0;
   this->m_bTree = bTree;
   unsigned int index;
-  unsigned int *chunkOrder = (unsigned int *)MEM_mallocN(
-      sizeof(unsigned int) * this->m_numberOfChunks, __func__);
+  unsigned int *chunkOrder = (unsigned int *)MEM_mallocN(sizeof(unsigned int) * this->m_chunks_len,
+                                                         __func__);
 
-  for (chunkNumber = 0; chunkNumber < this->m_numberOfChunks; chunkNumber++) {
+  for (chunkNumber = 0; chunkNumber < this->m_chunks_len; chunkNumber++) {
     chunkOrder[chunkNumber] = chunkNumber;
   }
   NodeOperation *operation = this->getOutputOperation();
@@ -225,9 +225,9 @@ void ExecutionGroup::execute(ExecutionSystem *graph)
 
   switch (chunkorder) {
     case COM_TO_RANDOM:
-      for (index = 0; index < 2 * this->m_numberOfChunks; index++) {
-        int index1 = rand() % this->m_numberOfChunks;
-        int index2 = rand() % this->m_numberOfChunks;
+      for (index = 0; index < 2 * this->m_chunks_len; index++) {
+        int index1 = rand() % this->m_chunks_len;
+        int index2 = rand() % this->m_chunks_len;
         int s = chunkOrder[index1];
         chunkOrder[index1] = chunkOrder[index2];
         chunkOrder[index2] = s;
@@ -237,9 +237,9 @@ void ExecutionGroup::execute(ExecutionSystem *graph)
       ChunkOrderHotspot *hotspots[1];
       hotspots[0] = new ChunkOrderHotspot(border_width * centerX, border_height * centerY, 0.0f);
       rcti rect;
-      ChunkOrder *chunkOrders = (ChunkOrder *)MEM_mallocN(
-          sizeof(ChunkOrder) * this->m_numberOfChunks, __func__);
-      for (index = 0; index < this->m_numberOfChunks; index++) {
+      ChunkOrder *chunkOrders = (ChunkOrder *)MEM_mallocN(sizeof(ChunkOrder) * this->m_chunks_len,
+                                                          __func__);
+      for (index = 0; index < this->m_chunks_len; index++) {
         determineChunkRect(&rect, index);
         chunkOrders[index].number = index;
         chunkOrders[index].x = rect.xmin - this->m_viewerBorder.xmin;
@@ -247,8 +247,8 @@ void ExecutionGroup::execute(ExecutionSystem *graph)
         chunkOrders[index].update_distance(hotspots, 1);
       }
 
-      std::sort(&chunkOrders[0], &chunkOrders[this->m_numberOfChunks - 1]);
-      for (index = 0; index < this->m_numberOfChunks; index++) {
+      std::sort(&chunkOrders[0], &chunkOrders[this->m_chunks_len - 1]);
+      for (index = 0; index < this->m_chunks_len; index++) {
         chunkOrder[index] = chunkOrders[index].number;
       }
 
@@ -265,7 +265,7 @@ void ExecutionGroup::execute(ExecutionSystem *graph)
       unsigned int bx = mx + 2 * tx;
       unsigned int by = my + 2 * ty;
 
-      float addition = this->m_numberOfChunks / COM_RULE_OF_THIRDS_DIVIDER;
+      float addition = this->m_chunks_len / COM_RULE_OF_THIRDS_DIVIDER;
       hotspots[0] = new ChunkOrderHotspot(mx, my, addition * 0);
       hotspots[1] = new ChunkOrderHotspot(tx, my, addition * 1);
       hotspots[2] = new ChunkOrderHotspot(bx, my, addition * 2);
@@ -276,9 +276,9 @@ void ExecutionGroup::execute(ExecutionSystem *graph)
       hotspots[7] = new ChunkOrderHotspot(mx, ty, addition * 7);
       hotspots[8] = new ChunkOrderHotspot(mx, by, addition * 8);
       rcti rect;
-      ChunkOrder *chunkOrders = (ChunkOrder *)MEM_mallocN(
-          sizeof(ChunkOrder) * this->m_numberOfChunks, __func__);
-      for (index = 0; index < this->m_numberOfChunks; index++) {
+      ChunkOrder *chunkOrders = (ChunkOrder *)MEM_mallocN(sizeof(ChunkOrder) * this->m_chunks_len,
+                                                          __func__);
+      for (index = 0; index < this->m_chunks_len; index++) {
         determineChunkRect(&rect, index);
         chunkOrders[index].number = index;
         chunkOrders[index].x = rect.xmin - this->m_viewerBorder.xmin;
@@ -286,9 +286,9 @@ void ExecutionGroup::execute(ExecutionSystem *graph)
         chunkOrders[index].update_distance(hotspots, 9);
       }
 
-      std::sort(&chunkOrders[0], &chunkOrders[this->m_numberOfChunks]);
+      std::sort(&chunkOrders[0], &chunkOrders[this->m_chunks_len]);
 
-      for (index = 0; index < this->m_numberOfChunks; index++) {
+      for (index = 0; index < this->m_chunks_len; index++) {
         chunkOrder[index] = chunkOrders[index].number;
       }
 
@@ -322,12 +322,11 @@ void ExecutionGroup::execute(ExecutionSystem *graph)
     finished = true;
     int numberEvaluated = 0;
 
-    for (index = startIndex;
-         index < this->m_numberOfChunks && numberEvaluated < maxNumberEvaluated;
+    for (index = startIndex; index < this->m_chunks_len && numberEvaluated < maxNumberEvaluated;
          index++) {
       chunkNumber = chunkOrder[index];
-      int yChunk = chunkNumber / this->m_numberOfXChunks;
-      int xChunk = chunkNumber - (yChunk * this->m_numberOfXChunks);
+      int yChunk = chunkNumber / this->m_x_chunks_len;
+      int xChunk = chunkNumber - (yChunk * this->m_x_chunks_len);
       switch (m_chunk_execution_states[chunkNumber]) {
         case eChunkExecutionState::NOT_SCHEDULED: {
           scheduleChunkWhenPossible(graph, xChunk, yChunk);
@@ -401,7 +400,7 @@ void ExecutionGroup::finalizeChunkExecution(int chunkNumber, MemoryBuffer **memo
     this->m_chunk_execution_states[chunkNumber] = eChunkExecutionState::EXECUTED;
   }
 
-  atomic_add_and_fetch_u(&this->m_chunksFinished, 1);
+  atomic_add_and_fetch_u(&this->m_chunks_finished, 1);
   if (memoryBuffers) {
     for (unsigned int index = 0; index < this->m_max_read_buffer_offset; index++) {
       MemoryBuffer *buffer = memoryBuffers[index];
@@ -416,16 +415,16 @@ void ExecutionGroup::finalizeChunkExecution(int chunkNumber, MemoryBuffer **memo
   }
   if (this->m_bTree) {
     // status report is only performed for top level Execution Groups.
-    float progress = this->m_chunksFinished;
-    progress /= this->m_numberOfChunks;
+    float progress = this->m_chunks_finished;
+    progress /= this->m_chunks_len;
     this->m_bTree->progress(this->m_bTree->prh, progress);
 
     char buf[128];
     BLI_snprintf(buf,
                  sizeof(buf),
                  TIP_("Compositing | Tile %u-%u"),
-                 this->m_chunksFinished,
-                 this->m_numberOfChunks);
+                 this->m_chunks_finished,
+                 this->m_chunks_len);
     this->m_bTree->stats_draw(this->m_bTree->sdh, buf);
   }
 }
@@ -456,8 +455,8 @@ inline void ExecutionGroup::determineChunkRect(rcti *rect,
 
 void ExecutionGroup::determineChunkRect(rcti *rect, const unsigned int chunkNumber) const
 {
-  const unsigned int yChunk = chunkNumber / this->m_numberOfXChunks;
-  const unsigned int xChunk = chunkNumber - (yChunk * this->m_numberOfXChunks);
+  const unsigned int yChunk = chunkNumber / this->m_x_chunks_len;
+  const unsigned int xChunk = chunkNumber - (yChunk * this->m_x_chunks_len);
   determineChunkRect(rect, xChunk, yChunk);
 }
 
@@ -492,8 +491,8 @@ bool ExecutionGroup::scheduleAreaWhenPossible(ExecutionSystem *graph, rcti *area
   int maxychunk = (maxy + (int)m_chunkSize - 1) / (int)m_chunkSize;
   minxchunk = max_ii(minxchunk, 0);
   minychunk = max_ii(minychunk, 0);
-  maxxchunk = min_ii(maxxchunk, (int)m_numberOfXChunks);
-  maxychunk = min_ii(maxychunk, (int)m_numberOfYChunks);
+  maxxchunk = min_ii(maxxchunk, (int)m_x_chunks_len);
+  maxychunk = min_ii(maxychunk, (int)m_y_chunks_len);
 
   bool result = true;
   for (indexx = minxchunk; indexx < maxxchunk; indexx++) {
@@ -519,13 +518,13 @@ bool ExecutionGroup::scheduleChunk(unsigned int chunkNumber)
 
 bool ExecutionGroup::scheduleChunkWhenPossible(ExecutionSystem *graph, int xChunk, int yChunk)
 {
-  if (xChunk < 0 || xChunk >= (int)this->m_numberOfXChunks) {
+  if (xChunk < 0 || xChunk >= (int)this->m_x_chunks_len) {
     return true;
   }
-  if (yChunk < 0 || yChunk >= (int)this->m_numberOfYChunks) {
+  if (yChunk < 0 || yChunk >= (int)this->m_y_chunks_len) {
     return true;
   }
-  int chunkNumber = yChunk * this->m_numberOfXChunks + xChunk;
+  int chunkNumber = yChunk * this->m_x_chunks_len + xChunk;
   // chunk is already executed
   if (this->m_chunk_execution_states[chunkNumber] == eChunkExecutionState::EXECUTED) {
     return true;
diff --git a/source/blender/compositor/intern/COM_ExecutionGroup.h b/source/blender/compositor/intern/COM_ExecutionGroup.h
index 7ca886f6fc5..f73f4473b5d 100644
--- a/source/blender/compositor/intern/COM_ExecutionGroup.h
+++ b/source/blender/compositor/intern/COM_ExecutionGroup.h
@@ -76,7 +76,7 @@ class ExecutionGroup {
    * an input execution group is a group that is at the end of the calculation
    * (the output is important for the user).
    */
-  int m_isOutput;
+  bool m_is_output;
 
   /**
    * \brief Width of the output
@@ -97,17 +97,17 @@ class ExecutionGroup {
   /**
    * \brief number of chunks in the x-axis
    */
-  unsigned int m_numberOfXChunks;
+  unsigned int m_x_chunks_len;
 
   /**
    * \brief number of chunks in the y-axis
    */
-  unsigned int m_numberOfYChunks;
+  unsigned int m_y_chunks_len;
 
   /**
    * \brief total number of chunks
    */
-  unsigned int m_numberOfChunks;
+  unsigned int m_chunks_len;
 
   /**
    * \brief contains this ExecutionGroup a complex NodeOperation.
@@ -145,7 +145,7 @@ class ExecutionGroup {
   /**
    * \brief total number of chunks that have been calculated for this ExecutionGroup
    */
-  unsigned int m_chunksFinished;
+  unsigned int m_chunks_finished;
 
   /**
    * \brief m_chunk_execution_states holds per chunk the execution state. this state can be
@@ -269,18 +269,18 @@ class ExecutionGroup {
    * \note ViewerOperation, CompositeOperation, PreviewOperation.
    * \see NodeOperation.isOutputOperation
    */
-  int isOutputExecutionGroup() const
+  bool isOutputExecutionGroup() const
   {
-    return this->m_isOutput;
+    return this->m_is_output;
   }
 
   /**
    * \brief set whether this ExecutionGroup is an output
    * \param isOutput:
    */
-  void setOutputExecutionGroup(int isOutput)
+  void setOutputExecutionGroup(bool is_output)
   {
-    this->m_isOutput = isOutput;
+    this->m_is_output = is_output;
   }
 
   /**