@bloomengine/engine 0.3.1

package/native/third_party/JoltPhysics/Jolt/Physics/IslandBuilder.cpp

@@ -0,0 +1,492 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#include <Jolt/Jolt.h>
+
+#include <Jolt/Physics/IslandBuilder.h>
+#include <Jolt/Physics/Body/Body.h>
+#include <Jolt/Physics/PhysicsSettings.h>
+#include <Jolt/Core/Profiler.h>
+#include <Jolt/Core/Atomics.h>
+#include <Jolt/Core/TempAllocator.h>
+#include <Jolt/Core/QuickSort.h>
+
+JPH_NAMESPACE_BEGIN
+
+IslandBuilder::~IslandBuilder()
+{
+	JPH_ASSERT(mConstraintLinks == nullptr);
+	JPH_ASSERT(mContactLinks == nullptr);
+	JPH_ASSERT(mBodyIslands == nullptr);
+	JPH_ASSERT(mBodyIslandEnds == nullptr);
+	JPH_ASSERT(mConstraintIslands == nullptr);
+	JPH_ASSERT(mConstraintIslandEnds == nullptr);
+	JPH_ASSERT(mContactIslands == nullptr);
+	JPH_ASSERT(mContactIslandEnds == nullptr);
+	JPH_ASSERT(mIslandsSorted == nullptr);
+
+	delete [] mBodyLinks;
+}
+
+void IslandBuilder::Init(uint32 inMaxActiveBodies)
+{
+	mMaxActiveBodies = inMaxActiveBodies;
+
+	// Link each body to itself, BuildBodyIslands() will restore this so that we don't need to do this each step
+	JPH_ASSERT(mBodyLinks == nullptr);
+	mBodyLinks = new BodyLink [mMaxActiveBodies];
+	for (uint32 i = 0; i < mMaxActiveBodies; ++i)
+		mBodyLinks[i].mLinkedTo.store(i, memory_order_relaxed);
+}
+
+void IslandBuilder::PrepareContactConstraints(uint32 inMaxContacts, TempAllocator *inTempAllocator)
+{
+	JPH_PROFILE_FUNCTION();
+
+	// Need to call Init first
+	JPH_ASSERT(mBodyLinks != nullptr);
+
+	// Check that the builder has been reset
+	JPH_ASSERT(mNumContacts == 0);
+	JPH_ASSERT(mNumIslands == 0);
+
+	// Create contact link buffer, not initialized so each contact needs to be explicitly set
+	JPH_ASSERT(mContactLinks == nullptr);
+	mContactLinks = (uint32 *)inTempAllocator->Allocate(inMaxContacts * sizeof(uint32));
+	mMaxContacts = inMaxContacts;
+
+#ifdef JPH_VALIDATE_ISLAND_BUILDER
+	// Create validation structures
+	JPH_ASSERT(mLinkValidation == nullptr);
+	mLinkValidation = (LinkValidation *)inTempAllocator->Allocate(inMaxContacts * sizeof(LinkValidation));
+	mNumLinkValidation = 0;
+#endif
+}
+
+void IslandBuilder::PrepareNonContactConstraints(uint32 inNumConstraints, TempAllocator *inTempAllocator)
+{
+	JPH_PROFILE_FUNCTION();
+
+	// Need to call Init first
+	JPH_ASSERT(mBodyLinks != nullptr);
+
+	// Check that the builder has been reset
+	JPH_ASSERT(mNumIslands == 0);
+
+	// Store number of constraints
+	mNumConstraints = inNumConstraints;
+
+	// Create constraint link buffer, not initialized so each constraint needs to be explicitly set
+	JPH_ASSERT(mConstraintLinks == nullptr);
+	mConstraintLinks = (uint32 *)inTempAllocator->Allocate(inNumConstraints * sizeof(uint32));
+}
+
+uint32 IslandBuilder::GetLowestBodyIndex(uint32 inActiveBodyIndex) const
+{
+	uint32 index = inActiveBodyIndex;
+	for (;;)
+	{
+		uint32 link_to = mBodyLinks[index].mLinkedTo.load(memory_order_relaxed);
+		if (link_to == index)
+			break;
+		index = link_to;
+	}
+	return index;
+}
+
+void IslandBuilder::LinkBodies(uint32 inFirst, uint32 inSecond)
+{
+	// Both need to be active, we don't want to create an island with static objects
+	if (inFirst >= mMaxActiveBodies || inSecond >= mMaxActiveBodies)
+		return;
+
+#ifdef JPH_VALIDATE_ISLAND_BUILDER
+	// Add link to the validation list
+	if (mNumLinkValidation < uint32(mMaxContacts))
+		mLinkValidation[mNumLinkValidation++] = { inFirst, inSecond };
+	else
+		JPH_ASSERT(false, "Out of links");
+#endif
+
+	// Start the algorithm with the two bodies
+	uint32 first_link_to = inFirst;
+	uint32 second_link_to = inSecond;
+
+	for (;;)
+	{
+		// Follow the chain until we get to the body with lowest index
+		// If the swap compare below fails, we'll keep searching from the lowest index for the new lowest index
+		first_link_to = GetLowestBodyIndex(first_link_to);
+		second_link_to = GetLowestBodyIndex(second_link_to);
+
+		// If the targets are the same, the bodies are already connected
+		if (first_link_to != second_link_to)
+		{
+			// We always link the highest to the lowest
+			if (first_link_to < second_link_to)
+			{
+				// Attempt to link the second to the first
+				// Since we found this body to be at the end of the chain it must point to itself, and if it
+				// doesn't it has been reparented and we need to retry the algorithm
+				if (!mBodyLinks[second_link_to].mLinkedTo.compare_exchange_weak(second_link_to, first_link_to, memory_order_relaxed))
+					continue;
+			}
+			else
+			{
+				// Attempt to link the first to the second
+				// Since we found this body to be at the end of the chain it must point to itself, and if it
+				// doesn't it has been reparented and we need to retry the algorithm
+				if (!mBodyLinks[first_link_to].mLinkedTo.compare_exchange_weak(first_link_to, second_link_to, memory_order_relaxed))
+					continue;
+			}
+		}
+
+		// Linking succeeded!
+		// Chains of bodies can become really long, resulting in an O(N) loop to find the lowest body index
+		// to prevent this we attempt to update the link of the bodies that were passed in to directly point
+		// to the lowest index that we found. If the value became lower than our lowest link, some other
+		// thread must have relinked these bodies in the mean time so we won't update the value.
+		uint32 lowest_link_to = min(first_link_to, second_link_to);
+		AtomicMin(mBodyLinks[inFirst].mLinkedTo, lowest_link_to, memory_order_relaxed);
+		AtomicMin(mBodyLinks[inSecond].mLinkedTo, lowest_link_to, memory_order_relaxed);
+		break;
+	}
+}
+
+void IslandBuilder::LinkConstraint(uint32 inConstraintIndex, uint32 inFirst, uint32 inSecond)
+{
+	LinkBodies(inFirst, inSecond);
+
+	JPH_ASSERT(inConstraintIndex < mNumConstraints);
+	uint32 min_value = min(inFirst, inSecond); // Use fact that invalid index is 0xffffffff, we want the active body of two
+	JPH_ASSERT(min_value != Body::cInactiveIndex); // At least one of the bodies must be active
+	mConstraintLinks[inConstraintIndex] = min_value;
+}
+
+void IslandBuilder::LinkContact(uint32 inContactIndex, uint32 inFirst, uint32 inSecond)
+{
+	JPH_ASSERT(inContactIndex < mMaxContacts);
+	mContactLinks[inContactIndex] = min(inFirst, inSecond); // Use fact that invalid index is 0xffffffff, we want the active body of two
+}
+
+#ifdef JPH_VALIDATE_ISLAND_BUILDER
+
+void IslandBuilder::ValidateIslands(uint32 inNumActiveBodies) const
+{
+	JPH_PROFILE_FUNCTION();
+
+	// Go through all links so far
+	for (uint32 i = 0; i < mNumLinkValidation; ++i)
+	{
+		// If the bodies in this link ended up in different groups we have a problem
+		if (mBodyLinks[mLinkValidation[i].mFirst].mIslandIndex != mBodyLinks[mLinkValidation[i].mSecond].mIslandIndex)
+		{
+			Trace("Fail: %u, %u", mLinkValidation[i].mFirst, mLinkValidation[i].mSecond);
+			Trace("Num Active: %u", inNumActiveBodies);
+
+			for (uint32 j = 0; j < mNumLinkValidation; ++j)
+				Trace("builder.Link(%u, %u);", mLinkValidation[j].mFirst, mLinkValidation[j].mSecond);
+
+			IslandBuilder tmp;
+			tmp.Init(inNumActiveBodies);
+			for (uint32 j = 0; j < mNumLinkValidation; ++j)
+			{
+				Trace("Link %u -> %u", mLinkValidation[j].mFirst, mLinkValidation[j].mSecond);
+				tmp.LinkBodies(mLinkValidation[j].mFirst, mLinkValidation[j].mSecond);
+				for (uint32 t = 0; t < inNumActiveBodies; ++t)
+					Trace("%u -> %u", t, (uint32)tmp.mBodyLinks[t].mLinkedTo);
+			}
+
+			JPH_ASSERT(false, "IslandBuilder validation failed");
+		}
+	}
+}
+
+#endif
+
+void IslandBuilder::BuildBodyIslands(const BodyID *inActiveBodies, uint32 inNumActiveBodies, TempAllocator *inTempAllocator)
+{
+	JPH_PROFILE_FUNCTION();
+
+	// Store the amount of active bodies
+	mNumActiveBodies = inNumActiveBodies;
+
+	// Create output arrays for body ID's, don't call constructors
+	JPH_ASSERT(mBodyIslands == nullptr);
+	mBodyIslands = (BodyID *)inTempAllocator->Allocate(inNumActiveBodies * sizeof(BodyID));
+
+	// Create output array for start index of each island. At this point we don't know how many islands there will be, but we know it cannot be more than inNumActiveBodies.
+	// Note: We allocate 1 extra entry because we always increment the count of the next island.
+	uint32 *body_island_starts = (uint32 *)inTempAllocator->Allocate((inNumActiveBodies + 1) * sizeof(uint32));
+
+	// First island always starts at 0
+	body_island_starts[0] = 0;
+
+	// Calculate island index for all bodies
+	JPH_ASSERT(mNumIslands == 0);
+	for (uint32 i = 0; i < inNumActiveBodies; ++i)
+	{
+		BodyLink &link = mBodyLinks[i];
+		uint32 s = link.mLinkedTo.load(memory_order_relaxed);
+		if (s != i)
+		{
+			// Links to another body, take island index from other body (this must have been filled in already since we're looping from low to high)
+			JPH_ASSERT(s < uint32(i));
+			uint32 island_index = mBodyLinks[s].mIslandIndex;
+			link.mIslandIndex = island_index;
+
+			// Increment the start of the next island
+			body_island_starts[island_index + 1]++;
+		}
+		else
+		{
+			// Does not link to other body, this is the start of a new island
+			link.mIslandIndex = mNumIslands;
+			++mNumIslands;
+
+			// Set the start of the next island to 1
+			body_island_starts[mNumIslands] = 1;
+		}
+	}
+
+#ifdef JPH_VALIDATE_ISLAND_BUILDER
+	ValidateIslands(inNumActiveBodies);
+#endif
+
+	// Make the start array absolute (so far we only counted)
+	for (uint32 island = 1; island < mNumIslands; ++island)
+		body_island_starts[island] += body_island_starts[island - 1];
+
+	// Convert the to a linear list grouped by island
+	for (uint32 i = 0; i < inNumActiveBodies; ++i)
+	{
+		BodyLink &link = mBodyLinks[i];
+
+		// Copy the body to the correct location in the array and increment it
+		uint32 &start = body_island_starts[link.mIslandIndex];
+		mBodyIslands[start] = inActiveBodies[i];
+		start++;
+
+		// Reset linked to field for the next update
+		link.mLinkedTo.store(i, memory_order_relaxed);
+	}
+
+	// We should now have a full array
+	JPH_ASSERT(mNumIslands == 0 || body_island_starts[mNumIslands - 1] == inNumActiveBodies);
+
+	// We've incremented all body indices so that they now point at the end instead of the starts
+	JPH_ASSERT(mBodyIslandEnds == nullptr);
+	mBodyIslandEnds = body_island_starts;
+}
+
+void IslandBuilder::BuildConstraintIslands(const uint32 *inConstraintToBody, uint32 inNumConstraints, uint32 *&outConstraints, uint32 *&outConstraintsEnd, TempAllocator *inTempAllocator) const
+{
+	JPH_PROFILE_FUNCTION();
+
+	// Check if there's anything to do
+	if (inNumConstraints == 0)
+		return;
+
+	// Create output arrays for constraints
+	// Note: For the end indices we allocate 1 extra entry so we don't have to do an if in the inner loop
+	uint32 *constraints = (uint32 *)inTempAllocator->Allocate(inNumConstraints * sizeof(uint32));
+	uint32 *constraint_ends = (uint32 *)inTempAllocator->Allocate((mNumIslands + 1) * sizeof(uint32));
+
+	// Reset sizes
+	for (uint32 island = 0; island < mNumIslands; ++island)
+		constraint_ends[island] = 0;
+
+	// Loop over array and increment start relative position for the next island
+	for (uint32 constraint = 0; constraint < inNumConstraints; ++constraint)
+	{
+		uint32 body_idx = inConstraintToBody[constraint];
+		uint32 next_island_idx = mBodyLinks[body_idx].mIslandIndex + 1;
+		JPH_ASSERT(next_island_idx <= mNumIslands);
+		constraint_ends[next_island_idx]++;
+	}
+
+	// Make start positions absolute
+	for (uint32 island = 1; island < mNumIslands; ++island)
+		constraint_ends[island] += constraint_ends[island - 1];
+
+	// Loop over array and collect constraints
+	for (uint32 constraint = 0; constraint < inNumConstraints; ++constraint)
+	{
+		uint32 body_idx = inConstraintToBody[constraint];
+		uint32 island_idx = mBodyLinks[body_idx].mIslandIndex;
+		constraints[constraint_ends[island_idx]++] = constraint;
+	}
+
+	JPH_ASSERT(outConstraints == nullptr);
+	outConstraints = constraints;
+	JPH_ASSERT(outConstraintsEnd == nullptr);
+	outConstraintsEnd = constraint_ends;
+}
+
+void IslandBuilder::SortIslands(TempAllocator *inTempAllocator)
+{
+	JPH_PROFILE_FUNCTION();
+
+	if (mNumContacts > 0 || mNumConstraints > 0)
+	{
+		// Allocate mapping table
+		JPH_ASSERT(mIslandsSorted == nullptr);
+		mIslandsSorted = (uint32 *)inTempAllocator->Allocate(mNumIslands * sizeof(uint32));
+
+		// Initialize index
+		for (uint32 island = 0; island < mNumIslands; ++island)
+			mIslandsSorted[island] = island;
+
+		// Determine the sum of contact constraints / constraints per island
+		uint32 *num_constraints = (uint32 *)inTempAllocator->Allocate(mNumIslands * sizeof(uint32));
+		if (mNumContacts > 0 && mNumConstraints > 0)
+		{
+			num_constraints[0] = mConstraintIslandEnds[0] + mContactIslandEnds[0];
+			for (uint32 island = 1; island < mNumIslands; ++island)
+				num_constraints[island] = mConstraintIslandEnds[island] - mConstraintIslandEnds[island - 1]
+										+ mContactIslandEnds[island] - mContactIslandEnds[island - 1];
+		}
+		else if (mNumContacts > 0)
+		{
+			num_constraints[0] = mContactIslandEnds[0];
+			for (uint32 island = 1; island < mNumIslands; ++island)
+				num_constraints[island] = mContactIslandEnds[island] - mContactIslandEnds[island - 1];
+		}
+		else
+		{
+			num_constraints[0] = mConstraintIslandEnds[0];
+			for (uint32 island = 1; island < mNumIslands; ++island)
+				num_constraints[island] = mConstraintIslandEnds[island] - mConstraintIslandEnds[island - 1];
+		}
+
+		// Sort so the biggest islands go first, this means that the jobs that take longest will be running
+		// first which improves the chance that all jobs finish at the same time.
+		QuickSort(mIslandsSorted, mIslandsSorted + mNumIslands, [num_constraints](uint32 inLHS, uint32 inRHS) {
+			return num_constraints[inLHS] > num_constraints[inRHS];
+		});
+
+		inTempAllocator->Free(num_constraints, mNumIslands * sizeof(uint32));
+	}
+}
+
+void IslandBuilder::Finalize(const BodyID *inActiveBodies, uint32 inNumActiveBodies, uint32 inNumContacts, TempAllocator *inTempAllocator)
+{
+	JPH_PROFILE_FUNCTION();
+
+	mNumContacts = inNumContacts;
+
+	BuildBodyIslands(inActiveBodies, inNumActiveBodies, inTempAllocator);
+	BuildConstraintIslands(mConstraintLinks, mNumConstraints, mConstraintIslands, mConstraintIslandEnds, inTempAllocator);
+	BuildConstraintIslands(mContactLinks, mNumContacts, mContactIslands, mContactIslandEnds, inTempAllocator);
+	SortIslands(inTempAllocator);
+
+	mNumPositionSteps = (uint8 *)inTempAllocator->Allocate(mNumIslands * sizeof(uint8));
+
+#ifdef JPH_TRACK_SIMULATION_STATS
+	mIslandStats = (IslandStats *)inTempAllocator->Allocate(mNumIslands * sizeof(IslandStats));
+	for (uint32 i = 0; i < mNumIslands; ++i)
+		new (&mIslandStats[i]) IslandStats();
+#endif
+}
+
+void IslandBuilder::GetBodiesInIsland(uint32 inIslandIndex, BodyID *&outBodiesBegin, BodyID *&outBodiesEnd) const
+{
+	JPH_ASSERT(inIslandIndex < mNumIslands);
+	uint32 sorted_index = mIslandsSorted != nullptr? mIslandsSorted[inIslandIndex] : inIslandIndex;
+	outBodiesBegin = sorted_index > 0? mBodyIslands + mBodyIslandEnds[sorted_index - 1] : mBodyIslands;
+	outBodiesEnd = mBodyIslands + mBodyIslandEnds[sorted_index];
+}
+
+bool IslandBuilder::GetConstraintsInIsland(uint32 inIslandIndex, uint32 *&outConstraintsBegin, uint32 *&outConstraintsEnd) const
+{
+	JPH_ASSERT(inIslandIndex < mNumIslands);
+	if (mNumConstraints == 0)
+	{
+		outConstraintsBegin = nullptr;
+		outConstraintsEnd = nullptr;
+		return false;
+	}
+	else
+	{
+		uint32 sorted_index = mIslandsSorted[inIslandIndex];
+		outConstraintsBegin = sorted_index > 0? mConstraintIslands + mConstraintIslandEnds[sorted_index - 1] : mConstraintIslands;
+		outConstraintsEnd = mConstraintIslands + mConstraintIslandEnds[sorted_index];
+		return outConstraintsBegin != outConstraintsEnd;
+	}
+}
+
+bool IslandBuilder::GetContactsInIsland(uint32 inIslandIndex, uint32 *&outContactsBegin, uint32 *&outContactsEnd) const
+{
+	JPH_ASSERT(inIslandIndex < mNumIslands);
+	if (mNumContacts == 0)
+	{
+		outContactsBegin = nullptr;
+		outContactsEnd = nullptr;
+		return false;
+	}
+	else
+	{
+		uint32 sorted_index = mIslandsSorted[inIslandIndex];
+		outContactsBegin = sorted_index > 0? mContactIslands + mContactIslandEnds[sorted_index - 1] : mContactIslands;
+		outContactsEnd = mContactIslands + mContactIslandEnds[sorted_index];
+		return outContactsBegin != outContactsEnd;
+	}
+}
+
+void IslandBuilder::ResetIslands(TempAllocator *inTempAllocator)
+{
+	JPH_PROFILE_FUNCTION();
+
+#ifdef JPH_TRACK_SIMULATION_STATS
+	inTempAllocator->Free(mIslandStats, mNumIslands * sizeof(IslandStats));
+#endif
+
+	inTempAllocator->Free(mNumPositionSteps, mNumIslands * sizeof(uint8));
+
+	if (mIslandsSorted != nullptr)
+	{
+		inTempAllocator->Free(mIslandsSorted, mNumIslands * sizeof(uint32));
+		mIslandsSorted = nullptr;
+	}
+
+	if (mContactIslands != nullptr)
+	{
+		inTempAllocator->Free(mContactIslandEnds, (mNumIslands + 1) * sizeof(uint32));
+		mContactIslandEnds = nullptr;
+		inTempAllocator->Free(mContactIslands, mNumContacts * sizeof(uint32));
+		mContactIslands = nullptr;
+	}
+
+	if (mConstraintIslands != nullptr)
+	{
+		inTempAllocator->Free(mConstraintIslandEnds, (mNumIslands + 1) * sizeof(uint32));
+		mConstraintIslandEnds = nullptr;
+		inTempAllocator->Free(mConstraintIslands, mNumConstraints * sizeof(uint32));
+		mConstraintIslands = nullptr;
+	}
+
+	inTempAllocator->Free(mBodyIslandEnds, (mNumActiveBodies + 1) * sizeof(uint32));
+	mBodyIslandEnds = nullptr;
+	inTempAllocator->Free(mBodyIslands, mNumActiveBodies * sizeof(uint32));
+	mBodyIslands = nullptr;
+
+	inTempAllocator->Free(mConstraintLinks, mNumConstraints * sizeof(uint32));
+	mConstraintLinks = nullptr;
+
+#ifdef JPH_VALIDATE_ISLAND_BUILDER
+	inTempAllocator->Free(mLinkValidation, mMaxContacts * sizeof(LinkValidation));
+	mLinkValidation = nullptr;
+#endif
+
+	inTempAllocator->Free(mContactLinks, mMaxContacts * sizeof(uint32));
+	mContactLinks = nullptr;
+
+	mNumActiveBodies = 0;
+	mNumConstraints = 0;
+	mMaxContacts = 0;
+	mNumContacts = 0;
+	mNumIslands = 0;
+}
+
+JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Physics/IslandBuilder.h

@@ -0,0 +1,144 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <Jolt/Physics/Body/BodyID.h>
+#include <Jolt/Core/NonCopyable.h>
+#include <Jolt/Core/Atomics.h>
+
+JPH_NAMESPACE_BEGIN
+
+class TempAllocator;
+
+//#define JPH_VALIDATE_ISLAND_BUILDER
+
+/// Keeps track of connected bodies and builds islands for multithreaded velocity/position update
+class JPH_EXPORT IslandBuilder : public NonCopyable
+{
+public:
+	/// Destructor
+							~IslandBuilder();
+
+	/// Initialize the island builder with the maximum amount of bodies that could be active
+	void					Init(uint32 inMaxActiveBodies);
+
+	/// Prepare for simulation step by allocating space for the contact constraints
+	void					PrepareContactConstraints(uint32 inMaxContactConstraints, TempAllocator *inTempAllocator);
+
+	/// Prepare for simulation step by allocating space for the non-contact constraints
+	void					PrepareNonContactConstraints(uint32 inNumConstraints, TempAllocator *inTempAllocator);
+
+	/// Link two bodies by their index in the BodyManager::mActiveBodies list to form islands
+	void					LinkBodies(uint32 inFirst, uint32 inSecond);
+
+	/// Link a constraint to a body by their index in the BodyManager::mActiveBodies
+	void					LinkConstraint(uint32 inConstraintIndex, uint32 inFirst, uint32 inSecond);
+
+	/// Link a contact to a body by their index in the BodyManager::mActiveBodies
+	void					LinkContact(uint32 inContactIndex, uint32 inFirst, uint32 inSecond);
+
+	/// Finalize the islands after all bodies have been Link()-ed
+	void					Finalize(const BodyID *inActiveBodies, uint32 inNumActiveBodies, uint32 inNumContacts, TempAllocator *inTempAllocator);
+
+	/// Get the amount of islands formed
+	uint32					GetNumIslands() const							{ return mNumIslands; }
+
+	/// Get iterator for a particular island, return false if there are no constraints
+	void					GetBodiesInIsland(uint32 inIslandIndex, BodyID *&outBodiesBegin, BodyID *&outBodiesEnd) const;
+	bool					GetConstraintsInIsland(uint32 inIslandIndex, uint32 *&outConstraintsBegin, uint32 *&outConstraintsEnd) const;
+	bool					GetContactsInIsland(uint32 inIslandIndex, uint32 *&outContactsBegin, uint32 *&outContactsEnd) const;
+
+	/// The number of position iterations for each island
+	void					SetNumPositionSteps(uint32 inIslandIndex, uint inNumPositionSteps)	{ JPH_ASSERT(inIslandIndex < mNumIslands); JPH_ASSERT(inNumPositionSteps < 256); mNumPositionSteps[inIslandIndex] = uint8(inNumPositionSteps); }
+	uint					GetNumPositionSteps(uint32 inIslandIndex) const						{ JPH_ASSERT(inIslandIndex < mNumIslands); return mNumPositionSteps[inIslandIndex]; }
+
+#ifdef JPH_TRACK_SIMULATION_STATS
+	struct IslandStats
+	{
+		atomic<uint64>		mVelocityConstraintTicks = 0;
+		atomic<uint64>		mPositionConstraintTicks = 0;
+		atomic<uint64>		mUpdateBoundsTicks = 0;
+		uint8				mNumVelocitySteps = 0;
+		uint8				mNumPositionSteps = 0;												///< Tracking this a 2nd time since IslandBuilder::mNumPositionSteps is not filled in when there are no constraints or for large islands.
+		bool				mIsLargeIsland = false;
+	};
+
+	/// Tracks simulation stats per island
+	IslandStats &			GetIslandStats(uint32 inIslandIndex)								{ return mIslandStats[inIslandIndex]; }
+#endif
+
+	/// After you're done calling the three functions above, call this function to free associated data
+	void					ResetIslands(TempAllocator *inTempAllocator);
+
+private:
+	/// Returns the index of the lowest body in the group
+	uint32					GetLowestBodyIndex(uint32 inActiveBodyIndex) const;
+
+#ifdef JPH_VALIDATE_ISLAND_BUILDER
+	/// Helper function to validate all islands so far generated
+	void					ValidateIslands(uint32 inNumActiveBodies) const;
+#endif
+
+	// Helper functions to build various islands
+	void					BuildBodyIslands(const BodyID *inActiveBodies, uint32 inNumActiveBodies, TempAllocator *inTempAllocator);
+	void					BuildConstraintIslands(const uint32 *inConstraintToBody, uint32 inNumConstraints, uint32 *&outConstraints, uint32 *&outConstraintsEnd, TempAllocator *inTempAllocator) const;
+
+	/// Sorts the islands so that the islands with most constraints go first
+	void					SortIslands(TempAllocator *inTempAllocator);
+
+	/// Intermediate data structure that for each body keeps track what the lowest index of the body is that it is connected to
+	struct BodyLink
+	{
+		JPH_OVERRIDE_NEW_DELETE
+
+		atomic<uint32>		mLinkedTo;										///< An index in mBodyLinks pointing to another body in this island with a lower index than this body
+		uint32				mIslandIndex;									///< The island index of this body (filled in during Finalize)
+	};
+
+	// Intermediate data
+	BodyLink *				mBodyLinks = nullptr;							///< Maps bodies to the first body in the island
+	uint32 *				mConstraintLinks = nullptr;						///< Maps constraint index to body index (which maps to island index)
+	uint32 *				mContactLinks = nullptr;						///< Maps contact constraint index to body index (which maps to island index)
+
+	// Final data
+	BodyID *				mBodyIslands = nullptr;							///< Bodies ordered by island
+	uint32 *				mBodyIslandEnds = nullptr;						///< End index of each body island
+
+	uint32 *				mConstraintIslands = nullptr;					///< Constraints ordered by island
+	uint32 *				mConstraintIslandEnds = nullptr;				///< End index of each constraint island
+
+	uint32 *				mContactIslands = nullptr;						///< Contacts ordered by island
+	uint32 *				mContactIslandEnds = nullptr;					///< End index of each contact island
+
+	uint32 *				mIslandsSorted = nullptr;						///< A list of island indices in order of most constraints first
+
+	uint8 *					mNumPositionSteps = nullptr;					///< Number of position steps for each island
+
+#ifdef JPH_TRACK_SIMULATION_STATS
+	IslandStats *			mIslandStats = nullptr;							///< Per island statistics
+#endif
+
+	// Counters
+	uint32					mMaxActiveBodies;								///< Maximum size of the active bodies list (see BodyManager::mActiveBodies)
+	uint32					mNumActiveBodies = 0;							///< Number of active bodies passed to
+	uint32					mNumConstraints = 0;							///< Size of the constraint list (see ConstraintManager::mConstraints)
+	uint32					mMaxContacts = 0;								///< Maximum amount of contacts supported
+	uint32					mNumContacts = 0;								///< Size of the contacts list (see ContactConstraintManager::mNumConstraints)
+	uint32					mNumIslands = 0;								///< Final number of islands
+
+#ifdef JPH_VALIDATE_ISLAND_BUILDER
+	/// Structure to keep track of all added links to validate that islands were generated correctly
+	struct LinkValidation
+	{
+		uint32				mFirst;
+		uint32				mSecond;
+	};
+
+	LinkValidation *		mLinkValidation = nullptr;
+	atomic<uint32>			mNumLinkValidation;
+#endif
+};
+
+JPH_NAMESPACE_END