Normalize whitespace

Also fix one badly concatenated token causing a build failure on Linux

JoltC/Enums.h

@@ -17,16 +17,16 @@ ENSURE_EQUAL(JPC_DEFAULT_CONVEX_RADIUS, JPH::cDefaultConvexRadius)
 ENSURE_EQUAL(JPC_CAPSULE_PROJECTION_SLOP, JPH::cCapsuleProjectionSlop)
 
 typedef enum JPC_ShapeType: uint8_t {
-    JPC_SHAPE_TYPE_CONVEX,
-    JPC_SHAPE_TYPE_COMPOUND,
-    JPC_SHAPE_TYPE_DECORATED,
-    JPC_SHAPE_TYPE_MESH,
-    JPC_SHAPE_TYPE_HEIGHT_FIELD,
-    JPC_SHAPE_TYPE_SOFTBODY,
-    JPC_SHAPE_TYPE_USER1,
-    JPC_SHAPE_TYPE_USER2,
-    JPC_SHAPE_TYPE_USER3,
-    JPC_SHAPE_TYPE_USER4,
+	JPC_SHAPE_TYPE_CONVEX,
+	JPC_SHAPE_TYPE_COMPOUND,
+	JPC_SHAPE_TYPE_DECORATED,
+	JPC_SHAPE_TYPE_MESH,
+	JPC_SHAPE_TYPE_HEIGHT_FIELD,
+	JPC_SHAPE_TYPE_SOFTBODY,
+	JPC_SHAPE_TYPE_USER1,
+	JPC_SHAPE_TYPE_USER2,
+	JPC_SHAPE_TYPE_USER3,
+	JPC_SHAPE_TYPE_USER4,
 } JPC_ShapeType;
 
 ENSURE_ENUM_EQ(JPC_SHAPE_TYPE_CONVEX, JPH::EShapeType::Convex)
@@ -40,37 +40,37 @@ ENSURE_ENUM_EQ(JPC_SHAPE_TYPE_USER3, JPH::EShapeType::User3)
 ENSURE_ENUM_EQ(JPC_SHAPE_TYPE_USER4, JPH::EShapeType::User4)
 
 typedef enum JPC_ShapeSubType: uint8_t {
-    JPC_SHAPE_SUB_TYPE_SPHERE,
-    JPC_SHAPE_SUB_TYPE_BOX,
-    JPC_SHAPE_SUB_TYPE_TRIANGLE,
-    JPC_SHAPE_SUB_TYPE_CAPSULE,
-    JPC_SHAPE_SUB_TYPE_TAPEREDCAPSULE,
-    JPC_SHAPE_SUB_TYPE_CYLINDER,
-    JPC_SHAPE_SUB_TYPE_CONVEX_HULL,
-    JPC_SHAPE_SUB_TYPE_STATIC_COMPOUND,
-    JPC_SHAPE_SUB_TYPE_MUTABLE_COMPOUND,
-    JPC_SHAPE_SUB_TYPE_ROTATED_TRANSLATED,
-    JPC_SHAPE_SUB_TYPE_SCALED,
-    JPC_SHAPE_SUB_TYPE_OFFSET_CENTER_OF_MASS,
-    JPC_SHAPE_SUB_TYPE_MESH,
-    JPC_SHAPE_SUB_TYPE_HEIGHT_FIELD,
-    JPC_SHAPE_SUB_TYPE_SOFT_BODY,
-    JPC_SHAPE_SUB_TYPE_USER1,
-    JPC_SHAPE_SUB_TYPE_USER2,
-    JPC_SHAPE_SUB_TYPE_USER3,
-    JPC_SHAPE_SUB_TYPE_USER4,
-    JPC_SHAPE_SUB_TYPE_USER5,
-    JPC_SHAPE_SUB_TYPE_USER6,
-    JPC_SHAPE_SUB_TYPE_USER7,
-    JPC_SHAPE_SUB_TYPE_USER8,
-    JPC_SHAPE_SUB_TYPE_USER_CONVEX1,
-    JPC_SHAPE_SUB_TYPE_USER_CONVEX2,
-    JPC_SHAPE_SUB_TYPE_USER_CONVEX3,
-    JPC_SHAPE_SUB_TYPE_USER_CONVEX4,
-    JPC_SHAPE_SUB_TYPE_USER_CONVEX5,
-    JPC_SHAPE_SUB_TYPE_USER_CONVEX6,
-    JPC_SHAPE_SUB_TYPE_USER_CONVEX7,
-    JPC_SHAPE_SUB_TYPE_USER_CONVEX8,
+	JPC_SHAPE_SUB_TYPE_SPHERE,
+	JPC_SHAPE_SUB_TYPE_BOX,
+	JPC_SHAPE_SUB_TYPE_TRIANGLE,
+	JPC_SHAPE_SUB_TYPE_CAPSULE,
+	JPC_SHAPE_SUB_TYPE_TAPEREDCAPSULE,
+	JPC_SHAPE_SUB_TYPE_CYLINDER,
+	JPC_SHAPE_SUB_TYPE_CONVEX_HULL,
+	JPC_SHAPE_SUB_TYPE_STATIC_COMPOUND,
+	JPC_SHAPE_SUB_TYPE_MUTABLE_COMPOUND,
+	JPC_SHAPE_SUB_TYPE_ROTATED_TRANSLATED,
+	JPC_SHAPE_SUB_TYPE_SCALED,
+	JPC_SHAPE_SUB_TYPE_OFFSET_CENTER_OF_MASS,
+	JPC_SHAPE_SUB_TYPE_MESH,
+	JPC_SHAPE_SUB_TYPE_HEIGHT_FIELD,
+	JPC_SHAPE_SUB_TYPE_SOFT_BODY,
+	JPC_SHAPE_SUB_TYPE_USER1,
+	JPC_SHAPE_SUB_TYPE_USER2,
+	JPC_SHAPE_SUB_TYPE_USER3,
+	JPC_SHAPE_SUB_TYPE_USER4,
+	JPC_SHAPE_SUB_TYPE_USER5,
+	JPC_SHAPE_SUB_TYPE_USER6,
+	JPC_SHAPE_SUB_TYPE_USER7,
+	JPC_SHAPE_SUB_TYPE_USER8,
+	JPC_SHAPE_SUB_TYPE_USER_CONVEX1,
+	JPC_SHAPE_SUB_TYPE_USER_CONVEX2,
+	JPC_SHAPE_SUB_TYPE_USER_CONVEX3,
+	JPC_SHAPE_SUB_TYPE_USER_CONVEX4,
+	JPC_SHAPE_SUB_TYPE_USER_CONVEX5,
+	JPC_SHAPE_SUB_TYPE_USER_CONVEX6,
+	JPC_SHAPE_SUB_TYPE_USER_CONVEX7,
+	JPC_SHAPE_SUB_TYPE_USER_CONVEX8,
 } JPC_ShapeSubType;
 
 ENSURE_ENUM_EQ(JPC_SHAPE_SUB_TYPE_SPHERE, JPH::EShapeSubType::Sphere)
@@ -117,31 +117,31 @@ ENSURE_ENUM_EQ(JPC_PHYSICS_UPDATE_ERROR_BODY_PAIR_CACHE_FULL, JPH::EPhysicsUpdat
 ENSURE_ENUM_EQ(JPC_PHYSICS_UPDATE_ERROR_CONTACT_CONSTRAINTS_FULL, JPH::EPhysicsUpdateError::ContactConstraintsFull)
 
 typedef enum JPC_ConstraintType: uint32_t {
-    JPC_CONSTRAINT_TYPE_CONSTRAINT,
-    JPC_CONSTRAINT_TYPE_TWO_BODY_CONSTRAINT,
+	JPC_CONSTRAINT_TYPE_CONSTRAINT,
+	JPC_CONSTRAINT_TYPE_TWO_BODY_CONSTRAINT,
 } JPC_ConstraintType;
 
 ENSURE_ENUM_EQ(JPC_CONSTRAINT_TYPE_CONSTRAINT, JPH::EConstraintType::Constraint)
 ENSURE_ENUM_EQ(JPC_CONSTRAINT_TYPE_TWO_BODY_CONSTRAINT, JPH::EConstraintType::TwoBodyConstraint)
 
 typedef enum JPC_ConstraintSubType: uint32_t {
-    JPC_CONSTRAINT_SUB_TYPE_FIXED,
-    JPC_CONSTRAINT_SUB_TYPE_POINT,
-    JPC_CONSTRAINT_SUB_TYPE_HINGE,
-    JPC_CONSTRAINT_SUB_TYPE_SLIDER,
-    JPC_CONSTRAINT_SUB_TYPE_DISTANCE,
-    JPC_CONSTRAINT_SUB_TYPE_CONE,
-    JPC_CONSTRAINT_SUB_TYPE_SWING_TWIST,
-    JPC_CONSTRAINT_SUB_TYPE_SIX_DOF,
-    JPC_CONSTRAINT_SUB_TYPE_PATH,
-    JPC_CONSTRAINT_SUB_TYPE_VEHICLE,
-    JPC_CONSTRAINT_SUB_TYPE_RACK_AND_PINION,
-    JPC_CONSTRAINT_SUB_TYPE_GEAR,
-    JPC_CONSTRAINT_SUB_TYPE_PULLEY,
-    JPC_CONSTRAINT_SUB_TYPE_USER1,
-    JPC_CONSTRAINT_SUB_TYPE_USER2,
-    JPC_CONSTRAINT_SUB_TYPE_USER3,
-    JPC_CONSTRAINT_SUB_TYPE_USER4,
+	JPC_CONSTRAINT_SUB_TYPE_FIXED,
+	JPC_CONSTRAINT_SUB_TYPE_POINT,
+	JPC_CONSTRAINT_SUB_TYPE_HINGE,
+	JPC_CONSTRAINT_SUB_TYPE_SLIDER,
+	JPC_CONSTRAINT_SUB_TYPE_DISTANCE,
+	JPC_CONSTRAINT_SUB_TYPE_CONE,
+	JPC_CONSTRAINT_SUB_TYPE_SWING_TWIST,
+	JPC_CONSTRAINT_SUB_TYPE_SIX_DOF,
+	JPC_CONSTRAINT_SUB_TYPE_PATH,
+	JPC_CONSTRAINT_SUB_TYPE_VEHICLE,
+	JPC_CONSTRAINT_SUB_TYPE_RACK_AND_PINION,
+	JPC_CONSTRAINT_SUB_TYPE_GEAR,
+	JPC_CONSTRAINT_SUB_TYPE_PULLEY,
+	JPC_CONSTRAINT_SUB_TYPE_USER1,
+	JPC_CONSTRAINT_SUB_TYPE_USER2,
+	JPC_CONSTRAINT_SUB_TYPE_USER3,
+	JPC_CONSTRAINT_SUB_TYPE_USER4,
 } JPC_ConstraintSubType;
 
 ENSURE_ENUM_EQ(JPC_CONSTRAINT_SUB_TYPE_FIXED, JPH::EConstraintSubType::Fixed)
@@ -163,17 +163,17 @@ ENSURE_ENUM_EQ(JPC_CONSTRAINT_SUB_TYPE_USER3, JPH::EConstraintSubType::User3)
 ENSURE_ENUM_EQ(JPC_CONSTRAINT_SUB_TYPE_USER4, JPH::EConstraintSubType::User4)
 
 typedef enum JPC_ConstraintSpace: uint32_t {
-    JPC_CONSTRAINT_SPACE_LOCAL_TO_BODY_COM,
-    JPC_CONSTRAINT_SPACE_WORLD_SPACE,
+	JPC_CONSTRAINT_SPACE_LOCAL_TO_BODY_COM,
+	JPC_CONSTRAINT_SPACE_WORLD_SPACE,
 } JPC_ConstraintSpace;
 
 ENSURE_ENUM_EQ(JPC_CONSTRAINT_SPACE_LOCAL_TO_BODY_COM, JPH::EConstraintSpace::LocalToBodyCOM)
 ENSURE_ENUM_EQ(JPC_CONSTRAINT_SPACE_WORLD_SPACE, JPH::EConstraintSpace::WorldSpace)
 
 typedef enum JPC_MotionType: uint8_t {
-    JPC_MOTION_TYPE_STATIC,
-    JPC_MOTION_TYPE_KINEMATIC,
-    JPC_MOTION_TYPE_DYNAMIC,
+	JPC_MOTION_TYPE_STATIC,
+	JPC_MOTION_TYPE_KINEMATIC,
+	JPC_MOTION_TYPE_DYNAMIC,
 } JPC_MotionType;
 
 ENSURE_ENUM_EQ(JPC_MOTION_TYPE_STATIC,    JPH::EMotionType::Static)
@@ -181,31 +181,31 @@ ENSURE_ENUM_EQ(JPC_MOTION_TYPE_KINEMATIC, JPH::EMotionType::Kinematic)
 ENSURE_ENUM_EQ(JPC_MOTION_TYPE_DYNAMIC,   JPH::EMotionType::Dynamic)
 
 typedef enum JPC_MotionQuality: uint8_t {
-    JPC_MOTION_QUALITY_DISCRETE,
-    JPC_MOTION_QUALITY_LINEAR_CAST,
+	JPC_MOTION_QUALITY_DISCRETE,
+	JPC_MOTION_QUALITY_LINEAR_CAST,
 } JPC_MotionQuality;
 
 ENSURE_ENUM_EQ(JPC_MOTION_QUALITY_DISCRETE,    JPH::EMotionQuality::Discrete)
 ENSURE_ENUM_EQ(JPC_MOTION_QUALITY_LINEAR_CAST, JPH::EMotionQuality::LinearCast)
 
 typedef enum JPC_OverrideMassProperties: uint8_t {
-    JPC_OVERRIDE_MASS_PROPS_CALC_MASS_INERTIA,
-    JPC_OVERRIDE_MASS_PROPS_CALC_INERTIA,
-    JPC_OVERRIDE_MASS_PROPS_MASS_INERTIA_PROVIDED,
+	JPC_OVERRIDE_MASS_PROPS_CALC_MASS_INERTIA,
+	JPC_OVERRIDE_MASS_PROPS_CALC_INERTIA,
+	JPC_OVERRIDE_MASS_PROPS_MASS_INERTIA_PROVIDED,
 } JPC_OverrideMassProperties;
 
 ENSURE_ENUM_EQ(JPC_OVERRIDE_MASS_PROPS_CALC_MASS_INERTIA,
-               JPH::EOverrideMassProperties::CalculateMassAndInertia);
+			   JPH::EOverrideMassProperties::CalculateMassAndInertia);
 ENSURE_ENUM_EQ(JPC_OVERRIDE_MASS_PROPS_CALC_INERTIA,
-               JPH::EOverrideMassProperties::CalculateInertia);
+			   JPH::EOverrideMassProperties::CalculateInertia);
 ENSURE_ENUM_EQ(JPC_OVERRIDE_MASS_PROPS_MASS_INERTIA_PROVIDED,
-               JPH::EOverrideMassProperties::MassAndInertiaProvided);
+			   JPH::EOverrideMassProperties::MassAndInertiaProvided);
 
 typedef enum JPC_GroundState: uint32_t {
-    JPC_CHARACTER_GROUND_STATE_ON_GROUND,
-    JPC_CHARACTER_GROUND_STATE_ON_STEEP_GROUND,
-    JPC_CHARACTER_GROUND_STATE_NOT_SUPPORTED,
-    JPC_CHARACTER_GROUND_STATE_IN_AIR,
+	JPC_CHARACTER_GROUND_STATE_ON_GROUND,
+	JPC_CHARACTER_GROUND_STATE_ON_STEEP_GROUND,
+	JPC_CHARACTER_GROUND_STATE_NOT_SUPPORTED,
+	JPC_CHARACTER_GROUND_STATE_IN_AIR,
 } JPC_GroundState;
 
 // ENSURE_ENUM_EQ(JPC_CHARACTER_GROUND_STATE_ON_GROUND, JPH::EGroundState::OnGround)
@@ -214,28 +214,28 @@ typedef enum JPC_GroundState: uint32_t {
 // ENSURE_ENUM_EQ(JPC_CHARACTER_GROUND_STATE_IN_AIR, JPH::EGroundState::InAir)
 
 typedef enum JPC_Activation: uint32_t {
-    JPC_ACTIVATION_ACTIVATE      = 0,
-    JPC_ACTIVATION_DONT_ACTIVATE = 1,
+	JPC_ACTIVATION_ACTIVATE      = 0,
+	JPC_ACTIVATION_DONT_ACTIVATE = 1,
 } JPC_Activation;
 
 ENSURE_ENUM_EQ(JPC_ACTIVATION_ACTIVATE,      JPH::EActivation::Activate)
 ENSURE_ENUM_EQ(JPC_ACTIVATION_DONT_ACTIVATE, JPH::EActivation::DontActivate)
 
 typedef enum JPC_ValidateResult: uint32_t {
-    JPC_VALIDATE_RESULT_ACCEPT_ALL_CONTACTS,
-    JPC_VALIDATE_RESULT_ACCEPT_CONTACT,
-    JPC_VALIDATE_RESULT_REJECT_CONTACT,
-    JPC_VALIDATE_RESULT_REJECT_ALL_CONTACTS,
+	JPC_VALIDATE_RESULT_ACCEPT_ALL_CONTACTS,
+	JPC_VALIDATE_RESULT_ACCEPT_CONTACT,
+	JPC_VALIDATE_RESULT_REJECT_CONTACT,
+	JPC_VALIDATE_RESULT_REJECT_ALL_CONTACTS,
 } JPC_ValidateResult;
 
 ENSURE_ENUM_EQ(JPC_VALIDATE_RESULT_ACCEPT_ALL_CONTACTS,
-               JPH::ValidateResult::AcceptAllContactsForThisBodyPair);
+			   JPH::ValidateResult::AcceptAllContactsForThisBodyPair);
 ENSURE_ENUM_EQ(JPC_VALIDATE_RESULT_ACCEPT_CONTACT,
-               JPH::ValidateResult::AcceptContact);
+			   JPH::ValidateResult::AcceptContact);
 ENSURE_ENUM_EQ(JPC_VALIDATE_RESULT_REJECT_CONTACT,
-               JPH::ValidateResult::RejectContact);
+			   JPH::ValidateResult::RejectContact);
 ENSURE_ENUM_EQ(JPC_VALIDATE_RESULT_REJECT_ALL_CONTACTS,
-               JPH::ValidateResult::RejectAllContactsForThisBodyPair);
+			   JPH::ValidateResult::RejectAllContactsForThisBodyPair);
 
 // EBackFaceMode
 typedef uint8_t JPC_BackFaceMode;
@@ -246,23 +246,23 @@ ENSURE_ENUM_EQ(JPC_BACK_FACE_MODE_IGNORE, JPH::EBackFaceMode::IgnoreBackFaces)
 ENSURE_ENUM_EQ(JPC_BACK_FACE_MODE_COLLIDE, JPH::EBackFaceMode::CollideWithBackFaces)
 
 typedef enum JPC_BodyType: uint8_t {
-    JPC_BODY_TYPE_RIGID_BODY = 0,
-    JPC_BODY_TYPE_SOFT_BODY  = 1,
+	JPC_BODY_TYPE_RIGID_BODY = 0,
+	JPC_BODY_TYPE_SOFT_BODY  = 1,
 } JPC_BodyType;
 
 ENSURE_ENUM_EQ(JPC_BODY_TYPE_RIGID_BODY, JPH::EBodyType::RigidBody)
 ENSURE_ENUM_EQ(JPC_BODY_TYPE_SOFT_BODY, JPH::EBodyType::SoftBody)
 
 typedef enum JPC_AllowedDOFs: uint8_t {
-    JPC_ALLOWED_DOFS_NONE         = 0b000000,
-    JPC_ALLOWED_DOFS_ALL          = 0b111111,
-    JPC_ALLOWED_DOFS_TRANSLATIONX = 0b000001,
-    JPC_ALLOWED_DOFS_TRANSLATIONY = 0b000010,
-    JPC_ALLOWED_DOFS_TRANSLATIONZ = 0b000100,
-    JPC_ALLOWED_DOFS_ROTATIONX    = 0b001000,
-    JPC_ALLOWED_DOFS_ROTATIONY    = 0b010000,
-    JPC_ALLOWED_DOFS_ROTATIONZ    = 0b100000,
-    JPC_ALLOWED_DOFS_PLANE2D      = JPC_ALLOWED_DOFS_TRANSLATIONX | JPC_ALLOWED_DOFS_TRANSLATIONY | JPC_ALLOWED_DOFS_ROTATIONZ,
+	JPC_ALLOWED_DOFS_NONE         = 0b000000,
+	JPC_ALLOWED_DOFS_ALL          = 0b111111,
+	JPC_ALLOWED_DOFS_TRANSLATIONX = 0b000001,
+	JPC_ALLOWED_DOFS_TRANSLATIONY = 0b000010,
+	JPC_ALLOWED_DOFS_TRANSLATIONZ = 0b000100,
+	JPC_ALLOWED_DOFS_ROTATIONX    = 0b001000,
+	JPC_ALLOWED_DOFS_ROTATIONY    = 0b010000,
+	JPC_ALLOWED_DOFS_ROTATIONZ    = 0b100000,
+	JPC_ALLOWED_DOFS_PLANE2D      = JPC_ALLOWED_DOFS_TRANSLATIONX | JPC_ALLOWED_DOFS_TRANSLATIONY | JPC_ALLOWED_DOFS_ROTATIONZ,
 } JPC_AllowedDOFs;
 
 ENSURE_ENUM_EQ(JPC_ALLOWED_DOFS_NONE, JPH::EAllowedDOFs::None)
@@ -276,21 +276,21 @@ ENSURE_ENUM_EQ(JPC_ALLOWED_DOFS_ROTATIONZ, JPH::EAllowedDOFs::RotationZ)
 ENSURE_ENUM_EQ(JPC_ALLOWED_DOFS_PLANE2D, JPH::EAllowedDOFs::Plane2D)
 
 typedef enum JPC_Features: uint32_t {
-    JPC_FEATURE_DOUBLE_PRECISION = (1 << 0),
-    JPC_FEATURE_NEON = (1 << 1),
-    JPC_FEATURE_SSE = (1 << 2),
-    JPC_FEATURE_SSE4_1 = (1 << 3),
-    JPC_FEATURE_SSE4_2 = (1 << 4),
-    JPC_FEATURE_AVX = (1 << 5),
-    JPC_FEATURE_AVX2 = (1 << 6),
-    JPC_FEATURE_AVX512 = (1 << 7),
-    JPC_FEATURE_F16C = (1 << 8),
-    JPC_FEATURE_LZCNT = (1 << 9),
-    JPC_FEATURE_TZCNT = (1 << 10),
-    JPC_FEATURE_FMADD = (1 << 11),
-    JPC_FEATURE_PLATFORM_DETERMINISTIC = (1 << 12),
-    JPC_FEATURE_FLOATING_POINT_EXCEPTIONS = (1 << 13),
-    JPC_FEATURE_DEBUG = (1 << 14),
+	JPC_FEATURE_DOUBLE_PRECISION = (1 << 0),
+	JPC_FEATURE_NEON = (1 << 1),
+	JPC_FEATURE_SSE = (1 << 2),
+	JPC_FEATURE_SSE4_1 = (1 << 3),
+	JPC_FEATURE_SSE4_2 = (1 << 4),
+	JPC_FEATURE_AVX = (1 << 5),
+	JPC_FEATURE_AVX2 = (1 << 6),
+	JPC_FEATURE_AVX512 = (1 << 7),
+	JPC_FEATURE_F16C = (1 << 8),
+	JPC_FEATURE_LZCNT = (1 << 9),
+	JPC_FEATURE_TZCNT = (1 << 10),
+	JPC_FEATURE_FMADD = (1 << 11),
+	JPC_FEATURE_PLATFORM_DETERMINISTIC = (1 << 12),
+	JPC_FEATURE_FLOATING_POINT_EXCEPTIONS = (1 << 13),
+	JPC_FEATURE_DEBUG = (1 << 14),
 } JPC_Features;
 
 typedef int JPC_ShapeColor;

JoltC/JoltC.h

@@ -1,10 +1,10 @@
 #pragma once
 
 #ifndef ENSURE_TESTS
-    #define ENSURE_EQUAL(a, b)
-    #define ENSURE_ENUM_EQ(a, b)
-    #define ENSURE_SIZE_ALIGN(a, b)
-    #define ENSURE_FIELD(a, b, c, d)
+	#define ENSURE_EQUAL(a, b)
+	#define ENSURE_ENUM_EQ(a, b)
+	#define ENSURE_SIZE_ALIGN(a, b)
+	#define ENSURE_FIELD(a, b, c, d)
 	#define ENSURE_NORMAL_FIELD(a, b)
 #endif
 

JoltCImpl/Test.cpp

@@ -28,7 +28,7 @@
 template<typename E>
 constexpr auto to_integral(E e) -> typename std::underlying_type<E>::type 
 {
-    return static_cast<typename std::underlying_type<E>::type>(e);
+	return static_cast<typename std::underlying_type<E>::type>(e);
 }
 
 #define ENSURE_TESTS
@@ -36,21 +36,21 @@ constexpr auto to_integral(E e) -> typename std::underlying_type<E>::type
 // Ensures that a constant value defined in JoltC doesn't drift out of sync with
 // its Jolt Physics C++ counterpart.
 #define ENSURE_EQUAL(c_const, cpp_const) \
-    static_assert(c_const == cpp_const, #c_const " did not match " #cpp_const); \
-    static_assert(std::is_same_v<decltype(c_const), decltype(cpp_const)>, "type of " #c_const " did not match type of " #cpp_const);
+	static_assert(c_const == cpp_const, #c_const " did not match " #cpp_const); \
+	static_assert(std::is_same_v<decltype(c_const), decltype(cpp_const)>, "type of " #c_const " did not match type of " #cpp_const);
 
 // Ensures that a C constant that represents an enum value matches the integral
 // value of a C++ enum.
 #define ENSURE_ENUM_EQ(c_const, cpp_enum) \
-    static_assert(c_const == to_integral(cpp_enum), #c_const " did not match " #cpp_enum); \
-    static_assert(sizeof(c_const) == sizeof(cpp_enum), #c_const " did not have same size as " #cpp_enum);
+	static_assert(c_const == to_integral(cpp_enum), #c_const " did not match " #cpp_enum); \
+	static_assert(sizeof(c_const) == sizeof(cpp_enum), #c_const " did not have same size as " #cpp_enum);
 
 // Ensures that a C struct we define is compatible in layout with its
 // corresponding C++ type, and that the C++ type is safe to represent in C.
 #define ENSURE_SIZE_ALIGN(c_type, cpp_type) \
-    static_assert(sizeof(c_type) == sizeof(cpp_type), "size of " #c_type " did not match size of " #cpp_type); \
-    static_assert(alignof(c_type) == alignof(cpp_type), "align of " #c_type " did not match align of " #cpp_type); \
-    static_assert(!std::is_polymorphic_v<cpp_type>, #cpp_type " is polymorphic and cannot be mirrored");
+	static_assert(sizeof(c_type) == sizeof(cpp_type), "size of " #c_type " did not match size of " #cpp_type); \
+	static_assert(alignof(c_type) == alignof(cpp_type), "align of " #c_type " did not match align of " #cpp_type); \
+	static_assert(!std::is_polymorphic_v<cpp_type>, #cpp_type " is polymorphic and cannot be mirrored");
 
 // Internal macro to get the type of a struct field by name.
 #define unsafe_fieldtype(st, m) decltype(((st *)(0))->m)
@@ -60,9 +60,9 @@ constexpr auto to_integral(E e) -> typename std::underlying_type<E>::type
 //
 // Comparing the offsets and alignments of each field helps provide some guarantee that
 #define ENSURE_FIELD(type0, field0, type1, field1) \
-    static_assert(offsetof(type0, field0) == offsetof(type1, field1), \
-        #type0 "." #field0 " did not have same offset as " #type1 "." #field1); \
-    ENSURE_SIZE_ALIGN(unsafe_fieldtype(type0, field0), unsafe_fieldtype(type1, field1)) \
+	static_assert(offsetof(type0, field0) == offsetof(type1, field1), \
+		#type0 "." #field0 " did not have same offset as " #type1 "." #field1); \
+	ENSURE_SIZE_ALIGN(unsafe_fieldtype(type0, field0), unsafe_fieldtype(type1, field1)) \
 
 // Just like ENSURE_FIELD, but follows the normal conventions of both JoltC and
 // Jolt Physics to reduce boilerplate.
@@ -70,6 +70,6 @@ constexpr auto to_integral(E e) -> typename std::underlying_type<E>::type
 // JoltC's types begin with JPC_ while Jolt's types are in the JPH namespace.
 // Jolt prefixes public members with 'm' but JoltC strips that name away.
 #define ENSURE_NORMAL_FIELD(basetype, basefield) \
-    ENSURE_FIELD(JPC_ ## basetype, basefield, JPH:: ## basetype, m ## basefield);
+	ENSURE_FIELD(JPC_ ## basetype, basefield, JPH::basetype, m ## basefield);
 
 #include "JoltC/JoltC.h"