Sonar fixes (#124)

Jolt/AABBTree/AABBTreeToBuffer.h

@@ -91,18 +91,16 @@ public:
 
 		struct NodeData
 		{
-											NodeData()									: mNode(nullptr), mNodeStart((uint)-1), mTriangleStart((uint)-1), mNumChildren(0), mParentChildNodeStart(nullptr), mParentTrianglesStart(nullptr) { }
-
-			const AABBTreeBuilder::Node *	mNode;										// Node that this entry belongs to
+			const AABBTreeBuilder::Node *	mNode = nullptr;							// Node that this entry belongs to
 			Vec3							mNodeBoundsMin;								// Quantized node bounds
 			Vec3							mNodeBoundsMax;
-			uint							mNodeStart;									// Start of node in mTree
-			uint							mTriangleStart;								// Start of the triangle data in mTree
-			uint							mNumChildren;								// Number of children
+			uint							mNodeStart = uint(-1);						// Start of node in mTree
+			uint							mTriangleStart = uint(-1);					// Start of the triangle data in mTree
+			uint							mNumChildren = 0;							// Number of children
 			uint							mChildNodeStart[NumChildrenPerNode];		// Start of the children of the node in mTree
 			uint							mChildTrianglesStart[NumChildrenPerNode];	// Start of the triangle data in mTree
-			uint *							mParentChildNodeStart;						// Where to store mNodeStart (to patch mChildNodeStart of my parent)
-			uint *							mParentTrianglesStart;						// Where to store mTriangleStart (to patch mChildTrianglesStart of my parent)
+			uint *							mParentChildNodeStart = nullptr;			// Where to store mNodeStart (to patch mChildNodeStart of my parent)
+			uint *							mParentTrianglesStart = nullptr;			// Where to store mTriangleStart (to patch mChildTrianglesStart of my parent)
 		};
 		
 		deque<NodeData *> to_process;

Jolt/Core/Factory.cpp

@@ -34,10 +34,10 @@ bool Factory::Register(const RTTI *inRTTI)
 		return true;
 
 	// Insert this class by name
-	mClassNameMap.insert(ClassNameMap::value_type(inRTTI->GetName(), inRTTI));
+	mClassNameMap.try_emplace(inRTTI->GetName(), inRTTI);
 
 	// Insert this class by hash
-	if (!mClassHashMap.insert(ClassHashMap::value_type(inRTTI->GetHash(), inRTTI)).second)
+	if (!mClassHashMap.try_emplace(inRTTI->GetHash(), inRTTI).second)
 	{
 		JPH_ASSERT(false, "Hash collision registering type!");
 		return false;

Jolt/Core/Profiler.cpp

@@ -96,7 +96,7 @@ void Profiler::sAggregate(int inDepth, uint32 inColor, ProfileSample *&ioSample,
 	if (aggregator_idx == ioKeyToAggregator.end())
 	{
 		// Not found, add to map and insert in array
-		ioKeyToAggregator.insert(KeyToAggregator::value_type(ioSample->mName, ioAggregators.size()));
+		ioKeyToAggregator.try_emplace(ioSample->mName, ioAggregators.size());
 		ioAggregators.emplace_back(ioSample->mName);
 		aggregator = &ioAggregators.back();
 	}

Jolt/Core/RTTI.cpp

@@ -128,7 +128,7 @@ const void *RTTI::CastTo(const void *inObject, const RTTI *inRTTI) const
 	return nullptr;
 }
 
-void RTTI::AddAttribute(RTTIAttribute *inAttribute)
+void RTTI::AddAttribute(const RTTIAttribute *inAttribute)
 { 
 	mAttributes.push_back(inAttribute); 
 }

Jolt/Core/RTTI.h

@@ -164,7 +164,7 @@ public:
 	const void *				CastTo(const void *inObject, const RTTI *inRTTI) const;
 
 	/// Attribute access
-	void						AddAttribute(RTTIAttribute *inAttribute);
+	void						AddAttribute(const RTTIAttribute *inAttribute);
 	int							GetAttributeCount() const;
 	const RTTIAttribute *		GetAttribute(int inIdx) const;
 	const RTTIAttribute *		GetAttribute(const RTTI *inRTTI, const char *inName) const;

Jolt/Core/Result.h

@@ -28,7 +28,6 @@ public:
 			break;
 
 		case EState::Invalid:
-		default:
 			break;
 		}
 	}
@@ -48,7 +47,6 @@ public:
 			break;
 
 		case EState::Invalid:
-		default:
 			break;
 		}
 
@@ -76,7 +74,6 @@ public:
 			break;
 
 		case EState::Invalid:
-		default:
 			break;
 		}
 
@@ -101,7 +98,6 @@ public:
 			break;
 
 		case EState::Invalid:
-		default:
 			break;
 		}
 
@@ -124,7 +120,6 @@ public:
 			break;
 
 		case EState::Invalid:
-		default:
 			break;
 		}
 

Jolt/Geometry/AABox.h

@@ -78,7 +78,7 @@ public:
 	}
 
 	/// Intersect this bounding box with inOther, returns the intersection
-	const AABox		Intersect(const AABox &inOther) const
+	AABox			Intersect(const AABox &inOther) const
 	{
 		return AABox(Vec3::sMax(mMin, inOther.mMin), Vec3::sMin(mMax, inOther.mMax));
 	}
@@ -98,19 +98,19 @@ public:
 	}
 
 	/// Get center of bounding box
-	const Vec3		GetCenter() const
+	Vec3			GetCenter() const
 	{
 		return 0.5f * (mMin + mMax);
 	}
 
 	/// Get extent of bounding box (half of the size)
-	const Vec3		GetExtent() const
+	Vec3			GetExtent() const
 	{
 		return 0.5f * (mMax - mMin);
 	}
 
 	/// Get size of bounding box
-	const Vec3		GetSize() const
+	Vec3			GetSize() const
 	{
 		return mMax - mMin;
 	}
@@ -193,7 +193,7 @@ public:
 	}
 
 	/// Calculate the support vector for this convex shape.
-	const Vec3		GetSupport(Vec3Arg inDirection) const
+	Vec3			GetSupport(Vec3Arg inDirection) const
 	{
 		return Vec3::sSelect(mMax, mMin, Vec3::sLess(inDirection, Vec3::sZero()));
 	}
@@ -260,7 +260,7 @@ public:
 	}
 
 	/// Get the closest point on or in this box to inPoint
-	inline Vec3		GetClosestPoint(Vec3Arg inPoint) const
+	Vec3			GetClosestPoint(Vec3Arg inPoint) const
 	{
 		return Vec3::sMin(Vec3::sMax(inPoint, mMin), mMax);
 	}

Jolt/Geometry/ConvexHullBuilder.cpp

@@ -207,7 +207,7 @@ int ConvexHullBuilder::GetNumVerticesUsed() const
 	return (int)used_verts.size();
 }
 
-bool ConvexHullBuilder::ContainsFace(const vector<int> &inIndices)
+bool ConvexHullBuilder::ContainsFace(const vector<int> &inIndices) const
 {
 	for (Face *f : mFaces)
 	{
@@ -318,9 +318,9 @@ ConvexHullBuilder::EResult ConvexHullBuilder::Initialize(int inMaxVertices, floa
 		Face *t2 = CreateTriangle(idx1, idx3, idx2);
 
 		// Link faces edges
-		LinkFace(t1->mFirstEdge, t2->mFirstEdge->mNextEdge->mNextEdge);
-		LinkFace(t1->mFirstEdge->mNextEdge, t2->mFirstEdge->mNextEdge);
-		LinkFace(t1->mFirstEdge->mNextEdge->mNextEdge, t2->mFirstEdge);
+		sLinkFace(t1->mFirstEdge, t2->mFirstEdge->mNextEdge->mNextEdge);
+		sLinkFace(t1->mFirstEdge->mNextEdge, t2->mFirstEdge->mNextEdge);
+		sLinkFace(t1->mFirstEdge->mNextEdge->mNextEdge, t2->mFirstEdge);
 
 #ifdef JPH_CONVEX_BUILDER_DEBUG
 		// Draw current state
@@ -369,9 +369,9 @@ ConvexHullBuilder::EResult ConvexHullBuilder::Initialize(int inMaxVertices, floa
 		// Create edges for face 1
 		vector<Edge *> edges_f1;
 		edges_f1.reserve(edges_2d.size());
-		for (int i = 0; i < (int)edges_2d.size(); ++i)
+		for (int start_idx : edges_2d)
 		{
-			Edge *edge = new Edge(f1, edges_2d[i]);
+			Edge *edge = new Edge(f1, start_idx);
 			if (edges_f1.empty())
 				f1->mFirstEdge = edge;
 			else
@@ -396,7 +396,7 @@ ConvexHullBuilder::EResult ConvexHullBuilder::Initialize(int inMaxVertices, floa
 
 		// Link edges
 		for (size_t i = 0; i < edges_2d.size(); ++i)
-			LinkFace(edges_f1[i], edges_f2[(2 * edges_2d.size() - 2 - i) % edges_2d.size()]);
+			sLinkFace(edges_f1[i], edges_f2[(2 * edges_2d.size() - 2 - i) % edges_2d.size()]);
 
 		// Calculate the plane for both faces
 		f1->CalculateNormalAndCentroid(mPositions.data());
@@ -422,12 +422,12 @@ ConvexHullBuilder::EResult ConvexHullBuilder::Initialize(int inMaxVertices, floa
 	Face *t4 = CreateTriangle(idx1, idx3, idx2);
 
 	// Link face edges
-	LinkFace(t1->mFirstEdge, t4->mFirstEdge->mNextEdge->mNextEdge);
-	LinkFace(t1->mFirstEdge->mNextEdge, t2->mFirstEdge->mNextEdge->mNextEdge);
-	LinkFace(t1->mFirstEdge->mNextEdge->mNextEdge, t3->mFirstEdge->mNextEdge);
-	LinkFace(t2->mFirstEdge, t4->mFirstEdge->mNextEdge);
-	LinkFace(t2->mFirstEdge->mNextEdge, t3->mFirstEdge->mNextEdge->mNextEdge);
-	LinkFace(t3->mFirstEdge, t4->mFirstEdge);
+	sLinkFace(t1->mFirstEdge, t4->mFirstEdge->mNextEdge->mNextEdge);
+	sLinkFace(t1->mFirstEdge->mNextEdge, t2->mFirstEdge->mNextEdge->mNextEdge);
+	sLinkFace(t1->mFirstEdge->mNextEdge->mNextEdge, t3->mFirstEdge->mNextEdge);
+	sLinkFace(t2->mFirstEdge, t4->mFirstEdge->mNextEdge);
+	sLinkFace(t2->mFirstEdge->mNextEdge, t3->mFirstEdge->mNextEdge->mNextEdge);
+	sLinkFace(t3->mFirstEdge, t4->mFirstEdge);
 
 	// Build the initial conflict lists
 	Faces faces { t1, t2, t3, t4 };
@@ -486,7 +486,7 @@ ConvexHullBuilder::EResult ConvexHullBuilder::Initialize(int inMaxVertices, floa
 		AddPoint(face_with_furthest_point, furthest_point_idx, coplanar_tolerance_sq, new_faces);
 
 		// Redistribute points on conflict lists belonging to removed faces
-		for (Face *face : mFaces)
+		for (const Face *face : mFaces)
 			if (face->mRemoved)
 				for (int idx : face->mConflictList)
 					AssignPointToFace(idx, new_faces);
@@ -529,7 +529,7 @@ void ConvexHullBuilder::AddPoint(Face *inFacingFace, int inIdx, float inCoplanar
 
 	// Create new faces
 	outNewFaces.reserve(edges.size());
-	for (FullEdge &e : edges)
+	for (const FullEdge &e : edges)
 	{
 		JPH_ASSERT(e.mStartIdx != e.mEndIdx);
 		Face *f = CreateTriangle(e.mStartIdx, e.mEndIdx, inIdx);
@@ -539,8 +539,8 @@ void ConvexHullBuilder::AddPoint(Face *inFacingFace, int inIdx, float inCoplanar
 	// Link edges
 	for (Faces::size_type i = 0; i < outNewFaces.size(); ++i)
 	{
-		LinkFace(outNewFaces[i]->mFirstEdge, edges[i].mNeighbourEdge);
-		LinkFace(outNewFaces[i]->mFirstEdge->mNextEdge, outNewFaces[(i + 1) % outNewFaces.size()]->mFirstEdge->mNextEdge->mNextEdge);
+		sLinkFace(outNewFaces[i]->mFirstEdge, edges[i].mNeighbourEdge);
+		sLinkFace(outNewFaces[i]->mFirstEdge->mNextEdge, outNewFaces[(i + 1) % outNewFaces.size()]->mFirstEdge->mNextEdge->mNextEdge);
 	}
 
 	// Loop on faces that were modified until nothing needs to be checked anymore
@@ -622,7 +622,7 @@ void ConvexHullBuilder::FreeFace(Face *inFace)
 	delete inFace;
 }
 
-void ConvexHullBuilder::LinkFace(Edge *inEdge1, Edge *inEdge2)
+void ConvexHullBuilder::sLinkFace(Edge *inEdge1, Edge *inEdge2)
 {
 	// Check not connected yet
 	JPH_ASSERT(inEdge1->mNeighbourEdge == nullptr);
@@ -638,7 +638,7 @@ void ConvexHullBuilder::LinkFace(Edge *inEdge1, Edge *inEdge2)
 	inEdge2->mNeighbourEdge = inEdge1;
 }
 
-void ConvexHullBuilder::UnlinkFace(Face *inFace)
+void ConvexHullBuilder::sUnlinkFace(Face *inFace)
 {
 	// Unlink from neighbours
 	Edge *e = inFace->mFirstEdge;
@@ -697,7 +697,7 @@ void ConvexHullBuilder::FindEdge(Face *inFacingFace, Vec3Arg inVertex, FullEdges
 		if (raw_e == cur_entry.mFirstEdge)
 		{
 			// This face needs to be removed, unlink it now, caller will free
-			UnlinkFace(e->mFace);
+			sUnlinkFace(e->mFace);
 
 			// Pop from stack
 			if (--cur_stack_pos < 0)
@@ -871,7 +871,7 @@ void ConvexHullBuilder::MergeCoplanarOrConcaveFaces(Face *inFace, float inCoplan
 
 		// Test if centroid of one face is above plane of the other face by inCoplanarToleranceSq.
 		// If so we need to merge other face into inFace.
-		Face *other_face = edge->mNeighbourEdge->mFace;
+		const Face *other_face = edge->mNeighbourEdge->mFace;
 		Vec3 delta_centroid = other_face->mCentroid - inFace->mCentroid;
 		float dist_other_face_centroid = inFace->mNormal.Dot(delta_centroid);
 		float signed_dist_other_face_centroid_sq = abs(dist_other_face_centroid) * dist_other_face_centroid;
@@ -1018,7 +1018,7 @@ void ConvexHullBuilder::RemoveInvalidEdges(Face *inFace, Faces &ioAffectedFaces)
 		inFace->CalculateNormalAndCentroid(mPositions.data());
 }
 
-bool ConvexHullBuilder::RemoveTwoEdgeFace(Face *inFace, Faces &ioAffectedFaces)
+bool ConvexHullBuilder::RemoveTwoEdgeFace(Face *inFace, Faces &ioAffectedFaces) const
 {
 	// Check if this face contains only 2 edges
 	Edge *edge = inFace->mFirstEdge;

Jolt/Geometry/ConvexHullBuilder.h

@@ -108,7 +108,7 @@ public:
 	int					GetNumVerticesUsed() const;
 
 	/// Returns true if the hull contains a polygon with inIndices (counter clockwise indices in mPositions)
-	bool				ContainsFace(const vector<int> &inIndices);
+	bool				ContainsFace(const vector<int> &inIndices) const;
 
 	/// Calculate the center of mass and the volume of the current convex hull
 	void				GetCenterOfMassAndVolume(Vec3 &outCenterOfMass, float &outVolume) const;
@@ -168,10 +168,10 @@ private:
 	void				FreeFaces();
 
 	/// Link face edge to other face edge
-	void				LinkFace(Edge *inEdge1, Edge *inEdge2);
+	static void			sLinkFace(Edge *inEdge1, Edge *inEdge2);
 
 	/// Unlink this face from all of its neighbours
-	void				UnlinkFace(Face *inFace);
+	static void			sUnlinkFace(Face *inFace);
 
 	/// Given one face that faces inVertex, find the edges of the faces that are not facing inVertex.
 	/// Will flag all those faces for removal.
@@ -199,7 +199,7 @@ private:
 	/// Removes inFace if it consists of only 2 edges, linking its neighbouring faces together
 	/// Any faces that need to be checked for validity will be added to ioAffectedFaces.
 	/// @return True if face was removed.
-	bool				RemoveTwoEdgeFace(Face *inFace, Faces &ioAffectedFaces);
+	bool				RemoveTwoEdgeFace(Face *inFace, Faces &ioAffectedFaces) const;
 
 #ifdef JPH_ENABLE_ASSERTS
 	/// Dumps the text representation of a face to the TTY

Jolt/Geometry/ConvexSupport.h

@@ -20,7 +20,7 @@ struct TransformedConvexObject
 	}
 
 	/// Calculate the support vector for this convex shape.
-	const Vec3				GetSupport(Vec3Arg inDirection) const
+	Vec3					GetSupport(Vec3Arg inDirection) const
 	{
 		return mTransform * mObject.GetSupport(mTransform.Multiply3x3Transposed(inDirection));
 	}
@@ -31,8 +31,8 @@ struct TransformedConvexObject
 	{
 		mObject.GetSupportingFace(mTransform.Multiply3x3Transposed(inDirection), outVertices);
 
-		for (typename VERTEX_ARRAY::size_type i = 0; i < outVertices.size(); ++i)
-			outVertices[i] = mTransform * outVertices[i];
+		for (Vec3 &v : outVertices)
+			v = mTransform * v;
 	}
 
 	Mat44					mTransform;
@@ -50,7 +50,7 @@ struct AddConvexRadius
 	}
 
 	/// Calculate the support vector for this convex shape. 
-	const Vec3				GetSupport(Vec3Arg inDirection) const
+	Vec3					GetSupport(Vec3Arg inDirection) const
 	{
 		float length = inDirection.Length();
 		return length > 0.0f ? mObject.GetSupport(inDirection) + (mRadius / length) * inDirection : mObject.GetSupport(inDirection);
@@ -71,7 +71,7 @@ struct MinkowskiDifference
 	}
 
 	/// Calculate the support vector for this convex shape. 
-	const Vec3				GetSupport(Vec3Arg inDirection) const
+	Vec3					GetSupport(Vec3Arg inDirection) const
 	{
 		return mObjectA.GetSupport(inDirection) - mObjectB.GetSupport(-inDirection);
 	}
@@ -84,7 +84,7 @@ struct MinkowskiDifference
 struct PointConvexSupport
 {
 	/// Calculate the support vector for this convex shape.
-	Vec3					GetSupport(Vec3Arg inDirection) const
+	Vec3					GetSupport([[maybe_unused]] Vec3Arg inDirection) const
 	{
 		return mPoint;
 	}
@@ -130,7 +130,7 @@ struct TriangleConvexSupport
 
 	/// Get the vertices of the face that faces inDirection the most
 	template <class VERTEX_ARRAY>
-	void					GetSupportingFace(Vec3Arg inDirection, VERTEX_ARRAY &outVertices) const
+	void					GetSupportingFace([[maybe_unused]] Vec3Arg inDirection, VERTEX_ARRAY &outVertices) const
 	{
 		outVertices.push_back(mV1);
 		outVertices.push_back(mV2);
@@ -174,7 +174,7 @@ struct PolygonConvexSupport
 
 	/// Get the vertices of the face that faces inDirection the most
 	template <class VERTEX_ARRAY_ARG>
-	void					GetSupportingFace(Vec3Arg inDirection, VERTEX_ARRAY_ARG &outVertices) const
+	void					GetSupportingFace([[maybe_unused]] Vec3Arg inDirection, VERTEX_ARRAY_ARG &outVertices) const
 	{
 		for (Vec3 v : mVertices)
 			outVertices.push_back(v);

Jolt/ObjectStream/ObjectStream.cpp

@@ -9,7 +9,7 @@ JPH_NAMESPACE_BEGIN
 
 // Define macro to declare functions for a specific primitive type
 #define JPH_DECLARE_PRIMITIVE(name)														\
-	bool				OSIsType(name *inNull, int inArrayDepth, ObjectStream::EDataType inDataType, const char *inClassName) \
+	bool				OSIsType(name *, int inArrayDepth, ObjectStream::EDataType inDataType, const char *inClassName) \
 	{																					\
 		return inArrayDepth == 0 && inDataType == ObjectStream::EDataType::T_##name;	\
 	}

Jolt/ObjectStream/ObjectStream.h

@@ -53,38 +53,38 @@ protected:
 
 // Define macro to declare functions for a specific primitive type
 #define JPH_DECLARE_PRIMITIVE(name)													\
-	bool						OSIsType(name *inNull, int inArrayDepth, ObjectStream::EDataType inDataType, const char *inClassName);
+	bool						OSIsType(name *, int inArrayDepth, ObjectStream::EDataType inDataType, const char *inClassName);
 
 // This file uses the JPH_DECLARE_PRIMITIVE macro to define all types
 #include <Jolt/ObjectStream/ObjectStreamTypes.h>
 
 // Define serialization templates
 template <class T>
-bool OSIsType(vector<T> *inArray, int inArrayDepth, ObjectStream::EDataType inDataType, const char *inClassName)	
+bool OSIsType(vector<T> *, int inArrayDepth, ObjectStream::EDataType inDataType, const char *inClassName)	
 { 
 	return (inArrayDepth > 0 && OSIsType((T *)nullptr, inArrayDepth - 1, inDataType, inClassName)); 
 }
 
 template <class T, uint N>
-bool OSIsType(StaticArray<T, N> *inArray, int inArrayDepth, ObjectStream::EDataType inDataType, const char *inClassName)	
+bool OSIsType(StaticArray<T, N> *, int inArrayDepth, ObjectStream::EDataType inDataType, const char *inClassName)	
 { 
 	return (inArrayDepth > 0 && OSIsType((T *)nullptr, inArrayDepth - 1, inDataType, inClassName)); 
 }
 
 template <class T, uint N>
-bool OSIsType(T (*inArray)[N], int inArrayDepth, ObjectStream::EDataType inDataType, const char *inClassName)	
+bool OSIsType(T (*)[N], int inArrayDepth, ObjectStream::EDataType inDataType, const char *inClassName)	
 { 
 	return (inArrayDepth > 0 && OSIsType((T *)nullptr, inArrayDepth - 1, inDataType, inClassName)); 
 }
 
 template <class T>
-bool OSIsType(Ref<T> *inNull, int inArrayDepth, ObjectStream::EDataType inDataType, const char *inClassName)
+bool OSIsType(Ref<T> *, int inArrayDepth, ObjectStream::EDataType inDataType, const char *inClassName)
 {
 	return OSIsType((T *)nullptr, inArrayDepth, inDataType, inClassName);
 }
 
 template <class T>
-bool OSIsType(RefConst<T> *inNull, int inArrayDepth, ObjectStream::EDataType inDataType, const char *inClassName)
+bool OSIsType(RefConst<T> *, int inArrayDepth, ObjectStream::EDataType inDataType, const char *inClassName)
 {
 	return OSIsType((T *)nullptr, inArrayDepth, inDataType, inClassName);
 }

Jolt/ObjectStream/ObjectStreamBinaryIn.cpp

@@ -140,7 +140,7 @@ bool ObjectStreamBinaryIn::ReadPrimitiveData(string &outPrimitive)
 	outPrimitive = data;
 
 	// Insert string in table
-	mStringTable.insert(StringTable::value_type(mNextStringID++, outPrimitive));
+	mStringTable.try_emplace(mNextStringID++, outPrimitive);
 	return true;
 }
 

Jolt/ObjectStream/ObjectStreamBinaryOut.cpp

@@ -90,7 +90,7 @@ void ObjectStreamBinaryOut::WritePrimitiveData(const string &inPrimitive)
 	}
 
 	// Insert string in table
-	mStringTable.insert(StringTable::value_type(inPrimitive, mNextStringID++));
+	mStringTable.try_emplace(inPrimitive, mNextStringID++);
 
 	// Write string
 	uint32 len = min((uint32)inPrimitive.size(), (uint32)0x7fffffff);

Jolt/ObjectStream/ObjectStreamIn.cpp

@@ -163,9 +163,9 @@ void *ObjectStreamIn::Read(const RTTI *inRTTI)
 		}
 
 		// Release unreferenced objects except the main object
-		for (IdentifierMap::const_iterator j = mIdentifierMap.begin(); j != mIdentifierMap.end(); ++j) 
+		for (const IdentifierMap::value_type &j : mIdentifierMap) 
 		{
-			const ObjectInfo &obj_info = j->second;
+			const ObjectInfo &obj_info = j.second;
 
 			if (obj_info.mInstance != main_object) 
 			{
@@ -192,9 +192,9 @@ void *ObjectStreamIn::Read(const RTTI *inRTTI)
 	else
 	{
 		// Release all objects if a fatal error occurred
-		for (IdentifierMap::iterator i = mIdentifierMap.begin(); i != mIdentifierMap.end(); ++i) 
+		for (const IdentifierMap::value_type &i : mIdentifierMap) 
 		{
-			const ObjectInfo &obj_info = i->second;
+			const ObjectInfo &obj_info = i.second;
 			obj_info.mRTTI->DestructObject(obj_info.mInstance);
 		}
 
@@ -232,7 +232,7 @@ void *ObjectStreamIn::ReadObject(const RTTI *& outRTTI)
 					if (ReadClassData(class_desc, object)) 
 					{
 						// Add object to identifier map
-						mIdentifierMap.insert(IdentifierMap::value_type(identifier, ObjectInfo(object, outRTTI)));
+						mIdentifierMap.try_emplace(identifier, object, outRTTI);
 					} 
 					else 
 					{
@@ -273,8 +273,7 @@ bool ObjectStreamIn::ReadRTTI()
 		Trace("ObjectStreamIn: Unknown class: \"%s\".", class_name.c_str());
 
 	// Insert class description
-	mClassDescriptionMap.insert(ClassDescriptionMap::value_type(class_name, ClassDescription(rtti)));
-	ClassDescription &class_desc = mClassDescriptionMap.find(class_name)->second;
+	ClassDescription &class_desc = mClassDescriptionMap.try_emplace(class_name, rtti).first->second;
 
 	// Read the number of entries in the description
 	uint32 count;
@@ -304,9 +303,9 @@ bool ObjectStreamIn::ReadRTTI()
 		}
 
 		// Read instance/pointer class name
-		if (attribute.mDataType == EDataType::Instance || attribute.mDataType == EDataType::Pointer) 
-			if (!ReadName(attribute.mClassName)) 
-				return false;
+		if ((attribute.mDataType == EDataType::Instance || attribute.mDataType == EDataType::Pointer) 
+			&& !ReadName(attribute.mClassName)) 
+			return false;
 
 		// Find attribute in rtti
 		if (rtti) 
@@ -384,7 +383,7 @@ bool ObjectStreamIn::ReadPointerData(const RTTI *inRTTI, void **inPointer, int i
 		else 
 		{
 			// Put pointer on the list to be resolved later on
-			mUnresolvedLinks.push_back(Link());
+			mUnresolvedLinks.emplace_back();
 			mUnresolvedLinks.back().mPointer = inPointer;
 			mUnresolvedLinks.back().mRefCountOffset = inRefCountOffset;
 			mUnresolvedLinks.back().mIdentifier = identifier;

Jolt/ObjectStream/ObjectStreamIn.h

@@ -119,30 +119,28 @@ private:
 	/// Class descriptions
 	struct AttributeDescription
 	{
-								AttributeDescription()									: mArrayDepth(0), mDataType(EDataType::Invalid), mIndex(-1) { }
-
-		int						mArrayDepth;
-		EDataType				mDataType;
+		int						mArrayDepth = 0;
+		EDataType				mDataType = EDataType::Invalid;
 		string					mClassName;
-		int						mIndex;
+		int						mIndex = -1;
 	};
 
 	struct ClassDescription
 	{
-								ClassDescription()										: mRTTI(nullptr) { }
+								ClassDescription() = default;
 		explicit 				ClassDescription(const RTTI *inRTTI)					: mRTTI(inRTTI) { }
 
-		const RTTI *			mRTTI;
+		const RTTI *			mRTTI = nullptr;
 		vector<AttributeDescription>	mAttributes;
 	};
 	
 	struct ObjectInfo
 	{
-								ObjectInfo()											: mInstance(nullptr), mRTTI(nullptr) { }
+								ObjectInfo() = default;
 								ObjectInfo(void *inInstance, const RTTI *inRTTI)		: mInstance(inInstance), mRTTI(inRTTI) { }
 
-		void *					mInstance;
-		const RTTI *			mRTTI;
+		void *					mInstance = nullptr;
+		const RTTI *			mRTTI = nullptr;
 	};
 
 	struct Link

Jolt/ObjectStream/ObjectStreamOut.cpp

@@ -34,7 +34,7 @@ ObjectStreamOut *ObjectStreamOut::Open(EStreamType inType, ostream &inStream)
 bool ObjectStreamOut::Write(const void *inObject, const RTTI *inRTTI)
 {
 	// Assign a new identifier to the object and write it
-	mIdentifierMap.insert(IdentifierMap::value_type(inObject, ObjectInfo(mNextIdentifier++, inRTTI)));
+	mIdentifierMap.try_emplace(inObject, mNextIdentifier++, inRTTI);
 	WriteObject(inObject);
 
 	// Write all linked objects
@@ -151,7 +151,7 @@ void ObjectStreamOut::WritePointerData(const RTTI *inRTTI, const void *inPointer
 		{
 			// Assign a new identifier to this object and queue it for serialization
 			identifier = mNextIdentifier++;
-			mIdentifierMap.insert(IdentifierMap::value_type(inPointer, ObjectInfo(identifier, inRTTI)));
+			mIdentifierMap.try_emplace(inPointer, identifier, inRTTI);
 			mObjectQueue.push(inPointer);
 		}
 	} 
@@ -168,7 +168,7 @@ void ObjectStreamOut::WritePointerData(const RTTI *inRTTI, const void *inPointer
 
 // Define macro to declare functions for a specific primitive type
 #define JPH_DECLARE_PRIMITIVE(name)															\
-	void	OSWriteDataType(ObjectStreamOut &ioStream, name *inNull)						\
+	void	OSWriteDataType(ObjectStreamOut &ioStream, name *)								\
 	{																						\
 		ioStream.WriteDataType(ObjectStream::EDataType::T_##name);							\
 	}																						\

Jolt/ObjectStream/ObjectStreamOut.h

@@ -84,9 +84,9 @@ public:
 	virtual void				WritePrimitiveData(const Mat44 &inPrimitive) = 0;
 
 	///@name Layout hints (for text output)
-	virtual void				HintNextItem()												{ }
-	virtual void				HintIndentUp()												{ }
-	virtual void				HintIndentDown()											{ }
+	virtual void				HintNextItem()												{ /* Default is do nothing */ }
+	virtual void				HintIndentUp()												{ /* Default is do nothing */ }
+	virtual void				HintIndentDown()											{ /* Default is do nothing */ }
 
 protected:
 	/// Static constructor
@@ -121,7 +121,7 @@ private:
 
 // Define macro to declare functions for a specific primitive type
 #define JPH_DECLARE_PRIMITIVE(name)															\
-	void	OSWriteDataType(ObjectStreamOut &ioStream, name *inNull);						\
+	void	OSWriteDataType(ObjectStreamOut &ioStream, name *);								\
 	void	OSWriteData(ObjectStreamOut &ioStream, const name &inPrimitive);
 
 // This file uses the JPH_DECLARE_PRIMITIVE macro to define all types
@@ -129,7 +129,7 @@ private:
 
 // Define serialization templates for dynamic arrays
 template <class T>
-void OSWriteDataType(ObjectStreamOut &ioStream, vector<T> *inNull)		
+void OSWriteDataType(ObjectStreamOut &ioStream, vector<T> *)		
 { 
 	ioStream.WriteDataType(ObjectStream::EDataType::Array); 
 	OSWriteDataType(ioStream, (T *)nullptr); 
@@ -151,7 +151,7 @@ void OSWriteData(ObjectStreamOut &ioStream, const vector<T> &inArray)
 
 /// Define serialization templates for static arrays
 template <class T, uint N>
-void OSWriteDataType(ObjectStreamOut &ioStream, StaticArray<T, N> *inNull)		
+void OSWriteDataType(ObjectStreamOut &ioStream, StaticArray<T, N> *)		
 { 
 	ioStream.WriteDataType(ObjectStream::EDataType::Array); 
 	OSWriteDataType(ioStream, (T *)nullptr); 
@@ -173,7 +173,7 @@ void OSWriteData(ObjectStreamOut &ioStream, const StaticArray<T, N> &inArray)
 
 /// Define serialization templates for C style arrays
 template <class T, uint N>
-void OSWriteDataType(ObjectStreamOut &ioStream, T (*inNull)[N])		
+void OSWriteDataType(ObjectStreamOut &ioStream, T (*)[N])		
 { 
 	ioStream.WriteDataType(ObjectStream::EDataType::Array); 
 	OSWriteDataType(ioStream, (T *)nullptr); 
@@ -195,7 +195,7 @@ void OSWriteData(ObjectStreamOut &ioStream, const T (&inArray)[N])
 
 /// Define serialization templates for references
 template <class T>
-void OSWriteDataType(ObjectStreamOut &ioStream, Ref<T> *inNull)
+void OSWriteDataType(ObjectStreamOut &ioStream, Ref<T> *)
 {
 	OSWriteDataType(ioStream, (T *)nullptr);
 }
@@ -210,7 +210,7 @@ void OSWriteData(ObjectStreamOut &ioStream, const Ref<T> &inRef)
 }
 
 template <class T>
-void OSWriteDataType(ObjectStreamOut &ioStream, RefConst<T> *inNull)
+void OSWriteDataType(ObjectStreamOut &ioStream, RefConst<T> *)
 {
 	OSWriteDataType(ioStream, (T *)nullptr);
 }

Jolt/ObjectStream/SerializableObject.h

@@ -15,12 +15,12 @@ JPH_NAMESPACE_BEGIN
 #define JPH_DECLARE_SERIALIZATION_FUNCTIONS(prefix, class_name)														\
 	prefix bool			OSReadData(ObjectStreamIn &ioStream, class_name &inInstance);								\
 	prefix bool			OSReadData(ObjectStreamIn &ioStream, class_name *&inPointer);								\
-	prefix bool			OSIsType(class_name *inNull, int inArrayDepth, ObjectStream::EDataType inDataType, const char *inClassName); \
-	prefix bool			OSIsType(class_name **inNull, int inArrayDepth, ObjectStream::EDataType inDataType, const char *inClassName); \
+	prefix bool			OSIsType(class_name *, int inArrayDepth, ObjectStream::EDataType inDataType, const char *inClassName); \
+	prefix bool			OSIsType(class_name **, int inArrayDepth, ObjectStream::EDataType inDataType, const char *inClassName); \
 	prefix void			OSWriteData(ObjectStreamOut &ioStream, const class_name &inInstance);						\
 	prefix void			OSWriteData(ObjectStreamOut &ioStream, class_name *const &inPointer);						\
-	prefix void			OSWriteDataType(ObjectStreamOut &ioStream, class_name *inNull);								\
-	prefix void			OSWriteDataType(ObjectStreamOut &ioStream, class_name **inNull);							\
+	prefix void			OSWriteDataType(ObjectStreamOut &ioStream, class_name *);									\
+	prefix void			OSWriteDataType(ObjectStreamOut &ioStream, class_name **);									\
 	prefix void			OSVisitCompounds(const class_name &inObject, const CompoundVisitor &inVisitor);				\
 	prefix void			OSVisitCompounds(const class_name *inObject, const CompoundVisitor &inVisitor);
 
@@ -34,11 +34,11 @@ JPH_NAMESPACE_BEGIN
 	{																												\
 		return ioStream.ReadPointerData(JPH_RTTI(class_name), (void **)&inPointer);									\
 	}																												\
-	bool				OSIsType(class_name *inNull, int inArrayDepth, ObjectStream::EDataType inDataType, const char *inClassName) \
+	bool				OSIsType(class_name *, int inArrayDepth, ObjectStream::EDataType inDataType, const char *inClassName) \
 	{																												\
 		return inArrayDepth == 0 && inDataType == ObjectStream::EDataType::Instance && strcmp(inClassName, #class_name) == 0; \
 	}																												\
-	bool				OSIsType(class_name **inNull, int inArrayDepth, ObjectStream::EDataType inDataType, const char *inClassName) \
+	bool				OSIsType(class_name **, int inArrayDepth, ObjectStream::EDataType inDataType, const char *inClassName) \
 	{																												\
 		return inArrayDepth == 0 && inDataType == ObjectStream::EDataType::Pointer && strcmp(inClassName, #class_name) == 0; \
 	}																												\
@@ -53,12 +53,12 @@ JPH_NAMESPACE_BEGIN
 		else 																										\
 			ioStream.WritePointerData(nullptr, nullptr);															\
 	}																												\
-	void				OSWriteDataType(ObjectStreamOut &ioStream, class_name *inNull)								\
+	void				OSWriteDataType(ObjectStreamOut &ioStream, class_name *)									\
 	{																												\
 		ioStream.WriteDataType(ObjectStream::EDataType::Instance);													\
 		ioStream.WriteName(#class_name);																			\
 	}																												\
-	void				OSWriteDataType(ObjectStreamOut &ioStream, class_name **inNull)								\
+	void				OSWriteDataType(ObjectStreamOut &ioStream, class_name **)									\
 	{																												\
 		ioStream.WriteDataType(ObjectStream::EDataType::Pointer);													\
 		ioStream.WriteName(#class_name);																			\

Jolt/Physics/Body/Body.cpp

@@ -21,13 +21,12 @@ Body Body::sFixedToWorld(false);
 Body::Body(bool) :
 	mPosition(Vec3::sZero()),
 	mRotation(Quat::sIdentity()),
+	mShape(new SphereShape(FLT_EPSILON)), // Dummy shape
 	mFriction(0.0f),
 	mRestitution(0.0f),
 	mObjectLayer(cObjectLayerInvalid),
 	mMotionType(EMotionType::Static)
 {
-	// Dummy shape
-	mShape = new SphereShape(FLT_EPSILON);
 }
 
 #ifdef _DEBUG

Jolt/Physics/Body/BodyInterface.cpp

@@ -35,7 +35,7 @@ void BodyInterface::AddBody(const BodyID &inBodyID, EActivation inActivationMode
 	BodyLockWrite lock(*mBodyLockInterface, inBodyID);
 	if (lock.Succeeded())
 	{
-		Body &body = lock.GetBody();
+		const Body &body = lock.GetBody();
 
 		// Add to broadphase
 		BodyID id = inBodyID;
@@ -53,7 +53,7 @@ void BodyInterface::RemoveBody(const BodyID &inBodyID)
 	BodyLockWrite lock(*mBodyLockInterface, inBodyID);
 	if (lock.Succeeded())
 	{
-		Body &body = lock.GetBody();
+		const Body &body = lock.GetBody();
 
 		// Deactivate body
 		if (body.IsActive())
@@ -73,7 +73,7 @@ bool BodyInterface::IsAdded(const BodyID &inBodyID) const
 
 BodyID BodyInterface::CreateAndAddBody(const BodyCreationSettings &inSettings, EActivation inActivationMode)
 {
-	Body *b = CreateBody(inSettings);
+	const Body *b = CreateBody(inSettings);
 	if (b == nullptr)
 		return BodyID(); // Out of bodies
 	AddBody(b->GetID(), inActivationMode);
@@ -118,7 +118,7 @@ void BodyInterface::ActivateBody(const BodyID &inBodyID)
 	BodyLockWrite lock(*mBodyLockInterface, inBodyID);
 	if (lock.Succeeded())
 	{
-		Body &body = lock.GetBody();
+		const Body &body = lock.GetBody();
 
 		if (!body.IsActive())
 			mBodyManager->ActivateBodies(&inBodyID, 1);
@@ -137,7 +137,7 @@ void BodyInterface::DeactivateBody(const BodyID &inBodyID)
 	BodyLockWrite lock(*mBodyLockInterface, inBodyID);
 	if (lock.Succeeded())
 	{
-		Body &body = lock.GetBody();
+		const Body &body = lock.GetBody();
 
 		if (body.IsActive())
 			mBodyManager->DeactivateBodies(&inBodyID, 1);

Jolt/Physics/Body/BodyLock.h

@@ -9,7 +9,7 @@ JPH_NAMESPACE_BEGIN
 
 /// Base class for locking bodies for the duration of the scope of this class (do not use directly)
 template <bool Write, class BodyType>
-class BodyLockBase
+class BodyLockBase : public NonCopyable
 {
 public:
 	/// Constructor will lock the body

Jolt/Physics/Body/BodyLockInterface.h

@@ -12,7 +12,7 @@
 JPH_NAMESPACE_BEGIN
 
 /// Base class interface for locking a body. Usually you will use BodyLockRead / BodyLockWrite / BodyLockMultiRead / BodyLockMultiWrite instead.
-class BodyLockInterface
+class BodyLockInterface : public NonCopyable
 {
 public:
 	/// Redefine MutexMask
@@ -60,16 +60,16 @@ public:
 
 	///@name Locking functions
 	virtual SharedMutex *		LockRead(const BodyID &inBodyID) const override		{ return nullptr; }
-	virtual void				UnlockRead(SharedMutex *inMutex) const override		{ }
+	virtual void				UnlockRead(SharedMutex *inMutex) const override		{ /* Nothing to do */ }
 	virtual SharedMutex *		LockWrite(const BodyID &inBodyID) const override	{ return nullptr; }
-	virtual void				UnlockWrite(SharedMutex *inMutex) const override	{ }
+	virtual void				UnlockWrite(SharedMutex *inMutex) const override	{ /* Nothing to do */ }
 
 	///@name Batch locking functions
 	virtual MutexMask			GetMutexMask(const BodyID *inBodies, int inNumber) const override { return 0; }
-	virtual void				LockRead(MutexMask inMutexMask) const override		{ }
-	virtual void				UnlockRead(MutexMask inMutexMask) const override	{ }
-	virtual void				LockWrite(MutexMask inMutexMask) const override		{ }
-	virtual void				UnlockWrite(MutexMask inMutexMask) const override	{ }
+	virtual void				LockRead(MutexMask inMutexMask) const override		{ /* Nothing to do */ }
+	virtual void				UnlockRead(MutexMask inMutexMask) const override	{ /* Nothing to do */ }
+	virtual void				LockWrite(MutexMask inMutexMask) const override		{ /* Nothing to do */ }
+	virtual void				UnlockWrite(MutexMask inMutexMask) const override	{ /* Nothing to do */ }
 };
 
 /// Implementation that uses the body manager to lock the correct mutex for a body

Jolt/Physics/Collision/Shape/ConvexHullShape.cpp

@@ -41,14 +41,14 @@ ShapeSettings::ShapeResult ConvexHullShapeSettings::Create() const
 }
 
 ConvexHullShape::ConvexHullShape(const ConvexHullShapeSettings &inSettings, ShapeResult &outResult) :
-	ConvexShape(EShapeSubType::ConvexHull, inSettings, outResult)
+	ConvexShape(EShapeSubType::ConvexHull, inSettings, outResult),
+	mConvexRadius(inSettings.mMaxConvexRadius)
 {
 	using BuilderFace = ConvexHullBuilder::Face;
 	using Edge = ConvexHullBuilder::Edge;
 	using Faces = vector<BuilderFace *>;
 	
-	// Copy convex radius
-	mConvexRadius = inSettings.mMaxConvexRadius;
+	// Check convex radius
 	if (mConvexRadius < 0.0f)
 	{
 		outResult.SetError("Invalid convex radius");
@@ -980,16 +980,13 @@ bool ConvexHullShape::CastRay(const RayCast &inRay, const SubShapeIDCreator &inS
 {
 	// Determine if ray hits the shape
 	float min_fraction, max_fraction;
-	if (CastRayHelper(inRay, min_fraction, max_fraction))
+	if (CastRayHelper(inRay, min_fraction, max_fraction)
+		&& min_fraction < ioHit.mFraction) // Check if this is a closer hit
 	{
-		// Check if this is a closer hit
-		if (min_fraction < ioHit.mFraction)
-		{
-			// Better hit than the current hit
-			ioHit.mFraction = min_fraction;
-			ioHit.mSubShapeID2 = inSubShapeIDCreator.GetID();
-			return true;
-		}
+		// Better hit than the current hit
+		ioHit.mFraction = min_fraction;
+		ioHit.mSubShapeID2 = inSubShapeIDCreator.GetID();
+		return true;
 	}
 	return false;
 }
@@ -998,30 +995,27 @@ void ConvexHullShape::CastRay(const RayCast &inRay, const RayCastSettings &inRay
 {
 	// Determine if ray hits the shape
 	float min_fraction, max_fraction;
-	if (CastRayHelper(inRay, min_fraction, max_fraction))
+	if (CastRayHelper(inRay, min_fraction, max_fraction)
+		&& min_fraction < ioCollector.GetEarlyOutFraction()) // Check if this is closer than the early out fraction
 	{
-		// Check if this is closer than the early out fraction
-		if (min_fraction < ioCollector.GetEarlyOutFraction())
-		{
-			// Better hit than the current hit
-			RayCastResult hit;
-			hit.mBodyID = TransformedShape::sGetBodyID(ioCollector.GetContext());
-			hit.mSubShapeID2 = inSubShapeIDCreator.GetID();
+		// Better hit than the current hit
+		RayCastResult hit;
+		hit.mBodyID = TransformedShape::sGetBodyID(ioCollector.GetContext());
+		hit.mSubShapeID2 = inSubShapeIDCreator.GetID();
 
-			// Check front side hit
-			if (inRayCastSettings.mTreatConvexAsSolid || min_fraction > 0.0f)
-			{
-				hit.mFraction = min_fraction;
-				ioCollector.AddHit(hit);
-			}
+		// Check front side hit
+		if (inRayCastSettings.mTreatConvexAsSolid || min_fraction > 0.0f)
+		{
+			hit.mFraction = min_fraction;
+			ioCollector.AddHit(hit);
+		}
 
-			// Check back side hit
-			if (inRayCastSettings.mBackFaceMode == EBackFaceMode::CollideWithBackFaces 
-				&& max_fraction < ioCollector.GetEarlyOutFraction())
-			{
-				hit.mFraction = max_fraction;
-				ioCollector.AddHit(hit);
-			}
+		// Check back side hit
+		if (inRayCastSettings.mBackFaceMode == EBackFaceMode::CollideWithBackFaces 
+			&& max_fraction < ioCollector.GetEarlyOutFraction())
+		{
+			hit.mFraction = max_fraction;
+			ioCollector.AddHit(hit);
 		}
 	}
 }

Jolt/Physics/Collision/Shape/ConvexShape.cpp

@@ -272,43 +272,40 @@ void ConvexShape::sCastConvexVsConvex(const ShapeCast &inShapeCast, const ShapeC
 	EPAPenetrationDepth epa;
 	float fraction = ioCollector.GetEarlyOutFraction();
 	Vec3 contact_point_a, contact_point_b, contact_normal;
-	if (epa.CastShape(inShapeCast.mCenterOfMassStart, inShapeCast.mDirection, inShapeCastSettings.mCollisionTolerance, inShapeCastSettings.mPenetrationTolerance, *cast_support, *target_support, cast_support->GetConvexRadius(), target_support->GetConvexRadius(), inShapeCastSettings.mReturnDeepestPoint, fraction, contact_point_a, contact_point_b, contact_normal))
+	if (epa.CastShape(inShapeCast.mCenterOfMassStart, inShapeCast.mDirection, inShapeCastSettings.mCollisionTolerance, inShapeCastSettings.mPenetrationTolerance, *cast_support, *target_support, cast_support->GetConvexRadius(), target_support->GetConvexRadius(), inShapeCastSettings.mReturnDeepestPoint, fraction, contact_point_a, contact_point_b, contact_normal)
+		&& (inShapeCastSettings.mBackFaceModeConvex == EBackFaceMode::CollideWithBackFaces 
+			|| contact_normal.Dot(inShapeCast.mDirection) > 0.0f)) // Test if backfacing
 	{
-		// Test if backfacing
-		if (inShapeCastSettings.mBackFaceModeConvex == EBackFaceMode::CollideWithBackFaces 
-			|| contact_normal.Dot(inShapeCast.mDirection) > 0.0f)
+		// Convert to world space
+		contact_point_a = inCenterOfMassTransform2 * contact_point_a;
+		contact_point_b = inCenterOfMassTransform2 * contact_point_b;
+		Vec3 contact_normal_world = inCenterOfMassTransform2.Multiply3x3(contact_normal);
+
+		ShapeCastResult result(fraction, contact_point_a, contact_point_b, contact_normal_world, false, inSubShapeIDCreator1.GetID(), inSubShapeIDCreator2.GetID(), TransformedShape::sGetBodyID(ioCollector.GetContext()));
+
+		// Gather faces
+		if (inShapeCastSettings.mCollectFacesMode == ECollectFacesMode::CollectFaces)
 		{
+			// Get supporting face of shape 1
+			Mat44 transform_1_to_2 = inShapeCast.mCenterOfMassStart;
+			transform_1_to_2.SetTranslation(transform_1_to_2.GetTranslation() + fraction * inShapeCast.mDirection);
+			cast_shape->GetSupportingFace(transform_1_to_2.Multiply3x3Transposed(-contact_normal), inShapeCast.mScale, result.mShape1Face);
+
 			// Convert to world space
-			contact_point_a = inCenterOfMassTransform2 * contact_point_a;
-			contact_point_b = inCenterOfMassTransform2 * contact_point_b;
-			Vec3 contact_normal_world = inCenterOfMassTransform2.Multiply3x3(contact_normal);
+			Mat44 transform_1_to_world = inCenterOfMassTransform2 * transform_1_to_2;
+			for (Vec3 &p : result.mShape1Face)
+				p = transform_1_to_world * p;
 
-			ShapeCastResult result(fraction, contact_point_a, contact_point_b, contact_normal_world, false, inSubShapeIDCreator1.GetID(), inSubShapeIDCreator2.GetID(), TransformedShape::sGetBodyID(ioCollector.GetContext()));
+			// Get supporting face of shape 2
+			shape->GetSupportingFace(contact_normal, inScale, result.mShape2Face);
 
-			// Gather faces
-			if (inShapeCastSettings.mCollectFacesMode == ECollectFacesMode::CollectFaces)
-			{
-				// Get supporting face of shape 1
-				Mat44 transform_1_to_2 = inShapeCast.mCenterOfMassStart;
-				transform_1_to_2.SetTranslation(transform_1_to_2.GetTranslation() + fraction * inShapeCast.mDirection);
-				cast_shape->GetSupportingFace(transform_1_to_2.Multiply3x3Transposed(-contact_normal), inShapeCast.mScale, result.mShape1Face);
-
-				// Convert to world space
-				Mat44 transform_1_to_world = inCenterOfMassTransform2 * transform_1_to_2;
-				for (Vec3 &p : result.mShape1Face)
-					p = transform_1_to_world * p;
-
-				// Get supporting face of shape 2
-				shape->GetSupportingFace(contact_normal, inScale, result.mShape2Face);
-
-				// Convert to world space
-				for (Vec3 &p : result.mShape2Face)
-					p = inCenterOfMassTransform2 * p;
-			}
-
-			JPH_IF_TRACK_NARROWPHASE_STATS(TrackNarrowPhaseCollector track;)
-			ioCollector.AddHit(result);
+			// Convert to world space
+			for (Vec3 &p : result.mShape2Face)
+				p = inCenterOfMassTransform2 * p;
 		}
+
+		JPH_IF_TRACK_NARROWPHASE_STATS(TrackNarrowPhaseCollector track;)
+		ioCollector.AddHit(result);
 	}
 }
 

Jolt/Physics/Collision/Shape/MeshShape.cpp

@@ -132,10 +132,10 @@ MeshShape::MeshShape(const MeshShapeSettings &inSettings, ShapeResult &outResult
 		else
 		{
 			// Check vertex indices
-			for (int i = 0; i < 3; ++i)
-				if (triangle.mIdx[i] >= inSettings.mTriangleVertices.size())
+			for (uint32 idx : triangle.mIdx)
+				if (idx >= inSettings.mTriangleVertices.size())
 				{
-					outResult.SetError(StringFormat("Vertex index %u is beyond vertex list (size: %u)", triangle.mIdx[i], (uint)inSettings.mTriangleVertices.size()));
+					outResult.SetError(StringFormat("Vertex index %u is beyond vertex list (size: %u)", idx, (uint)inSettings.mTriangleVertices.size()));
 					return;
 				}
 		}
@@ -178,7 +178,7 @@ MeshShape::MeshShape(const MeshShapeSettings &inSettings, ShapeResult &outResult
 
 	// Fill in active edge bits
 	IndexedTriangleList indexed_triangles = inSettings.mIndexedTriangles; // Copy indices since we're adding the 'active edge' flag
-	FindActiveEdges(inSettings.mTriangleVertices, indexed_triangles);
+	sFindActiveEdges(inSettings.mTriangleVertices, indexed_triangles);
 
 	// Create triangle splitter
 	TriangleSplitterBinning splitter(inSettings.mTriangleVertices, indexed_triangles);
@@ -215,7 +215,7 @@ MeshShape::MeshShape(const MeshShapeSettings &inSettings, ShapeResult &outResult
 	outResult.Set(this);
 }
 
-void MeshShape::FindActiveEdges(const VertexList &inVertices, IndexedTriangleList &ioIndices)
+void MeshShape::sFindActiveEdges(const VertexList &inVertices, IndexedTriangleList &ioIndices)
 {
 	struct Edge
 	{
@@ -917,7 +917,7 @@ struct MeshShape::MSGetTrianglesContext
 		if (mIsInsideOut)
 		{
 			// Scaled inside out, flip the triangles
-			for (Vec3 *v = vertices, *v_end = v + 3 * inNumTriangles; v < v_end; v += 3)
+			for (const Vec3 *v = vertices, *v_end = v + 3 * inNumTriangles; v < v_end; v += 3)
 			{
 				(mLocalToWorld * v[0]).StoreFloat3(mTriangleVertices++);
 				(mLocalToWorld * v[2]).StoreFloat3(mTriangleVertices++);
@@ -927,7 +927,7 @@ struct MeshShape::MSGetTrianglesContext
 		else
 		{
 			// Normal scale
-			for (Vec3 *v = vertices, *v_end = v + 3 * inNumTriangles; v < v_end; ++v)
+			for (const Vec3 *v = vertices, *v_end = v + 3 * inNumTriangles; v < v_end; ++v)
 				(mLocalToWorld * *v).StoreFloat3(mTriangleVertices++);
 		}
 

Jolt/Physics/Collision/Shape/MeshShape.h

@@ -138,7 +138,7 @@ private:
 	static constexpr int			MaxTrianglesPerLeaf = 1 << NumTriangleBits;					///< Number of triangles that are stored max per leaf aabb node 
 
 	/// Find and flag active edges
-	void							FindActiveEdges(const VertexList &inVertices, IndexedTriangleList &ioIndices);
+	static void						sFindActiveEdges(const VertexList &inVertices, IndexedTriangleList &ioIndices);
 
 	/// Visit the entire tree using a visitor pattern
 	template <class Visitor>

Jolt/Physics/Constraints/ConstraintManager.cpp

@@ -78,7 +78,7 @@ void ConstraintManager::GetActiveConstraints(uint32 inStartConstraintIdx, uint32
 	outNumActiveConstraints = num_active_constraints;
 }
 
-void ConstraintManager::BuildIslands(Constraint **inActiveConstraints, uint32 inNumActiveConstraints, IslandBuilder &ioBuilder, BodyManager &inBodyManager)
+void ConstraintManager::sBuildIslands(Constraint **inActiveConstraints, uint32 inNumActiveConstraints, IslandBuilder &ioBuilder, BodyManager &inBodyManager)
 {
 	JPH_PROFILE_FUNCTION();
 
@@ -89,14 +89,14 @@ void ConstraintManager::BuildIslands(Constraint **inActiveConstraints, uint32 in
 	}
 }
 
-void ConstraintManager::SortConstraints(Constraint **inActiveConstraints, uint32 *inConstraintIdxBegin, uint32 *inConstraintIdxEnd) const
+void ConstraintManager::sSortConstraints(Constraint **inActiveConstraints, uint32 *inConstraintIdxBegin, uint32 *inConstraintIdxEnd)
 {
 	JPH_PROFILE_FUNCTION();
 
 	sort(inConstraintIdxBegin, inConstraintIdxEnd, [inActiveConstraints](uint32 inLHS, uint32 inRHS) { return inActiveConstraints[inLHS]->mConstraintIndex < inActiveConstraints[inRHS]->mConstraintIndex; });
 }
 
-void ConstraintManager::SetupVelocityConstraints(Constraint **inActiveConstraints, uint32 inNumActiveConstraints, float inDeltaTime)
+void ConstraintManager::sSetupVelocityConstraints(Constraint **inActiveConstraints, uint32 inNumActiveConstraints, float inDeltaTime)
 {
 	JPH_PROFILE_FUNCTION();
 
@@ -104,7 +104,7 @@ void ConstraintManager::SetupVelocityConstraints(Constraint **inActiveConstraint
 		(*c)->SetupVelocityConstraint(inDeltaTime);
 }
 
-void ConstraintManager::SetupVelocityConstraints(Constraint **inActiveConstraints, const uint32 *inConstraintIdxBegin, const uint32 *inConstraintIdxEnd, float inDeltaTime)
+void ConstraintManager::sSetupVelocityConstraints(Constraint **inActiveConstraints, const uint32 *inConstraintIdxBegin, const uint32 *inConstraintIdxEnd, float inDeltaTime)
 {
 	JPH_PROFILE_FUNCTION();
 
@@ -115,7 +115,7 @@ void ConstraintManager::SetupVelocityConstraints(Constraint **inActiveConstraint
 	}
 }
 
-void ConstraintManager::WarmStartVelocityConstraints(Constraint **inActiveConstraints, const uint32 *inConstraintIdxBegin, const uint32 *inConstraintIdxEnd, float inWarmStartImpulseRatio)
+void ConstraintManager::sWarmStartVelocityConstraints(Constraint **inActiveConstraints, const uint32 *inConstraintIdxBegin, const uint32 *inConstraintIdxEnd, float inWarmStartImpulseRatio)
 {
 	JPH_PROFILE_FUNCTION();
 
@@ -126,7 +126,7 @@ void ConstraintManager::WarmStartVelocityConstraints(Constraint **inActiveConstr
 	}
 }
 
-bool ConstraintManager::SolveVelocityConstraints(Constraint **inActiveConstraints, const uint32 *inConstraintIdxBegin, const uint32 *inConstraintIdxEnd, float inDeltaTime)
+bool ConstraintManager::sSolveVelocityConstraints(Constraint **inActiveConstraints, const uint32 *inConstraintIdxBegin, const uint32 *inConstraintIdxEnd, float inDeltaTime)
 {
 	JPH_PROFILE_FUNCTION();
 
@@ -141,7 +141,7 @@ bool ConstraintManager::SolveVelocityConstraints(Constraint **inActiveConstraint
 	return any_impulse_applied;
 }
 
-bool ConstraintManager::SolvePositionConstraints(Constraint **inActiveConstraints, const uint32 *inConstraintIdxBegin, const uint32 *inConstraintIdxEnd, float inDeltaTime, float inBaumgarte)
+bool ConstraintManager::sSolvePositionConstraints(Constraint **inActiveConstraints, const uint32 *inConstraintIdxBegin, const uint32 *inConstraintIdxEnd, float inDeltaTime, float inBaumgarte)
 {
 	JPH_PROFILE_FUNCTION();
 

Jolt/Physics/Constraints/ConstraintManager.h

@@ -34,25 +34,25 @@ public:
 	void					GetActiveConstraints(uint32 inStartConstraintIdx, uint32 inEndConstraintIdx, Constraint **outActiveConstraints, uint32 &outNumActiveConstraints) const;
 
 	/// Link bodies to form islands
-	void					BuildIslands(Constraint **inActiveConstraints, uint32 inNumActiveConstraints, IslandBuilder &ioBuilder, BodyManager &inBodyManager);
+	static void				sBuildIslands(Constraint **inActiveConstraints, uint32 inNumActiveConstraints, IslandBuilder &ioBuilder, BodyManager &inBodyManager);
 
 	/// In order to have a deterministic simulation, we need to sort the constraints of an island before solving them
-	void					SortConstraints(Constraint **inActiveConstraints, uint32 *inConstraintIdxBegin, uint32 *inConstraintIdxEnd) const;
+	static void				sSortConstraints(Constraint **inActiveConstraints, uint32 *inConstraintIdxBegin, uint32 *inConstraintIdxEnd);
 
 	/// Prior to solving the velocity constraints, you must call SetupVelocityConstraints once to precalculate values that are independent of velocity
-	void					SetupVelocityConstraints(Constraint **inActiveConstraints, uint32 inNumActiveConstraints, float inDeltaTime);
+	static void				sSetupVelocityConstraints(Constraint **inActiveConstraints, uint32 inNumActiveConstraints, float inDeltaTime);
 
 	/// Same as above, but applies to a limited amount of constraints only
-	void					SetupVelocityConstraints(Constraint **inActiveConstraints, const uint32 *inConstraintIdxBegin, const uint32 *inConstraintIdxEnd, float inDeltaTime);
+	static void				sSetupVelocityConstraints(Constraint **inActiveConstraints, const uint32 *inConstraintIdxBegin, const uint32 *inConstraintIdxEnd, float inDeltaTime);
 
 	/// Apply last frame's impulses, must be called prior to SolveVelocityConstraints
-	void					WarmStartVelocityConstraints(Constraint **inActiveConstraints, const uint32 *inConstraintIdxBegin, const uint32 *inConstraintIdxEnd, float inWarmStartImpulseRatio);
+	static void				sWarmStartVelocityConstraints(Constraint **inActiveConstraints, const uint32 *inConstraintIdxBegin, const uint32 *inConstraintIdxEnd, float inWarmStartImpulseRatio);
 
 	/// This function is called multiple times to iteratively come to a solution that meets all velocity constraints
-	bool					SolveVelocityConstraints(Constraint **inActiveConstraints, const uint32 *inConstraintIdxBegin, const uint32 *inConstraintIdxEnd, float inDeltaTime);
+	static bool				sSolveVelocityConstraints(Constraint **inActiveConstraints, const uint32 *inConstraintIdxBegin, const uint32 *inConstraintIdxEnd, float inDeltaTime);
 
 	/// This function is called multiple times to iteratively come to a solution that meets all position constraints
-	bool					SolvePositionConstraints(Constraint **inActiveConstraints, const uint32 *inConstraintIdxBegin, const uint32 *inConstraintIdxEnd, float inDeltaTime, float inBaumgarte);
+	static bool				sSolvePositionConstraints(Constraint **inActiveConstraints, const uint32 *inConstraintIdxBegin, const uint32 *inConstraintIdxEnd, float inDeltaTime, float inBaumgarte);
 
 #ifdef JPH_DEBUG_RENDERER
 	/// Draw all constraints

Jolt/Physics/Constraints/ContactConstraintManager.cpp

@@ -796,7 +796,7 @@ void ContactConstraintManager::GetContactsFromCache(ContactAllocator &ioContactA
 			float penetration_depth = -FLT_MAX;
 			for (uint32 i = 0; i < output_cm->mNumContactPoints; ++i)
 			{
-				CachedContactPoint &ccp = output_cm->mContactPoints[i];
+				const CachedContactPoint &ccp = output_cm->mContactPoints[i];
 				manifold.mWorldSpaceContactPointsOn1[i] = transform_body1 * Vec3::sLoadFloat3Unsafe(ccp.mPosition1);
 				manifold.mWorldSpaceContactPointsOn2[i] = transform_body2 * Vec3::sLoadFloat3Unsafe(ccp.mPosition2);
 				penetration_depth = max(penetration_depth, (manifold.mWorldSpaceContactPointsOn1[0] - manifold.mWorldSpaceContactPointsOn2[0]).Dot(world_space_normal));
@@ -1290,7 +1290,7 @@ void ContactConstraintManager::ContactPointRemovedCallbacks()
 	read_cache.Clear();
 }
 
-void ContactConstraintManager::SetupVelocityConstraints(uint32 *inConstraintIdxBegin, uint32 *inConstraintIdxEnd, float inDeltaTime)
+void ContactConstraintManager::SetupVelocityConstraints(const uint32 *inConstraintIdxBegin, const uint32 *inConstraintIdxEnd, float inDeltaTime)
 {
 	JPH_PROFILE_FUNCTION();
 
@@ -1299,8 +1299,8 @@ void ContactConstraintManager::SetupVelocityConstraints(uint32 *inConstraintIdxB
 		ContactConstraint &constraint = mConstraints[*constraint_idx];
 
 		// Fetch bodies
-		Body &body1 = *constraint.mBody1;
-		Body &body2 = *constraint.mBody2;
+		const Body &body1 = *constraint.mBody1;
+		const Body &body2 = *constraint.mBody2;
 		
 		// Get body transforms
 		Mat44 transform_body1 = body1.GetCenterOfMassTransform();
@@ -1469,7 +1469,7 @@ bool ContactConstraintManager::SolveVelocityConstraints(const uint32 *inConstrai
 	return any_impulse_applied;
 }
 
-void ContactConstraintManager::StoreAppliedImpulses(const uint32 *inConstraintIdxBegin, const uint32 *inConstraintIdxEnd)
+void ContactConstraintManager::StoreAppliedImpulses(const uint32 *inConstraintIdxBegin, const uint32 *inConstraintIdxEnd) const
 {
 	// Copy back total applied impulse to cache for the next frame
 	for (const uint32 *constraint_idx = inConstraintIdxBegin; constraint_idx < inConstraintIdxEnd; ++constraint_idx)

Jolt/Physics/Constraints/ContactConstraintManager.h

@@ -148,7 +148,7 @@ public:
 	void						SortContacts(uint32 *inConstraintIdxBegin, uint32 *inConstraintIdxEnd) const;
 
 	/// AddContactConstraint will also setup the velocity constraints for the first sub step. For subsequent sub steps this function must be called prior to warm starting the constraint.
-	void						SetupVelocityConstraints(uint32 *inConstraintIdxBegin, uint32 *inConstraintIdxEnd, float inDeltaTime);
+	void						SetupVelocityConstraints(const uint32 *inConstraintIdxBegin, const uint32 *inConstraintIdxEnd, float inDeltaTime);
 
 	/// Apply last frame's impulses as an initial guess for this frame's impulses
 	void						WarmStartVelocityConstraints(const uint32 *inConstraintIdxBegin, const uint32 *inConstraintIdxEnd, float inWarmStartImpulseRatio);
@@ -186,7 +186,7 @@ public:
 	bool						SolveVelocityConstraints(const uint32 *inConstraintIdxBegin, const uint32 *inConstraintIdxEnd);
 
 	/// Save back the lambdas to the contact cache for the next warm start
-	void						StoreAppliedImpulses(const uint32 *inConstraintIdxBegin, const uint32 *inConstraintIdxEnd);
+	void						StoreAppliedImpulses(const uint32 *inConstraintIdxBegin, const uint32 *inConstraintIdxEnd) const;
 
 	/// Solve position constraints.
 	/// This is using the approach described in 'Modeling and Solving Constraints' by Erin Catto presented at GDC 2007.

Jolt/Physics/Constraints/PathConstraint.cpp

@@ -62,13 +62,11 @@ TwoBodyConstraint *PathConstraintSettings::Create(Body &inBody1, Body &inBody2)
 }
 
 PathConstraint::PathConstraint(Body &inBody1, Body &inBody2, const PathConstraintSettings &inSettings) :
-	TwoBodyConstraint(inBody1, inBody2, inSettings)
+	TwoBodyConstraint(inBody1, inBody2, inSettings),
+	mRotationConstraintType(inSettings.mRotationConstraintType),
+	mMaxFrictionForce(inSettings.mMaxFrictionForce),
+	mPositionMotorSettings(inSettings.mPositionMotorSettings)
 {
-	// Copy properties
-	mMaxFrictionForce = inSettings.mMaxFrictionForce;
-	mPositionMotorSettings = inSettings.mPositionMotorSettings;
-	mRotationConstraintType = inSettings.mRotationConstraintType;
-
 	// Calculate transform that takes us from the path start to center of mass space of body 1
 	mPathToBody1 = Mat44::sRotationTranslation(inSettings.mPathRotation, inSettings.mPathPosition - inBody1.GetShape()->GetCenterOfMass());
 

Jolt/Physics/Constraints/SixDOFConstraint.cpp

@@ -329,7 +329,6 @@ void SixDOFConstraint::SetupVelocityConstraint(float inDeltaTime)
 			switch (mMotorState[i])
 			{
 			case EMotorState::Off:
-			default:
 				if (HasFriction(axis))
 					mMotorTranslationConstraintPart[i].CalculateConstraintProperties(inDeltaTime, *mBody1, r1_plus_u, *mBody2, r2, translation_axis);
 				else
@@ -455,7 +454,6 @@ void SixDOFConstraint::SetupVelocityConstraint(float inDeltaTime)
 				switch (mMotorState[axis])
 				{
 				case EMotorState::Off:
-				default:
 					if (HasFriction(axis))
 						mMotorRotationConstraintPart[i].CalculateConstraintProperties(inDeltaTime, *mBody1, *mBody2, rotation_axis);
 					else
@@ -515,7 +513,6 @@ bool SixDOFConstraint::SolveVelocityConstraint(float inDeltaTime)
 				switch (mMotorState[i])
 				{
 				case EMotorState::Off:
-				default:
 				{
 					// Apply friction only
 					float max_lambda = mMaxFriction[i] * inDeltaTime;
@@ -539,7 +536,6 @@ bool SixDOFConstraint::SolveVelocityConstraint(float inDeltaTime)
 				switch (mMotorState[axis])
 				{
 				case EMotorState::Off:
-				default:
 				{
 					// Apply friction only
 					float max_lambda = mMaxFriction[axis] * inDeltaTime;

Jolt/Physics/Constraints/SwingTwistConstraint.cpp

@@ -147,8 +147,8 @@ void SwingTwistConstraint::SetSwingMotorState(EMotorState inState)
 		mSwingMotorState = inState; 
 
 		// Ensure that warm starting next frame doesn't apply any impulses (motor parts are repurposed for different modes)
-		for (int i = 1; i < 3; ++i)
-			mMotorConstraintPart[i].Deactivate();
+		for (AngleConstraintPart &c : mMotorConstraintPart)
+			c.Deactivate();
 	}
 }
 
@@ -247,8 +247,8 @@ void SwingTwistConstraint::SetupVelocityConstraint(float inDeltaTime)
 			else
 			{
 				// Disable friction
-				for (int i = 1; i < 3; ++i)
-					mMotorConstraintPart[i].Deactivate();
+				for (AngleConstraintPart &c : mMotorConstraintPart)
+					c.Deactivate();
 			}
 			break;
 
@@ -295,16 +295,16 @@ void SwingTwistConstraint::SetupVelocityConstraint(float inDeltaTime)
 	else
 	{
 		// Disable rotation motor
-		for (int i = 0; i < 3; ++i)
-			mMotorConstraintPart[i].Deactivate();
+		for (AngleConstraintPart &c : mMotorConstraintPart)
+			c.Deactivate();
 	}
 }
 
 void SwingTwistConstraint::WarmStartVelocityConstraint(float inWarmStartImpulseRatio)
 {
 	// Warm starting: Apply previous frame impulse
-	for (int i = 0; i < 3; ++i)
-		mMotorConstraintPart[i].WarmStart(*mBody1, *mBody2, inWarmStartImpulseRatio);
+	for (AngleConstraintPart &c : mMotorConstraintPart)
+		c.WarmStart(*mBody1, *mBody2, inWarmStartImpulseRatio);
 	mSwingTwistConstraintPart.WarmStart(*mBody1, *mBody2, inWarmStartImpulseRatio);
 	mPointConstraintPart.WarmStart(*mBody1, *mBody2, inWarmStartImpulseRatio);
 }
@@ -435,8 +435,8 @@ void SwingTwistConstraint::SaveState(StateRecorder &inStream) const
 
 	mPointConstraintPart.SaveState(inStream);
 	mSwingTwistConstraintPart.SaveState(inStream);
-	for (int i = 0; i < 3; ++i)
-		mMotorConstraintPart[i].SaveState(inStream);
+	for (const AngleConstraintPart &c : mMotorConstraintPart)
+		c.SaveState(inStream);
 
 	inStream.Write(mSwingMotorState);
 	inStream.Write(mTwistMotorState);
@@ -450,8 +450,8 @@ void SwingTwistConstraint::RestoreState(StateRecorder &inStream)
 
 	mPointConstraintPart.RestoreState(inStream);
 	mSwingTwistConstraintPart.RestoreState(inStream);
-	for (int i = 0; i < 3; ++i)
-		mMotorConstraintPart[i].RestoreState(inStream);
+	for (AngleConstraintPart &c : mMotorConstraintPart)
+		c.RestoreState(inStream);
 
 	inStream.Read(mSwingMotorState);
 	inStream.Read(mTwistMotorState);

Jolt/Physics/PhysicsSystem.cpp

@@ -713,7 +713,7 @@ void PhysicsSystem::JobSetupVelocityConstraints(float inDeltaTime, PhysicsUpdate
 	BodyAccess::Grant grant(BodyAccess::EAccess::None, BodyAccess::EAccess::Read);
 #endif
 
-	mConstraintManager.SetupVelocityConstraints(ioStep->mContext->mActiveConstraints, ioStep->mNumActiveConstraints, inDeltaTime); 
+	ConstraintManager::sSetupVelocityConstraints(ioStep->mContext->mActiveConstraints, ioStep->mNumActiveConstraints, inDeltaTime); 
 }
 
 void PhysicsSystem::JobBuildIslandsFromConstraints(PhysicsUpdateContext *ioContext, PhysicsUpdateContext::Step *ioStep)
@@ -730,7 +730,7 @@ void PhysicsSystem::JobBuildIslandsFromConstraints(PhysicsUpdateContext *ioConte
 	mIslandBuilder.PrepareNonContactConstraints(ioStep->mNumActiveConstraints, ioContext->mTempAllocator);
 
 	// Build the islands
-	mConstraintManager.BuildIslands(ioStep->mContext->mActiveConstraints, ioStep->mNumActiveConstraints, mIslandBuilder, mBodyManager);
+	ConstraintManager::sBuildIslands(ioStep->mContext->mActiveConstraints, ioStep->mNumActiveConstraints, mIslandBuilder, mBodyManager);
 }
 
 void PhysicsSystem::TrySpawnJobFindCollisions(PhysicsUpdateContext::Step *ioStep) const
@@ -1286,7 +1286,7 @@ void PhysicsSystem::JobSolveVelocityConstraints(PhysicsUpdateContext *ioContext,
 			}
 
 			// Sort constraints to give a deterministic simulation
-			mConstraintManager.SortConstraints(active_constraints, constraints_begin, constraints_end);
+			ConstraintManager::sSortConstraints(active_constraints, constraints_begin, constraints_end);
 
 			// Sort contacts to give a deterministic simulation
 			mContactManager.SortContacts(contacts_begin, contacts_end);
@@ -1315,18 +1315,18 @@ void PhysicsSystem::JobSolveVelocityConstraints(PhysicsUpdateContext *ioContext,
 				continue;
 
 			// Prepare velocity constraints. In the first step this is done when adding the contact constraints.
-			mConstraintManager.SetupVelocityConstraints(active_constraints, constraints_begin, constraints_end, delta_time);
+			ConstraintManager::sSetupVelocityConstraints(active_constraints, constraints_begin, constraints_end, delta_time);
 			mContactManager.SetupVelocityConstraints(contacts_begin, contacts_end, delta_time);
 		}
 
 		// Warm start
-		mConstraintManager.WarmStartVelocityConstraints(active_constraints, constraints_begin, constraints_end, warm_start_impulse_ratio);
+		ConstraintManager::sWarmStartVelocityConstraints(active_constraints, constraints_begin, constraints_end, warm_start_impulse_ratio);
 		mContactManager.WarmStartVelocityConstraints(contacts_begin, contacts_end, warm_start_impulse_ratio);
 
 		// Solve
 		for (int velocity_step = 0; velocity_step < mPhysicsSettings.mNumVelocitySteps; ++velocity_step)
 		{
-			bool constraint_impulse = mConstraintManager.SolveVelocityConstraints(active_constraints, constraints_begin, constraints_end, delta_time);
+			bool constraint_impulse = ConstraintManager::sSolveVelocityConstraints(active_constraints, constraints_begin, constraints_end, delta_time);
 			bool contact_impulse = mContactManager.SolveVelocityConstraints(contacts_begin, contacts_end);
 			if (!constraint_impulse && !contact_impulse)
 				break;
@@ -2081,7 +2081,7 @@ void PhysicsSystem::JobSolvePositionConstraints(PhysicsUpdateContext *ioContext,
 			float baumgarte = mPhysicsSettings.mBaumgarte;
 			for (int position_step = 0; position_step < mPhysicsSettings.mNumPositionSteps; ++position_step)
 			{
-				bool constraint_impulse = mConstraintManager.SolvePositionConstraints(active_constraints, constraints_begin, constraints_end, delta_time, baumgarte);
+				bool constraint_impulse = ConstraintManager::sSolvePositionConstraints(active_constraints, constraints_begin, constraints_end, delta_time, baumgarte);
 				bool contact_impulse = mContactManager.SolvePositionConstraints(contacts_begin, contacts_end);
 				if (!constraint_impulse && !contact_impulse)
 					break;