Add .clang-format

Author: roym899

.clang-format

@@ -0,0 +1,31 @@
+BasedOnStyle: Google
+
+# Make it slightly more similar to Rust.
+# Based loosely on https://gist.github.com/YodaEmbedding/c2c77dc693d11f3734d78489f9a6eea4
+AccessModifierOffset: -2
+AlignAfterOpenBracket: BlockIndent
+AllowAllArgumentsOnNextLine: false
+AllowShortBlocksOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: Empty
+AllowShortIfStatementsOnASingleLine: Never
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: true
+BinPackArguments: false
+ColumnLimit: 100
+ContinuationIndentWidth: 4
+EmptyLineBeforeAccessModifier: LogicalBlock
+IndentWidth: 4
+IndentWrappedFunctionNames: true
+InsertTrailingCommas: Wrapped
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: All
+PointerAlignment: Left
+ReflowComments: true
+SeparateDefinitionBlocks: Always
+SpacesBeforeTrailingComments: 1
+
+# Don't change include blocks, we want to control this manually.
+# Sorting headers however is allowed as all our headers should be standalone.
+IncludeBlocks: Preserve
+SortIncludes: CaseInsensitive

src/main.cpp

@@ -7,78 +7,76 @@
 #include <rerun.hpp>
 
 template <>
-struct rerun::ComponentBatchAdapter<rerun::components::Position3D,
-                                    std::vector<Eigen::Vector3f>> {
-  // Sanity check that this is binary compatible.
-  static_assert(sizeof(components::Position3D) == sizeof(Eigen::Vector3f));
-  static_assert(alignof(components::Position3D) <= alignof(Eigen::Vector3f));
+struct rerun::ComponentBatchAdapter<rerun::components::Position3D, std::vector<Eigen::Vector3f>> {
+    // Sanity check that this is binary compatible.
+    static_assert(sizeof(components::Position3D) == sizeof(Eigen::Vector3f));
+    static_assert(alignof(components::Position3D) <= alignof(Eigen::Vector3f));
 
-  ComponentBatch<components::Position3D>
-  operator()(const std::vector<Eigen::Vector3f> &container) {
-    return ComponentBatch<components::Position3D>::borrow(
-        reinterpret_cast<const components::Position3D *>(container.data()),
-        container.size());
-  }
+    ComponentBatch<components::Position3D> operator()(const std::vector<Eigen::Vector3f> &container
+    ) {
+        return ComponentBatch<components::Position3D>::borrow(
+            reinterpret_cast<const components::Position3D *>(container.data()),
+            container.size()
+        );
+    }
 
-  ComponentBatch<components::Position3D>
-  operator()(std::vector<Eigen::Vector3f> &&container) {
-    throw std::runtime_error("Not implemented for temporaries");
-  }
+    ComponentBatch<components::Position3D> operator()(std::vector<Eigen::Vector3f> &&container) {
+        throw std::runtime_error("Not implemented for temporaries");
+    }
 };
 
 template <>
-struct rerun::ComponentBatchAdapter<rerun::components::Position3D,
-                                    Eigen::MatrixX3f> {
-  // Sanity check that this is binary compatible.
-  static_assert(sizeof(components::Position3D) ==
-                sizeof(Eigen::MatrixX3f::Scalar) *
-                    Eigen::MatrixX3f::ColsAtCompileTime);
-  static_assert(alignof(components::Position3D) <= alignof(Eigen::MatrixX3f));
+struct rerun::ComponentBatchAdapter<rerun::components::Position3D, Eigen::MatrixX3f> {
+    // Sanity check that this is binary compatible.
+    static_assert(
+        sizeof(components::Position3D) ==
+        sizeof(Eigen::MatrixX3f::Scalar) * Eigen::MatrixX3f::ColsAtCompileTime
+    );
+    static_assert(alignof(components::Position3D) <= alignof(Eigen::MatrixX3f));
 
-  ComponentBatch<components::Position3D>
-  operator()(const Eigen::MatrixX3f &matrix) {
-    return ComponentBatch<components::Position3D>::borrow(
-        reinterpret_cast<const components::Position3D *>(matrix.data()),
-        matrix.rows());
-  }
+    ComponentBatch<components::Position3D> operator()(const Eigen::MatrixX3f &matrix) {
+        return ComponentBatch<components::Position3D>::borrow(
+            reinterpret_cast<const components::Position3D *>(matrix.data()),
+            matrix.rows()
+        );
+    }
 
-  ComponentBatch<components::Position3D>
-  operator()(std::vector<Eigen::MatrixX3f> &&container) {
-    throw std::runtime_error("Not implemented for temporaries");
-  }
+    ComponentBatch<components::Position3D> operator()(std::vector<Eigen::MatrixX3f> &&container) {
+        throw std::runtime_error("Not implemented for temporaries");
+    }
 };
 
 std::vector<Eigen::Vector3f> generate_random_points_vector(int num_points) {
-  std::vector<Eigen::Vector3f> points(num_points);
-  for (auto &point : points) {
-    point.setRandom();
-  }
-  return points;
+    std::vector<Eigen::Vector3f> points(num_points);
+    for (auto &point : points) {
+        point.setRandom();
+    }
+    return points;
 }
 
 int main() {
-  auto rec = rerun::RecordingStream("rerun_cpp_example_opencv_eigen");
-  rec.connect("127.0.0.1:9876").throw_on_failure();
+    auto rec = rerun::RecordingStream("rerun_cpp_example_opencv_eigen");
+    rec.connect("127.0.0.1:9876").throw_on_failure();
 
-  const int num_points = 1000;
+    const int num_points = 1000;
 
-  // Points represented by std::vector<Eigen::Vector3f>
-  auto points3d_vector = generate_random_points_vector(1000);
-  rec.log("points_from_vector", rerun::Points3D(points3d_vector));
+    // Points represented by std::vector<Eigen::Vector3f>
+    auto points3d_vector = generate_random_points_vector(1000);
+    rec.log("points_from_vector", rerun::Points3D(points3d_vector));
 
-  // Points represented by Eigen::MatX3f (Nx3 matrix)
-  Eigen::MatrixX3f points3d_matrix = Eigen::MatrixX3f::Random(num_points, 3);
-  rec.log("points_from_matrix", rerun::Points3D(points3d_matrix));
+    // Points represented by Eigen::MatX3f (Nx3 matrix)
+    Eigen::MatrixX3f points3d_matrix = Eigen::MatrixX3f::Random(num_points, 3);
+    rec.log("points_from_matrix", rerun::Points3D(points3d_matrix));
 
-  // Image
-  std::string image_path = "rerun-logo.png";
-  cv::Mat img = imread(image_path, cv::IMREAD_COLOR);
-  if (img.empty()) {
-    std::cout << "Could not read the image: " << image_path << std::endl;
-    return 1;
-  }
-  imshow("Display window", img);
-  cv::waitKey(0);
+    // Image
+    std::string image_path = "rerun-logo.png";
+    cv::Mat img = imread(image_path, cv::IMREAD_COLOR);
+    if (img.empty()) {
+        std::cout << "Could not read the image: " << image_path << std::endl;
+        return 1;
+    }
+    imshow("Display window", img);
+    cv::waitKey(0);
 
-  return 0;
+    return 0;
 }