ClangFormat: apply to source, most of intern

Apply clang format as proposed in T53211.

For details on usage and instructions for migrating branches
without conflicts, see:

https://wiki.blender.org/wiki/Tools/ClangFormat

1 files changed, 98 insertions, 89 deletions

diff --git a/intern/cycles/render/coverage.cpp b/intern/cycles/render/coverage.cpp
index 72ef4cda3ff..0a29903728a 100644
--- a/intern/cycles/render/coverage.cpp
+++ b/intern/cycles/render/coverage.cpp
@@ -25,119 +25,128 @@
 
 CCL_NAMESPACE_BEGIN
 
-static bool crypomatte_comp(const pair<float, float>& i, const pair<float, float> j) { return i.first > j.first; }
+static bool crypomatte_comp(const pair<float, float> &i, const pair<float, float> j)
+{
+  return i.first > j.first;
+}
 
 void Coverage::finalize()
 {
-	int pass_offset = 0;
-	if(kernel_data.film.cryptomatte_passes & CRYPT_OBJECT) {
-		finalize_buffer(coverage_object, pass_offset);
-		pass_offset += kernel_data.film.cryptomatte_depth * 4;
-	}
-	if(kernel_data.film.cryptomatte_passes & CRYPT_MATERIAL) {
-		finalize_buffer(coverage_material, pass_offset);
-		pass_offset += kernel_data.film.cryptomatte_depth * 4;
-	}
-	if(kernel_data.film.cryptomatte_passes & CRYPT_ASSET) {
-		finalize_buffer(coverage_asset, pass_offset);
-	}
+  int pass_offset = 0;
+  if (kernel_data.film.cryptomatte_passes & CRYPT_OBJECT) {
+    finalize_buffer(coverage_object, pass_offset);
+    pass_offset += kernel_data.film.cryptomatte_depth * 4;
+  }
+  if (kernel_data.film.cryptomatte_passes & CRYPT_MATERIAL) {
+    finalize_buffer(coverage_material, pass_offset);
+    pass_offset += kernel_data.film.cryptomatte_depth * 4;
+  }
+  if (kernel_data.film.cryptomatte_passes & CRYPT_ASSET) {
+    finalize_buffer(coverage_asset, pass_offset);
+  }
 }
 
 void Coverage::init_path_trace()
 {
-	kg->coverage_object = kg->coverage_material =  kg->coverage_asset = NULL;
+  kg->coverage_object = kg->coverage_material = kg->coverage_asset = NULL;
 
-	if(kernel_data.film.cryptomatte_passes & CRYPT_ACCURATE) {
-		if(kernel_data.film.cryptomatte_passes & CRYPT_OBJECT) {
-			coverage_object.clear();
-			coverage_object.resize(tile.w * tile.h);
-		}
-		if(kernel_data.film.cryptomatte_passes & CRYPT_MATERIAL) {
-			coverage_material.clear();
-			coverage_material.resize(tile.w * tile.h);
-		}
-		if(kernel_data.film.cryptomatte_passes & CRYPT_ASSET) {
-			coverage_asset.clear();
-			coverage_asset.resize(tile.w * tile.h);
-		}
-	}
+  if (kernel_data.film.cryptomatte_passes & CRYPT_ACCURATE) {
+    if (kernel_data.film.cryptomatte_passes & CRYPT_OBJECT) {
+      coverage_object.clear();
+      coverage_object.resize(tile.w * tile.h);
+    }
+    if (kernel_data.film.cryptomatte_passes & CRYPT_MATERIAL) {
+      coverage_material.clear();
+      coverage_material.resize(tile.w * tile.h);
+    }
+    if (kernel_data.film.cryptomatte_passes & CRYPT_ASSET) {
+      coverage_asset.clear();
+      coverage_asset.resize(tile.w * tile.h);
+    }
+  }
 }
 
 void Coverage::init_pixel(int x, int y)
 {
-	if(kernel_data.film.cryptomatte_passes & CRYPT_ACCURATE) {
-		const int pixel_index = tile.w * (y - tile.y) + x - tile.x;
-		if(kernel_data.film.cryptomatte_passes & CRYPT_OBJECT) {
-			kg->coverage_object = &coverage_object[pixel_index];
-		}
-		if(kernel_data.film.cryptomatte_passes & CRYPT_MATERIAL) {
-			kg->coverage_material = &coverage_material[pixel_index];
-		}
-		if(kernel_data.film.cryptomatte_passes & CRYPT_ASSET) {
-			kg->coverage_asset = &coverage_asset[pixel_index];
-		}
-	}
+  if (kernel_data.film.cryptomatte_passes & CRYPT_ACCURATE) {
+    const int pixel_index = tile.w * (y - tile.y) + x - tile.x;
+    if (kernel_data.film.cryptomatte_passes & CRYPT_OBJECT) {
+      kg->coverage_object = &coverage_object[pixel_index];
+    }
+    if (kernel_data.film.cryptomatte_passes & CRYPT_MATERIAL) {
+      kg->coverage_material = &coverage_material[pixel_index];
+    }
+    if (kernel_data.film.cryptomatte_passes & CRYPT_ASSET) {
+      kg->coverage_asset = &coverage_asset[pixel_index];
+    }
+  }
 }
 
-void Coverage::finalize_buffer(vector<CoverageMap> & coverage, const int pass_offset)
+void Coverage::finalize_buffer(vector<CoverageMap> &coverage, const int pass_offset)
 {
-	if(kernel_data.film.cryptomatte_passes & CRYPT_ACCURATE) {
-		flatten_buffer(coverage, pass_offset);
-	}
-	else {
-		sort_buffer(pass_offset);
-	}
+  if (kernel_data.film.cryptomatte_passes & CRYPT_ACCURATE) {
+    flatten_buffer(coverage, pass_offset);
+  }
+  else {
+    sort_buffer(pass_offset);
+  }
 }
 
 void Coverage::flatten_buffer(vector<CoverageMap> &coverage, const int pass_offset)
 {
-	/* Sort the coverage map and write it to the output */
-	int pixel_index = 0;
-	int pass_stride = tile.buffers->params.get_passes_size();
-	for(int y = 0; y < tile.h; ++y) {
-		for(int x = 0; x < tile.w; ++x) {
-			const CoverageMap& pixel = coverage[pixel_index];
-			if(!pixel.empty()) {
-				/* buffer offset */
-				int index = x + y * tile.stride;
-				float *buffer = (float*)tile.buffer + index*pass_stride;
+  /* Sort the coverage map and write it to the output */
+  int pixel_index = 0;
+  int pass_stride = tile.buffers->params.get_passes_size();
+  for (int y = 0; y < tile.h; ++y) {
+    for (int x = 0; x < tile.w; ++x) {
+      const CoverageMap &pixel = coverage[pixel_index];
+      if (!pixel.empty()) {
+        /* buffer offset */
+        int index = x + y * tile.stride;
+        float *buffer = (float *)tile.buffer + index * pass_stride;
 
-				/* sort the cryptomatte pixel */
-				vector<pair<float, float> > sorted_pixel;
-				for(CoverageMap::const_iterator it = pixel.begin(); it != pixel.end(); ++it) {
-					sorted_pixel.push_back(std::make_pair(it->second, it->first));
-				}
-				sort(sorted_pixel.begin(), sorted_pixel.end(), crypomatte_comp);
-				int num_slots = 2 * (kernel_data.film.cryptomatte_depth);
-				if(sorted_pixel.size() > num_slots) {
-					float leftover = 0.0f;
-					for(vector<pair<float, float> >::iterator it = sorted_pixel.begin()+num_slots; it != sorted_pixel.end(); ++it) {
-						leftover += it->first;
-					}
-					sorted_pixel[num_slots-1].first += leftover;
-				}
-				int limit = min(num_slots, sorted_pixel.size());
-				for(int i = 0; i < limit; ++i) {
-					kernel_write_id_slots(buffer + kernel_data.film.pass_cryptomatte + pass_offset, 2 * (kernel_data.film.cryptomatte_depth), sorted_pixel[i].second, sorted_pixel[i].first);
-				}
-			}
-			++pixel_index;
-		}
-	}
+        /* sort the cryptomatte pixel */
+        vector<pair<float, float>> sorted_pixel;
+        for (CoverageMap::const_iterator it = pixel.begin(); it != pixel.end(); ++it) {
+          sorted_pixel.push_back(std::make_pair(it->second, it->first));
+        }
+        sort(sorted_pixel.begin(), sorted_pixel.end(), crypomatte_comp);
+        int num_slots = 2 * (kernel_data.film.cryptomatte_depth);
+        if (sorted_pixel.size() > num_slots) {
+          float leftover = 0.0f;
+          for (vector<pair<float, float>>::iterator it = sorted_pixel.begin() + num_slots;
+               it != sorted_pixel.end();
+               ++it) {
+            leftover += it->first;
+          }
+          sorted_pixel[num_slots - 1].first += leftover;
+        }
+        int limit = min(num_slots, sorted_pixel.size());
+        for (int i = 0; i < limit; ++i) {
+          kernel_write_id_slots(buffer + kernel_data.film.pass_cryptomatte + pass_offset,
+                                2 * (kernel_data.film.cryptomatte_depth),
+                                sorted_pixel[i].second,
+                                sorted_pixel[i].first);
+        }
+      }
+      ++pixel_index;
+    }
+  }
 }
 
 void Coverage::sort_buffer(const int pass_offset)
 {
-	/* Sort the coverage map and write it to the output */
-	int pass_stride = tile.buffers->params.get_passes_size();
-	for(int y = 0; y < tile.h; ++y) {
-		for(int x = 0; x < tile.w; ++x) {
-			/* buffer offset */
-			int index = x + y*tile.stride;
-			float *buffer = (float*)tile.buffer + index*pass_stride;
-			kernel_sort_id_slots(buffer + kernel_data.film.pass_cryptomatte + pass_offset, 2 * (kernel_data.film.cryptomatte_depth));
-		}
-	}
+  /* Sort the coverage map and write it to the output */
+  int pass_stride = tile.buffers->params.get_passes_size();
+  for (int y = 0; y < tile.h; ++y) {
+    for (int x = 0; x < tile.w; ++x) {
+      /* buffer offset */
+      int index = x + y * tile.stride;
+      float *buffer = (float *)tile.buffer + index * pass_stride;
+      kernel_sort_id_slots(buffer + kernel_data.film.pass_cryptomatte + pass_offset,
+                           2 * (kernel_data.film.cryptomatte_depth));
+    }
+  }
 }
 
 CCL_NAMESPACE_END