Ran spell checker over all comments in the Jolt folder

Build/CMakeLists.txt

@@ -21,7 +21,7 @@ option(CROSS_COMPILE_ARM "Cross compile to aarch64-linux-gnu" OFF)
 option(BUILD_SHARED_LIBS "Compile Jolt as a shared library" OFF)
 
 # When turning this option on, the library will be compiled with interprocedural optimizations enabled, also known as link-time optimizations or link-time code generation.
-# Note that if you turn this on you need to use SET_INTERPROCEDURAL_OPTIMIZATION() or set(CMAKE_INTERPROCEDURAL_OPTIMIZATION ON) to enable LTO specificly for your own project as well.
+# Note that if you turn this on you need to use SET_INTERPROCEDURAL_OPTIMIZATION() or set(CMAKE_INTERPROCEDURAL_OPTIMIZATION ON) to enable LTO specifically for your own project as well.
 # If you don't do this you may get an error: /usr/bin/ld: libJolt.a: error adding symbols: file format not recognized
 option(INTERPROCEDURAL_OPTIMIZATION "Enable interprocedural optimizations" ON)
 

Jolt/AABBTree/NodeCodec/NodeCodecQuadTreeHalfFloat.h

@@ -145,7 +145,7 @@ public:
 				uint offset = node->mNodeProperties[i] != 0? inChildrenTrianglesStart[i] : inChildrenNodeStart[i];
 				if (offset & OFFSET_NON_SIGNIFICANT_MASK)
 				{
-					outError = "NodeCodecQuadTreeHalfFloat: Internal Error: Offset has non-signifiant bits set";
+					outError = "NodeCodecQuadTreeHalfFloat: Internal Error: Offset has non-significant bits set";
 					return false;
 				}
 				offset >>= OFFSET_NON_SIGNIFICANT_BITS;
@@ -168,7 +168,7 @@ public:
 			uint offset = inRoot->HasChildren()? inRootNodeStart : inRootTrianglesStart;
 			if (offset & OFFSET_NON_SIGNIFICANT_MASK)
 			{
-				outError = "NodeCodecQuadTreeHalfFloat: Internal Error: Offset has non-signifiant bits set";
+				outError = "NodeCodecQuadTreeHalfFloat: Internal Error: Offset has non-significant bits set";
 				return false;
 			}
 			offset >>= OFFSET_NON_SIGNIFICANT_BITS;

Jolt/AABBTree/TriangleCodec/TriangleCodecIndexed8BitPackSOA4Flags.h

@@ -436,7 +436,7 @@ public:
 			return first_block[inTriangleIndex >> 2].mFlags[inTriangleIndex & 0b11];
 		}
 
-		/// Unpacks triangles and flags, convencience function
+		/// Unpacks triangles and flags, convenience function
 		JPH_INLINE void				Unpack(const void *inTriangleStart, uint32 inNumTriangles, Vec3 *outTriangles, uint8 *outTriangleFlags) const
 		{
 			Unpack(inTriangleStart, inNumTriangles, outTriangles);

Jolt/Core/JobSystem.h

@@ -198,7 +198,7 @@ protected:
 			// Releasing a reference must use release semantics...
 			if (mReferenceCount.fetch_sub(1, memory_order_release) == 1)
 			{
-				// ... so that we can use aquire to ensure that we see any updates from other threads that released a ref before freeing the job
+				// ... so that we can use acquire to ensure that we see any updates from other threads that released a ref before freeing the job
 				atomic_thread_fence(memory_order_acquire);
 				mJobSystem->FreeJob(this);
 			}

Jolt/Core/JobSystemThreadPool.h

@@ -36,7 +36,7 @@ public:
 	/// Initialize the thread pool
 	/// @param inMaxJobs Max number of jobs that can be allocated at any time
 	/// @param inMaxBarriers Max number of barriers that can be allocated at any time
-	/// @param inNumThreads Number of threads to start (the number of concurrent jobs is 1 more because the main thread will also run jobs while waiting for a barrier to complete). Use -1 to autodetect the amount of CPU's.
+	/// @param inNumThreads Number of threads to start (the number of concurrent jobs is 1 more because the main thread will also run jobs while waiting for a barrier to complete). Use -1 to auto detect the amount of CPU's.
 	void					Init(uint inMaxJobs, uint inMaxBarriers, int inNumThreads = -1);
 
 	// See JobSystem

Jolt/Core/LockFreeHashMap.h

@@ -38,7 +38,7 @@ public:
 	inline T *				FromOffset(uint32 inOffset) const;
 
 private:
-	uint8 *					mObjectStore = nullptr;			///< This contains a contigous list of objects (possibly of varying size)
+	uint8 *					mObjectStore = nullptr;			///< This contains a contiguous list of objects (possibly of varying size)
 	uint32					mObjectStoreSizeBytes = 0;		///< The size of mObjectStore in bytes
 	atomic<uint32>			mWriteOffset { 0 };				///< Next offset to write to in mObjectStore
 };

Jolt/Core/Profiler.h

@@ -150,7 +150,7 @@ private:
 	/// We measure the amount of ticks per second, this function resets the reference time point
 	void						UpdateReferenceTime();
 
-	/// Get the amount of ticks per second, note that this number will never be fully accurate as the amound of ticks per second may vary with CPU load, so this number is only to be used to give an indication of time for profiling purposes
+	/// Get the amount of ticks per second, note that this number will never be fully accurate as the amount of ticks per second may vary with CPU load, so this number is only to be used to give an indication of time for profiling purposes
 	uint64						GetProcessorTicksPerSecond() const;
 
 	/// Dump profiling statistics

Jolt/Core/Reference.h

@@ -27,7 +27,7 @@ template <class T> class RefConst;
 /// some responsibility to the programmer. The most notable point is that you cannot
 /// have one object reference another and have the other reference the first one
 /// back, because this way the reference count of both objects will never become
-/// lower than 1, resulting in a memory leak. By carefully designing your classses
+/// lower than 1, resulting in a memory leak. By carefully designing your classes
 /// (and particularly identifying who owns who in the class hierarchy) you can avoid
 /// these problems.
 template <class T>
@@ -62,7 +62,7 @@ public:
 		// Releasing a reference must use release semantics...
 		if (mRefCount.fetch_sub(1, memory_order_release) == 1)
 		{
-			// ... so that we can use aquire to ensure that we see any updates from other threads that released a ref before deleting the object
+			// ... so that we can use acquire to ensure that we see any updates from other threads that released a ref before deleting the object
 			atomic_thread_fence(memory_order_acquire);
 			delete static_cast<const T *>(this);
 		}

Jolt/Core/Semaphore.h

@@ -26,7 +26,7 @@ public:
 						Semaphore();
 						~Semaphore();
 
-	/// Release the semaphore, signalling the thread waiting on the barrier that there may be work
+	/// Release the semaphore, signaling the thread waiting on the barrier that there may be work
 	void				Release(uint inNumber = 1);
 
 	/// Acquire the semaphore inNumber times

Jolt/Geometry/ConvexHullBuilder.cpp

@@ -218,7 +218,7 @@ bool ConvexHullBuilder::AssignPointToFace(int inPositionIdx, const Faces &inFace
 			// This point is in front of the face, add it to the conflict list
 			if (best_dist_sq > best_face->mFurthestPointDistanceSq)
 			{
-				// This point is futher away than any others, update the distance and add point as last point
+				// This point is further away than any others, update the distance and add point as last point
 				best_face->mFurthestPointDistanceSq = best_dist_sq;
 				best_face->mConflictList.push_back(inPositionIdx);
 			}

Jolt/Geometry/ConvexHullBuilder.h

@@ -75,7 +75,7 @@ public:
 		Vec3			mCentroid;							///< Center of the face
 		ConflictList	mConflictList;						///< Positions associated with this edge (that are closest to this edge). The last position in the list is the point that is furthest away from the face.
 		Edge *			mFirstEdge = nullptr;				///< First edge of this face
-		float			mFurthestPointDistanceSq = 0.0f;	///< Squared distance of furtest point from the conflict list to the face
+		float			mFurthestPointDistanceSq = 0.0f;	///< Squared distance of furthest point from the conflict list to the face
 		bool			mRemoved = false;					///< Flag that indicates that face has been removed (face will be freed later)
 #ifdef JPH_CONVEX_BUILDER_DEBUG
 		int				mIteration;							///< Iteration that this face was created
@@ -144,7 +144,7 @@ private:
 	public:
 		Edge *			mNeighbourEdge;						///< Edge that this edge is connected to
 		int				mStartIdx;							///< Vertex index in mPositions that indicates the start vertex of this edge
-		int				mEndIdx;							///< Vertex index in mPosition that indicats the end vertex of this edge
+		int				mEndIdx;							///< Vertex index in mPosition that indicates the end vertex of this edge
 	};
 
 	// Private typedefs

Jolt/Geometry/ConvexHullBuilder2D.cpp

@@ -135,7 +135,7 @@ void ConvexHullBuilder2D::AssignPointToEdge(int inPositionIdx, const Array<Edge
 	{
 		if (best_dist_sq > best_edge->mFurthestPointDistanceSq)
 		{
-			// This point is futher away than any others, update the distance and add point as last point
+			// This point is further away than any others, update the distance and add point as last point
 			best_edge->mFurthestPointDistanceSq = best_dist_sq;
 			best_edge->mConflictList.push_back(inPositionIdx);
 		}

Jolt/Geometry/ConvexHullBuilder2D.h

@@ -86,10 +86,10 @@ private:
 		Vec3			mNormal;									///< Normal of the edge (not normalized)
 		Vec3			mCenter;									///< Center of the edge
 		ConflictList	mConflictList;								///< Positions associated with this edge (that are closest to this edge). Last entry is the one furthest away from the edge, remainder is unsorted.
-		Edge *			mPrevEdge = nullptr;						///< Previous edge in cicular list
+		Edge *			mPrevEdge = nullptr;						///< Previous edge in circular list
 		Edge *			mNextEdge = nullptr;						///< Next edge in circular list
 		int				mStartIdx;									///< Position index of start of this edge
-		float			mFurthestPointDistanceSq = 0.0f;			///< Squared distance of furtest point from the conflict list to the edge
+		float			mFurthestPointDistanceSq = 0.0f;			///< Squared distance of furthest point from the conflict list to the edge
 	};
 
 	const Positions &	mPositions;									///< List of positions (some of them are part of the hull)

Jolt/Geometry/EPAConvexHullBuilder.h

@@ -567,7 +567,7 @@ private:
 	{
 		if (inT->mRemoved)
 		{
-			// Valdiate that removed triangles are not connected to anything
+			// Validate that removed triangles are not connected to anything
 			for (const Edge &my_edge : inT->mEdge)
 				JPH_ASSERT(my_edge.mNeighbourTriangle == nullptr);
 		}

Jolt/Geometry/EPAPenetrationDepth.h

@@ -494,7 +494,7 @@ public:
 		return false;
 	}
 
-	/// Test if a cast shape inA moving from inStart to lambda * inStart.GetTranslation() + inDirection where lambda e [0, ioLambda> instersects inB
+	/// Test if a cast shape inA moving from inStart to lambda * inStart.GetTranslation() + inDirection where lambda e [0, ioLambda> intersects inB
 	///
 	/// @param inStart Start position and orientation of the convex object
 	/// @param inDirection Direction of the sweep (ioLambda * inDirection determines length)
@@ -504,7 +504,7 @@ public:
 	/// @param inB The convex object B, must support the GetSupport(Vec3) function.
 	/// @param inConvexRadiusA The convex radius of A, this will be added on all sides to pad A.
 	/// @param inConvexRadiusB The convex radius of B, this will be added on all sides to pad B.
-	/// @param inReturnDeepestPoint If the shapes are initially interesecting this determines if the EPA algorithm will run to find the deepest point
+	/// @param inReturnDeepestPoint If the shapes are initially intersecting this determines if the EPA algorithm will run to find the deepest point
 	/// @param ioLambda The max fraction along the sweep, on output updated with the actual collision fraction.
 	///	@param outPointA is the contact point on A
 	///	@param outPointB is the contact point on B

Jolt/Geometry/Ellipse.h

@@ -18,7 +18,7 @@ public:
 	/// Construct ellipse with radius A along the X-axis and B along the Y-axis
 					Ellipse(float inA, float inB) : mA(inA), mB(inB) { JPH_ASSERT(inA > 0.0f); JPH_ASSERT(inB > 0.0f); }
 
-	/// Check if inPoint is inside the ellipsse
+	/// Check if inPoint is inside the ellipse
 	bool			IsInside(const Float2 &inPoint) const
 	{
 		return Square(inPoint.x / mA) + Square(inPoint.y / mB) <= 1.0f;
@@ -26,7 +26,7 @@ public:
 
 	/// Get the closest point on the ellipse to inPoint
 	/// Assumes inPoint is outside the ellipse
-	/// @see Rotation Joint Limits in Quaterion Space by Gino van den Bergen, section 10.1 in Game Engine Gems 3.
+	/// @see Rotation Joint Limits in Quaternion Space by Gino van den Bergen, section 10.1 in Game Engine Gems 3.
 	Float2			GetClosestPoint(const Float2 &inPoint) const
 	{
 		float a_sq = Square(mA);

Jolt/Geometry/GJKClosestPoint.h

@@ -244,7 +244,7 @@ public:
 			{
 				// Separating axis found
 #ifdef JPH_GJK_DEBUG
-				Trace("Seperating axis");
+				Trace("Separating axis");
 #endif
 				return false;
 			}
@@ -293,7 +293,7 @@ public:
 				return true;
 			}
 
-			// The next seperation axis to test is the negative of the closest point of the Minkowski sum to the origin
+			// The next separation axis to test is the negative of the closest point of the Minkowski sum to the origin
 			// Note: This must be done before terminating as converged since the separating axis is -v
 			ioV = -ioV;
 
@@ -456,7 +456,7 @@ public:
 				break;
 			}
 
-			// The next seperation axis to test is the negative of the closest point of the Minkowski sum to the origin
+			// The next separation axis to test is the negative of the closest point of the Minkowski sum to the origin
 			// Note: This must be done before terminating as converged since the separating axis is -v
 			ioV = -ioV;
 
@@ -508,7 +508,7 @@ public:
 		outNumPoints = mNumPoints;
 	}
 
-	/// Test if a ray inRayOrigin + lambda * inRayDirection for lambda e [0, ioLambda> instersects inA
+	/// Test if a ray inRayOrigin + lambda * inRayDirection for lambda e [0, ioLambda> intersects inA
 	///
 	/// Code based upon: Ray Casting against General Convex Objects with Application to Continuous Collision Detection - Gino van den Bergen
 	///
@@ -651,7 +651,7 @@ public:
 		return true;
 	}
 
-	/// Test if a cast shape inA moving from inStart to lambda * inStart.GetTranslation() + inDirection where lambda e [0, ioLambda> instersects inB
+	/// Test if a cast shape inA moving from inStart to lambda * inStart.GetTranslation() + inDirection where lambda e [0, ioLambda> intersects inB
 	///
 	/// @param inStart Start position and orientation of the convex object
 	/// @param inDirection Direction of the sweep (ioLambda * inDirection determines length)
@@ -675,7 +675,7 @@ public:
 		return CastRay(Vec3::sZero(), inDirection, inTolerance, difference, ioLambda);
 	}
 
-	/// Test if a cast shape inA moving from inStart to lambda * inStart.GetTranslation() + inDirection where lambda e [0, ioLambda> instersects inB
+	/// Test if a cast shape inA moving from inStart to lambda * inStart.GetTranslation() + inDirection where lambda e [0, ioLambda> intersects inB
 	///
 	/// @param inStart Start position and orientation of the convex object
 	/// @param inDirection Direction of the sweep (ioLambda * inDirection determines length)
@@ -697,7 +697,7 @@ public:
 	{
 		float tolerance_sq = Square(inTolerance);
 
-		// Calculate how close A and B (without their convex radius) need to be to eachother in order for us to consider this a collision
+		// Calculate how close A and B (without their convex radius) need to be to each other in order for us to consider this a collision
 		float sum_convex_radius = inConvexRadiusA + inConvexRadiusB;
 
 		// Transform the shape to be cast to the starting position

Jolt/Geometry/OrientedBox.h

@@ -26,10 +26,10 @@ public:
 	/// Construct from axis aligned box and transform. Only works for rotation/translation matrix (no scaling / shearing).
 					OrientedBox(Mat44Arg inOrientation, const AABox &inBox)				: OrientedBox(inOrientation.PreTranslated(inBox.GetCenter()), inBox.GetExtent()) { }
 
-	/// Test if oriented boxe overlaps with axis aligned box eachother
+	/// Test if oriented box overlaps with axis aligned box each other
 	bool			Overlaps(const AABox &inBox, float inEpsilon = 1.0e-6f) const;
 
-	/// Test if two oriented boxes overlap eachother
+	/// Test if two oriented boxes overlap each other
 	bool			Overlaps(const OrientedBox &inBox, float inEpsilon = 1.0e-6f) const;
 
 	Mat44			mOrientation;														///< Transform that positions and rotates the local space axis aligned box into world space

Jolt/Math/DMat44.h

@@ -55,7 +55,7 @@ public:
 	/// Convert to Mat44 rounding to nearest
 	JPH_INLINE Mat44			ToMat44() const											{ return Mat44(mCol[0], mCol[1], mCol[2], Vec3(mCol3)); }
 
-	/// Comparsion
+	/// Comparison
 	JPH_INLINE bool				operator == (DMat44Arg inM2) const;
 	JPH_INLINE bool				operator != (DMat44Arg inM2) const						{ return !(*this == inM2); }
 

Jolt/Math/EigenValueSymmetric.h

@@ -92,7 +92,7 @@ bool EigenValueSymmetric(const Matrix &inMatrix, Matrix &outEigVec, Vector &outE
 			return true;
 		}
 
-		// On the first three sweeps use a fraction of the sum of the off diagonal elements as treshold
+		// On the first three sweeps use a fraction of the sum of the off diagonal elements as threshold
 		float tresh = sweep < 4? 0.2f * sm / Square(n) : 0.0f;
 
 		for (uint ip = 0; ip < n - 1; ++ip)

Jolt/Math/Mat44.h

@@ -94,7 +94,7 @@ public:
 	JPH_INLINE float			operator () (uint inRow, uint inColumn) const			{ JPH_ASSERT(inRow < 4); JPH_ASSERT(inColumn < 4); return mCol[inColumn].mF32[inRow]; }
 	JPH_INLINE float &			operator () (uint inRow, uint inColumn)					{ JPH_ASSERT(inRow < 4); JPH_ASSERT(inColumn < 4); return mCol[inColumn].mF32[inRow]; }
 
-	/// Comparsion
+	/// Comparison
 	JPH_INLINE bool				operator == (Mat44Arg inM2) const;
 	JPH_INLINE bool				operator != (Mat44Arg inM2) const						{ return !(*this == inM2); }
 

Jolt/Math/UVec4.inl

@@ -227,7 +227,7 @@ UVec4 UVec4::sSort4True(UVec4Arg inValue, UVec4Arg inIndex)
 	// If inValue.y is false then shift Z and further to Y and further
 	v = UVec4::sSelect(v.Swizzle<SWIZZLE_X, SWIZZLE_Z, SWIZZLE_W, SWIZZLE_W>(), v, inValue.SplatY());
 
-	// If inValue.x is false then shift X and furhter to Y and furhter
+	// If inValue.x is false then shift X and further to Y and further
 	v = UVec4::sSelect(v.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_W, SWIZZLE_W>(), v, inValue.SplatX());
 
 	return v;

Jolt/Math/Vec4.h

@@ -242,10 +242,10 @@ public:
 	/// Get vector that contains the sign of each element (returns 1.0f if positive, -1.0f if negative)
 	JPH_INLINE Vec4				GetSign() const;
 
-	/// Calcluate the sine and cosine for each element of this vector (input in radians)
+	/// Calculate the sine and cosine for each element of this vector (input in radians)
 	inline void					SinCos(Vec4 &outSin, Vec4 &outCos) const;
 
-	/// Calcluate the tangent for each element of this vector (input in radians)
+	/// Calculate the tangent for each element of this vector (input in radians)
 	inline Vec4					Tan() const;
 
 	/// Calculate the arc sine for each element of this vector (returns value in the range [-PI / 2, PI / 2])

Jolt/Physics/Body/Body.h

@@ -131,7 +131,7 @@ public:
 	CollisionGroup &		GetCollisionGroup()												{ return mCollisionGroup; }
 	void					SetCollisionGroup(const CollisionGroup &inGroup)				{ mCollisionGroup = inGroup; }
 
-	/// If this body can go to sleep. Note that disabling sleeping on a sleeping object wil not wake it up.
+	/// If this body can go to sleep. Note that disabling sleeping on a sleeping object will not wake it up.
 	bool					GetAllowSleeping() const										{ return mMotionProperties->mAllowSleeping; }
 	void					SetAllowSleeping(bool inAllow);
 
@@ -216,7 +216,7 @@ public:
 	/// @param inLinearDrag Linear drag factor that slows down the body when in the fluid (approx. 0.5)
 	/// @param inAngularDrag Angular drag factor that slows down rotation when the body is in the fluid (approx. 0.01)
 	/// @param inFluidVelocity The average velocity of the fluid (in m/s) in which the body resides
-	/// @param inGravity The graviy vector (pointing down)
+	/// @param inGravity The gravity vector (pointing down)
 	/// @param inDeltaTime Delta time of the next simulation step (in s)
 	/// @return true if an impulse was applied, false if the body was not in the fluid
 	bool					ApplyBuoyancyImpulse(RVec3Arg inSurfacePosition, Vec3Arg inSurfaceNormal, float inBuoyancy, float inLinearDrag, float inAngularDrag, Vec3Arg inFluidVelocity, Vec3Arg inGravity, float inDeltaTime);
@@ -308,7 +308,7 @@ public:
 	/// Function to update body's position (should only be called by the BodyInterface since it also requires updating the broadphase)
 	void					SetPositionAndRotationInternal(RVec3Arg inPosition, QuatArg inRotation, bool inResetSleepTimer = true);
 
-	/// Updates the center of mass and optionally mass propertes after shifting the center of mass or changes to the shape (should only be called by the BodyInterface since it also requires updating the broadphase)
+	/// Updates the center of mass and optionally mass properties after shifting the center of mass or changes to the shape (should only be called by the BodyInterface since it also requires updating the broadphase)
 	/// @param inPreviousCenterOfMass Center of mass of the shape before the alterations
 	/// @param inUpdateMassProperties When true, the mass and inertia tensor is recalculated
 	void					UpdateCenterOfMassInternal(Vec3Arg inPreviousCenterOfMass, bool inUpdateMassProperties);

Jolt/Physics/Body/BodyID.h

@@ -48,7 +48,7 @@ public:
 	/// Get sequence number of body.
 	/// The sequence number can be used to check if a body ID with the same body index has been reused by another body.
 	/// It is mainly used in multi threaded situations where a body is removed and its body index is immediately reused by a body created from another thread.
-	/// Functions querying the broadphase can (after aquiring a body lock) detect that the body has been removed (we assume that this won't happen more than 128 times in a row).
+	/// Functions querying the broadphase can (after acquiring a body lock) detect that the body has been removed (we assume that this won't happen more than 128 times in a row).
 	inline uint8			GetSequenceNumber() const
 	{
 		return uint8(mID >> 24);

Jolt/Physics/Body/BodyInterface.h

@@ -109,7 +109,7 @@ public:
 	/// @return Created body ID or an invalid ID when out of bodies
 	BodyID						CreateAndAddSoftBody(const SoftBodyCreationSettings &inSettings, EActivation inActivationMode);
 
-	/// Broadphase add state handle, used to keep track of a batch while ading to the broadphase.
+	/// Broadphase add state handle, used to keep track of a batch while adding to the broadphase.
 	using AddState = void *;
 
 	///@name Batch adding interface, see Broadphase for further documentation.

Jolt/Physics/Character/CharacterVirtual.cpp

@@ -641,7 +641,7 @@ void CharacterVirtual::SolveConstraints(Vec3Arg inVelocity, float inDeltaTime, f
 		// Get the normal of the plane we're hitting
 		Vec3 plane_normal = constraint->mPlane.GetNormal();
 
-		// If we're hitting a steep slope we cancel the velocity towards the slope first so that we don't end up slidinng up the slope
+		// If we're hitting a steep slope we cancel the velocity towards the slope first so that we don't end up sliding up the slope
 		// (we may hit the slope before the vertical wall constraint we added which will result in a small movement up causing jitter in the character movement)
 		if (constraint->mIsSteepSlope)
 		{
@@ -1256,7 +1256,7 @@ bool CharacterVirtual::WalkStairs(float inDeltaTime, Vec3Arg inStepUp, Vec3Arg i
 #endif // JPH_DEBUG_RENDERER
 
 	// Move down towards the floor.
-	// Note that we travel the same amount down as we travelled up with the specified extra
+	// Note that we travel the same amount down as we traveled up with the specified extra
 	Vec3 down = -up + inStepDownExtra;
 	if (!GetFirstContactForSweep(new_position, down, contact, dummy_ignored_contacts, inBroadPhaseLayerFilter, inObjectLayerFilter, inBodyFilter, inShapeFilter))
 		return false; // No floor found, we're in mid air, cancel stair walk

Jolt/Physics/Character/CharacterVirtual.h

@@ -195,7 +195,7 @@ public:
 
 	/// This function will return true if the character has moved into a slope that is too steep (e.g. a vertical wall).
 	/// You would call WalkStairs to attempt to step up stairs.
-	/// @param inLinearVelocity The linear velocity that the player desired. This is used to determine if we're pusing into a step.
+	/// @param inLinearVelocity The linear velocity that the player desired. This is used to determine if we're pushing into a step.
 	bool								CanWalkStairs(Vec3Arg inLinearVelocity) const;
 
 	/// When stair walking is needed, you can call the WalkStairs function to cast up, forward and down again to try to find a valid position

Jolt/Physics/Collision/CastSphereVsTriangles.cpp

@@ -111,7 +111,7 @@ float CastSphereVsTriangles::RayCylinder(Vec3Arg inRayDirection, Vec3Arg inCylin
 	if (t < 0.0f || t > 1.0f)
 		return FLT_MAX; // Intersection lies outside segment
 	if (start_dot_axis + t * direction_dot_axis < 0.0f || start_dot_axis + t * direction_dot_axis > axis_len_sq)
-		return FLT_MAX; // Intersection outside the end point of the cyclinder, stop processing, we will possibly hit a vertex
+		return FLT_MAX; // Intersection outside the end point of the cylinder, stop processing, we will possibly hit a vertex
 	return t;
 }
 

Jolt/Physics/Collision/CollideSphereVsTriangles.cpp

@@ -21,7 +21,7 @@ static constexpr uint8 sClosestFeatureToActiveEdgesMask[] = {
 	0b001,		// 0b011: Vertex 1 & 2 -> edge 1
 	0b110,		// 0b100: Vertex 3 -> edge 2 or 3
 	0b100,		// 0b101: Vertex 1 & 3 -> edge 3
-	0b010,		// 0b110: Vertex 2 & 3 -> egde 2
+	0b010,		// 0b110: Vertex 2 & 3 -> edge 2
 	// 0b111: Vertex 1, 2 & 3 -> interior, guarded by an if
 };
 

Jolt/Physics/Collision/CollisionCollector.h

@@ -32,7 +32,7 @@ class CollisionCollectorTraitsCollideShape
 {
 public:
 	/// For shape collisions we use -penetration depth to order hits.
-	static constexpr float InitialEarlyOutFraction = FLT_MAX;				///< Most shallow hit: Separatation is infinite
+	static constexpr float InitialEarlyOutFraction = FLT_MAX;				///< Most shallow hit: Separation is infinite
 	static constexpr float ShouldEarlyOutFraction = -FLT_MAX;				///< Deepest hit: Penetration is infinite
 };
 

Jolt/Physics/Collision/CollisionDispatch.h

@@ -39,7 +39,7 @@ public:
 			sCollideShape[(int)inShape1->GetSubType()][(int)inShape2->GetSubType()](inShape1, inShape2, inScale1, inScale2, inCenterOfMassTransform1, inCenterOfMassTransform2, inSubShapeIDCreator1, inSubShapeIDCreator2, inCollideShapeSettings, ioCollector, inShapeFilter);
 	}
 
-	/// Cast a shape againt this shape, passes any hits found to ioCollector.
+	/// Cast a shape against this shape, passes any hits found to ioCollector.
 	/// Note: This version takes the shape cast in local space relative to the center of mass of inShape, take a look at sCastShapeVsShapeWorldSpace if you have a shape cast in world space.
 	/// @param inShapeCastLocal The shape to cast against the other shape and its start and direction.
 	/// @param inShapeCastSettings Settings for performing the cast

Jolt/Physics/Collision/EstimateCollisionResponse.cpp

@@ -185,7 +185,7 @@ void EstimateCollisionResponse(const Body &inBody1, const Body &inBody2, const C
 				float lambda1 = impulse.mFrictionImpulse1 + constraint.mFriction1.SolveGetLambda(outResult.mTangent1, outResult);
 				float lambda2 = impulse.mFrictionImpulse2 + constraint.mFriction2.SolveGetLambda(outResult.mTangent2, outResult);
 
-				// Caclulate max impulse based on contact impulse
+				// Calculate max impulse based on contact impulse
 				float max_impulse = inCombinedFriction * impulse.mContactImpulse;
 
 				// If the total lambda that we will apply is too large, scale it back

Jolt/Physics/Collision/Shape/CompoundShape.cpp

@@ -211,7 +211,7 @@ void CompoundShape::GetSubmergedVolume(Mat44Arg inCenterOfMassTransform, Vec3Arg
 		outCenterOfBuoyancy /= outSubmergedVolume;
 
 #ifdef JPH_DEBUG_RENDERER
-	// Draw senter of buoyancy
+	// Draw center of buoyancy
 	if (sDrawSubmergedVolumes)
 		DebugRenderer::sInstance->DrawWireSphere(inBaseOffset + outCenterOfBuoyancy, 0.05f, Color::sRed, 1);
 #endif // JPH_DEBUG_RENDERER

Jolt/Physics/Collision/Shape/CompoundShapeVisitors.h

@@ -175,7 +175,7 @@ struct CompoundShape::CastShapeVisitor
 		return mCollector.ShouldEarlyOut();
 	}
 
-	/// Tests the shape cast against 4 boundign boxes, returns the distance along the shape cast where the shape first enters the bounding box
+	/// Tests the shape cast against 4 bounding boxes, returns the distance along the shape cast where the shape first enters the bounding box
 	JPH_INLINE Vec4		TestBounds(Vec4Arg inBoundsMinX, Vec4Arg inBoundsMinY, Vec4Arg inBoundsMinZ, Vec4Arg inBoundsMaxX, Vec4Arg inBoundsMaxY, Vec4Arg inBoundsMaxZ) const
 	{
 		// Scale the bounding boxes

Jolt/Physics/Collision/Shape/ConvexHullShape.cpp

@@ -123,7 +123,7 @@ ConvexHullShape::ConvexHullShape(const ConvexHullShapeSettings &inSettings, Shap
 	// Calculate inertia matrix assuming density is 1, note that element (3, 3) is garbage
 	mInertia = Mat44::sIdentity() * (covariance_matrix(0, 0) + covariance_matrix(1, 1) + covariance_matrix(2, 2)) - covariance_matrix;
 
-	// Convert polygons fron the builder to our internal representation
+	// Convert polygons from the builder to our internal representation
 	using VtxMap = UnorderedMap<int, uint8>;
 	VtxMap vertex_map;
 	for (BuilderFace *builder_face : builder_faces)
@@ -324,7 +324,7 @@ ConvexHullShape::ConvexHullShape(const ConvexHullShapeSettings &inSettings, Shap
 				// |n2x n2y n2z| |y| = - | r + c2 | <=> n point = -r (1, 1, 1) - (c1, c2, c3)
 				// |n3x n3y n3z| |z|     | r + c3 |
 				// Where point = (x, y, z), n1x is the x component of the first plane, c1 = plane constant of plane 1, etc.
-				// The relation between how much the interesection point shifts as a function of r is: -r * n^-1 (1, 1, 1) = r * offset
+				// The relation between how much the intersection point shifts as a function of r is: -r * n^-1 (1, 1, 1) = r * offset
 				// Where offset = -n^-1 (1, 1, 1) or -n^-1 (1, 1, 0) in case only the first 2 planes are offset
 				// The error that is introduced by a convex radius r is: error = r * |offset| - r
 				// So the max convex radius given error is: r = error / (|offset| - 1)

Jolt/Physics/Collision/Shape/GetTrianglesContext.h

@@ -85,7 +85,7 @@ public:
 		sCreateUnitSphereHelper(ioVertices, -Vec3::sAxisY(), -Vec3::sAxisX(), -Vec3::sAxisZ(), inDetailLevel);
 	}
 
-	/// Helper function that creates an open cyclinder of half height 1 and radius 1
+	/// Helper function that creates an open cylinder of half height 1 and radius 1
 	static void		sCreateUnitOpenCylinder(std::vector<Vec3> &ioVertices, int inDetailLevel)
 	{
 		const Vec3 bottom_offset(0.0f, -2.0f, 0.0f);

Jolt/Physics/Collision/Shape/HeightFieldShape.h

@@ -56,8 +56,8 @@ public:
 	virtual ShapeResult				Create() const override;
 
 	/// Determine the minimal and maximal value of mHeightSamples (will ignore cNoCollisionValue)
-	/// @param outMinValue The minimal value fo mHeightSamples or FLT_MAX if no samples have collision
-	/// @param outMaxValue The maximal value fo mHeightSamples or -FLT_MAX if no samples have collision
+	/// @param outMinValue The minimal value of mHeightSamples or FLT_MAX if no samples have collision
+	/// @param outMaxValue The maximal value of mHeightSamples or -FLT_MAX if no samples have collision
 	/// @param outQuantizationScale (value - outMinValue) * outQuantizationScale quantizes a height sample to 16 bits
 	void							DetermineMinAndMaxSample(float &outMinValue, float &outMaxValue, float &outQuantizationScale) const;
 
@@ -312,7 +312,7 @@ private:
 		uint16						mMax[4];
 	};
 
-	/// For block (inBlockX, inBlockY) get get the range block and the entry in the range block
+	/// For block (inBlockX, inBlockY) get the range block and the entry in the range block
 	inline void						GetRangeBlock(uint inBlockX, uint inBlockY, uint inRangeBlockOffset, uint inRangeBlockStride, RangeBlock *&outBlock, uint &outIndexInBlock);
 
 	/// Offset of first RangedBlock in grid per level

Jolt/Physics/Collision/Shape/Shape.cpp

@@ -297,7 +297,7 @@ void Shape::sCollidePointUsingRayCast(const Shape &inShape, Vec3Arg inPoint, con
 		RayCastSettings settings;
 		settings.mBackFaceMode = EBackFaceMode::CollideWithBackFaces;
 
-		// Cast a ray that's 10% longer than the heigth of our bounding box
+		// Cast a ray that's 10% longer than the height of our bounding box
 		inShape.CastRay(RayCast { inPoint, 1.1f * bounds.GetSize().GetY() * Vec3::sAxisY() }, settings, inSubShapeIDCreator, collector, inShapeFilter);
 
 		// Odd amount of hits means inside

Jolt/Physics/Constraints/ConeConstraint.h

@@ -19,7 +19,7 @@ public:
 	// See: ConstraintSettings::SaveBinaryState
 	virtual void				SaveBinaryState(StreamOut &inStream) const override;
 
-	/// Create an an instance of this constraint
+	/// Create an instance of this constraint
 	virtual TwoBodyConstraint *	Create(Body &inBody1, Body &inBody2) const override;
 
 	/// This determines in which space the constraint is setup, all properties below should be in the specified space

Jolt/Physics/Constraints/ConstraintPart/RotationEulerConstraintPart.h

@@ -22,7 +22,7 @@ JPH_NAMESPACE_BEGIN
 /// \f[J = \begin{bmatrix}0 & -E & 0 & E\end{bmatrix}\f]
 ///
 /// Used terms (here and below, everything in world space):\n
-/// delta_theta_* = difference in rotation between initial rotation of bodyies 1 and 2.\n
+/// delta_theta_* = difference in rotation between initial rotation of bodies 1 and 2.\n
 /// x1, x2 = center of mass for the bodies.\n
 /// v = [v1, w1, v2, w2].\n
 /// v1, v2 = linear velocity of body 1 and 2.\n
@@ -70,7 +70,7 @@ public:
 		//
 		// q20 = initial orientation of body 2
 		// q10 = initial orientation of body 1
-		// r0 = initial rotation rotation from body 1 to body 2
+		// r0 = initial rotation from body 1 to body 2
 		return inBody2.GetRotation().Conjugated() * inBody1.GetRotation();
 	}
 
@@ -90,7 +90,7 @@ public:
 		// where:
 		//
 		// q10, q20 = world space initial orientation of body 1 and 2
-		// r0 = initial rotation rotation from body 1 to body 2 in local space of body 1
+		// r0 = initial rotation from body 1 to body 2 in local space of body 1
 		//
 		// We can also write this in terms of the constraint matrices:
 		//

Jolt/Physics/Constraints/ConstraintPart/RotationQuatConstraintPart.h

@@ -121,7 +121,7 @@ public:
 		//
 		// q20 = initial orientation of body 2
 		// q10 = initial orientation of body 1
-		// r0 = initial rotation rotation from body 1 to body 2
+		// r0 = initial rotation from body 1 to body 2
 		return inBody2.GetRotation().Conjugated() * inBody1.GetRotation();
 	}
 

Jolt/Physics/Constraints/ConstraintPart/SpringPart.h

@@ -15,7 +15,7 @@ class SpringPart
 private:
 	JPH_INLINE void				CalculateSpringPropertiesHelper(float inDeltaTime, float inInvEffectiveMass, float inBias, float inC, float inStiffness, float inDamping, float &outEffectiveMass)
 	{
-		// Soft constraints as per: Soft Contraints: Reinventing The Spring - Erin Catto - GDC 2011
+		// Soft constraints as per: Soft Constraints: Reinventing The Spring - Erin Catto - GDC 2011
 
 		// Note that the calculation of beta and gamma below are based on the solution of an implicit Euler integration scheme
 		// This scheme is unconditionally stable but has built in damping, so even when you set the damping ratio to 0 there will still

Jolt/Physics/Constraints/ConstraintPart/SwingTwistConstraintPart.h

@@ -71,7 +71,7 @@ public:
 		mSwingZHalfMinAngle = half_swing.GetZ();
 		mSwingZHalfMaxAngle = half_swing.GetW();
 
-		// Store axis flags which are used at runtime to quickly decided which contraints to apply
+		// Store axis flags which are used at runtime to quickly decided which constraints to apply
 		mRotationFlags = 0;
 		if (inTwistMinAngle > -cLockedAngle && inTwistMaxAngle < cLockedAngle)
 		{
@@ -298,7 +298,7 @@ public:
 			else
 			{
 				// Use pyramid to solve limits
-				// The quaterion rotating by angle y around the Y axis then rotating by angle z around the Z axis is:
+				// The quaternion rotating by angle y around the Y axis then rotating by angle z around the Z axis is:
 				// q = Quat::sRotation(Vec3::sAxisZ(), z) * Quat::sRotation(Vec3::sAxisY(), y)
 				// [q.x, q.y, q.z, q.w] = [-sin(y / 2) * sin(z / 2), sin(y / 2) * cos(z / 2), cos(y / 2) * sin(z / 2), cos(y / 2) * cos(z / 2)]
 				// So we can calculate y / 2 = atan2(q.y, q.w) and z / 2 = atan2(q.z, q.w)
@@ -430,7 +430,7 @@ public:
 			{
 				mWorldSpaceTwistLimitRotationAxis = (inConstraintToWorld * q_swing).RotateAxisX();
 				if ((clamped_axis & cClampedTwistMin) != 0)
-					mWorldSpaceTwistLimitRotationAxis = -mWorldSpaceTwistLimitRotationAxis; // Flip axis if hittin min limit because the impulse limit is going to be between [-FLT_MAX, 0]
+					mWorldSpaceTwistLimitRotationAxis = -mWorldSpaceTwistLimitRotationAxis; // Flip axis if hitting min limit because the impulse limit is going to be between [-FLT_MAX, 0]
 				mTwistLimitConstraintPart.CalculateConstraintProperties(inBody1, inBody2, mWorldSpaceTwistLimitRotationAxis);
 			}
 			else

Jolt/Physics/Constraints/DistanceConstraint.h

@@ -18,7 +18,7 @@ public:
 	// See: ConstraintSettings::SaveBinaryState
 	virtual void				SaveBinaryState(StreamOut &inStream) const override;
 
-	/// Create an an instance of this constraint
+	/// Create an instance of this constraint
 	virtual TwoBodyConstraint *	Create(Body &inBody1, Body &inBody2) const override;
 
 	/// This determines in which space the constraint is setup, all properties below should be in the specified space

Jolt/Physics/Constraints/FixedConstraint.h

@@ -19,7 +19,7 @@ public:
 	// See: ConstraintSettings::SaveBinaryState
 	virtual void				SaveBinaryState(StreamOut &inStream) const override;
 
-	/// Create an an instance of this constraint
+	/// Create an instance of this constraint
 	virtual TwoBodyConstraint *	Create(Body &inBody1, Body &inBody2) const override;
 
 	/// This determines in which space the constraint is setup, all properties below should be in the specified space
@@ -44,7 +44,7 @@ protected:
 };
 
 /// A fixed constraint welds two bodies together removing all degrees of freedom between them.
-/// This variant uses euler angles for the rotation constraint.
+/// This variant uses Euler angles for the rotation constraint.
 class JPH_EXPORT FixedConstraint final : public TwoBodyConstraint
 {
 public:

Jolt/Physics/Constraints/GearConstraint.h

@@ -18,7 +18,7 @@ public:
 	// See: ConstraintSettings::SaveBinaryState
 	virtual void				SaveBinaryState(StreamOut &inStream) const override;
 
-	/// Create an an instance of this constraint.
+	/// Create an instance of this constraint.
 	virtual TwoBodyConstraint *	Create(Body &inBody1, Body &inBody2) const override;
 
 	/// Defines the ratio between the rotation of both gears

Jolt/Physics/Constraints/HingeConstraint.h

@@ -21,7 +21,7 @@ public:
 	// See: ConstraintSettings::SaveBinaryState
 	virtual void				SaveBinaryState(StreamOut &inStream) const override;
 
-	/// Create an an instance of this constraint
+	/// Create an instance of this constraint
 	virtual TwoBodyConstraint *	Create(Body &inBody1, Body &inBody2) const override;
 
 	/// This determines in which space the constraint is setup, all properties below should be in the specified space

Jolt/Physics/Constraints/PathConstraint.h

@@ -21,7 +21,7 @@ enum class EPathRotationConstraintType
 	ConstrainAroundTangent,			///< Only allow rotation around the tangent vector (following the path)
 	ConstrainAroundNormal,			///< Only allow rotation around the normal vector (perpendicular to the path)
 	ConstrainAroundBinormal,		///< Only allow rotation around the binormal vector (perpendicular to the path)
-	ConstrainToPath,				///< Fully constrain the rotation of body 2 to the path (follwing the tangent and normal of the path)
+	ConstrainToPath,				///< Fully constrain the rotation of body 2 to the path (following the tangent and normal of the path)
 	FullyConstrained,				///< Fully constrain the rotation of the body 2 to the rotation of body 1
 };
 
@@ -34,7 +34,7 @@ public:
 	// See: ConstraintSettings::SaveBinaryState
 	virtual void					SaveBinaryState(StreamOut &inStream) const override;
 
-	/// Create an an instance of this constraint
+	/// Create an instance of this constraint
 	virtual TwoBodyConstraint *		Create(Body &inBody1, Body &inBody2) const override;
 
 	/// The path that constrains the two bodies

Jolt/Physics/Constraints/PathConstraintPath.h

@@ -44,7 +44,7 @@ public:
 	/// @param outPathBinormal Returns the binormal to the path at outPathPosition (a vector so that normal cross tangent = binormal)
 	virtual void		GetPointOnPath(float inFraction, Vec3 &outPathPosition, Vec3 &outPathTangent, Vec3 &outPathNormal, Vec3 &outPathBinormal) const = 0;
 
-	/// If the path is looping or not. If a path is looping, the first and last point are automatically connected to eachother. They should not be the same points.
+	/// If the path is looping or not. If a path is looping, the first and last point are automatically connected to each other. They should not be the same points.
 	void				SetIsLooping(bool inIsLooping)						{ mIsLooping = inIsLooping; }
 	bool				IsLooping() const									{ return mIsLooping; }
 
@@ -64,7 +64,7 @@ protected:
 	virtual void		RestoreBinaryState(StreamIn &inStream);
 
 private:
-	/// If the path is looping or not. If a path is looping, the first and last point are automatically connected to eachother. They should not be the same points.
+	/// If the path is looping or not. If a path is looping, the first and last point are automatically connected to each other. They should not be the same points.
 	bool				mIsLooping = false;
 };
 

Jolt/Physics/Constraints/PointConstraint.h

@@ -18,7 +18,7 @@ public:
 	// See: ConstraintSettings::SaveBinaryState
 	virtual void				SaveBinaryState(StreamOut &inStream) const override;
 
-	/// Create an an instance of this constraint
+	/// Create an instance of this constraint
 	virtual TwoBodyConstraint *	Create(Body &inBody1, Body &inBody2) const override;
 
 	/// This determines in which space the constraint is setup, all properties below should be in the specified space

Jolt/Physics/Constraints/PulleyConstraint.h

@@ -23,7 +23,7 @@ public:
 	// See: ConstraintSettings::SaveBinaryState
 	virtual void				SaveBinaryState(StreamOut &inStream) const override;
 
-	/// Create an an instance of this constraint
+	/// Create an instance of this constraint
 	virtual TwoBodyConstraint *	Create(Body &inBody1, Body &inBody2) const override;
 
 	/// This determines in which space the constraint is setup, specified properties below should be in the specified space

Jolt/Physics/Constraints/RackAndPinionConstraint.h

@@ -18,7 +18,7 @@ public:
 	// See: ConstraintSettings::SaveBinaryState
 	virtual void				SaveBinaryState(StreamOut &inStream) const override;
 
-	/// Create an an instance of this constraint.
+	/// Create an instance of this constraint.
 	/// Body1 should be the pinion (gear) and body 2 the rack (slider).
 	virtual TwoBodyConstraint *	Create(Body &inBody1, Body &inBody2) const override;
 

Jolt/Physics/Constraints/SixDOFConstraint.cpp

@@ -443,7 +443,7 @@ void SixDOFConstraint::SetupVelocityConstraint(float inDeltaTime)
 	// Setup rotation constraints
 	if (IsRotationFullyConstrained())
 	{
-		// All rotation locked: Setup rotation contraint
+		// All rotation locked: Setup rotation constraint
 		mRotationConstraintPart.CalculateConstraintProperties(*mBody1, Mat44::sRotation(mBody1->GetRotation()), *mBody2, Mat44::sRotation(mBody2->GetRotation()));
 	}
 	else if (IsRotationConstrained() || mRotationMotorActive)

Jolt/Physics/Constraints/SixDOFConstraint.h

@@ -38,7 +38,7 @@ public:
 	// See: ConstraintSettings::SaveBinaryState
 	virtual void				SaveBinaryState(StreamOut &inStream) const override;
 
-	/// Create an an instance of this constraint
+	/// Create an instance of this constraint
 	virtual TwoBodyConstraint *	Create(Body &inBody1, Body &inBody2) const override;
 
 	/// This determines in which space the constraint is setup, all properties below should be in the specified space

Jolt/Physics/Constraints/SliderConstraint.h

@@ -21,7 +21,7 @@ public:
 	// See: ConstraintSettings::SaveBinaryState
 	virtual void				SaveBinaryState(StreamOut &inStream) const override;
 
-	/// Create an an instance of this constraint.
+	/// Create an instance of this constraint.
 	/// Note that the rotation constraint will be solved from body 1. This means that if body 1 and body 2 have different masses / inertias (kinematic body = infinite mass / inertia), body 1 should be the heaviest body.
 	virtual TwoBodyConstraint *	Create(Body &inBody1, Body &inBody2) const override;
 

Jolt/Physics/Constraints/SpringSettings.h

@@ -63,7 +63,7 @@ public:
 	/// When mSpringMode = ESpringMode::FrequencyAndDamping mDamping is the damping ratio (0 = no damping, 1 = critical damping).
 	/// When mSpringMode = ESpringMode::StiffnessAndDamping mDamping is the damping (c) in the spring equation F = -k * x - c * v for a linear or T = -k * theta - c * w for an angular spring.
 	/// Note that if you set mDamping = 0, you will not get an infinite oscillation. Because we integrate physics using an explicit Euler scheme, there is always energy loss.
-	/// This is done to keep the simulation from exploding, because with a damping of 0 and even the slightest rounding error, the oscillation could become bigger and bigger until the simluation explodes.
+	/// This is done to keep the simulation from exploding, because with a damping of 0 and even the slightest rounding error, the oscillation could become bigger and bigger until the simulation explodes.
 	float						mDamping = 0.0f;
 };
 

Jolt/Physics/Constraints/SwingTwistConstraint.h

@@ -25,7 +25,7 @@ public:
 	// See: ConstraintSettings::SaveBinaryState
 	virtual void				SaveBinaryState(StreamOut &inStream) const override;
 
-	/// Create an an instance of this constraint
+	/// Create an instance of this constraint
 	virtual TwoBodyConstraint *	Create(Body &inBody1, Body &inBody2) const override;
 
 	/// This determines in which space the constraint is setup, all properties below should be in the specified space

Jolt/Physics/Constraints/TwoBodyConstraint.h

@@ -17,7 +17,7 @@ class JPH_EXPORT TwoBodyConstraintSettings : public ConstraintSettings
 public:
 	JPH_DECLARE_SERIALIZABLE_ABSTRACT(JPH_EXPORT, TwoBodyConstraintSettings)
 
-	/// Create an an instance of this constraint
+	/// Create an instance of this constraint
 	/// You can use Body::sFixedToWorld for inBody1 if you want to attach inBody2 to the world
 	virtual TwoBodyConstraint *	Create(Body &inBody1, Body &inBody2) const = 0;
 };

Jolt/Physics/LargeIslandSplitter.cpp

@@ -294,7 +294,7 @@ bool LargeIslandSplitter::SplitIsland(uint32 inIslandIndex, const IslandBuilder
 	inIslandBuilder.GetConstraintsInIsland(inIslandIndex, constraints_start, constraints_end);
 	uint num_constraints_in_island = uint(constraints_end - constraints_start);
 
-	// Check if it exceeds the treshold
+	// Check if it exceeds the threshold
 	uint island_size = num_contacts_in_island + num_constraints_in_island;
 	if (island_size < cLargeIslandTreshold)
 		return false;

Jolt/Physics/PhysicsSettings.h

@@ -46,7 +46,7 @@ struct PhysicsSettings
 	/// step which may not be the actual closest points by the time the two objects hit (unit: meters)
 	float		mSpeculativeContactDistance = 0.02f;
 
-	/// How much bodies are allowed to sink into eachother (unit: meters)
+	/// How much bodies are allowed to sink into each other (unit: meters)
 	float		mPenetrationSlop = 0.02f;
 
 	/// Fraction of its inner radius a body must move per step to enable casting for the LinearCast motion quality

Jolt/Physics/PhysicsSystem.cpp

@@ -609,7 +609,7 @@ EPhysicsUpdateError PhysicsSystem::Update(float inDeltaTime, int inCollisionStep
 
 	// Return any errors
 	EPhysicsUpdateError errors = static_cast<EPhysicsUpdateError>(context.mErrors.load(memory_order_acquire));
-	JPH_ASSERT(errors == EPhysicsUpdateError::None, "An error occured during the physics update, see EPhysicsUpdateError for more information");
+	JPH_ASSERT(errors == EPhysicsUpdateError::None, "An error occurred during the physics update, see EPhysicsUpdateError for more information");
 	return errors;
 }
 
@@ -1497,12 +1497,12 @@ void PhysicsSystem::JobIntegrateVelocity(const PhysicsUpdateContext *ioContext,
 			// For motion type discrete we need to do this anyway, for motion type linear cast we have multiple choices
 			// 1. Rotate the body first and then sweep
 			// 2. First sweep and then rotate the body at the end
-			// 3. Pick some inbetween rotation (e.g. half way), then sweep and finally rotate the remainder
+			// 3. Pick some in between rotation (e.g. half way), then sweep and finally rotate the remainder
 			// (1) has some clear advantages as when a long thin body hits a surface away from the center of mass, this will result in a large angular velocity and a limited reduction in linear velocity.
 			// When simulation the rotation first before doing the translation, the body will be able to rotate away from the contact point allowing the center of mass to approach the surface. When using
 			// approach (2) in this case what will happen is that we will immediately detect the same collision again (the body has not rotated and the body was already colliding at the end of the previous
 			// time step) resulting in a lot of stolen time and the body appearing to be frozen in an unnatural pose (like it is glued at an angle to the surface). (2) obviously has some negative side effects
-			// too as simulating the rotation first may cause it to tunnel through a small object that the linear cast might have otherwise dectected. In any case a linear cast is not good for detecting
+			// too as simulating the rotation first may cause it to tunnel through a small object that the linear cast might have otherwise detected. In any case a linear cast is not good for detecting
 			// tunneling due to angular rotation, so we don't care about that too much (you'd need a full cast to take angular effects into account).
 			body.AddRotationStep(body.GetAngularVelocity() * delta_time);
 
@@ -1526,7 +1526,7 @@ void PhysicsSystem::JobIntegrateVelocity(const PhysicsUpdateContext *ioContext,
 					float inner_radius = body.GetShape()->GetInnerRadius();
 					JPH_ASSERT(inner_radius > 0.0f, "The shape has no inner radius, this makes the shape unsuitable for the linear cast motion quality as we cannot move it without risking tunneling.");
 
-					// Measure translation in this step and check if it above the treshold to perform a linear cast
+					// Measure translation in this step and check if it above the threshold to perform a linear cast
 					float linear_cast_threshold_sq = Square(mPhysicsSettings.mLinearCastThreshold * inner_radius);
 					if (delta_pos.LengthSq() > linear_cast_threshold_sq)
 					{
@@ -1583,12 +1583,12 @@ void PhysicsSystem::JobPostIntegrateVelocity(PhysicsUpdateContext *ioContext, Ph
 
 	if (ioStep->mNumCCDBodies == 0)
 	{
-		// No continous collision detection jobs -> kick the next job ourselves
+		// No continuous collision detection jobs -> kick the next job ourselves
 		ioStep->mContactRemovedCallbacks.RemoveDependency();
 	}
 	else
 	{
-		// Run the continous collision detection jobs
+		// Run the continuous collision detection jobs
 		int num_continuous_collision_jobs = min(int(ioStep->mNumCCDBodies + cNumCCDBodiesPerJob - 1) / cNumCCDBodiesPerJob, ioContext->GetMaxConcurrency());
 		ioStep->mResolveCCDContacts.AddDependency(num_continuous_collision_jobs);
 		ioStep->mContactRemovedCallbacks.AddDependency(num_continuous_collision_jobs - 1); // Already had 1 dependency
@@ -2001,7 +2001,7 @@ void PhysicsSystem::JobResolveCCDContacts(PhysicsUpdateContext *ioContext, Physi
 					// Check if the other body found a hit that is further away
 					if (ccd_body2->mFraction > ccd_body->mFraction)
 					{
-						// Reset the colliding body of the other CCD body. The other body will shorten its distance travelled and will not do any collision response (we'll do that).
+						// Reset the colliding body of the other CCD body. The other body will shorten its distance traveled and will not do any collision response (we'll do that).
 						// This means that at this point we have triggered a contact point add/persist for our further hit by accident for the other body.
 						// We accept this as calling the contact point callbacks here would require persisting the manifolds up to this point and doing the callbacks single threaded.
 						ccd_body2->mBodyID2 = BodyID();

Jolt/Physics/SoftBody/SoftBodyCreationSettings.h

@@ -63,7 +63,7 @@ public:
 	float				mMaxLinearVelocity = 500.0f;		///< Maximum linear velocity that a vertex can reach (m/s)
 	float				mRestitution = 0.0f;				///< Restitution when colliding
 	float				mFriction = 0.2f;					///< Friction coefficient when colliding
-	float				mPressure = 0.0f;					///< n * R * T, amount of substance * ideal gass constant * absolute temperature, see https://en.wikipedia.org/wiki/Pressure
+	float				mPressure = 0.0f;					///< n * R * T, amount of substance * ideal gas constant * absolute temperature, see https://en.wikipedia.org/wiki/Pressure
 	float				mGravityFactor = 1.0f;				///< Value to multiply gravity with for this body
 	bool				mUpdatePosition = true;				///< Update the position of the body while simulating (set to false for something that is attached to the static world)
 	bool				mMakeRotationIdentity = true;		///< Bake specified mRotation in the vertices and set the body rotation to identity (simulation is slightly more accurate if the rotation of a soft body is kept to identity)

Jolt/Physics/SoftBody/SoftBodyMotionProperties.cpp

@@ -413,7 +413,7 @@ void SoftBodyMotionProperties::ApplyCollisionConstraintsAndUpdateVelocities(cons
 						}
 						else
 						{
-							// Body is not moveable, equations are simpler
+							// Body is not movable, equations are simpler
 
 							// Calculate normal and tangential velocity (equation 30)
 							Vec3 v_normal = contact_normal * contact_normal.Dot(v.mVelocity);

Jolt/Physics/Vehicle/TrackedVehicleController.h

@@ -151,7 +151,7 @@ protected:
 	float						mRightRatio = 1.0f;							///< Value between -1 and 1 indicating an extra multiplier to the rotation rate of the right track (used for steering)
 	float						mBrakeInput = 0.0f;							///< Value between 0 and 1 indicating how strong the brake pedal is pressed
 
-	// Simluation information
+	// Simulation information
 	VehicleEngine				mEngine;									///< Engine state of the vehicle
 	VehicleTransmission			mTransmission;								///< Transmission state of the vehicle
 	VehicleTracks				mTracks;									///< Tracks of the vehicle

Jolt/Physics/Vehicle/VehicleConstraint.cpp

@@ -99,7 +99,7 @@ VehicleConstraint::VehicleConstraint(Body &inVehicleBody, const VehicleConstrain
 		JPH_ASSERT(r.mStiffness >= 0.0f);
 	}
 
-	// Construct our controler class
+	// Construct our controller class
 	mController = inSettings.mController->ConstructController(*this);
 
 	// Create wheels

Jolt/Physics/Vehicle/VehicleConstraint.h

@@ -33,7 +33,7 @@ public:
 	float						mMaxPitchRollAngle = JPH_PI;				///< Defines the maximum pitch/roll angle (rad), can be used to avoid the car from getting upside down. The vehicle up direction will stay within a cone centered around the up axis with half top angle mMaxPitchRollAngle, set to pi to turn off.
 	Array<Ref<WheelSettings>>	mWheels;									///< List of wheels and their properties
 	Array<VehicleAntiRollBar>	mAntiRollBars;								///< List of anti rollbars and their properties
-	Ref<VehicleControllerSettings> mController;								///< Defines how the vehicle can accelerate / decellerate
+	Ref<VehicleControllerSettings> mController;								///< Defines how the vehicle can accelerate / decelerate
 
 protected:
 	/// This function should not be called directly, it is used by sRestoreFromBinaryState.
@@ -120,10 +120,10 @@ public:
 	/// Access to the vehicle body
 	Body *						GetVehicleBody() const						{ return mBody; }
 
-	/// Access to the vehicle controller interface (determines acceleration / decelleration)
+	/// Access to the vehicle controller interface (determines acceleration / deceleration)
 	const VehicleController *	GetController() const						{ return mController; }
 
-	/// Access to the vehicle controller interface (determines acceleration / decelleration)
+	/// Access to the vehicle controller interface (determines acceleration / deceleration)
 	VehicleController *			GetController()								{ return mController; }
 
 	/// Get the state of the wheels
@@ -136,7 +136,7 @@ public:
 	Wheel *						GetWheel(uint inIdx)						{ return mWheels[inIdx]; }
 	const Wheel *				GetWheel(uint inIdx) const					{ return mWheels[inIdx]; }
 
-	/// Get the basis vectors for the wheel in local space to the vehicle body (note: basis does not rotate when the wheel rotates arounds its axis)
+	/// Get the basis vectors for the wheel in local space to the vehicle body (note: basis does not rotate when the wheel rotates around its axis)
 	/// @param inWheel Wheel to fetch basis for
 	/// @param outForward Forward vector for the wheel
 	/// @param outUp Up vector for the wheel
@@ -197,14 +197,14 @@ private:
 	// Calculate the constraint properties for mPitchRollPart
 	void						CalculatePitchRollConstraintProperties(RMat44Arg inBodyTransform);
 
-	// Simluation information
+	// Simulation information
 	Body *						mBody;										///< Body of the vehicle
 	Vec3						mForward;									///< Local space forward vector for the vehicle
 	Vec3						mUp;										///< Local space up vector for the vehicle
 	Vec3						mWorldUp;									///< Vector indicating the world space up direction (used to limit vehicle pitch/roll)
 	Wheels						mWheels;									///< Wheel states of the vehicle
 	Array<VehicleAntiRollBar>	mAntiRollBars;								///< Anti rollbars of the vehicle
-	VehicleController *			mController;								///< Controls the acceleration / declerration of the vehicle
+	VehicleController *			mController;								///< Controls the acceleration / deceleration of the vehicle
 	bool						mIsActive = false;							///< If this constraint is active
 	uint						mNumStepsBetweenCollisionTestActive = 1;	///< Number of simulation steps between wheel collision tests when the vehicle is active
 	uint						mNumStepsBetweenCollisionTestInactive = 1;	///< Number of simulation steps between wheel collision tests when the vehicle is inactive

Jolt/Physics/Vehicle/VehicleController.h

@@ -20,7 +20,7 @@ class WheelSettings;
 class Wheel;
 class StateRecorder;
 
-/// Basic settings object for interface that controls acceleration / decelleration of the vehicle
+/// Basic settings object for interface that controls acceleration / deceleration of the vehicle
 class JPH_EXPORT VehicleControllerSettings : public SerializableObject, public RefTarget<VehicleControllerSettings>
 {
 public:
@@ -36,7 +36,7 @@ public:
 	virtual VehicleController *	ConstructController(VehicleConstraint &inConstraint) const = 0;
 };
 
-/// Runtime data for interface that controls acceleration / decelleration of the vehicle
+/// Runtime data for interface that controls acceleration / deceleration of the vehicle
 class JPH_EXPORT VehicleController : public RefTarget<VehicleController>, public NonCopyable
 {
 public:

Jolt/Physics/Vehicle/VehicleTransmission.h

@@ -50,7 +50,7 @@ public:
 	/// @param inClutchFriction Value between 0 and 1 indicating how much friction the clutch gives (0 = no friction, 1 = full friction)
 	void					Set(int inCurrentGear, float inClutchFriction) { mCurrentGear = inCurrentGear; mClutchFriction = inClutchFriction; }
 
-	/// Update the current gear and clutch friction if the transmission is in aut mode
+	/// Update the current gear and clutch friction if the transmission is in auto mode
 	/// @param inDeltaTime Time step delta time in s
 	/// @param inCurrentRPM Current RPM for engine
 	/// @param inForwardInput Hint if the user wants to drive forward (> 0) or backwards (< 0)

Jolt/Physics/Vehicle/Wheel.h

@@ -87,7 +87,7 @@ public:
 	/// Velocity of the contact point (m / s, not relative to the wheel but in world space)
 	Vec3					GetContactPointVelocity() const				{ JPH_ASSERT(HasContact()); return mContactPointVelocity; }
 
-	/// Returns the current contact mormal in world space (note by the time you call this the vehicle has moved)
+	/// Returns the current contact normal in world space (note by the time you call this the vehicle has moved)
 	Vec3					GetContactNormal() const					{ JPH_ASSERT(HasContact()); return mContactNormal; }
 
 	/// Returns longitudinal direction (direction along the wheel relative to floor) in world space (note by the time you call this the vehicle has moved)

Jolt/Physics/Vehicle/WheeledVehicleController.cpp

@@ -431,7 +431,7 @@ void WheeledVehicleController::PostCollide(float inDeltaTime, PhysicsSystem &inP
 		// TW(i) is the torque applied to the wheel outside of the engine (brake + torque due to friction with the ground)
 		// F(i) is the fraction of the engine torque applied from engine to wheel i
 		//
-		// Because the angular accelaration and torque are connected through: Torque = I * dw/dt
+		// Because the angular acceleration and torque are connected through: Torque = I * dw/dt
 		//
 		// We have the angular acceleration of the engine at time t:
 		//

Jolt/Physics/Vehicle/WheeledVehicleController.h

@@ -174,7 +174,7 @@ protected:
 	float						mBrakeInput = 0.0f;							///< Value between 0 and 1 indicating how strong the brake pedal is pressed
 	float						mHandBrakeInput = 0.0f;						///< Value between 0 and 1 indicating how strong the hand brake is pulled
 
-	// Simluation information
+	// Simulation information
 	VehicleEngine				mEngine;									///< Engine state of the vehicle
 	VehicleTransmission			mTransmission;								///< Transmission state of the vehicle
 	Differentials				mDifferentials;								///< Differential states of the vehicle

Jolt/Renderer/DebugRenderer.h

@@ -109,7 +109,7 @@ public:
 	/// @param inHalfAngle Specifies the cone angle in radians (angle measured between inAxis and cone surface).
 	/// @param inLength The length of the cone.
 	/// @param inColor Color to use for drawing the cone.
-	/// @param inCastShadow determins if this geometry should cast a shadow or not.
+	/// @param inCastShadow determines if this geometry should cast a shadow or not.
 	/// @param inDrawMode determines if we draw the geometry solid or in wireframe.
 	void								DrawOpenCone(RVec3Arg inTop, Vec3Arg inAxis, Vec3Arg inPerpendicular, float inHalfAngle, float inLength, ColorArg inColor, ECastShadow inCastShadow = ECastShadow::On, EDrawMode inDrawMode = EDrawMode::Solid);
 
@@ -119,7 +119,7 @@ public:
 	/// @param inSwingZHalfAngle See SwingTwistConstraintPart
 	/// @param inEdgeLength Size of the edge of the cone shape
 	/// @param inColor Color to use for drawing the cone.
-	/// @param inCastShadow determins if this geometry should cast a shadow or not.
+	/// @param inCastShadow determines if this geometry should cast a shadow or not.
 	/// @param inDrawMode determines if we draw the geometry solid or in wireframe.
 	void								DrawSwingConeLimits(RMat44Arg inMatrix, float inSwingYHalfAngle, float inSwingZHalfAngle, float inEdgeLength, ColorArg inColor, ECastShadow inCastShadow = ECastShadow::On, EDrawMode inDrawMode = EDrawMode::Solid);
 
@@ -131,7 +131,7 @@ public:
 	/// @param inMaxSwingZAngle See SwingTwistConstraintPart
 	/// @param inEdgeLength Size of the edge of the cone shape
 	/// @param inColor Color to use for drawing the cone.
-	/// @param inCastShadow determins if this geometry should cast a shadow or not.
+	/// @param inCastShadow determines if this geometry should cast a shadow or not.
 	/// @param inDrawMode determines if we draw the geometry solid or in wireframe.
 	void								DrawSwingPyramidLimits(RMat44Arg inMatrix, float inMinSwingYAngle, float inMaxSwingYAngle, float inMinSwingZAngle, float inMaxSwingZAngle, float inEdgeLength, ColorArg inColor, ECastShadow inCastShadow = ECastShadow::On, EDrawMode inDrawMode = EDrawMode::Solid);
 
@@ -143,7 +143,7 @@ public:
 	/// @param inMinAngle The pie will be drawn between [inMinAngle, inMaxAngle] (in radians).
 	/// @param inMaxAngle The pie will be drawn between [inMinAngle, inMaxAngle] (in radians).
 	/// @param inColor Color to use for drawing the pie.
-	/// @param inCastShadow determins if this geometry should cast a shadow or not.
+	/// @param inCastShadow determines if this geometry should cast a shadow or not.
 	/// @param inDrawMode determines if we draw the geometry solid or in wireframe.
 	void								DrawPie(RVec3Arg inCenter, float inRadius, Vec3Arg inNormal, Vec3Arg inAxis, float inMinAngle, float inMaxAngle, ColorArg inColor, ECastShadow inCastShadow = ECastShadow::On, EDrawMode inDrawMode = EDrawMode::Solid);