Apply clang-format

src/Aabb.h

@@ -15,14 +15,16 @@ struct Aabb {
 		min(DBL_MAX, DBL_MAX, DBL_MAX),
 		max(-DBL_MAX, -DBL_MAX, -DBL_MAX),
 		radius(0.1)
-	{}
+	{
+	}
 	// Fast constructor for pre-conditioned values
 	// Should only be used when _min < _max for all {x,y,z}
 	Aabb(const vector3d &_min, const vector3d &_max, float rad) :
 		min(_min),
 		max(_max),
 		radius(rad)
-	{}
+	{
+	}
 	void Update(const Aabb &b)
 	{
 		max.x = std::max(max.x, b.max.x);
@@ -69,7 +71,7 @@ struct Aabb {
 };
 
 // SIMD-capable AABB type without additional overhead
-template<typename Vec3>
+template <typename Vec3>
 struct AABB {
 	using Number = typename Vec3::element_type;
 
@@ -100,8 +102,8 @@ struct AABB {
 
 	auto IntersectsRay(const Vec3 &start, const Vec3 &inv_dir, Number dist) const
 	{
-		using std::min;
 		using std::max;
+		using std::min;
 
 		Vec3 l1 = (this->min - start) * inv_dir;
 		Vec3 l2 = (this->max - start) * inv_dir;

src/Frame.h

@@ -172,7 +172,8 @@ class Frame {
 	struct Dummy {
 		Dummy() :
 			madeWithFactory(false)
-		{}
+		{
+		}
 		bool madeWithFactory;
 	};
 

src/collider/CollisionSpace.cpp

@@ -272,7 +272,7 @@ void CollisionSpace::RebuildBVHTree(SingleBVHTree *tree, uint32_t numGeoms, cons
 		vector3d pos = geom->GetPosition();
 		double radius = geom->GetGeomTree()->GetRadius();
 
-		AABBd aabb { {pos - radius }, { pos + radius } };
+		AABBd aabb{ { pos - radius }, { pos + radius } };
 
 		aabbs.push_back(aabb);
 		bounds.Update(aabb);

src/collider/CollisionSpace.h

@@ -4,11 +4,11 @@
 #ifndef _COLLISION_SPACE
 #define _COLLISION_SPACE
 
-#include "../vector3.h"
 #include "../Aabb.h"
+#include "../vector3.h"
 
-#include <vector>
 #include <memory>
+#include <vector>
 
 class Geom;
 class SingleBVHTree;

src/collider/Geom.h

@@ -43,6 +43,7 @@ class Geom {
 	vector3d m_pos;
 	const GeomTree *m_geomtree;
 	matrix4x4d m_orient, m_invOrient;
+
 public:
 	matrix4x4d m_animTransform;
 

src/graphics/Drawables.cpp

@@ -876,12 +876,12 @@ namespace Graphics {
 			Graphics::VertexArray va = Graphics::VertexArray(Graphics::ATTRIB_POSITION | Graphics::ATTRIB_UV0);
 
 			// Generate two triangles for the grid plane
-			va.Add(vector3f( grid_size.x, 0, -grid_size.y), vector2f( grid_size.x, -grid_size.y));
-			va.Add(vector3f(-grid_size.x, 0,  grid_size.y), vector2f(-grid_size.x,  grid_size.y));
+			va.Add(vector3f(grid_size.x, 0, -grid_size.y), vector2f(grid_size.x, -grid_size.y));
+			va.Add(vector3f(-grid_size.x, 0, grid_size.y), vector2f(-grid_size.x, grid_size.y));
 			va.Add(vector3f(-grid_size.x, 0, -grid_size.y), vector2f(-grid_size.x, -grid_size.y));
-			va.Add(vector3f( grid_size.x, 0, -grid_size.y), vector2f( grid_size.x, -grid_size.y));
-			va.Add(vector3f( grid_size.x, 0,  grid_size.y), vector2f( grid_size.x,  grid_size.y));
-			va.Add(vector3f(-grid_size.x, 0,  grid_size.y), vector2f(-grid_size.x,  grid_size.y));
+			va.Add(vector3f(grid_size.x, 0, -grid_size.y), vector2f(grid_size.x, -grid_size.y));
+			va.Add(vector3f(grid_size.x, 0, grid_size.y), vector2f(grid_size.x, grid_size.y));
+			va.Add(vector3f(-grid_size.x, 0, grid_size.y), vector2f(-grid_size.x, grid_size.y));
 
 			GridData data = {};
 			data.thin_color = m_minorColor.ToColor4f();

src/scenegraph/Model.cpp

@@ -20,9 +20,9 @@
 #include "scenegraph/Animation.h"
 #include "scenegraph/Label3D.h"
 #include "scenegraph/MatrixTransform.h"
-#include "scenegraph/Tag.h"
 #include "scenegraph/NodeVisitor.h"
 #include "scenegraph/StaticGeometry.h"
+#include "scenegraph/Tag.h"
 #include "utils.h"
 
 namespace SceneGraph {

src/vector3.h

@@ -227,84 +227,96 @@ inline vector3<float>::vector3(const vector2f &v, float t) :
 	x(v.x),
 	y(v.y),
 	z(t)
-{}
+{
+}
 template <>
 inline vector3<float>::vector3(const vector3<double> &v) :
 	x(float(v.x)),
 	y(float(v.y)),
 	z(float(v.z))
-{}
+{
+}
 template <>
 inline vector3<double>::vector3(const vector3<float> &v) :
 	x(v.x),
 	y(v.y),
 	z(v.z)
-{}
+{
+}
 template <>
 inline vector3<double>::vector3(const vector2f &v, double t) :
 	x(v.x),
 	y(v.y),
 	z(t)
-{}
+{
+}
 template <>
 inline vector3<float>::vector3(float val) :
 	x(val),
 	y(val),
 	z(val)
-{}
+{
+}
 template <>
 inline vector3<double>::vector3(double val) :
 	x(val),
 	y(val),
 	z(val)
-{}
+{
+}
 template <>
 inline vector3<float>::vector3(float _x, float _y, float _z) :
 	x(_x),
 	y(_y),
 	z(_z)
-{}
+{
+}
 template <>
 inline vector3<double>::vector3(double _x, double _y, double _z) :
 	x(_x),
 	y(_y),
 	z(_z)
-{}
+{
+}
 template <>
 inline vector3<float>::vector3(const float vals[3]) :
 	x(vals[0]),
 	y(vals[1]),
 	z(vals[2])
-{}
+{
+}
 template <>
 inline vector3<float>::vector3(const double vals[3]) :
 	x(float(vals[0])),
 	y(float(vals[1])),
 	z(float(vals[2]))
-{}
+{
+}
 template <>
 inline vector3<double>::vector3(const float vals[3]) :
 	x(vals[0]),
 	y(vals[1]),
 	z(vals[2])
-{}
+{
+}
 template <>
 inline vector3<double>::vector3(const double vals[3]) :
 	x(vals[0]),
 	y(vals[1]),
 	z(vals[2])
-{}
+{
+}
 
 // max() overload for use with C++ ADL
-template<typename T>
+template <typename T>
 vector3<T> max(const vector3<T> &lhs, const vector3<T> &rhs)
 {
 	using std::max; // support max(T) overloads
 	return vector3<T>(max(lhs.x, rhs.x), max(lhs.y, rhs.y), max(lhs.z, rhs.z));
 }
 
 // min() overload for use with C++ ADL
-template<typename T>
+template <typename T>
 vector3<T> min(const vector3<T> &lhs, const vector3<T> &rhs)
 {
 	using std::min; // support min(T) overloads