From 3d84200b171b6babc5c7212a5e493c7bb468b7a1 Mon Sep 17 00:00:00 2001
From: iarwain <iarwain@orx-project.org>
Date: Sat, 21 Dec 2024 06:57:55 -0500
Subject: [PATCH] - Updated LiquidFun:   . Muted a compile warning on all
 platforms correctly   . Don't build examples & tests by default   . Added
 build-emscripten.bat   . Added Web binaries of LiquidFun

---
 LiquidFun-1.1.0/lib/web/libliquidfun.a        |  Bin 0 -> 424692 bytes
 .../Box2D/Box2D/Particle/b2ParticleSystem.cpp | 9410 +++++++++--------
 .../src/liquidfun/Box2D/CMakeLists.txt        |    4 +-
 .../src/liquidfun/Box2D/build-emscripten.bat  |    7 +
 4 files changed, 4717 insertions(+), 4704 deletions(-)
 create mode 100644 LiquidFun-1.1.0/lib/web/libliquidfun.a
 create mode 100644 LiquidFun-1.1.0/src/liquidfun/Box2D/build-emscripten.bat

diff --git a/LiquidFun-1.1.0/lib/web/libliquidfun.a b/LiquidFun-1.1.0/lib/web/libliquidfun.a
new file mode 100644
index 0000000000000000000000000000000000000000..41bc165f22382bd09ea9602d5ad0a15e5cf6098d
GIT binary patch
literal 424692
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
YusZfES9c_SQoV|!XN~y(6Z4?|51^HWe*gdg

literal 0
HcmV?d00001

diff --git a/LiquidFun-1.1.0/src/liquidfun/Box2D/Box2D/Particle/b2ParticleSystem.cpp b/LiquidFun-1.1.0/src/liquidfun/Box2D/Box2D/Particle/b2ParticleSystem.cpp
index 56452240..4f4cd152 100644
--- a/LiquidFun-1.1.0/src/liquidfun/Box2D/Box2D/Particle/b2ParticleSystem.cpp
+++ b/LiquidFun-1.1.0/src/liquidfun/Box2D/Box2D/Particle/b2ParticleSystem.cpp
@@ -1,4702 +1,4708 @@
-/*
-* Copyright (c) 2013 Google, Inc.
-*
-* This software is provided 'as-is', without any express or implied
-* warranty.  In no event will the authors be held liable for any damages
-* arising from the use of this software.
-* Permission is granted to anyone to use this software for any purpose,
-* including commercial applications, and to alter it and redistribute it
-* freely, subject to the following restrictions:
-* 1. The origin of this software must not be misrepresented; you must not
-* claim that you wrote the original software. If you use this software
-* in a product, an acknowledgment in the product documentation would be
-* appreciated but is not required.
-* 2. Altered source versions must be plainly marked as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-#include <Box2D/Particle/b2ParticleSystem.h>
-#include <Box2D/Particle/b2ParticleGroup.h>
-#include <Box2D/Particle/b2VoronoiDiagram.h>
-#include <Box2D/Particle/b2ParticleAssembly.h>
-#include <Box2D/Common/b2BlockAllocator.h>
-#include <Box2D/Dynamics/b2World.h>
-#include <Box2D/Dynamics/b2WorldCallbacks.h>
-#include <Box2D/Dynamics/b2Body.h>
-#include <Box2D/Dynamics/b2Fixture.h>
-#include <Box2D/Collision/Shapes/b2Shape.h>
-#include <Box2D/Collision/Shapes/b2EdgeShape.h>
-#include <Box2D/Collision/Shapes/b2ChainShape.h>
-#include <algorithm>
-
-#ifdef LIQUIDFUN_SIMD_NEON
-
-static uint32 hasNeon = 1;
-
-#if defined(ANDROID) && !defined(__ARM_NEON__)
-
-#include "cpu-features.h"
-static uint64_t cpuFeatures = 0;
-
-#endif
-
-#endif
-
-// Define LIQUIDFUN_SIMD_TEST_VS_REFERENCE to run both SIMD and reference
-// versions, and assert that the results are identical. This is useful when
-// modifying one of the functions, to help verify correctness.
-// #define LIQUIDFUN_SIMD_TEST_VS_REFERENCE
-
-// For ease of debugging, remove 'inline'. Then, when an assert hits in the
-// test-vs-reference functions, you can easily jump the instruction pointer
-// to the top of the function to re-run the test.
-#define LIQUIDFUN_SIMD_INLINE inline
-
-
-static const uint32 xTruncBits = 12;
-static const uint32 yTruncBits = 12;
-static const uint32 tagBits = 8u * sizeof(uint32);
-static const uint32 yOffset = 1u << (yTruncBits - 1u);
-static const uint32 yShift = tagBits - yTruncBits;
-static const uint32 xShift = tagBits - yTruncBits - xTruncBits;
-static const uint32 xScale = 1u << xShift;
-static const uint32 xOffset = xScale * (1u << (xTruncBits - 1u));
-static const uint32 yMask = ((1u << yTruncBits) - 1u) << yShift;
-static const uint32 xMask = ~yMask;
-static const uint32 relativeTagRight = 1u << xShift;
-
-#if defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wshift-negative-value"
-#endif //__clang__
-static const uint32 relativeTagBottomLeft = (uint32)((1 << yShift) +
-                                                    (-1 << xShift));
-#if defined(__clang__)
-#pragma GCC diagnostic pop
-#endif //__clang__
-
-static const uint32 relativeTagBottomRight = (1u << yShift) + (1u << xShift);
-
-// This functor is passed to std::remove_if in RemoveSpuriousBodyContacts
-// to implement the algorithm described there.  It was hoisted out and friended
-// as it would not compile with g++ 4.6.3 as a local class.  It is only used in
-// that function.
-class b2ParticleBodyContactRemovePredicate
-{
-public:
-	b2ParticleBodyContactRemovePredicate(b2ParticleSystem* system,
-										 int32* discarded)
-		: m_system(system), m_lastIndex(-1), m_currentContacts(0),
-		  m_discarded(discarded) {}
-
-	bool operator()(const b2ParticleBodyContact& contact)
-	{
-		// This implements the selection criteria described in
-		// RemoveSpuriousBodyContacts().
-		// This functor is iterating through a list of Body contacts per
-		// Particle, ordered from near to far.  For up to the maximum number of
-		// contacts we allow per point per step, we verify that the contact
-		// normal of the Body that genenerated the contact makes physical sense
-		// by projecting a point back along that normal and seeing if it
-		// intersects the fixture generating the contact.
-
-		if (contact.index != m_lastIndex)
-		{
-			m_currentContacts = 0;
-			m_lastIndex = contact.index;
-		}
-
-		if (m_currentContacts++ > k_maxContactsPerPoint)
-		{
-			++(*m_discarded);
-			return true;
-		}
-
-		// Project along inverse normal (as returned in the contact) to get the
-		// point to check.
-		b2Vec2 n = contact.normal;
-		// weight is 1-(inv(diameter) * distance)
-		n *= m_system->m_particleDiameter * (1 - contact.weight);
-		b2Vec2 pos = m_system->m_positionBuffer.data[contact.index] + n;
-
-		// pos is now a point projected back along the contact normal to the
-		// contact distance. If the surface makes sense for a contact, pos will
-		// now lie on or in the fixture generating
-		if (!contact.fixture->TestPoint(pos))
-		{
-			int32 childCount = contact.fixture->GetShape()->GetChildCount();
-			for (int32 childIndex = 0; childIndex < childCount; childIndex++)
-			{
-				float32 distance;
-				b2Vec2 normal;
-				contact.fixture->ComputeDistance(pos, &distance, &normal,
-																	childIndex);
-				if (distance < b2_linearSlop)
-				{
-					return false;
-				}
-			}
-			++(*m_discarded);
-			return true;
-		}
-
-		return false;
-	}
-private:
-	// Max number of contacts processed per particle, from nearest to farthest.
-	// This must be at least 2 for correctness with concave shapes; 3 was
-	// experimentally arrived at as looking reasonable.
-	static const int32 k_maxContactsPerPoint = 3;
-	const b2ParticleSystem* m_system;
-	// Index of last particle processed.
-	int32 m_lastIndex;
-	// Number of contacts processed for the current particle.
-	int32 m_currentContacts;
-	// Output the number of discarded contacts.
-	int32* m_discarded;
-};
-
-namespace {
-
-// Compares the expiration time of two particle indices.
-class ExpirationTimeComparator
-{
-public:
-	// Initialize the class with a pointer to an array of particle
-	// lifetimes.
-	ExpirationTimeComparator(const int32* const expirationTimes) :
-		m_expirationTimes(expirationTimes)
-	{
-	}
-	// Empty destructor.
-	~ExpirationTimeComparator() { }
-
-	// Compare the lifetime of particleIndexA and particleIndexB
-	// returning true if the lifetime of A is greater than B for particles
-	// that will expire.  If either particle's lifetime is infinite (<= 0.0f)
-	// this function return true if the lifetime of A is lesser than B.
-	// When used with std::sort() this results in an array of particle
-	// indicies sorted in reverse order by particle lifetime.
-	// For example, the set of lifetimes
-	// (1.0, 0.7, 0.3, 0.0, -1.0, -2.0)
-	// would be sorted as
-	// (0.0, -1.0, -2.0, 1.0, 0.7, 0.3)
-	bool operator() (const int32 particleIndexA,
-					 const int32 particleIndexB) const
-	{
-		const int32 expirationTimeA = m_expirationTimes[particleIndexA];
-		const int32 expirationTimeB = m_expirationTimes[particleIndexB];
-		const bool infiniteExpirationTimeA = expirationTimeA <= 0.0f;
-		const bool infiniteExpirationTimeB = expirationTimeB <= 0.0f;
-		return infiniteExpirationTimeA == infiniteExpirationTimeB ?
-			expirationTimeA > expirationTimeB : infiniteExpirationTimeA;
-	}
-
-private:
-	const int32* m_expirationTimes;
-};
-
-// *Very* lightweight pair implementation.
-template<typename A, typename B>
-struct LightweightPair
-{
-	A first;
-	B second;
-
-	// Compares the value of two FixtureParticle objects returning
-	// true if left is a smaller value than right.
-	static bool Compare(const LightweightPair& left,
-						const LightweightPair& right)
-	{
-		return left.first < right.first &&
-			left.second < right.second;
-	}
-
-};
-
-// Allocator for a fixed set of items.
-class FixedSetAllocator
-{
-public:
-	// Associate a memory allocator with this object.
-	FixedSetAllocator(b2StackAllocator* allocator);
-	// Deallocate storage for this class.
-	~FixedSetAllocator()
-	{
-		Clear();
-	}
-
-	// Allocate internal storage for this object returning the size.
-	int32 Allocate(const int32 itemSize, const int32 count);
-
-	// Deallocate the internal buffer if it's allocated.
-	void Clear();
-
-	// Get the number of items in the set.
-	int32 GetCount() const { return m_count; }
-
-	// Invalidate an item from the set by index.
-	void Invalidate(const int32 itemIndex)
-	{
-		b2Assert(m_valid);
-		m_valid[itemIndex] = 0;
-	}
-
-	// Get the buffer which indicates whether items are valid in the set.
-	const int8* GetValidBuffer() const { return m_valid; }
-
-protected:
-	// Get the internal buffer.
-	void* GetBuffer() const { return m_buffer; }
-	void* GetBuffer() { return m_buffer; }
-
-	// Reduce the number of items in the set.
-	void SetCount(int32 count)
-	{
-		b2Assert(count <= m_count);
-		m_count = count;
-	}
-
-private:
-	// Set buffer.
-	void* m_buffer;
-	// Array of size m_count which indicates whether an item is in the
-	// corresponding index of m_set (1) or the item is invalid (0).
-	int8* m_valid;
-	// Number of items in m_set.
-	int32 m_count;
-	// Allocator used to allocate / free the set.
-	b2StackAllocator* m_allocator;
-};
-
-// Allocator for a fixed set of objects.
-template<typename T>
-class TypedFixedSetAllocator : public FixedSetAllocator
-{
-public:
-	// Initialize members of this class.
-	TypedFixedSetAllocator(b2StackAllocator* allocator) :
-		FixedSetAllocator(allocator) { }
-
-	// Allocate a set of objects, returning the new size of the set.
-	int32 Allocate(const int32 numberOfObjects)
-	{
-		Clear();
-		return FixedSetAllocator::Allocate(sizeof(T), numberOfObjects);
-	}
-
-	// Get the index of an item in the set if it's valid return an index
-	// >= 0, -1 otherwise.
-	int32 GetIndex(const T* item) const
-	{
-		if (item)
-		{
-			b2Assert(item >= GetBuffer() &&
-					 item < GetBuffer() + GetCount());
-			const int32 index =
-				(int32)(((uint8*)item - (uint8*)GetBuffer()) /
-						sizeof(*item));
-			if (GetValidBuffer()[index])
-			{
-				return index;
-			}
-		}
-		return -1;
-	}
-
-	// Get the internal buffer.
-	const T* GetBuffer() const
-	{
-		return (const T*)FixedSetAllocator::GetBuffer();
-	}
-	T* GetBuffer() { return (T*)FixedSetAllocator::GetBuffer(); }
-};
-
-// Associates a fixture with a particle index.
-typedef LightweightPair<b2Fixture*,int32> FixtureParticle;
-
-// Associates a fixture with a particle index.
-typedef LightweightPair<int32,int32> ParticlePair;
-
-}  // namespace
-
-// Set of fixture / particle indices.
-class FixtureParticleSet :
-	public TypedFixedSetAllocator<FixtureParticle>
-{
-public:
-	// Initialize members of this class.
-	FixtureParticleSet(b2StackAllocator* allocator) :
-		TypedFixedSetAllocator<FixtureParticle>(allocator) { }
-
-
-	// Initialize from a set of particle / body contacts for particles
-	// that have the b2_fixtureContactListenerParticle flag set.
-	void Initialize(const b2ParticleBodyContact * const bodyContacts,
-					const int32 numBodyContacts,
-					const uint32 * const particleFlagsBuffer);
-
-	// Find the index of a particle / fixture pair in the set or -1
-	// if it's not present.
-	// NOTE: This was not written as a template function to avoid
-	// exposing any dependencies via this header.
-	int32 Find(const FixtureParticle& fixtureParticle) const;
-};
-
-// Set of particle / particle pairs.
-class b2ParticlePairSet : public TypedFixedSetAllocator<ParticlePair>
-{
-public:
-	// Initialize members of this class.
-	b2ParticlePairSet(b2StackAllocator* allocator) :
-		TypedFixedSetAllocator<ParticlePair>(allocator) { }
-
-	// Initialize from a set of particle contacts.
-	void Initialize(const b2ParticleContact * const contacts,
-					const int32 numContacts,
-					const uint32 * const particleFlagsBuffer);
-
-	// Find the index of a particle pair in the set or -1
-	// if it's not present.
-	// NOTE: This was not written as a template function to avoid
-	// exposing any dependencies via this header.
-	int32 Find(const ParticlePair& pair) const;
-};
-
-static inline uint32 computeTag(float32 x, float32 y)
-{
-	return ((uint32)(y + yOffset) << yShift) + (uint32)(xScale * x + xOffset);
-}
-
-static inline uint32 computeRelativeTag(uint32 tag, int32 x, int32 y)
-{
-	return tag + (y << yShift) + (x << xShift);
-}
-
-b2ParticleSystem::InsideBoundsEnumerator::InsideBoundsEnumerator(
-	uint32 lower, uint32 upper, const Proxy* first, const Proxy* last)
-{
-	m_xLower = lower & xMask;
-	m_xUpper = upper & xMask;
-	m_yLower = lower & yMask;
-	m_yUpper = upper & yMask;
-	m_first = first;
-	m_last = last;
-	b2Assert(m_first <= m_last);
-}
-
-int32 b2ParticleSystem::InsideBoundsEnumerator::GetNext()
-{
-	while (m_first < m_last)
-	{
-		uint32 xTag = m_first->tag & xMask;
-#if B2_ASSERT_ENABLED
-		uint32 yTag = m_first->tag & yMask;
-		b2Assert(yTag >= m_yLower);
-		b2Assert(yTag <= m_yUpper);
-#endif
-		if (xTag >= m_xLower && xTag <= m_xUpper)
-		{
-			return (m_first++)->index;
-		}
-		m_first++;
-	}
-	return b2_invalidParticleIndex;
-}
-
-b2ParticleSystem::b2ParticleSystem(const b2ParticleSystemDef* def,
-								   b2World* world) :
-	m_handleAllocator(b2_minParticleSystemBufferCapacity),
-	m_stuckParticleBuffer(world->m_blockAllocator),
-	m_proxyBuffer(world->m_blockAllocator),
-	m_contactBuffer(world->m_blockAllocator),
-	m_bodyContactBuffer(world->m_blockAllocator),
-	m_pairBuffer(world->m_blockAllocator),
-	m_triadBuffer(world->m_blockAllocator)
-{
-	b2Assert(def);
-	m_paused = false;
-	m_timestamp = 0;
-	m_allParticleFlags = 0;
-	m_needsUpdateAllParticleFlags = false;
-	m_allGroupFlags = 0;
-	m_needsUpdateAllGroupFlags = false;
-	m_hasForce = false;
-	m_iterationIndex = 0;
-
-	SetStrictContactCheck(def->strictContactCheck);
-	SetDensity(def->density);
-	SetGravityScale(def->gravityScale);
-	SetRadius(def->radius);
-	SetMaxParticleCount(def->maxCount);
-
-	m_count = 0;
-	m_internalAllocatedCapacity = 0;
-	m_forceBuffer = NULL;
-	m_weightBuffer = NULL;
-	m_staticPressureBuffer = NULL;
-	m_accumulationBuffer = NULL;
-	m_accumulation2Buffer = NULL;
-	m_depthBuffer = NULL;
-	m_groupBuffer = NULL;
-
-	m_groupCount = 0;
-	m_groupList = NULL;
-
-	b2Assert(def->lifetimeGranularity > 0.0f);
-	m_def = *def;
-
-	m_world = world;
-
-	m_stuckThreshold = 0;
-
-	m_timeElapsed = 0;
-	m_expirationTimeBufferRequiresSorting = false;
-
-	SetDestructionByAge(m_def.destroyByAge);
-
-#if defined(LIQUIDFUN_SIMD_NEON) && defined(ANDROID) && !defined(__ARM_NEON__)
-  if (cpuFeatures == 0 && hasNeon)
-  {
-    cpuFeatures = android_getCpuFeatures();
-    hasNeon = cpuFeatures & ANDROID_CPU_ARM_FEATURE_NEON;
-  }
-#endif
-}
-
-b2ParticleSystem::~b2ParticleSystem()
-{
-	while (m_groupList)
-	{
-		DestroyParticleGroup(m_groupList);
-	}
-
-	FreeUserOverridableBuffer(&m_handleIndexBuffer);
-	FreeUserOverridableBuffer(&m_flagsBuffer);
-	FreeUserOverridableBuffer(&m_lastBodyContactStepBuffer);
-	FreeUserOverridableBuffer(&m_bodyContactCountBuffer);
-	FreeUserOverridableBuffer(&m_consecutiveContactStepsBuffer);
-	FreeUserOverridableBuffer(&m_positionBuffer);
-	FreeUserOverridableBuffer(&m_velocityBuffer);
-	FreeUserOverridableBuffer(&m_colorBuffer);
-	FreeUserOverridableBuffer(&m_userDataBuffer);
-	FreeUserOverridableBuffer(&m_expirationTimeBuffer);
-	FreeUserOverridableBuffer(&m_indexByExpirationTimeBuffer);
-	FreeBuffer(&m_forceBuffer, m_internalAllocatedCapacity);
-	FreeBuffer(&m_weightBuffer, m_internalAllocatedCapacity);
-	FreeBuffer(&m_staticPressureBuffer, m_internalAllocatedCapacity);
-	FreeBuffer(&m_accumulationBuffer, m_internalAllocatedCapacity);
-	FreeBuffer(&m_accumulation2Buffer, m_internalAllocatedCapacity);
-	FreeBuffer(&m_depthBuffer, m_internalAllocatedCapacity);
-	FreeBuffer(&m_groupBuffer, m_internalAllocatedCapacity);
-}
-
-template <typename T> void b2ParticleSystem::FreeBuffer(T** b, int capacity)
-{
-	if (*b == NULL)
-		return;
-
-	m_world->m_blockAllocator.Free(*b, sizeof(**b) * capacity);
-	*b = NULL;
-}
-
-// Free buffer, if it was allocated with b2World's block allocator
-template <typename T> void b2ParticleSystem::FreeUserOverridableBuffer(
-	UserOverridableBuffer<T>* b)
-{
-	if (b->userSuppliedCapacity == 0)
-	{
-		FreeBuffer(&b->data, m_internalAllocatedCapacity);
-	}
-}
-
-// Reallocate a buffer
-template <typename T> T* b2ParticleSystem::ReallocateBuffer(
-	T* oldBuffer, int32 oldCapacity, int32 newCapacity)
-{
-	b2Assert(newCapacity > oldCapacity);
-	T* newBuffer = (T*) m_world->m_blockAllocator.Allocate(
-		sizeof(T) * newCapacity);
-	if (oldBuffer)
-	{
-		memcpy((void *)newBuffer, oldBuffer, sizeof(T) * oldCapacity);
-		m_world->m_blockAllocator.Free(oldBuffer, sizeof(T) * oldCapacity);
-	}
-	return newBuffer;
-}
-
-// Reallocate a buffer
-template <typename T> T* b2ParticleSystem::ReallocateBuffer(
-	T* buffer, int32 userSuppliedCapacity, int32 oldCapacity,
-	int32 newCapacity, bool deferred)
-{
-	b2Assert(newCapacity > oldCapacity);
-	// A 'deferred' buffer is reallocated only if it is not NULL.
-	// If 'userSuppliedCapacity' is not zero, buffer is user supplied and must
-	// be kept.
-	b2Assert(!userSuppliedCapacity || newCapacity <= userSuppliedCapacity);
-	if ((!deferred || buffer) && !userSuppliedCapacity)
-	{
-		buffer = ReallocateBuffer(buffer, oldCapacity, newCapacity);
-	}
-	return buffer;
-}
-
-// Reallocate a buffer
-template <typename T> T* b2ParticleSystem::ReallocateBuffer(
-	UserOverridableBuffer<T>* buffer, int32 oldCapacity, int32 newCapacity,
-	bool deferred)
-{
-	b2Assert(newCapacity > oldCapacity);
-	return ReallocateBuffer(buffer->data, buffer->userSuppliedCapacity,
-							oldCapacity, newCapacity, deferred);
-}
-
-/// Reallocate the handle / index map and schedule the allocation of a new
-/// pool for handle allocation.
-void b2ParticleSystem::ReallocateHandleBuffers(int32 newCapacity)
-{
-	b2Assert(newCapacity > m_internalAllocatedCapacity);
-	// Reallocate a new handle / index map buffer, copying old handle pointers
-	// is fine since they're kept around.
-	m_handleIndexBuffer.data = ReallocateBuffer(
-		&m_handleIndexBuffer, m_internalAllocatedCapacity, newCapacity,
-		true);
-	// Set the size of the next handle allocation.
-	m_handleAllocator.SetItemsPerSlab(newCapacity -
-									  m_internalAllocatedCapacity);
-}
-
-template <typename T> T* b2ParticleSystem::RequestBuffer(T* buffer)
-{
-	if (!buffer)
-	{
-		if (m_internalAllocatedCapacity == 0)
-		{
-			ReallocateInternalAllocatedBuffers(
-				b2_minParticleSystemBufferCapacity);
-		}
-		buffer = (T*) (m_world->m_blockAllocator.Allocate(
-						   sizeof(T) * m_internalAllocatedCapacity));
-		b2Assert(buffer);
-		memset((void *)buffer, 0, sizeof(T) * m_internalAllocatedCapacity);
-	}
-	return buffer;
-}
-
-b2ParticleColor* b2ParticleSystem::GetColorBuffer()
-{
-	m_colorBuffer.data = RequestBuffer(m_colorBuffer.data);
-	return m_colorBuffer.data;
-}
-
-void** b2ParticleSystem::GetUserDataBuffer()
-{
-	m_userDataBuffer.data = RequestBuffer(m_userDataBuffer.data);
-	return m_userDataBuffer.data;
-}
-
-static int32 LimitCapacity(int32 capacity, int32 maxCount)
-{
-	return maxCount && capacity > maxCount ? maxCount : capacity;
-}
-
-void b2ParticleSystem::ReallocateInternalAllocatedBuffers(int32 capacity)
-{
-	// Don't increase capacity beyond the smallest user-supplied buffer size.
-	capacity = LimitCapacity(capacity, m_def.maxCount);
-	capacity = LimitCapacity(capacity, m_flagsBuffer.userSuppliedCapacity);
-	capacity = LimitCapacity(capacity, m_positionBuffer.userSuppliedCapacity);
-	capacity = LimitCapacity(capacity, m_velocityBuffer.userSuppliedCapacity);
-	capacity = LimitCapacity(capacity, m_colorBuffer.userSuppliedCapacity);
-	capacity = LimitCapacity(capacity, m_userDataBuffer.userSuppliedCapacity);
-	if (m_internalAllocatedCapacity < capacity)
-	{
-		ReallocateHandleBuffers(capacity);
-		m_flagsBuffer.data = ReallocateBuffer(
-			&m_flagsBuffer, m_internalAllocatedCapacity, capacity, false);
-
-		// Conditionally defer these as they are optional if the feature is
-		// not enabled.
-		const bool stuck = m_stuckThreshold > 0;
-		m_lastBodyContactStepBuffer.data = ReallocateBuffer(
-			&m_lastBodyContactStepBuffer, m_internalAllocatedCapacity,
-			capacity, stuck);
-		m_bodyContactCountBuffer.data = ReallocateBuffer(
-			&m_bodyContactCountBuffer, m_internalAllocatedCapacity, capacity,
-			stuck);
-		m_consecutiveContactStepsBuffer.data = ReallocateBuffer(
-			&m_consecutiveContactStepsBuffer, m_internalAllocatedCapacity,
-			capacity, stuck);
-		m_positionBuffer.data = ReallocateBuffer(
-			&m_positionBuffer, m_internalAllocatedCapacity, capacity, false);
-		m_velocityBuffer.data = ReallocateBuffer(
-			&m_velocityBuffer, m_internalAllocatedCapacity, capacity, false);
-		m_forceBuffer = ReallocateBuffer(
-			m_forceBuffer, 0, m_internalAllocatedCapacity, capacity, false);
-		m_weightBuffer = ReallocateBuffer(
-			m_weightBuffer, 0, m_internalAllocatedCapacity, capacity, false);
-		m_staticPressureBuffer = ReallocateBuffer(
-			m_staticPressureBuffer, 0, m_internalAllocatedCapacity, capacity,
-			true);
-		m_accumulationBuffer = ReallocateBuffer(
-			m_accumulationBuffer, 0, m_internalAllocatedCapacity, capacity,
-			false);
-		m_accumulation2Buffer = ReallocateBuffer(
-			m_accumulation2Buffer, 0, m_internalAllocatedCapacity, capacity,
-			true);
-		m_depthBuffer = ReallocateBuffer(
-			m_depthBuffer, 0, m_internalAllocatedCapacity, capacity, true);
-		m_colorBuffer.data = ReallocateBuffer(
-			&m_colorBuffer, m_internalAllocatedCapacity, capacity, true);
-		m_groupBuffer = ReallocateBuffer(
-			m_groupBuffer, 0, m_internalAllocatedCapacity, capacity, false);
-		m_userDataBuffer.data = ReallocateBuffer(
-			&m_userDataBuffer, m_internalAllocatedCapacity, capacity, true);
-		m_expirationTimeBuffer.data = ReallocateBuffer(
-			&m_expirationTimeBuffer, m_internalAllocatedCapacity, capacity,
-			true);
-		m_indexByExpirationTimeBuffer.data = ReallocateBuffer(
-			&m_indexByExpirationTimeBuffer, m_internalAllocatedCapacity,
-			capacity, true);
-		m_internalAllocatedCapacity = capacity;
-	}
-}
-
-int32 b2ParticleSystem::CreateParticle(const b2ParticleDef& def)
-{
-	b2Assert(m_world->IsLocked() == false);
-	if (m_world->IsLocked())
-	{
-		return 0;
-	}
-
-	if (m_count >= m_internalAllocatedCapacity)
-	{
-		// Double the particle capacity.
-		int32 capacity =
-			m_count ? 2 * m_count : b2_minParticleSystemBufferCapacity;
-		ReallocateInternalAllocatedBuffers(capacity);
-	}
-	if (m_count >= m_internalAllocatedCapacity)
-	{
-		// If the oldest particle should be destroyed...
-		if (m_def.destroyByAge)
-		{
-			DestroyOldestParticle(0, false);
-			// Need to destroy this particle *now* so that it's possible to
-			// create a new particle.
-			SolveZombie();
-		}
-		else
-		{
-			return b2_invalidParticleIndex;
-		}
-	}
-	int32 index = m_count++;
-	m_flagsBuffer.data[index] = 0;
-	if (m_lastBodyContactStepBuffer.data)
-	{
-		m_lastBodyContactStepBuffer.data[index] = 0;
-	}
-	if (m_bodyContactCountBuffer.data)
-	{
-		m_bodyContactCountBuffer.data[index] = 0;
-	}
-	if (m_consecutiveContactStepsBuffer.data)
-	{
-		m_consecutiveContactStepsBuffer.data[index] = 0;
-	}
-	m_positionBuffer.data[index] = def.position;
-	m_velocityBuffer.data[index] = def.velocity;
-	m_weightBuffer[index] = 0;
-	m_forceBuffer[index] = b2Vec2_zero;
-	if (m_staticPressureBuffer)
-	{
-		m_staticPressureBuffer[index] = 0;
-	}
-	if (m_depthBuffer)
-	{
-		m_depthBuffer[index] = 0;
-	}
-	if (m_colorBuffer.data || !def.color.IsZero())
-	{
-		m_colorBuffer.data = RequestBuffer(m_colorBuffer.data);
-		m_colorBuffer.data[index] = def.color;
-	}
-	if (m_userDataBuffer.data || def.userData)
-	{
-		m_userDataBuffer.data= RequestBuffer(m_userDataBuffer.data);
-		m_userDataBuffer.data[index] = def.userData;
-	}
-	if (m_handleIndexBuffer.data)
-	{
-		m_handleIndexBuffer.data[index] = NULL;
-	}
-	Proxy& proxy = m_proxyBuffer.Append();
-
-	// If particle lifetimes are enabled or the lifetime is set in the particle
-	// definition, initialize the lifetime.
-	const bool finiteLifetime = def.lifetime > 0;
-	if (m_expirationTimeBuffer.data || finiteLifetime)
-	{
-		SetParticleLifetime(index, finiteLifetime ? def.lifetime :
-								ExpirationTimeToLifetime(
-									-GetQuantizedTimeElapsed()));
-		// Add a reference to the newly added particle to the end of the
-		// queue.
-		m_indexByExpirationTimeBuffer.data[index] = index;
-	}
-
-	proxy.index = index;
-	b2ParticleGroup* group = def.group;
-	m_groupBuffer[index] = group;
-	if (group)
-	{
-		if (group->m_firstIndex < group->m_lastIndex)
-		{
-			// Move particles in the group just before the new particle.
-			RotateBuffer(group->m_firstIndex, group->m_lastIndex, index);
-			b2Assert(group->m_lastIndex == index);
-			// Update the index range of the group to contain the new particle.
-			group->m_lastIndex = index + 1;
-		}
-		else
-		{
-			// If the group is empty, reset the index range to contain only the
-			// new particle.
-			group->m_firstIndex = index;
-			group->m_lastIndex = index + 1;
-		}
-	}
-	SetParticleFlags(index, def.flags);
-	return index;
-}
-
-/// Retrieve a handle to the particle at the specified index.
-const b2ParticleHandle* b2ParticleSystem::GetParticleHandleFromIndex(
-	const int32 index)
-{
-	b2Assert(index >= 0 && index < GetParticleCount() &&
-			 index != b2_invalidParticleIndex);
-	m_handleIndexBuffer.data = RequestBuffer(m_handleIndexBuffer.data);
-	b2ParticleHandle* handle = m_handleIndexBuffer.data[index];
-	if (handle)
-	{
-		return handle;
-	}
-	// Create a handle.
-	handle = m_handleAllocator.Allocate();
-	b2Assert(handle);
-	handle->SetIndex(index);
-	m_handleIndexBuffer.data[index] = handle;
-	return handle;
-}
-
-
-void b2ParticleSystem::DestroyParticle(
-	int32 index, bool callDestructionListener)
-{
-	uint32 flags = b2_zombieParticle;
-	if (callDestructionListener)
-	{
-		flags |= b2_destructionListenerParticle;
-	}
-	SetParticleFlags(index, m_flagsBuffer.data[index] | flags);
-}
-
-void b2ParticleSystem::DestroyOldestParticle(
-	const int32 index, const bool callDestructionListener)
-{
-	const int32 particleCount = GetParticleCount();
-	b2Assert(index >= 0 && index < particleCount);
-	// Make sure particle lifetime tracking is enabled.
-	b2Assert(m_indexByExpirationTimeBuffer.data);
-	// Destroy the oldest particle (preferring to destroy finite
-	// lifetime particles first) to free a slot in the buffer.
-	const int32 oldestFiniteLifetimeParticle =
-		m_indexByExpirationTimeBuffer.data[particleCount - (index + 1)];
-	const int32 oldestInfiniteLifetimeParticle =
-		m_indexByExpirationTimeBuffer.data[index];
-	DestroyParticle(
-		m_expirationTimeBuffer.data[oldestFiniteLifetimeParticle] > 0.0f ?
-			oldestFiniteLifetimeParticle : oldestInfiniteLifetimeParticle,
-		callDestructionListener);
-}
-
-int32 b2ParticleSystem::DestroyParticlesInShape(
-	const b2Shape& shape, const b2Transform& xf,
-	bool callDestructionListener)
-{
-	b2Assert(m_world->IsLocked() == false);
-	if (m_world->IsLocked())
-	{
-		return 0;
-	}
-
-	class DestroyParticlesInShapeCallback : public b2QueryCallback
-	{
-	public:
-		DestroyParticlesInShapeCallback(
-			b2ParticleSystem* system, const b2Shape& shape,
-			const b2Transform& xf, bool callDestructionListener)
-		{
-			m_system = system;
-			m_shape = &shape;
-			m_xf = xf;
-			m_callDestructionListener = callDestructionListener;
-			m_destroyed = 0;
-		}
-
-		bool ReportFixture(b2Fixture* fixture)
-		{
-			B2_NOT_USED(fixture);
-			return false;
-		}
-
-		bool ReportParticle(const b2ParticleSystem* particleSystem, int32 index)
-		{
-			if (particleSystem != m_system)
-				return false;
-
-			b2Assert(index >=0 && index < m_system->m_count);
-			if (m_shape->TestPoint(m_xf,
-								   m_system->m_positionBuffer.data[index]))
-			{
-				m_system->DestroyParticle(index, m_callDestructionListener);
-				m_destroyed++;
-			}
-			return true;
-		}
-
-		int32 Destroyed() { return m_destroyed; }
-
-	private:
-		b2ParticleSystem* m_system;
-		const b2Shape* m_shape;
-		b2Transform m_xf;
-		bool m_callDestructionListener;
-		int32 m_destroyed;
-	} callback(this, shape, xf, callDestructionListener);
-	b2AABB aabb;
-	shape.ComputeAABB(&aabb, xf, 0);
-	m_world->QueryAABB(&callback, aabb);
-	return callback.Destroyed();
-}
-
-int32 b2ParticleSystem::CreateParticleForGroup(
-	const b2ParticleGroupDef& groupDef, const b2Transform& xf, const b2Vec2& p)
-{
-	b2ParticleDef particleDef;
-	particleDef.flags = groupDef.flags;
-	particleDef.position = b2Mul(xf, p);
-	particleDef.velocity =
-		groupDef.linearVelocity +
-		b2Cross(groupDef.angularVelocity,
-				particleDef.position - groupDef.position);
-	particleDef.color = groupDef.color;
-	particleDef.lifetime = groupDef.lifetime;
-	particleDef.userData = groupDef.userData;
-	return CreateParticle(particleDef);
-}
-
-void b2ParticleSystem::CreateParticlesStrokeShapeForGroup(
-	const b2Shape *shape,
-	const b2ParticleGroupDef& groupDef, const b2Transform& xf)
-{
-	float32 stride = groupDef.stride;
-	if (stride == 0)
-	{
-		stride = GetParticleStride();
-	}
-	float32 positionOnEdge = 0;
-	int32 childCount = shape->GetChildCount();
-	for (int32 childIndex = 0; childIndex < childCount; childIndex++)
-	{
-		b2EdgeShape edge;
-		if (shape->GetType() == b2Shape::e_edge)
-		{
-			edge = *(b2EdgeShape*) shape;
-		}
-		else
-		{
-			b2Assert(shape->GetType() == b2Shape::e_chain);
-			((b2ChainShape*) shape)->GetChildEdge(&edge, childIndex);
-		}
-		b2Vec2 d = edge.m_vertex2 - edge.m_vertex1;
-		float32 edgeLength = d.Length();
-		while (positionOnEdge < edgeLength)
-		{
-			b2Vec2 p = edge.m_vertex1 + positionOnEdge / edgeLength * d;
-			CreateParticleForGroup(groupDef, xf, p);
-			positionOnEdge += stride;
-		}
-		positionOnEdge -= edgeLength;
-	}
-}
-
-void b2ParticleSystem::CreateParticlesFillShapeForGroup(
-	const b2Shape *shape,
-	const b2ParticleGroupDef& groupDef, const b2Transform& xf)
-{
-	float32 stride = groupDef.stride;
-	if (stride == 0)
-	{
-		stride = GetParticleStride();
-	}
-	b2Transform identity;
-	identity.SetIdentity();
-	b2AABB aabb;
-	b2Assert(shape->GetChildCount() == 1);
-	shape->ComputeAABB(&aabb, identity, 0);
-	for (float32 y = floorf(aabb.lowerBound.y / stride) * stride;
-		y < aabb.upperBound.y; y += stride)
-	{
-		for (float32 x = floorf(aabb.lowerBound.x / stride) * stride;
-			x < aabb.upperBound.x; x += stride)
-		{
-			b2Vec2 p(x, y);
-			if (shape->TestPoint(identity, p))
-			{
-				CreateParticleForGroup(groupDef, xf, p);
-			}
-		}
-	}
-}
-
-void b2ParticleSystem::CreateParticlesWithShapeForGroup(
-	const b2Shape* shape,
-	const b2ParticleGroupDef& groupDef, const b2Transform& xf)
-{
-	switch (shape->GetType()) {
-	case b2Shape::e_edge:
-	case b2Shape::e_chain:
-		CreateParticlesStrokeShapeForGroup(shape, groupDef, xf);
-		break;
-	case b2Shape::e_polygon:
-	case b2Shape::e_circle:
-		CreateParticlesFillShapeForGroup(shape, groupDef, xf);
-		break;
-	default:
-		b2Assert(false);
-		break;
-	}
-}
-
-void b2ParticleSystem::CreateParticlesWithShapesForGroup(
-	const b2Shape* const* shapes, int32 shapeCount,
-	const b2ParticleGroupDef& groupDef, const b2Transform& xf)
-{
-	class CompositeShape : public b2Shape
-	{
-	public:
-		CompositeShape(const b2Shape* const* shapes, int32 shapeCount)
-		{
-			m_shapes = shapes;
-			m_shapeCount = shapeCount;
-		}
-		b2Shape* Clone(b2BlockAllocator* allocator) const
-		{
-			b2Assert(false);
-			B2_NOT_USED(allocator);
-			return NULL;
-		}
-		int32 GetChildCount() const
-		{
-			return 1;
-		}
-		bool TestPoint(const b2Transform& xf, const b2Vec2& p) const
-		{
-			for (int32 i = 0; i < m_shapeCount; i++)
-			{
-				if (m_shapes[i]->TestPoint(xf, p))
-				{
-					return true;
-				}
-			}
-			return false;
-		}
-		void ComputeDistance(const b2Transform& xf, const b2Vec2& p,
-					float32* distance, b2Vec2* normal, int32 childIndex) const
-		{
-			b2Assert(false);
-			B2_NOT_USED(xf);
-			B2_NOT_USED(p);
-			B2_NOT_USED(distance);
-			B2_NOT_USED(normal);
-			B2_NOT_USED(childIndex);
-		}
-		bool RayCast(b2RayCastOutput* output, const b2RayCastInput& input,
-						const b2Transform& transform, int32 childIndex) const
-		{
-			b2Assert(false);
-			B2_NOT_USED(output);
-			B2_NOT_USED(input);
-			B2_NOT_USED(transform);
-			B2_NOT_USED(childIndex);
-			return false;
-		}
-		void ComputeAABB(
-				b2AABB* aabb, const b2Transform& xf, int32 childIndex) const
-		{
-			B2_NOT_USED(childIndex);
-			aabb->lowerBound.x = +FLT_MAX;
-			aabb->lowerBound.y = +FLT_MAX;
-			aabb->upperBound.x = -FLT_MAX;
-			aabb->upperBound.y = -FLT_MAX;
-			b2Assert(childIndex == 0);
-			for (int32 i = 0; i < m_shapeCount; i++)
-			{
-				int32 childCount = m_shapes[i]->GetChildCount();
-				for (int32 j = 0; j < childCount; j++)
-				{
-					b2AABB subaabb;
-					m_shapes[i]->ComputeAABB(&subaabb, xf, j);
-					aabb->Combine(subaabb);
-				}
-			}
-		}
-		void ComputeMass(b2MassData* massData, float32 density) const
-		{
-			b2Assert(false);
-			B2_NOT_USED(massData);
-			B2_NOT_USED(density);
-		}
-	private:
-		const b2Shape* const* m_shapes;
-		int32 m_shapeCount;
-	} compositeShape(shapes, shapeCount);
-	CreateParticlesFillShapeForGroup(&compositeShape, groupDef, xf);
-}
-
-b2ParticleGroup* b2ParticleSystem::CreateParticleGroup(
-	const b2ParticleGroupDef& groupDef)
-{
-	b2Assert(m_world->IsLocked() == false);
-	if (m_world->IsLocked())
-	{
-		return 0;
-	}
-
-	b2Transform transform;
-	transform.Set(groupDef.position, groupDef.angle);
-	int32 firstIndex = m_count;
-	if (groupDef.shape)
-	{
-		CreateParticlesWithShapeForGroup(groupDef.shape, groupDef, transform);
-	}
-	if (groupDef.shapes)
-	{
-		CreateParticlesWithShapesForGroup(
-					groupDef.shapes, groupDef.shapeCount, groupDef, transform);
-	}
-	if (groupDef.particleCount)
-	{
-		b2Assert(groupDef.positionData);
-		for (int32 i = 0; i < groupDef.particleCount; i++)
-		{
-			b2Vec2 p = groupDef.positionData[i];
-			CreateParticleForGroup(groupDef, transform, p);
-		}
-	}
-	int32 lastIndex = m_count;
-
-	void* mem = m_world->m_blockAllocator.Allocate(sizeof(b2ParticleGroup));
-	b2ParticleGroup* group = new (mem) b2ParticleGroup();
-	group->m_system = this;
-	group->m_firstIndex = firstIndex;
-	group->m_lastIndex = lastIndex;
-	group->m_strength = groupDef.strength;
-	group->m_userData = groupDef.userData;
-	group->m_transform = transform;
-	group->m_prev = NULL;
-	group->m_next = m_groupList;
-	if (m_groupList)
-	{
-		m_groupList->m_prev = group;
-	}
-	m_groupList = group;
-	++m_groupCount;
-	for (int32 i = firstIndex; i < lastIndex; i++)
-	{
-		m_groupBuffer[i] = group;
-	}
-	SetGroupFlags(group, groupDef.groupFlags);
-
-	// Create pairs and triads between particles in the group.
-	ConnectionFilter filter;
-	UpdateContacts(true);
-	UpdatePairsAndTriads(firstIndex, lastIndex, filter);
-
-	if (groupDef.group)
-	{
-		JoinParticleGroups(groupDef.group, group);
-		group = groupDef.group;
-	}
-
-	return group;
-}
-
-void b2ParticleSystem::JoinParticleGroups(b2ParticleGroup* groupA,
-										  b2ParticleGroup* groupB)
-{
-	b2Assert(m_world->IsLocked() == false);
-	if (m_world->IsLocked())
-	{
-		return;
-	}
-
-	b2Assert(groupA != groupB);
-	RotateBuffer(groupB->m_firstIndex, groupB->m_lastIndex, m_count);
-	b2Assert(groupB->m_lastIndex == m_count);
-	RotateBuffer(groupA->m_firstIndex, groupA->m_lastIndex,
-				 groupB->m_firstIndex);
-	b2Assert(groupA->m_lastIndex == groupB->m_firstIndex);
-
-	// Create pairs and triads connecting groupA and groupB.
-	class JoinParticleGroupsFilter : public ConnectionFilter
-	{
-		bool ShouldCreatePair(int32 a, int32 b) const
-		{
-			return
-				(a < m_threshold && m_threshold <= b) ||
-				(b < m_threshold && m_threshold <= a);
-		}
-		bool ShouldCreateTriad(int32 a, int32 b, int32 c) const
-		{
-			return
-				(a < m_threshold || b < m_threshold || c < m_threshold) &&
-				(m_threshold <= a || m_threshold <= b || m_threshold <= c);
-		}
-		int32 m_threshold;
-	public:
-		JoinParticleGroupsFilter(int32 threshold)
-		{
-			m_threshold = threshold;
-		}
-	} filter(groupB->m_firstIndex);
-	UpdateContacts(true);
-	UpdatePairsAndTriads(groupA->m_firstIndex, groupB->m_lastIndex, filter);
-
-	for (int32 i = groupB->m_firstIndex; i < groupB->m_lastIndex; i++)
-	{
-		m_groupBuffer[i] = groupA;
-	}
-	uint32 groupFlags = groupA->m_groupFlags | groupB->m_groupFlags;
-	SetGroupFlags(groupA, groupFlags);
-	groupA->m_lastIndex = groupB->m_lastIndex;
-	groupB->m_firstIndex = groupB->m_lastIndex;
-	DestroyParticleGroup(groupB);
-}
-
-void b2ParticleSystem::SplitParticleGroup(b2ParticleGroup* group)
-{
-	UpdateContacts(true);
-	int32 particleCount = group->GetParticleCount();
-	// We create several linked lists. Each list represents a set of connected
-	// particles.
-	ParticleListNode* nodeBuffer =
-		(ParticleListNode*) m_world->m_stackAllocator.Allocate(
-									sizeof(ParticleListNode) * particleCount);
-	InitializeParticleLists(group, nodeBuffer);
-	MergeParticleListsInContact(group, nodeBuffer);
-	ParticleListNode* survivingList =
-									FindLongestParticleList(group, nodeBuffer);
-	MergeZombieParticleListNodes(group, nodeBuffer, survivingList);
-	CreateParticleGroupsFromParticleList(group, nodeBuffer, survivingList);
-	UpdatePairsAndTriadsWithParticleList(group, nodeBuffer);
-	m_world->m_stackAllocator.Free(nodeBuffer);
-}
-
-void b2ParticleSystem::InitializeParticleLists(
-	const b2ParticleGroup* group, ParticleListNode* nodeBuffer)
-{
-	int32 bufferIndex = group->GetBufferIndex();
-	int32 particleCount = group->GetParticleCount();
-	for (int32 i = 0; i < particleCount; i++)
-	{
-		ParticleListNode* node = &nodeBuffer[i];
-		node->list = node;
-		node->next = NULL;
-		node->count = 1;
-		node->index = i + bufferIndex;
-	}
-}
-
-void b2ParticleSystem::MergeParticleListsInContact(
-	const b2ParticleGroup* group, ParticleListNode* nodeBuffer) const
-{
-	int32 bufferIndex = group->GetBufferIndex();
-	for (int32 k = 0; k < m_contactBuffer.GetCount(); k++)
-	{
-		const b2ParticleContact& contact = m_contactBuffer[k];
-		int32 a = contact.GetIndexA();
-		int32 b = contact.GetIndexB();
-		if (!group->ContainsParticle(a) || !group->ContainsParticle(b)) {
-			continue;
-		}
-		ParticleListNode* listA = nodeBuffer[a - bufferIndex].list;
-		ParticleListNode* listB = nodeBuffer[b - bufferIndex].list;
-		if (listA == listB) {
-			continue;
-		}
-		// To minimize the cost of insertion, make sure listA is longer than
-		// listB.
-		if (listA->count < listB->count)
-		{
-			b2Swap(listA, listB);
-		}
-		b2Assert(listA->count >= listB->count);
-		MergeParticleLists(listA, listB);
-	}
-}
-
-void b2ParticleSystem::MergeParticleLists(
-	ParticleListNode* listA, ParticleListNode* listB)
-{
-	// Insert listB between index 0 and 1 of listA
-	// Example:
-	//     listA => a1 => a2 => a3 => NULL
-	//     listB => b1 => b2 => NULL
-	// to
-	//     listA => listB => b1 => b2 => a1 => a2 => a3 => NULL
-	b2Assert(listA != listB);
-	for (ParticleListNode* b = listB;;)
-	{
-		b->list = listA;
-		ParticleListNode* nextB = b->next;
-		if (nextB)
-		{
-			b = nextB;
-		}
-		else
-		{
-			b->next = listA->next;
-			break;
-		}
-	}
-	listA->next = listB;
-	listA->count += listB->count;
-	listB->count = 0;
-}
-
-b2ParticleSystem::ParticleListNode* b2ParticleSystem::FindLongestParticleList(
-	const b2ParticleGroup* group, ParticleListNode* nodeBuffer)
-{
-	int32 particleCount = group->GetParticleCount();
-	ParticleListNode* result = nodeBuffer;
-	for (int32 i = 0; i < particleCount; i++)
-	{
-		ParticleListNode* node = &nodeBuffer[i];
-		if (result->count < node->count)
-		{
-			result = node;
-		}
-	}
-	return result;
-}
-
-void b2ParticleSystem::MergeZombieParticleListNodes(
-	const b2ParticleGroup* group, ParticleListNode* nodeBuffer,
-	ParticleListNode* survivingList) const
-{
-	int32 particleCount = group->GetParticleCount();
-	for (int32 i = 0; i < particleCount; i++)
-	{
-		ParticleListNode* node = &nodeBuffer[i];
-		if (node != survivingList &&
-			(m_flagsBuffer.data[node->index] & b2_zombieParticle))
-		{
-			MergeParticleListAndNode(survivingList, node);
-		}
-	}
-}
-
-void b2ParticleSystem::MergeParticleListAndNode(
-	ParticleListNode* list, ParticleListNode* node)
-{
-	// Insert node between index 0 and 1 of list
-	// Example:
-	//     list => a1 => a2 => a3 => NULL
-	//     node => NULL
-	// to
-	//     list => node => a1 => a2 => a3 => NULL
-	b2Assert(node != list);
-	b2Assert(node->list == node);
-	b2Assert(node->count == 1);
-	node->list = list;
-	node->next = list->next;
-	list->next = node;
-	list->count++;
-	node->count = 0;
-}
-
-void b2ParticleSystem::CreateParticleGroupsFromParticleList(
-	const b2ParticleGroup* group, ParticleListNode* nodeBuffer,
-	const ParticleListNode* survivingList)
-{
-	int32 particleCount = group->GetParticleCount();
-	b2ParticleGroupDef def;
-	def.groupFlags = group->GetGroupFlags();
-	def.userData = group->GetUserData();
-	for (int32 i = 0; i < particleCount; i++)
-	{
-		ParticleListNode* list = &nodeBuffer[i];
-		if (!list->count || list == survivingList)
-		{
-			continue;
-		}
-		b2Assert(list->list == list);
-		b2ParticleGroup* newGroup = CreateParticleGroup(def);
-		for (ParticleListNode* node = list; node; node = node->next)
-		{
-			int32 oldIndex = node->index;
-			uint32& flags = m_flagsBuffer.data[oldIndex];
-			b2Assert(!(flags & b2_zombieParticle));
-			int32 newIndex = CloneParticle(oldIndex, newGroup);
-			flags |= b2_zombieParticle;
-			node->index = newIndex;
-		}
-	}
-}
-
-void b2ParticleSystem::UpdatePairsAndTriadsWithParticleList(
-	const b2ParticleGroup* group, const ParticleListNode* nodeBuffer)
-{
-	int32 bufferIndex = group->GetBufferIndex();
-	// Update indices in pairs and triads. If an index belongs to the group,
-	// replace it with the corresponding value in nodeBuffer.
-	// Note that nodeBuffer is allocated only for the group and the index should
-	// be shifted by bufferIndex.
-	for (int32 k = 0; k < m_pairBuffer.GetCount(); k++)
-	{
-		b2ParticlePair& pair = m_pairBuffer[k];
-		int32 a = pair.indexA;
-		int32 b = pair.indexB;
-		if (group->ContainsParticle(a))
-		{
-			pair.indexA = nodeBuffer[a - bufferIndex].index;
-		}
-		if (group->ContainsParticle(b))
-		{
-			pair.indexB = nodeBuffer[b - bufferIndex].index;
-		}
-	}
-	for (int32 k = 0; k < m_triadBuffer.GetCount(); k++)
-	{
-		b2ParticleTriad& triad = m_triadBuffer[k];
-		int32 a = triad.indexA;
-		int32 b = triad.indexB;
-		int32 c = triad.indexC;
-		if (group->ContainsParticle(a))
-		{
-			triad.indexA = nodeBuffer[a - bufferIndex].index;
-		}
-		if (group->ContainsParticle(b))
-		{
-			triad.indexB = nodeBuffer[b - bufferIndex].index;
-		}
-		if (group->ContainsParticle(c))
-		{
-			triad.indexC = nodeBuffer[c - bufferIndex].index;
-		}
-	}
-}
-
-int32 b2ParticleSystem::CloneParticle(int32 oldIndex, b2ParticleGroup* group)
-{
-	b2ParticleDef def;
-	def.flags = m_flagsBuffer.data[oldIndex];
-	def.position = m_positionBuffer.data[oldIndex];
-	def.velocity = m_velocityBuffer.data[oldIndex];
-	if (m_colorBuffer.data)
-	{
-		def.color = m_colorBuffer.data[oldIndex];
-	}
-	if (m_userDataBuffer.data)
-	{
-		def.userData = m_userDataBuffer.data[oldIndex];
-	}
-	def.group = group;
-	int32 newIndex = CreateParticle(def);
-	if (m_handleIndexBuffer.data)
-	{
-		b2ParticleHandle* handle = m_handleIndexBuffer.data[oldIndex];
-		if (handle) handle->SetIndex(newIndex);
-		m_handleIndexBuffer.data[newIndex] = handle;
-		m_handleIndexBuffer.data[oldIndex] = NULL;
-	}
-	if (m_lastBodyContactStepBuffer.data)
-	{
-		m_lastBodyContactStepBuffer.data[newIndex] =
-			m_lastBodyContactStepBuffer.data[oldIndex];
-	}
-	if (m_bodyContactCountBuffer.data)
-	{
-		m_bodyContactCountBuffer.data[newIndex] =
-			m_bodyContactCountBuffer.data[oldIndex];
-	}
-	if (m_consecutiveContactStepsBuffer.data)
-	{
-		m_consecutiveContactStepsBuffer.data[newIndex] =
-			m_consecutiveContactStepsBuffer.data[oldIndex];
-	}
-	if (m_hasForce)
-	{
-		m_forceBuffer[newIndex] = m_forceBuffer[oldIndex];
-	}
-	if (m_staticPressureBuffer)
-	{
-		m_staticPressureBuffer[newIndex] = m_staticPressureBuffer[oldIndex];
-	}
-	if (m_depthBuffer)
-	{
-		m_depthBuffer[newIndex] = m_depthBuffer[oldIndex];
-	}
-	if (m_expirationTimeBuffer.data)
-	{
-		m_expirationTimeBuffer.data[newIndex] =
-			m_expirationTimeBuffer.data[oldIndex];
-	}
-	return newIndex;
-}
-
-void b2ParticleSystem::UpdatePairsAndTriadsWithReactiveParticles()
-{
-	class ReactiveFilter : public ConnectionFilter
-	{
-		bool IsNecessary(int32 index) const
-		{
-			return (m_flagsBuffer[index] & b2_reactiveParticle) != 0;
-		}
-		const uint32* m_flagsBuffer;
-	public:
-		ReactiveFilter(uint32* flagsBuffer)
-		{
-			m_flagsBuffer = flagsBuffer;
-		}
-	} filter(m_flagsBuffer.data);
-	UpdatePairsAndTriads(0, m_count, filter);
-
-	for (int32 i = 0; i < m_count; i++)
-	{
-		m_flagsBuffer.data[i] &= ~b2_reactiveParticle;
-	}
-	m_allParticleFlags &= ~b2_reactiveParticle;
-}
-
-static bool ParticleCanBeConnected(
-	uint32 flags, b2ParticleGroup* group)
-{
-	return
-		(flags & (b2_wallParticle | b2_springParticle | b2_elasticParticle)) ||
-		(group && group->GetGroupFlags() & b2_rigidParticleGroup);
-}
-
-void b2ParticleSystem::UpdatePairsAndTriads(
-	int32 firstIndex, int32 lastIndex, const ConnectionFilter& filter)
-{
-	// Create pairs or triads.
-	// All particles in each pair/triad should satisfy the following:
-	// * firstIndex <= index < lastIndex
-	// * don't have b2_zombieParticle
-	// * ParticleCanBeConnected returns true
-	// * ShouldCreatePair/ShouldCreateTriad returns true
-	// Any particles in each pair/triad should satisfy the following:
-	// * filter.IsNeeded returns true
-	// * have one of k_pairFlags/k_triadsFlags
-	b2Assert(firstIndex <= lastIndex);
-	uint32 particleFlags = 0;
-	for (int32 i = firstIndex; i < lastIndex; i++)
-	{
-		particleFlags |= m_flagsBuffer.data[i];
-	}
-	if (particleFlags & k_pairFlags)
-	{
-		for (int32 k = 0; k < m_contactBuffer.GetCount(); k++)
-		{
-			const b2ParticleContact& contact = m_contactBuffer[k];
-			int32 a = contact.GetIndexA();
-			int32 b = contact.GetIndexB();
-			uint32 af = m_flagsBuffer.data[a];
-			uint32 bf = m_flagsBuffer.data[b];
-			b2ParticleGroup* groupA = m_groupBuffer[a];
-			b2ParticleGroup* groupB = m_groupBuffer[b];
-			if (a >= firstIndex && a < lastIndex &&
-				b >= firstIndex && b < lastIndex &&
-				!((af | bf) & b2_zombieParticle) &&
-				((af | bf) & k_pairFlags) &&
-				(filter.IsNecessary(a) || filter.IsNecessary(b)) &&
-				ParticleCanBeConnected(af, groupA) &&
-				ParticleCanBeConnected(bf, groupB) &&
-				filter.ShouldCreatePair(a, b))
-			{
-				b2ParticlePair& pair = m_pairBuffer.Append();
-				pair.indexA = a;
-				pair.indexB = b;
-				pair.flags = contact.GetFlags();
-				pair.strength = b2Min(
-					groupA ? groupA->m_strength : 1,
-					groupB ? groupB->m_strength : 1);
-				pair.distance = b2Distance(m_positionBuffer.data[a],
-										   m_positionBuffer.data[b]);
-			}
-		}
-		std::stable_sort(
-			m_pairBuffer.Begin(), m_pairBuffer.End(), ComparePairIndices);
-		m_pairBuffer.Unique(MatchPairIndices);
-	}
-	if (particleFlags & k_triadFlags)
-	{
-		b2VoronoiDiagram diagram(
-			&m_world->m_stackAllocator, lastIndex - firstIndex);
-		for (int32 i = firstIndex; i < lastIndex; i++)
-		{
-			uint32 flags = m_flagsBuffer.data[i];
-			b2ParticleGroup* group = m_groupBuffer[i];
-			if (!(flags & b2_zombieParticle) &&
-				ParticleCanBeConnected(flags, group))
-			{
-				diagram.AddGenerator(
-					m_positionBuffer.data[i], i, filter.IsNecessary(i));
-			}
-		}
-		float32 stride = GetParticleStride();
-		diagram.Generate(stride / 2, stride * 2);
-		class UpdateTriadsCallback : public b2VoronoiDiagram::NodeCallback
-		{
-			void operator()(int32 a, int32 b, int32 c)
-			{
-				uint32 af = m_system->m_flagsBuffer.data[a];
-				uint32 bf = m_system->m_flagsBuffer.data[b];
-				uint32 cf = m_system->m_flagsBuffer.data[c];
-				if (((af | bf | cf) & k_triadFlags) &&
-					m_filter->ShouldCreateTriad(a, b, c))
-				{
-					const b2Vec2& pa = m_system->m_positionBuffer.data[a];
-					const b2Vec2& pb = m_system->m_positionBuffer.data[b];
-					const b2Vec2& pc = m_system->m_positionBuffer.data[c];
-					b2Vec2 dab = pa - pb;
-					b2Vec2 dbc = pb - pc;
-					b2Vec2 dca = pc - pa;
-					float32 maxDistanceSquared = b2_maxTriadDistanceSquared *
-												 m_system->m_squaredDiameter;
-					if (b2Dot(dab, dab) > maxDistanceSquared ||
-						b2Dot(dbc, dbc) > maxDistanceSquared ||
-						b2Dot(dca, dca) > maxDistanceSquared)
-					{
-						return;
-					}
-					b2ParticleGroup* groupA = m_system->m_groupBuffer[a];
-					b2ParticleGroup* groupB = m_system->m_groupBuffer[b];
-					b2ParticleGroup* groupC = m_system->m_groupBuffer[c];
-					b2ParticleTriad& triad = m_system->m_triadBuffer.Append();
-					triad.indexA = a;
-					triad.indexB = b;
-					triad.indexC = c;
-					triad.flags = af | bf | cf;
-					triad.strength = b2Min(b2Min(
-						groupA ? groupA->m_strength : 1,
-						groupB ? groupB->m_strength : 1),
-						groupC ? groupC->m_strength : 1);
-					b2Vec2 midPoint = (float32) 1 / 3 * (pa + pb + pc);
-					triad.pa = pa - midPoint;
-					triad.pb = pb - midPoint;
-					triad.pc = pc - midPoint;
-					triad.ka = -b2Dot(dca, dab);
-					triad.kb = -b2Dot(dab, dbc);
-					triad.kc = -b2Dot(dbc, dca);
-					triad.s = b2Cross(pa, pb) + b2Cross(pb, pc) + b2Cross(pc, pa);
-				}
-			}
-			b2ParticleSystem* m_system;
-			const ConnectionFilter* m_filter;
-		public:
-			UpdateTriadsCallback(
-				b2ParticleSystem* system, const ConnectionFilter* filter)
-			{
-				m_system = system;
-				m_filter = filter;
-			}
-		} callback(this, &filter);
-		diagram.GetNodes(callback);
-		std::stable_sort(
-			m_triadBuffer.Begin(), m_triadBuffer.End(), CompareTriadIndices);
-		m_triadBuffer.Unique(MatchTriadIndices);
-	}
-}
-
-bool b2ParticleSystem::ComparePairIndices(
-							const b2ParticlePair& a, const b2ParticlePair& b)
-{
-	int32 diffA = a.indexA - b.indexA;
-	if (diffA != 0) return diffA < 0;
-	return a.indexB < b.indexB;
-}
-
-bool b2ParticleSystem::MatchPairIndices(
-							const b2ParticlePair& a, const b2ParticlePair& b)
-{
-	return a.indexA == b.indexA && a.indexB == b.indexB;
-}
-
-bool b2ParticleSystem::CompareTriadIndices(
-							const b2ParticleTriad& a, const b2ParticleTriad& b)
-{
-	int32 diffA = a.indexA - b.indexA;
-	if (diffA != 0) return diffA < 0;
-	int32 diffB = a.indexB - b.indexB;
-	if (diffB != 0) return diffB < 0;
-	return a.indexC < b.indexC;
-}
-
-bool b2ParticleSystem::MatchTriadIndices(
-							const b2ParticleTriad& a, const b2ParticleTriad& b)
-{
-	return a.indexA == b.indexA && a.indexB == b.indexB && a.indexC == b.indexC;
-}
-
-// Only called from SolveZombie() or JoinParticleGroups().
-void b2ParticleSystem::DestroyParticleGroup(b2ParticleGroup* group)
-{
-	b2Assert(m_groupCount > 0);
-	b2Assert(group);
-
-	if (m_world->m_destructionListener)
-	{
-		m_world->m_destructionListener->SayGoodbye(group);
-	}
-
-	SetGroupFlags(group, 0);
-	for (int32 i = group->m_firstIndex; i < group->m_lastIndex; i++)
-	{
-		m_groupBuffer[i] = NULL;
-	}
-
-	if (group->m_prev)
-	{
-		group->m_prev->m_next = group->m_next;
-	}
-	if (group->m_next)
-	{
-		group->m_next->m_prev = group->m_prev;
-	}
-	if (group == m_groupList)
-	{
-		m_groupList = group->m_next;
-	}
-
-	--m_groupCount;
-	group->~b2ParticleGroup();
-	m_world->m_blockAllocator.Free(group, sizeof(b2ParticleGroup));
-}
-
-void b2ParticleSystem::ComputeWeight()
-{
-	// calculates the sum of contact-weights for each particle
-	// that means dimensionless density
-	memset(m_weightBuffer, 0, sizeof(*m_weightBuffer) * m_count);
-	for (int32 k = 0; k < m_bodyContactBuffer.GetCount(); k++)
-	{
-		const b2ParticleBodyContact& contact = m_bodyContactBuffer[k];
-		int32 a = contact.index;
-		float32 w = contact.weight;
-		m_weightBuffer[a] += w;
-	}
-	for (int32 k = 0; k < m_contactBuffer.GetCount(); k++)
-	{
-		const b2ParticleContact& contact = m_contactBuffer[k];
-		int32 a = contact.GetIndexA();
-		int32 b = contact.GetIndexB();
-		float32 w = contact.GetWeight();
-		m_weightBuffer[a] += w;
-		m_weightBuffer[b] += w;
-	}
-}
-
-void b2ParticleSystem::ComputeDepth()
-{
-	b2ParticleContact* contactGroups = (b2ParticleContact*) m_world->
-		m_stackAllocator.Allocate(sizeof(b2ParticleContact) * m_contactBuffer.GetCount());
-	int32 contactGroupsCount = 0;
-	for (int32 k = 0; k < m_contactBuffer.GetCount(); k++)
-	{
-		const b2ParticleContact& contact = m_contactBuffer[k];
-		int32 a = contact.GetIndexA();
-		int32 b = contact.GetIndexB();
-		const b2ParticleGroup* groupA = m_groupBuffer[a];
-		const b2ParticleGroup* groupB = m_groupBuffer[b];
-		if (groupA && groupA == groupB &&
-			(groupA->m_groupFlags & b2_particleGroupNeedsUpdateDepth))
-		{
-			contactGroups[contactGroupsCount++] = contact;
-		}
-	}
-	b2ParticleGroup** groupsToUpdate = (b2ParticleGroup**) m_world->
-		m_stackAllocator.Allocate(sizeof(b2ParticleGroup*) * m_groupCount);
-	int32 groupsToUpdateCount = 0;
-	for (b2ParticleGroup* group = m_groupList; group; group = group->GetNext())
-	{
-		if (group->m_groupFlags & b2_particleGroupNeedsUpdateDepth)
-		{
-			groupsToUpdate[groupsToUpdateCount++] = group;
-			SetGroupFlags(group,
-						  group->m_groupFlags &
-						  ~b2_particleGroupNeedsUpdateDepth);
-			for (int32 i = group->m_firstIndex; i < group->m_lastIndex; i++)
-			{
-				m_accumulationBuffer[i] = 0;
-			}
-		}
-	}
-	// Compute sum of weight of contacts except between different groups.
-	for (int32 k = 0; k < contactGroupsCount; k++)
-	{
-		const b2ParticleContact& contact = contactGroups[k];
-		int32 a = contact.GetIndexA();
-		int32 b = contact.GetIndexB();
-		float32 w = contact.GetWeight();
-		m_accumulationBuffer[a] += w;
-		m_accumulationBuffer[b] += w;
-	}
-	b2Assert(m_depthBuffer);
-	for (int32 i = 0; i < groupsToUpdateCount; i++)
-	{
-		const b2ParticleGroup* group = groupsToUpdate[i];
-		for (int32 j = group->m_firstIndex; j < group->m_lastIndex; j++)
-		{
-			float32 w = m_accumulationBuffer[j];
-			m_depthBuffer[j] = w < 0.8f ? 0 : b2_maxFloat;
-		}
-	}
-	// The number of iterations is equal to particle number from the deepest
-	// particle to the nearest surface particle, and in general it is smaller
-	// than sqrt of total particle number.
-	int32 iterationCount = (int32)b2Sqrt((float)m_count);
-	for (int32 t = 0; t < iterationCount; t++)
-	{
-		bool updated = false;
-		for (int32 k = 0; k < contactGroupsCount; k++)
-		{
-			const b2ParticleContact& contact = contactGroups[k];
-			int32 a = contact.GetIndexA();
-			int32 b = contact.GetIndexB();
-			float32 r = 1 - contact.GetWeight();
-			float32& ap0 = m_depthBuffer[a];
-			float32& bp0 = m_depthBuffer[b];
-			float32 ap1 = bp0 + r;
-			float32 bp1 = ap0 + r;
-			if (ap0 > ap1)
-			{
-				ap0 = ap1;
-				updated = true;
-			}
-			if (bp0 > bp1)
-			{
-				bp0 = bp1;
-				updated = true;
-			}
-		}
-		if (!updated)
-		{
-			break;
-		}
-	}
-	for (int32 i = 0; i < groupsToUpdateCount; i++)
-	{
-		const b2ParticleGroup* group = groupsToUpdate[i];
-		for (int32 j = group->m_firstIndex; j < group->m_lastIndex; j++)
-		{
-			float32& p = m_depthBuffer[j];
-			if (p < b2_maxFloat)
-			{
-				p *= m_particleDiameter;
-			}
-			else
-			{
-				p = 0;
-			}
-		}
-	}
-	m_world->m_stackAllocator.Free(groupsToUpdate);
-	m_world->m_stackAllocator.Free(contactGroups);
-}
-
-b2ParticleSystem::InsideBoundsEnumerator
-b2ParticleSystem::GetInsideBoundsEnumerator(const b2AABB& aabb) const
-{
-	uint32 lowerTag = computeTag(m_inverseDiameter * aabb.lowerBound.x - 1,
-								 m_inverseDiameter * aabb.lowerBound.y - 1);
-	uint32 upperTag = computeTag(m_inverseDiameter * aabb.upperBound.x + 1,
-								 m_inverseDiameter * aabb.upperBound.y + 1);
-	const Proxy* beginProxy = m_proxyBuffer.Begin();
-	const Proxy* endProxy = m_proxyBuffer.End();
-	const Proxy* firstProxy = std::lower_bound(beginProxy, endProxy, lowerTag);
-	const Proxy* lastProxy = std::upper_bound(firstProxy, endProxy, upperTag);
-	return InsideBoundsEnumerator(lowerTag, upperTag, firstProxy, lastProxy);
-}
-
-inline void b2ParticleSystem::AddContact(int32 a, int32 b,
-	b2GrowableBuffer<b2ParticleContact>& contacts) const
-{
-	b2Vec2 d = m_positionBuffer.data[b] - m_positionBuffer.data[a];
-	float32 distBtParticlesSq = b2Dot(d, d);
-	if (distBtParticlesSq < m_squaredDiameter)
-	{
-		float32 invD = b2InvSqrt(distBtParticlesSq);
-		b2ParticleContact& contact = contacts.Append();
-		contact.SetIndices(a, b);
-		contact.SetFlags(m_flagsBuffer.data[a] | m_flagsBuffer.data[b]);
-		// 1 - distBtParticles / diameter
-		contact.SetWeight(1 - distBtParticlesSq * invD * m_inverseDiameter);
-		contact.SetNormal(invD * d);
-	}
-}
-
-void b2ParticleSystem::FindContacts_Reference(
-	b2GrowableBuffer<b2ParticleContact>& contacts) const
-{
-	const Proxy* beginProxy = m_proxyBuffer.Begin();
-	const Proxy* endProxy = m_proxyBuffer.End();
-
-	contacts.SetCount(0);
-	for (const Proxy *a = beginProxy, *c = beginProxy; a < endProxy; a++)
-	{
-		uint32 rightTag = computeRelativeTag(a->tag, 1, 0);
-		for (const Proxy* b = a + 1; b < endProxy; b++)
-		{
-			if (rightTag < b->tag) break;
-			AddContact(a->index, b->index, contacts);
-		}
-		uint32 bottomLeftTag = computeRelativeTag(a->tag, -1, 1);
-		for (; c < endProxy; c++)
-		{
-			if (bottomLeftTag <= c->tag) break;
-		}
-		uint32 bottomRightTag = computeRelativeTag(a->tag, 1, 1);
-		for (const Proxy* b = c; b < endProxy; b++)
-		{
-			if (bottomRightTag < b->tag) break;
-			AddContact(a->index, b->index, contacts);
-		}
-	}
-}
-
-// Put the positions and indices in proxy-order. This allows us to process
-// particles with SIMD, since adjacent particles are adjacent in memory.
-void b2ParticleSystem::ReorderForFindContact(FindContactInput* reordered,
-	                                         int alignedCount) const
-{
-	int i = 0;
-	for (; i < m_count; ++i)
-	{
-		const int proxyIndex = m_proxyBuffer[i].index;
-		FindContactInput& r = reordered[i];
-		r.proxyIndex = proxyIndex;
-		r.position = m_positionBuffer.data[proxyIndex];
-	}
-
-	// We process multiple elements at a time, so we may read off the end of
-	// the array. Pad the array with a few elements, so we don't end up
-	// outputing spurious contacts.
-	for (; i < alignedCount; ++i)
-	{
-		FindContactInput& r = reordered[i];
-		r.proxyIndex = 0;
-		r.position = b2Vec2(b2_maxFloat, b2_maxFloat);
-	}
-}
-
-// Check particles to the right of 'startIndex', outputing FindContactChecks
-// until we find an index that is greater than 'bound'. We skip over the
-// indices NUM_V32_SLOTS at a time, because they are processed in groups
-// in the SIMD function.
-inline void b2ParticleSystem::GatherChecksOneParticle(
-	const uint32 bound,
-	const int startIndex,
-	const int particleIndex,
-	int* nextUncheckedIndex,
-	b2GrowableBuffer<FindContactCheck>& checks) const
-{
-	// The particles have to be heavily packed together in order for this
-	// loop to iterate more than once. In almost all situations, it will
-	// iterate less than twice.
-	for (int comparatorIndex = startIndex;
-		 comparatorIndex < m_count;
-	     comparatorIndex += NUM_V32_SLOTS)
-	{
-		if (m_proxyBuffer[comparatorIndex].tag > bound)
-			break;
-
-		FindContactCheck& out = checks.Append();
-		out.particleIndex = (uint16)particleIndex;
-		out.comparatorIndex = (uint16)comparatorIndex;
-
-		// This is faster inside the 'for' since there are so few iterations.
-		if (nextUncheckedIndex != NULL)
-		{
-			*nextUncheckedIndex = comparatorIndex + NUM_V32_SLOTS;
-		}
-	}
-}
-
-void b2ParticleSystem::GatherChecks(
-	b2GrowableBuffer<FindContactCheck>& checks) const
-{
-	int bottomLeftIndex = 0;
-	for (int particleIndex = 0; particleIndex < m_count; ++particleIndex)
-	{
-		const uint32 particleTag = m_proxyBuffer[particleIndex].tag;
-
-		// Add checks for particles to the right.
-		const uint32 rightBound = particleTag + relativeTagRight;
-		int nextUncheckedIndex = particleIndex + 1;
-		GatherChecksOneParticle(rightBound,
-								particleIndex + 1,
-								particleIndex,
-								&nextUncheckedIndex,
-								checks);
-
-		// Find comparator index below and to left of particle.
-		const uint32 bottomLeftTag = particleTag + relativeTagBottomLeft;
-		for (; bottomLeftIndex < m_count; ++bottomLeftIndex)
-		{
-			if (bottomLeftTag <= m_proxyBuffer[bottomLeftIndex].tag)
-				break;
-		}
-
-		// Add checks for particles below.
-		const uint32 bottomRightBound = particleTag + relativeTagBottomRight;
-		const int bottomStartIndex = b2Max(bottomLeftIndex, nextUncheckedIndex);
-		GatherChecksOneParticle(bottomRightBound,
-								bottomStartIndex,
-								particleIndex,
-								NULL,
-								checks);
-	}
-}
-
-#if defined(LIQUIDFUN_SIMD_NEON)
-void b2ParticleSystem::FindContacts_Simd(
-	b2GrowableBuffer<b2ParticleContact>& contacts) const
-{
-	contacts.SetCount(0);
-
-	const int alignedCount = m_count + NUM_V32_SLOTS;
-	FindContactInput* reordered = (FindContactInput*)
-		m_world->m_stackAllocator.Allocate(
-			sizeof(FindContactInput) * alignedCount);
-
-	// Put positions and indices into proxy-order.
-	// This allows us to efficiently check for contacts using SIMD.
-	ReorderForFindContact(reordered, alignedCount);
-
-	// Perform broad-band contact check using tags to approximate
-	// positions. This reduces the number of narrow-band contact checks
-	// that use actual positions.
-	static const int MAX_EXPECTED_CHECKS_PER_PARTICLE = 3;
-	b2GrowableBuffer<FindContactCheck> checks(m_world->m_blockAllocator);
-	checks.Reserve(MAX_EXPECTED_CHECKS_PER_PARTICLE * m_count);
-	GatherChecks(checks);
-
-	// Perform narrow-band contact checks using actual positions.
-	// Any particles whose centers are within one diameter of each other are
-	// considered contacting.
-	FindContactsFromChecks_Simd(reordered, checks.Data(), checks.GetCount(),
-								m_squaredDiameter, m_inverseDiameter,
-								m_flagsBuffer.data, contacts);
-
-	m_world->m_stackAllocator.Free(reordered);
-}
-#endif // defined(LIQUIDFUN_SIMD_NEON)
-
-LIQUIDFUN_SIMD_INLINE
-void b2ParticleSystem::FindContacts(
-	b2GrowableBuffer<b2ParticleContact>& contacts) const
-{
-	#if defined(LIQUIDFUN_SIMD_NEON)
-    if(hasNeon)
-    {
-      FindContacts_Simd(contacts);
-    }
-		else
-    {
-      FindContacts_Reference(contacts);
-    }
-	#else
-		FindContacts_Reference(contacts);
-	#endif
-
-	#if defined(LIQUIDFUN_SIMD_TEST_VS_REFERENCE)
-		b2GrowableBuffer<b2ParticleContact>
-			reference(m_world->m_blockAllocator);
-		FindContacts_Reference(reference);
-
-		b2Assert(contacts.GetCount() == reference.GetCount());
-		for (int32 i = 0; i < contacts.GetCount(); ++i)
-		{
-			b2Assert(contacts[i].ApproximatelyEqual(reference[i]));
-		}
-	#endif // defined(LIQUIDFUN_SIMD_TEST_VS_REFERENCE)
-}
-
-static inline bool b2ParticleContactIsZombie(const b2ParticleContact& contact)
-{
-	return (contact.GetFlags() & b2_zombieParticle) == b2_zombieParticle;
-}
-
-// Get the world's contact filter if any particles with the
-// b2_particleContactFilterParticle flag are present in the system.
-inline b2ContactFilter* b2ParticleSystem::GetParticleContactFilter() const
-{
-	return (m_allParticleFlags & b2_particleContactFilterParticle) ?
-		m_world->m_contactManager.m_contactFilter : NULL;
-}
-
-// Get the world's contact listener if any particles with the
-// b2_particleContactListenerParticle flag are present in the system.
-inline b2ContactListener* b2ParticleSystem::GetParticleContactListener() const
-{
-	return (m_allParticleFlags & b2_particleContactListenerParticle) ?
-		m_world->m_contactManager.m_contactListener : NULL;
-}
-
-// Recalculate 'tag' in proxies using m_positionBuffer.
-// The 'tag' is an approximation of position, in left-right, top-bottom order.
-void b2ParticleSystem::UpdateProxies_Reference(
-	b2GrowableBuffer<Proxy>& proxies) const
-{
-	const Proxy* const endProxy = proxies.End();
-	for (Proxy* proxy = proxies.Begin(); proxy < endProxy; ++proxy)
-	{
-		int32 i = proxy->index;
-		b2Vec2 p = m_positionBuffer.data[i];
-		proxy->tag = computeTag(m_inverseDiameter * p.x,
-								m_inverseDiameter * p.y);
-	}
-}
-
-#if defined(LIQUIDFUN_SIMD_NEON)
-// static
-void b2ParticleSystem::UpdateProxyTags(
-	const uint32* const tags,
-	b2GrowableBuffer<Proxy>& proxies)
-{
-	const Proxy* const endProxy = proxies.End();
-	for (Proxy* proxy = proxies.Begin(); proxy < endProxy; ++proxy)
-	{
-		proxy->tag = tags[proxy->index];
-	}
-}
-
-void b2ParticleSystem::UpdateProxies_Simd(
-	b2GrowableBuffer<Proxy>& proxies) const
-{
-	uint32* tags = (uint32*)
-		m_world->m_stackAllocator.Allocate(m_count * sizeof(uint32));
-
-	// Calculate tag for every position.
-	// 'tags' array is in position-order.
-	CalculateTags_Simd(m_positionBuffer.data, m_count,
-					   m_inverseDiameter, tags);
-
-	// Update 'tag' element in the 'proxies' array to the new values.
-	UpdateProxyTags(tags, proxies);
-
-	m_world->m_stackAllocator.Free(tags);
-}
-#endif // defined(LIQUIDFUN_SIMD_NEON)
-
-// static
-bool b2ParticleSystem::ProxyBufferHasIndex(
-	int32 index, const Proxy* const a, int count)
-{
-	for (int j = 0; j < count; ++j)
-	{
-		if (a[j].index == index)
-			return true;
-	}
-	return false;
-}
-
-// static
-int b2ParticleSystem::NumProxiesWithSameTag(
-	const Proxy* const a, const Proxy* const b, int count)
-{
-	const uint32 tag = a[0].tag;
-	for (int num = 0; num < count; ++num)
-	{
-		if (a[num].tag != tag || b[num].tag != tag)
-			return num;
-	}
-	return count;
-}
-
-// Precondition: both 'a' and 'b' should be sorted by tag, but don't need to be
-// sorted by index.
-// static
-bool b2ParticleSystem::AreProxyBuffersTheSame(const b2GrowableBuffer<Proxy>& a,
-								   			  const b2GrowableBuffer<Proxy>& b)
-{
-	if (a.GetCount() != b.GetCount())
-		return false;
-
-	// A given tag may have several indices. The order of these indices is
-	// not important, but the set must be equivalent.
-	for (int i = 0; i < a.GetCount();)
-	{
-		const int numWithSameTag = NumProxiesWithSameTag(
-			&a[i], &b[i], a.GetCount() - i);
-		if (numWithSameTag == 0)
-			return false;
-
-		for (int j = 0; j < numWithSameTag; ++j)
-		{
-			const bool hasIndex = ProxyBufferHasIndex(
-				a[i + j].index, &b[i], numWithSameTag);
-			if (!hasIndex)
-				return false;
-		}
-
-		i += numWithSameTag;
-	}
-	return true;
-}
-
-LIQUIDFUN_SIMD_INLINE
-void b2ParticleSystem::UpdateProxies(
-	b2GrowableBuffer<Proxy>& proxies) const
-{
-	#if defined(LIQUIDFUN_SIMD_TEST_VS_REFERENCE)
-		b2GrowableBuffer<Proxy> reference(proxies);
-	#endif
-
-	#if defined(LIQUIDFUN_SIMD_NEON)
-    if(hasNeon)
-    {
-      UpdateProxies_Simd(proxies);
-    }
-    else
-    {
-      UpdateProxies_Reference(proxies);
-    }
-	#else
-		UpdateProxies_Reference(proxies);
-	#endif
-
-	#if defined(LIQUIDFUN_SIMD_TEST_VS_REFERENCE)
-		UpdateProxies_Reference(reference);
-		b2Assert(AreProxyBuffersTheSame(proxies, reference));
-	#endif
-}
-
-
-// Sort the proxy array by 'tag'. This orders the particles into rows that
-// run left-to-right, top-to-bottom. The rows are spaced m_particleDiameter
-// apart, such that a particle in one row can only collide with the rows
-// immediately above and below it. This ordering makes collision computation
-// tractable.
-//
-// TODO OPT: The sort is a hot spot on the profiles. We could use SIMD to
-// speed this up. See http://www.vldb.org/pvldb/1/1454171.pdf for an excellent
-// explanation of a SIMD mergesort algorithm.
-void b2ParticleSystem::SortProxies(b2GrowableBuffer<Proxy>& proxies) const
-{
-	std::sort(proxies.Begin(), proxies.End());
-}
-
-class b2ParticleContactRemovePredicate
-{
-public:
-	b2ParticleContactRemovePredicate(
-		b2ParticleSystem* system,
-		b2ContactFilter* contactFilter) :
-		m_system(system),
-		m_contactFilter(contactFilter)
-	{}
-
-	bool operator()(const b2ParticleContact& contact)
-	{
-	    return (contact.GetFlags() & b2_particleContactFilterParticle)
-	        && !m_contactFilter->ShouldCollide(m_system, contact.GetIndexA(),
-	        								   contact.GetIndexB());
-	}
-
-private:
-	b2ParticleSystem* m_system;
-	b2ContactFilter* m_contactFilter;
-};
-
-// Only changes 'contacts', but the contact filter has a non-const 'this'
-// pointer, so this member function cannot be const.
-void b2ParticleSystem::FilterContacts(
-	b2GrowableBuffer<b2ParticleContact>& contacts)
-{
-	// Optionally filter the contact.
-	b2ContactFilter* const contactFilter = GetParticleContactFilter();
-	if (contactFilter == NULL)
-		return;
-
-	contacts.RemoveIf(b2ParticleContactRemovePredicate(this, contactFilter));
-}
-
-void b2ParticleSystem::NotifyContactListenerPreContact(
-	b2ParticlePairSet* particlePairs) const
-{
-	b2ContactListener* const contactListener = GetParticleContactListener();
-	if (contactListener == NULL)
-		return;
-
-	particlePairs->Initialize(m_contactBuffer.Begin(),
-							  m_contactBuffer.GetCount(),
-						      GetFlagsBuffer());
-}
-
-// Note: This function is not const because 'this' in BeginContact and
-// EndContact callbacks must be non-const. However, this function itself
-// does not change any internal data (though the callbacks might).
-void b2ParticleSystem::NotifyContactListenerPostContact(
-	b2ParticlePairSet& particlePairs)
-{
-	b2ContactListener* const contactListener = GetParticleContactListener();
-	if (contactListener == NULL)
-		return;
-
-	// Loop through all new contacts, reporting any new ones, and
-	// "invalidating" the ones that still exist.
-	const b2ParticleContact* const endContact = m_contactBuffer.End();
-	for (b2ParticleContact* contact = m_contactBuffer.Begin();
-		 contact < endContact; ++contact)
-	{
-		ParticlePair pair;
-		pair.first = contact->GetIndexA();
-		pair.second = contact->GetIndexB();
-		const int32 itemIndex = particlePairs.Find(pair);
-		if (itemIndex >= 0)
-		{
-			// Already touching, ignore this contact.
-			particlePairs.Invalidate(itemIndex);
-		}
-		else
-		{
-			// Just started touching, inform the listener.
-			contactListener->BeginContact(this, contact);
-		}
-	}
-
-	// Report particles that are no longer touching.
-	// That is, any pairs that were not invalidated above.
-	const int32 pairCount = particlePairs.GetCount();
-	const ParticlePair* const pairs = particlePairs.GetBuffer();
-	const int8* const valid = particlePairs.GetValidBuffer();
-	for (int32 i = 0; i < pairCount; ++i)
-	{
-		if (valid[i])
-		{
-			contactListener->EndContact(this, pairs[i].first,
-										pairs[i].second);
-		}
-	}
-}
-
-void b2ParticleSystem::UpdateContacts(bool exceptZombie)
-{
-	UpdateProxies(m_proxyBuffer);
-	SortProxies(m_proxyBuffer);
-
-	b2ParticlePairSet particlePairs(&m_world->m_stackAllocator);
-	NotifyContactListenerPreContact(&particlePairs);
-
-	FindContacts(m_contactBuffer);
-	FilterContacts(m_contactBuffer);
-
-	NotifyContactListenerPostContact(particlePairs);
-
-	if (exceptZombie)
-	{
-		m_contactBuffer.RemoveIf(b2ParticleContactIsZombie);
-	}
-}
-
-void b2ParticleSystem::DetectStuckParticle(int32 particle)
-{
-	// Detect stuck particles
-	//
-	// The basic algorithm is to allow the user to specify an optional
-	// threshold where we detect whenever a particle is contacting
-	// more than one fixture for more than threshold consecutive
-	// steps. This is considered to be "stuck", and these are put
-	// in a list the user can query per step, if enabled, to deal with
-	// such particles.
-
-	if (m_stuckThreshold <= 0)
-	{
-		return;
-	}
-
-	// Get the state variables for this particle.
-	int32 * const consecutiveCount =
-			&m_consecutiveContactStepsBuffer.data[particle];
-	int32 * const lastStep = &m_lastBodyContactStepBuffer.data[particle];
-	int32 * const bodyCount = &m_bodyContactCountBuffer.data[particle];
-
-	// This is only called when there is a body contact for this particle.
-	++(*bodyCount);
-
-	// We want to only trigger detection once per step, the first time we
-	// contact more than one fixture in a step for a given particle.
-	if (*bodyCount == 2)
-	{
-		++(*consecutiveCount);
-		if (*consecutiveCount > m_stuckThreshold)
-		{
-			int32& newStuckParticle = m_stuckParticleBuffer.Append();
-			newStuckParticle = particle;
-		}
-	}
-	*lastStep = m_timestamp;
-}
-
-// Get the world's contact listener if any particles with the
-// b2_fixtureContactListenerParticle flag are present in the system.
-inline b2ContactListener* b2ParticleSystem::GetFixtureContactListener() const
-{
-	return (m_allParticleFlags & b2_fixtureContactListenerParticle) ?
-		m_world->m_contactManager.m_contactListener : NULL;
-}
-
-// Get the world's contact filter if any particles with the
-// b2_fixtureContactFilterParticle flag are present in the system.
-inline b2ContactFilter* b2ParticleSystem::GetFixtureContactFilter() const
-{
-	return (m_allParticleFlags & b2_fixtureContactFilterParticle) ?
-		m_world->m_contactManager.m_contactFilter : NULL;
-}
-
-/// Compute the axis-aligned bounding box for all particles contained
-/// within this particle system.
-/// @param aabb Returns the axis-aligned bounding box of the system.
-void b2ParticleSystem::ComputeAABB(b2AABB* const aabb) const
-{
-	const int32 particleCount = GetParticleCount();
-	b2Assert(aabb);
-	aabb->lowerBound.x = +b2_maxFloat;
-	aabb->lowerBound.y = +b2_maxFloat;
-	aabb->upperBound.x = -b2_maxFloat;
-	aabb->upperBound.y = -b2_maxFloat;
-
-	for (int32 i = 0; i < particleCount; i++)
-	{
-		b2Vec2 p = m_positionBuffer.data[i];
-		aabb->lowerBound = b2Min(aabb->lowerBound, p);
-		aabb->upperBound = b2Max(aabb->upperBound, p);
-	}
-	aabb->lowerBound.x -= m_particleDiameter;
-	aabb->lowerBound.y -= m_particleDiameter;
-	aabb->upperBound.x += m_particleDiameter;
-	aabb->upperBound.y += m_particleDiameter;
-}
-
-// Associate a memory allocator with this object.
-FixedSetAllocator::FixedSetAllocator(
-		b2StackAllocator* allocator) :
-	m_buffer(NULL), m_valid(NULL), m_count(0), m_allocator(allocator)
-{
-	b2Assert(allocator);
-}
-
-// Allocate internal storage for this object.
-int32 FixedSetAllocator::Allocate(
-	const int32 itemSize, const int32 count)
-{
-	Clear();
-	if (count)
-	{
-		m_buffer = m_allocator->Allocate(
-			(itemSize + sizeof(*m_valid)) * count);
-		b2Assert(m_buffer);
-		m_valid = (int8*)m_buffer + (itemSize * count);
-		memset(m_valid, 1, sizeof(*m_valid) * count);
-		m_count = count;
-	}
-	return m_count;
-}
-
-// Deallocate the internal buffer if it's allocated.
-void FixedSetAllocator::Clear()
-{
-	if (m_buffer)
-	{
-		m_allocator->Free(m_buffer);
-		m_buffer = NULL;
-        m_count = 0;
-	}
-}
-
-// Search set for item returning the index of the item if it's found, -1
-// otherwise.
-template<typename T>
-static int32 FindItemIndexInFixedSet(const TypedFixedSetAllocator<T>& set,
-									 const T& item)
-{
-	if (set.GetCount())
-	{
-		const T* buffer = set.GetBuffer();
-		const T* last = buffer + set.GetCount();
-		const T* found = std::lower_bound( buffer, buffer + set.GetCount(),
-											item, T::Compare);
-		if( found != last )
-		{
-			return set.GetIndex( found );
-		}
-	}
-	return -1;
-}
-
-// Initialize from a set of particle / body contacts for particles
-// that have the b2_fixtureContactListenerParticle flag set.
-void FixtureParticleSet::Initialize(
-	const b2ParticleBodyContact * const bodyContacts,
-	const int32 numBodyContacts,
-	const uint32 * const particleFlagsBuffer)
-{
-	Clear();
-	if (Allocate(numBodyContacts))
-	{
-		FixtureParticle* set = GetBuffer();
-		int32 insertedContacts = 0;
-		for (int32 i = 0; i < numBodyContacts; ++i)
-		{
-			FixtureParticle* const fixtureParticle = &set[i];
-			const b2ParticleBodyContact& bodyContact = bodyContacts[i];
-			if (bodyContact.index == b2_invalidParticleIndex ||
-				!(particleFlagsBuffer[bodyContact.index] &
-				  b2_fixtureContactListenerParticle))
-			{
-				continue;
-			}
-			fixtureParticle->first = bodyContact.fixture;
-			fixtureParticle->second = bodyContact.index;
-			insertedContacts++;
-		}
-		SetCount(insertedContacts);
-		std::sort(set, set + insertedContacts, FixtureParticle::Compare);
-	}
-}
-
-// Find the index of a particle / fixture pair in the set or -1 if it's not
-// present.
-int32 FixtureParticleSet::Find(
-	const FixtureParticle& fixtureParticle) const
-{
-	return FindItemIndexInFixedSet(*this, fixtureParticle);
-}
-
-// Initialize from a set of particle contacts.
-void b2ParticlePairSet::Initialize(
-	const b2ParticleContact * const contacts, const int32 numContacts,
-	const uint32 * const particleFlagsBuffer)
-{
-	Clear();
-	if (Allocate(numContacts))
-	{
-		ParticlePair* set = GetBuffer();
-		int32 insertedContacts = 0;
-		for (int32 i = 0; i < numContacts; ++i)
-		{
-			ParticlePair* const pair = &set[i];
-			const b2ParticleContact& contact = contacts[i];
-			if (contact.GetIndexA() == b2_invalidParticleIndex ||
-				contact.GetIndexB() == b2_invalidParticleIndex ||
-				!((particleFlagsBuffer[contact.GetIndexA()] |
-				   particleFlagsBuffer[contact.GetIndexB()]) &
-				  b2_particleContactListenerParticle))
-			{
-				continue;
-			}
-			pair->first = contact.GetIndexA();
-			pair->second = contact.GetIndexB();
-			insertedContacts++;
-		}
-		SetCount(insertedContacts);
-		std::sort(set, set + insertedContacts, ParticlePair::Compare);
-	}
-}
-
-// Find the index of a particle pair in the set or -1 if it's not present.
-int32 b2ParticlePairSet::Find(const ParticlePair& pair) const
-{
-	int32 index = FindItemIndexInFixedSet(*this, pair);
-	if (index < 0)
-	{
-		ParticlePair swapped;
-		swapped.first = pair.second;
-		swapped.second = pair.first;
-		index = FindItemIndexInFixedSet(*this, swapped);
-	}
-	return index;
-}
-
-/// Callback class to receive pairs of fixtures and particles which may be
-/// overlapping. Used as an argument of b2World::QueryAABB.
-class b2FixtureParticleQueryCallback : public b2QueryCallback
-{
-public:
-	explicit b2FixtureParticleQueryCallback(b2ParticleSystem* system)
-	{
-		m_system = system;
-	}
-
-private:
-	// Skip reporting particles.
-	bool ShouldQueryParticleSystem(const b2ParticleSystem* system)
-	{
-		B2_NOT_USED(system);
-		return false;
-	}
-
-	// Receive a fixture and call ReportFixtureAndParticle() for each particle
-	// inside aabb of the fixture.
-	bool ReportFixture(b2Fixture* fixture)
-	{
-		if (fixture->IsSensor())
-		{
-			return true;
-		}
-		const b2Shape* shape = fixture->GetShape();
-		int32 childCount = shape->GetChildCount();
-		for (int32 childIndex = 0; childIndex < childCount; childIndex++)
-		{
-			b2AABB aabb = fixture->GetAABB(childIndex);
-			b2ParticleSystem::InsideBoundsEnumerator enumerator =
-								m_system->GetInsideBoundsEnumerator(aabb);
-			int32 index;
-			while ((index = enumerator.GetNext()) >= 0)
-			{
-				ReportFixtureAndParticle(fixture, childIndex, index);
-			}
-		}
-		return true;
-	}
-
-	// Receive a fixture and a particle which may be overlapping.
-	virtual void ReportFixtureAndParticle(
-						b2Fixture* fixture, int32 childIndex, int32 index) = 0;
-
-protected:
-	b2ParticleSystem* m_system;
-};
-
-void b2ParticleSystem::NotifyBodyContactListenerPreContact(
-	FixtureParticleSet* fixtureSet) const
-{
-	b2ContactListener* const contactListener = GetFixtureContactListener();
-	if (contactListener == NULL)
-		return;
-
-	fixtureSet->Initialize(m_bodyContactBuffer.Begin(),
-						   m_bodyContactBuffer.GetCount(),
-						   GetFlagsBuffer());
-}
-
-// If a contact listener is present and the contact is just starting
-// report the contact.  If the contact is already in progress invalid
-// the contact from m_fixtureSet.
-void b2ParticleSystem::NotifyBodyContactListenerPostContact(
-	FixtureParticleSet& fixtureSet)
-{
-	b2ContactListener* const contactListener = GetFixtureContactListener();
-	if (contactListener == NULL)
-		return;
-
-	// Loop through all new contacts, reporting any new ones, and
-	// "invalidating" the ones that still exist.
-	for (b2ParticleBodyContact* contact = m_bodyContactBuffer.Begin();
-		 contact != m_bodyContactBuffer.End(); ++contact)
-	{
-		b2Assert(contact);
-		FixtureParticle fixtureParticleToFind;
-		fixtureParticleToFind.first = contact->fixture;
-		fixtureParticleToFind.second = contact->index;
-		const int32 index = fixtureSet.Find(fixtureParticleToFind);
-		if (index >= 0)
-		{
-			// Already touching remove this from the set.
-			fixtureSet.Invalidate(index);
-		}
-		else
-		{
-			// Just started touching, report it!
-			contactListener->BeginContact(this, contact);
-		}
-	}
-
-	// If the contact listener is enabled, report all fixtures that are no
-	// longer in contact with particles.
-	const FixtureParticle* const fixtureParticles = fixtureSet.GetBuffer();
-	const int8* const fixtureParticlesValid = fixtureSet.GetValidBuffer();
-	const int32 fixtureParticleCount = fixtureSet.GetCount();
-	for (int32 i = 0; i < fixtureParticleCount; ++i)
-	{
-		if (fixtureParticlesValid[i])
-		{
-			const FixtureParticle* const fixtureParticle =
-				&fixtureParticles[i];
-			contactListener->EndContact(fixtureParticle->first, this,
-										fixtureParticle->second);
-		}
-	}
-}
-
-
-void b2ParticleSystem::UpdateBodyContacts()
-{
-	// If the particle contact listener is enabled, generate a set of
-	// fixture / particle contacts.
-	FixtureParticleSet fixtureSet(&m_world->m_stackAllocator);
-	NotifyBodyContactListenerPreContact(&fixtureSet);
-
-	if (m_stuckThreshold > 0)
-	{
-		const int32 particleCount = GetParticleCount();
-		for (int32 i = 0; i < particleCount; i++)
-		{
-			// Detect stuck particles, see comment in
-			// b2ParticleSystem::DetectStuckParticle()
-			m_bodyContactCountBuffer.data[i] = 0;
-			if (m_timestamp > (m_lastBodyContactStepBuffer.data[i] + 1))
-			{
-				m_consecutiveContactStepsBuffer.data[i] = 0;
-			}
-		}
-	}
-	m_bodyContactBuffer.SetCount(0);
-	m_stuckParticleBuffer.SetCount(0);
-
-	class UpdateBodyContactsCallback : public b2FixtureParticleQueryCallback
-	{
-		// Call the contact filter if it's set, to determine whether to
-		// filter this contact.  Returns true if contact calculations should
-		// be performed, false otherwise.
-		inline bool ShouldCollide(b2Fixture * const fixture,
-								  int32 particleIndex)
-		{
-			if (m_contactFilter)
-			{
-				const uint32* const flags = m_system->GetFlagsBuffer();
-				if (flags[particleIndex] & b2_fixtureContactFilterParticle)
-				{
-					return m_contactFilter->ShouldCollide(fixture, m_system,
-														  particleIndex);
-				}
-			}
-			return true;
-		}
-
-		void ReportFixtureAndParticle(
-								b2Fixture* fixture, int32 childIndex, int32 a)
-		{
-			b2Vec2 ap = m_system->m_positionBuffer.data[a];
-			float32 d;
-			b2Vec2 n;
-			fixture->ComputeDistance(ap, &d, &n, childIndex);
-			if (d < m_system->m_particleDiameter && ShouldCollide(fixture, a))
-			{
-				b2Body* b = fixture->GetBody();
-				b2Vec2 bp = b->GetWorldCenter();
-				float32 bm = b->GetMass();
-				float32 bI =
-					b->GetInertia() - bm * b->GetLocalCenter().LengthSquared();
-				float32 invBm = bm > 0 ? 1 / bm : 0;
-				float32 invBI = bI > 0 ? 1 / bI : 0;
-				float32 invAm =
-					m_system->m_flagsBuffer.data[a] &
-					b2_wallParticle ? 0 : m_system->GetParticleInvMass();
-				b2Vec2 rp = ap - bp;
-				float32 rpn = b2Cross(rp, n);
-				float32 invM = invAm + invBm + invBI * rpn * rpn;
-
-				b2ParticleBodyContact& contact =
-					m_system->m_bodyContactBuffer.Append();
-				contact.index = a;
-				contact.body = b;
-				contact.fixture = fixture;
-				contact.weight = 1 - d * m_system->m_inverseDiameter;
-				contact.normal = -n;
-				contact.mass = invM > 0 ? 1 / invM : 0;
-				m_system->DetectStuckParticle(a);
-			}
-		}
-
-		b2ContactFilter* m_contactFilter;
-
-	public:
-		UpdateBodyContactsCallback(
-			b2ParticleSystem* system, b2ContactFilter* contactFilter):
-			b2FixtureParticleQueryCallback(system)
-		{
-			m_contactFilter = contactFilter;
-		}
-	} callback(this, GetFixtureContactFilter());
-
-	b2AABB aabb;
-	ComputeAABB(&aabb);
-	m_world->QueryAABB(&callback, aabb);
-
-	if (m_def.strictContactCheck)
-	{
-		RemoveSpuriousBodyContacts();
-	}
-
-	NotifyBodyContactListenerPostContact(fixtureSet);
-}
-
-void b2ParticleSystem::RemoveSpuriousBodyContacts()
-{
-	// At this point we have a list of contact candidates based on AABB
-	// overlap.The AABB query that  generated this returns all collidable
-	// fixtures overlapping particle bounding boxes.  This breaks down around
-	// vertices where two shapes intersect, such as a "ground" surface made
-	// of multiple b2PolygonShapes; it potentially applies a lot of spurious
-	// impulses from normals that should not actually contribute.  See the
-	// Ramp example in Testbed.
-	//
-	// To correct for this, we apply this algorithm:
-	//   * sort contacts by particle and subsort by weight (nearest to farthest)
-	//   * for each contact per particle:
-	//      - project a point at the contact distance along the inverse of the
-	//        contact normal
-	//      - if this intersects the fixture that generated the contact, apply
-	//         it, otherwise discard as impossible
-	//      - repeat for up to n nearest contacts, currently we get good results
-	//        from n=3.
-	std::sort(m_bodyContactBuffer.Begin(), m_bodyContactBuffer.End(),
-				b2ParticleSystem::BodyContactCompare);
-
-	int32 discarded = 0;
-
-
-#if !defined(_WIN32) && !defined(WIN32)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunused-result"
-#endif // !_WIN32 && !WIN32
-  std::remove_if(m_bodyContactBuffer.Begin(),
-					m_bodyContactBuffer.End(),
-					b2ParticleBodyContactRemovePredicate(this, &discarded));
-#if !defined(_WIN32) && !defined(WIN32)
-#pragma GCC diagnostic pop
-#endif // !_WIN32 && !WIN32
-
-	m_bodyContactBuffer.SetCount(m_bodyContactBuffer.GetCount() - discarded);
-}
-
-bool b2ParticleSystem::BodyContactCompare(const b2ParticleBodyContact &lhs,
-										  const b2ParticleBodyContact &rhs)
-{
-	if (lhs.index == rhs.index)
-	{
-		// Subsort by weight, decreasing.
-		return lhs.weight > rhs.weight;
-	}
-	return lhs.index < rhs.index;
-}
-
-
-void b2ParticleSystem::SolveCollision(const b2TimeStep& step)
-{
-	// This function detects particles which are crossing boundary of bodies
-	// and modifies velocities of them so that they will move just in front of
-	// boundary. This function function also applies the reaction force to
-	// bodies as precisely as the numerical stability is kept.
-	b2AABB aabb;
-	aabb.lowerBound.x = +b2_maxFloat;
-	aabb.lowerBound.y = +b2_maxFloat;
-	aabb.upperBound.x = -b2_maxFloat;
-	aabb.upperBound.y = -b2_maxFloat;
-	for (int32 i = 0; i < m_count; i++)
-	{
-		b2Vec2 v = m_velocityBuffer.data[i];
-		b2Vec2 p1 = m_positionBuffer.data[i];
-		b2Vec2 p2 = p1 + step.dt * v;
-		aabb.lowerBound = b2Min(aabb.lowerBound, b2Min(p1, p2));
-		aabb.upperBound = b2Max(aabb.upperBound, b2Max(p1, p2));
-	}
-	class SolveCollisionCallback : public b2FixtureParticleQueryCallback
-	{
-		void ReportFixtureAndParticle(
-								b2Fixture* fixture, int32 childIndex, int32 a)
-		{
-			b2Body* body = fixture->GetBody();
-			b2Vec2 ap = m_system->m_positionBuffer.data[a];
-			b2Vec2 av = m_system->m_velocityBuffer.data[a];
-			b2RayCastOutput output;
-			b2RayCastInput input;
-			if (m_system->m_iterationIndex == 0)
-			{
-				// Put 'ap' in the local space of the previous frame
-				b2Vec2 p1 = b2MulT(body->m_xf0, ap);
-				if (fixture->GetShape()->GetType() == b2Shape::e_circle)
-				{
-					// Make relative to the center of the circle
-					p1 -= body->GetLocalCenter();
-					// Re-apply rotation about the center of the
-					// circle
-					p1 = b2Mul(body->m_xf0.q, p1);
-					// Subtract rotation of the current frame
-					p1 = b2MulT(body->m_xf.q, p1);
-					// Return to local space
-					p1 += body->GetLocalCenter();
-				}
-				// Return to global space and apply rotation of current frame
-				input.p1 = b2Mul(body->m_xf, p1);
-			}
-			else
-			{
-				input.p1 = ap;
-			}
-			input.p2 = ap + m_step.dt * av;
-			input.maxFraction = 1;
-			if (fixture->RayCast(&output, input, childIndex))
-			{
-				b2Vec2 n = output.normal;
-				b2Vec2 p =
-					(1 - output.fraction) * input.p1 +
-					output.fraction * input.p2 +
-					b2_linearSlop * n;
-				b2Vec2 v = m_step.inv_dt * (p - ap);
-				m_system->m_velocityBuffer.data[a] = v;
-				b2Vec2 f = m_step.inv_dt *
-					m_system->GetParticleMass() * (av - v);
-				m_system->ParticleApplyForce(a, f);
-			}
-		}
-
-		b2TimeStep m_step;
-
-	public:
-		SolveCollisionCallback(
-			b2ParticleSystem* system, const b2TimeStep& step):
-			b2FixtureParticleQueryCallback(system)
-		{
-			m_step = step;
-		}
-	} callback(this, step);
-	m_world->QueryAABB(&callback, aabb);
-}
-
-void b2ParticleSystem::SolveBarrier(const b2TimeStep& step)
-{
-	// If a particle is passing between paired barrier particles,
-	// its velocity will be decelerated to avoid passing.
-	for (int32 i = 0; i < m_count; i++)
-	{
-		uint32 flags = m_flagsBuffer.data[i];
-		static const uint32 k_barrierWallFlags =
-										b2_barrierParticle | b2_wallParticle;
-		if ((flags & k_barrierWallFlags) == k_barrierWallFlags)
-		{
-			m_velocityBuffer.data[i].SetZero();
-		}
-	}
-	float32 tmax = b2_barrierCollisionTime * step.dt;
-	for (int32 k = 0; k < m_pairBuffer.GetCount(); k++)
-	{
-		const b2ParticlePair& pair = m_pairBuffer[k];
-		if (pair.flags & b2_barrierParticle)
-		{
-			int32 a = pair.indexA;
-			int32 b = pair.indexB;
-			b2Vec2 pa = m_positionBuffer.data[a];
-			b2Vec2 pb = m_positionBuffer.data[b];
-			b2AABB aabb;
-			aabb.lowerBound = b2Min(pa, pb);
-			aabb.upperBound = b2Max(pa, pb);
-			b2ParticleGroup *aGroup = m_groupBuffer[a];
-			b2ParticleGroup *bGroup = m_groupBuffer[b];
-			b2Vec2 va = GetLinearVelocity(aGroup, a, pa);
-			b2Vec2 vb = GetLinearVelocity(bGroup, b, pb);
-			b2Vec2 pba = pb - pa;
-			b2Vec2 vba = vb - va;
-			InsideBoundsEnumerator enumerator = GetInsideBoundsEnumerator(aabb);
-			int32 c;
-			while ((c = enumerator.GetNext()) >= 0)
-			{
-				b2Vec2 pc = m_positionBuffer.data[c];
-				b2ParticleGroup *cGroup = m_groupBuffer[c];
-				if (aGroup != cGroup && bGroup != cGroup)
-				{
-					b2Vec2 vc = GetLinearVelocity(cGroup, c, pc);
-					// Solve the equation below:
-					//   (1-s)*(pa+t*va)+s*(pb+t*vb) = pc+t*vc
-					// which expresses that the particle c will pass a line
-					// connecting the particles a and b at the time of t.
-					// if s is between 0 and 1, c will pass between a and b.
-					b2Vec2 pca = pc - pa;
-					b2Vec2 vca = vc - va;
-					float32 e2 = b2Cross(vba, vca);
-					float32 e1 = b2Cross(pba, vca) - b2Cross(pca, vba);
-					float32 e0 = b2Cross(pba, pca);
-					float32 s, t;
-					b2Vec2 qba, qca;
-					if (e2 == 0)
-					{
-						if (e1 == 0) continue;
-						t = - e0 / e1;
-						if (!(t >= 0 && t < tmax)) continue;
-						qba = pba + t * vba;
-						qca = pca + t * vca;
-						s = b2Dot(qba, qca) / b2Dot(qba, qba);
-						if (!(s >= 0 && s <= 1)) continue;
-					}
-					else
-					{
-						float32 det = e1 * e1 - 4 * e0 * e2;
-						if (det < 0) continue;
-						float32 sqrtDet = b2Sqrt(det);
-						float32 t1 = (- e1 - sqrtDet) / (2 * e2);
-						float32 t2 = (- e1 + sqrtDet) / (2 * e2);
-						if (t1 > t2) b2Swap(t1, t2);
-						t = t1;
-						qba = pba + t * vba;
-						qca = pca + t * vca;
-						s = b2Dot(qba, qca) / b2Dot(qba, qba);
-						if (!(t >= 0 && t < tmax && s >= 0 && s <= 1))
-						{
-							t = t2;
-							if (!(t >= 0 && t < tmax)) continue;
-							qba = pba + t * vba;
-							qca = pca + t * vca;
-							s = b2Dot(qba, qca) / b2Dot(qba, qba);
-							if (!(s >= 0 && s <= 1)) continue;
-						}
-					}
-					// Apply a force to particle c so that it will have the
-					// interpolated velocity at the collision point on line ab.
-					b2Vec2 dv = va + s * vba - vc;
-					b2Vec2 f = GetParticleMass() * dv;
-					if (IsRigidGroup(cGroup))
-					{
-						// If c belongs to a rigid group, the force will be
-						// distributed in the group.
-						float32 mass = cGroup->GetMass();
-						float32 inertia = cGroup->GetInertia();
-						if (mass > 0)
-						{
-							cGroup->m_linearVelocity += 1 / mass * f;
-						}
-						if (inertia > 0)
-						{
-							cGroup->m_angularVelocity +=
-								b2Cross(pc - cGroup->GetCenter(), f) / inertia;
-						}
-					}
-					else
-					{
-						m_velocityBuffer.data[c] += dv;
-					}
-					// Apply a reversed force to particle c after particle
-					// movement so that momentum will be preserved.
-					ParticleApplyForce(c, -step.inv_dt * f);
-				}
-			}
-		}
-	}
-}
-
-void b2ParticleSystem::Solve(const b2TimeStep& step)
-{
-	if (m_count == 0)
-	{
-		return;
-	}
-	// If particle lifetimes are enabled, destroy particles that are too old.
-	if (m_expirationTimeBuffer.data)
-	{
-		SolveLifetimes(step);
-	}
-	if (m_allParticleFlags & b2_zombieParticle)
-	{
-		SolveZombie();
-	}
-	if (m_needsUpdateAllParticleFlags)
-	{
-		UpdateAllParticleFlags();
-	}
-	if (m_needsUpdateAllGroupFlags)
-	{
-		UpdateAllGroupFlags();
-	}
-	if (m_paused)
-	{
-		return;
-	}
-	for (m_iterationIndex = 0;
-		m_iterationIndex < step.particleIterations;
-		m_iterationIndex++)
-	{
-		++m_timestamp;
-		b2TimeStep subStep = step;
-		subStep.dt /= step.particleIterations;
-		subStep.inv_dt *= step.particleIterations;
-		UpdateContacts(false);
-		UpdateBodyContacts();
-		ComputeWeight();
-		if (m_allGroupFlags & b2_particleGroupNeedsUpdateDepth)
-		{
-			ComputeDepth();
-		}
-		if (m_allParticleFlags & b2_reactiveParticle)
-		{
-			UpdatePairsAndTriadsWithReactiveParticles();
-		}
-		if (m_hasForce)
-		{
-			SolveForce(subStep);
-		}
-		if (m_allParticleFlags & b2_viscousParticle)
-		{
-			SolveViscous();
-		}
-		if (m_allParticleFlags & b2_repulsiveParticle)
-		{
-			SolveRepulsive(subStep);
-		}
-		if (m_allParticleFlags & b2_powderParticle)
-		{
-			SolvePowder(subStep);
-		}
-		if (m_allParticleFlags & b2_tensileParticle)
-		{
-			SolveTensile(subStep);
-		}
-		if (m_allGroupFlags & b2_solidParticleGroup)
-		{
-			SolveSolid(subStep);
-		}
-		if (m_allParticleFlags & b2_colorMixingParticle)
-		{
-			SolveColorMixing();
-		}
-		SolveGravity(subStep);
-		if (m_allParticleFlags & b2_staticPressureParticle)
-		{
-			SolveStaticPressure(subStep);
-		}
-		SolvePressure(subStep);
-		SolveDamping(subStep);
-		if (m_allParticleFlags & k_extraDampingFlags)
-		{
-			SolveExtraDamping();
-		}
-		// SolveElastic and SolveSpring refer the current velocities for
-		// numerical stability, they should be called as late as possible.
-		if (m_allParticleFlags & b2_elasticParticle)
-		{
-			SolveElastic(subStep);
-		}
-		if (m_allParticleFlags & b2_springParticle)
-		{
-			SolveSpring(subStep);
-		}
-		LimitVelocity(subStep);
-		if (m_allGroupFlags & b2_rigidParticleGroup)
-		{
-			SolveRigidDamping();
-		}
-		if (m_allParticleFlags & b2_barrierParticle)
-		{
-			SolveBarrier(subStep);
-		}
-		// SolveCollision, SolveRigid and SolveWall should be called after
-		// other force functions because they may require particles to have
-		// specific velocities.
-		SolveCollision(subStep);
-		if (m_allGroupFlags & b2_rigidParticleGroup)
-		{
-			SolveRigid(subStep);
-		}
-		if (m_allParticleFlags & b2_wallParticle)
-		{
-			SolveWall();
-		}
-		// The particle positions can be updated only at the end of substep.
-		for (int32 i = 0; i < m_count; i++)
-		{
-			m_positionBuffer.data[i] += subStep.dt * m_velocityBuffer.data[i];
-		}
-	}
-}
-
-void b2ParticleSystem::UpdateAllParticleFlags()
-{
-	m_allParticleFlags = 0;
-	for (int32 i = 0; i < m_count; i++)
-	{
-		m_allParticleFlags |= m_flagsBuffer.data[i];
-	}
-	m_needsUpdateAllParticleFlags = false;
-}
-
-void b2ParticleSystem::UpdateAllGroupFlags()
-{
-	m_allGroupFlags = 0;
-	for (const b2ParticleGroup* group = m_groupList; group;
-		 group = group->GetNext())
-	{
-		m_allGroupFlags |= group->m_groupFlags;
-	}
-	m_needsUpdateAllGroupFlags = false;
-}
-
-void b2ParticleSystem::LimitVelocity(const b2TimeStep& step)
-{
-	float32 criticalVelocitySquared = GetCriticalVelocitySquared(step);
-	for (int32 i = 0; i < m_count; i++)
-	{
-		b2Vec2& v = m_velocityBuffer.data[i];
-		float32 v2 = b2Dot(v, v);
-		if (v2 > criticalVelocitySquared)
-		{
-			v *= b2Sqrt(criticalVelocitySquared / v2);
-		}
-	}
-}
-
-void b2ParticleSystem::SolveGravity(const b2TimeStep& step)
-{
-	b2Vec2 gravity = step.dt * m_def.gravityScale * m_world->GetGravity();
-	for (int32 i = 0; i < m_count; i++)
-	{
-		m_velocityBuffer.data[i] += gravity;
-	}
-}
-
-void b2ParticleSystem::SolveStaticPressure(const b2TimeStep& step)
-{
-	m_staticPressureBuffer = RequestBuffer(m_staticPressureBuffer);
-	float32 criticalPressure = GetCriticalPressure(step);
-	float32 pressurePerWeight = m_def.staticPressureStrength * criticalPressure;
-	float32 maxPressure = b2_maxParticlePressure * criticalPressure;
-	float32 relaxation = m_def.staticPressureRelaxation;
-	/// Compute pressure satisfying the modified Poisson equation:
-	///     Sum_for_j((p_i - p_j) * w_ij) + relaxation * p_i =
-	///     pressurePerWeight * (w_i - b2_minParticleWeight)
-	/// by iterating the calculation:
-	///     p_i = (Sum_for_j(p_j * w_ij) + pressurePerWeight *
-	///           (w_i - b2_minParticleWeight)) / (w_i + relaxation)
-	/// where
-	///     p_i and p_j are static pressure of particle i and j
-	///     w_ij is contact weight between particle i and j
-	///     w_i is sum of contact weight of particle i
-	for (int32 t = 0; t < m_def.staticPressureIterations; t++)
-	{
-		memset(m_accumulationBuffer, 0,
-			   sizeof(*m_accumulationBuffer) * m_count);
-		for (int32 k = 0; k < m_contactBuffer.GetCount(); k++)
-		{
-			const b2ParticleContact& contact = m_contactBuffer[k];
-			if (contact.GetFlags() & b2_staticPressureParticle)
-			{
-				int32 a = contact.GetIndexA();
-				int32 b = contact.GetIndexB();
-				float32 w = contact.GetWeight();
-				m_accumulationBuffer[a] +=
-					w * m_staticPressureBuffer[b]; // a <- b
-				m_accumulationBuffer[b] +=
-					w * m_staticPressureBuffer[a]; // b <- a
-			}
-		}
-		for (int32 i = 0; i < m_count; i++)
-		{
-			float32 w = m_weightBuffer[i];
-			if (m_flagsBuffer.data[i] & b2_staticPressureParticle)
-			{
-				float32 wh = m_accumulationBuffer[i];
-				float32 h =
-					(wh + pressurePerWeight * (w - b2_minParticleWeight)) /
-					(w + relaxation);
-				m_staticPressureBuffer[i] = b2Clamp(h, 0.0f, maxPressure);
-			}
-			else
-			{
-				m_staticPressureBuffer[i] = 0;
-			}
-		}
-	}
-}
-
-void b2ParticleSystem::SolvePressure(const b2TimeStep& step)
-{
-	// calculates pressure as a linear function of density
-	float32 criticalPressure = GetCriticalPressure(step);
-	float32 pressurePerWeight = m_def.pressureStrength * criticalPressure;
-	float32 maxPressure = b2_maxParticlePressure * criticalPressure;
-	for (int32 i = 0; i < m_count; i++)
-	{
-		float32 w = m_weightBuffer[i];
-		float32 h = pressurePerWeight * b2Max(0.0f, w - b2_minParticleWeight);
-		m_accumulationBuffer[i] = b2Min(h, maxPressure);
-	}
-	// ignores particles which have their own repulsive force
-	if (m_allParticleFlags & k_noPressureFlags)
-	{
-		for (int32 i = 0; i < m_count; i++)
-		{
-			if (m_flagsBuffer.data[i] & k_noPressureFlags)
-			{
-				m_accumulationBuffer[i] = 0;
-			}
-		}
-	}
-	// static pressure
-	if (m_allParticleFlags & b2_staticPressureParticle)
-	{
-		b2Assert(m_staticPressureBuffer);
-		for (int32 i = 0; i < m_count; i++)
-		{
-			if (m_flagsBuffer.data[i] & b2_staticPressureParticle)
-			{
-				m_accumulationBuffer[i] += m_staticPressureBuffer[i];
-			}
-		}
-	}
-	// applies pressure between each particles in contact
-	float32 velocityPerPressure = step.dt / (m_def.density * m_particleDiameter);
-	for (int32 k = 0; k < m_bodyContactBuffer.GetCount(); k++)
-	{
-		const b2ParticleBodyContact& contact = m_bodyContactBuffer[k];
-		int32 a = contact.index;
-		b2Body* b = contact.body;
-		float32 w = contact.weight;
-		float32 m = contact.mass;
-		b2Vec2 n = contact.normal;
-		b2Vec2 p = m_positionBuffer.data[a];
-		float32 h = m_accumulationBuffer[a] + pressurePerWeight * w;
-		b2Vec2 f = velocityPerPressure * w * m * h * n;
-		m_velocityBuffer.data[a] -= GetParticleInvMass() * f;
-		b->ApplyLinearImpulse(f, p, true);
-	}
-	for (int32 k = 0; k < m_contactBuffer.GetCount(); k++)
-	{
-		const b2ParticleContact& contact = m_contactBuffer[k];
-		int32 a = contact.GetIndexA();
-		int32 b = contact.GetIndexB();
-		float32 w = contact.GetWeight();
-		b2Vec2 n = contact.GetNormal();
-		float32 h = m_accumulationBuffer[a] + m_accumulationBuffer[b];
-		b2Vec2 f = velocityPerPressure * w * h * n;
-		m_velocityBuffer.data[a] -= f;
-		m_velocityBuffer.data[b] += f;
-	}
-}
-
-void b2ParticleSystem::SolveDamping(const b2TimeStep& step)
-{
-	// reduces normal velocity of each contact
-	float32 linearDamping = m_def.dampingStrength;
-	float32 quadraticDamping = 1 / GetCriticalVelocity(step);
-	for (int32 k = 0; k < m_bodyContactBuffer.GetCount(); k++)
-	{
-		const b2ParticleBodyContact& contact = m_bodyContactBuffer[k];
-		int32 a = contact.index;
-		b2Body* b = contact.body;
-		float32 w = contact.weight;
-		float32 m = contact.mass;
-		b2Vec2 n = contact.normal;
-		b2Vec2 p = m_positionBuffer.data[a];
-		b2Vec2 v = b->GetLinearVelocityFromWorldPoint(p) -
-				   m_velocityBuffer.data[a];
-		float32 vn = b2Dot(v, n);
-		if (vn < 0)
-		{
-			float32 damping =
-				b2Max(linearDamping * w, b2Min(- quadraticDamping * vn, 0.5f));
-			b2Vec2 f = damping * m * vn * n;
-			m_velocityBuffer.data[a] += GetParticleInvMass() * f;
-			b->ApplyLinearImpulse(-f, p, true);
-		}
-	}
-	for (int32 k = 0; k < m_contactBuffer.GetCount(); k++)
-	{
-		const b2ParticleContact& contact = m_contactBuffer[k];
-		int32 a = contact.GetIndexA();
-		int32 b = contact.GetIndexB();
-		float32 w = contact.GetWeight();
-		b2Vec2 n = contact.GetNormal();
-		b2Vec2 v = m_velocityBuffer.data[b] - m_velocityBuffer.data[a];
-		float32 vn = b2Dot(v, n);
-		if (vn < 0)
-		{
-			float32 damping =
-				b2Max(linearDamping * w, b2Min(- quadraticDamping * vn, 0.5f));
-			b2Vec2 f = damping * vn * n;
-			m_velocityBuffer.data[a] += f;
-			m_velocityBuffer.data[b] -= f;
-		}
-	}
-}
-
-inline bool b2ParticleSystem::IsRigidGroup(b2ParticleGroup *group) const
-{
-	return group && (group->m_groupFlags & b2_rigidParticleGroup);
-}
-
-inline b2Vec2 b2ParticleSystem::GetLinearVelocity(
-	b2ParticleGroup *group, int32 particleIndex,
-	const b2Vec2 &point) const
-{
-	if (IsRigidGroup(group))
-	{
-		return group->GetLinearVelocityFromWorldPoint(point);
-	}
-	else
-	{
-		return m_velocityBuffer.data[particleIndex];
-	}
-}
-
-inline void b2ParticleSystem::InitDampingParameter(
-	float32* invMass, float32* invInertia, float32* tangentDistance,
-	float32 mass, float32 inertia, const b2Vec2& center,
-	const b2Vec2& point, const b2Vec2& normal) const
-{
-	*invMass = mass > 0 ? 1 / mass : 0;
-	*invInertia = inertia > 0 ? 1 / inertia : 0;
-	*tangentDistance = b2Cross(point - center, normal);
-}
-
-inline void b2ParticleSystem::InitDampingParameterWithRigidGroupOrParticle(
-	float32* invMass, float32* invInertia, float32* tangentDistance,
-	bool isRigidGroup, b2ParticleGroup* group, int32 particleIndex,
-	const b2Vec2& point, const b2Vec2& normal) const
-{
-	if (isRigidGroup)
-	{
-		InitDampingParameter(
-			invMass, invInertia, tangentDistance,
-			group->GetMass(), group->GetInertia(), group->GetCenter(),
-			point, normal);
-	}
-	else
-	{
-		uint32 flags = m_flagsBuffer.data[particleIndex];
-		InitDampingParameter(
-			invMass, invInertia, tangentDistance,
-			flags & b2_wallParticle ? 0 : GetParticleMass(), 0, point,
-			point, normal);
-	}
-}
-
-inline float32 b2ParticleSystem::ComputeDampingImpulse(
-	float32 invMassA, float32 invInertiaA, float32 tangentDistanceA,
-	float32 invMassB, float32 invInertiaB, float32 tangentDistanceB,
-	float32 normalVelocity) const
-{
-	float32 invMass =
-		invMassA + invInertiaA * tangentDistanceA * tangentDistanceA +
-		invMassB + invInertiaB * tangentDistanceB * tangentDistanceB;
-	return invMass > 0 ? normalVelocity / invMass : 0;
-}
-
-inline void b2ParticleSystem::ApplyDamping(
-	float32 invMass, float32 invInertia, float32 tangentDistance,
-	bool isRigidGroup, b2ParticleGroup* group, int32 particleIndex,
-	float32 impulse, const b2Vec2& normal)
-{
-	if (isRigidGroup)
-	{
-		group->m_linearVelocity += impulse * invMass * normal;
-		group->m_angularVelocity += impulse * tangentDistance * invInertia;
-	}
-	else
-	{
-		m_velocityBuffer.data[particleIndex] += impulse * invMass * normal;
-	}
-}
-
-void b2ParticleSystem::SolveRigidDamping()
-{
-	// Apply impulse to rigid particle groups colliding with other objects
-	// to reduce relative velocity at the colliding point.
-	float32 damping = m_def.dampingStrength;
-	for (int32 k = 0; k < m_bodyContactBuffer.GetCount(); k++)
-	{
-		const b2ParticleBodyContact& contact = m_bodyContactBuffer[k];
-		int32 a = contact.index;
-		b2ParticleGroup* aGroup = m_groupBuffer[a];
-		if (IsRigidGroup(aGroup))
-		{
-			b2Body* b = contact.body;
-			b2Vec2 n = contact.normal;
-			float32 w = contact.weight;
-			b2Vec2 p = m_positionBuffer.data[a];
-			b2Vec2 v = b->GetLinearVelocityFromWorldPoint(p) -
-					   aGroup->GetLinearVelocityFromWorldPoint(p);
-			float32 vn = b2Dot(v, n);
-			if (vn < 0)
-			// The group's average velocity at particle position 'p' is pushing
-			// the particle into the body.
-			{
-				float32 invMassA, invInertiaA, tangentDistanceA;
-				float32 invMassB, invInertiaB, tangentDistanceB;
-				InitDampingParameterWithRigidGroupOrParticle(
-					&invMassA, &invInertiaA, &tangentDistanceA,
-					true, aGroup, a, p, n);
-				InitDampingParameter(
-					&invMassB, &invInertiaB, &tangentDistanceB,
-					b->GetMass(),
-					// Calculate b->m_I from public functions of b2Body.
-					b->GetInertia() -
-							b->GetMass() * b->GetLocalCenter().LengthSquared(),
-					b->GetWorldCenter(),
-					p, n);
-				float32 f = damping * b2Min(w, 1.0f) * ComputeDampingImpulse(
-					invMassA, invInertiaA, tangentDistanceA,
-					invMassB, invInertiaB, tangentDistanceB,
-					vn);
-				ApplyDamping(
-					invMassA, invInertiaA, tangentDistanceA,
-					true, aGroup, a, f, n);
-				b->ApplyLinearImpulse(-f * n, p, true);
-			}
-		}
-	}
-	for (int32 k = 0; k < m_contactBuffer.GetCount(); k++)
-	{
-		const b2ParticleContact& contact = m_contactBuffer[k];
-		int32 a = contact.GetIndexA();
-		int32 b = contact.GetIndexB();
-		b2Vec2 n = contact.GetNormal();
-		float32 w = contact.GetWeight();
-		b2ParticleGroup* aGroup = m_groupBuffer[a];
-		b2ParticleGroup* bGroup = m_groupBuffer[b];
-		bool aRigid = IsRigidGroup(aGroup);
-		bool bRigid = IsRigidGroup(bGroup);
-		if (aGroup != bGroup && (aRigid || bRigid))
-		{
-			b2Vec2 p =
-				0.5f * (m_positionBuffer.data[a] + m_positionBuffer.data[b]);
-			b2Vec2 v =
-				GetLinearVelocity(bGroup, b, p) -
-				GetLinearVelocity(aGroup, a, p);
-			float32 vn = b2Dot(v, n);
-			if (vn < 0)
-			{
-				float32 invMassA, invInertiaA, tangentDistanceA;
-				float32 invMassB, invInertiaB, tangentDistanceB;
-				InitDampingParameterWithRigidGroupOrParticle(
-					&invMassA, &invInertiaA, &tangentDistanceA,
-					aRigid, aGroup, a,
-					p, n);
-				InitDampingParameterWithRigidGroupOrParticle(
-					&invMassB, &invInertiaB, &tangentDistanceB,
-					bRigid, bGroup, b,
-					p, n);
-				float32 f = damping * w * ComputeDampingImpulse(
-					invMassA, invInertiaA, tangentDistanceA,
-					invMassB, invInertiaB, tangentDistanceB,
-					vn);
-				ApplyDamping(
-					invMassA, invInertiaA, tangentDistanceA,
-					aRigid, aGroup, a, f, n);
-				ApplyDamping(
-					invMassB, invInertiaB, tangentDistanceB,
-					bRigid, bGroup, b, -f, n);
-			}
-		}
-	}
-}
-
-void b2ParticleSystem::SolveExtraDamping()
-{
-	// Applies additional damping force between bodies and particles which can
-	// produce strong repulsive force. Applying damping force multiple times
-	// is effective in suppressing vibration.
-	for (int32 k = 0; k < m_bodyContactBuffer.GetCount(); k++)
-	{
-		const b2ParticleBodyContact& contact = m_bodyContactBuffer[k];
-		int32 a = contact.index;
-		if (m_flagsBuffer.data[a] & k_extraDampingFlags)
-		{
-			b2Body* b = contact.body;
-			float32 m = contact.mass;
-			b2Vec2 n = contact.normal;
-			b2Vec2 p = m_positionBuffer.data[a];
-			b2Vec2 v =
-				b->GetLinearVelocityFromWorldPoint(p) -
-				m_velocityBuffer.data[a];
-			float32 vn = b2Dot(v, n);
-			if (vn < 0)
-			{
-				b2Vec2 f = 0.5f * m * vn * n;
-				m_velocityBuffer.data[a] += GetParticleInvMass() * f;
-				b->ApplyLinearImpulse(-f, p, true);
-			}
-		}
-	}
-}
-
-void b2ParticleSystem::SolveWall()
-{
-	for (int32 i = 0; i < m_count; i++)
-	{
-		if (m_flagsBuffer.data[i] & b2_wallParticle)
-		{
-			m_velocityBuffer.data[i].SetZero();
-		}
-	}
-}
-
-void b2ParticleSystem::SolveRigid(const b2TimeStep& step)
-{
-	for (b2ParticleGroup* group = m_groupList; group; group = group->GetNext())
-	{
-		if (group->m_groupFlags & b2_rigidParticleGroup)
-		{
-			group->UpdateStatistics();
-			b2Rot rotation(step.dt * group->m_angularVelocity);
-			b2Transform transform(
-				group->m_center + step.dt * group->m_linearVelocity -
-				b2Mul(rotation, group->m_center), rotation);
-			group->m_transform = b2Mul(transform, group->m_transform);
-			b2Transform velocityTransform;
-			velocityTransform.p.x = step.inv_dt * transform.p.x;
-			velocityTransform.p.y = step.inv_dt * transform.p.y;
-			velocityTransform.q.s = step.inv_dt * transform.q.s;
-			velocityTransform.q.c = step.inv_dt * (transform.q.c - 1);
-			for (int32 i = group->m_firstIndex; i < group->m_lastIndex; i++)
-			{
-				m_velocityBuffer.data[i] = b2Mul(velocityTransform,
-												 m_positionBuffer.data[i]);
-			}
-		}
-	}
-}
-
-void b2ParticleSystem::SolveElastic(const b2TimeStep& step)
-{
-	float32 elasticStrength = step.inv_dt * m_def.elasticStrength;
-	for (int32 k = 0; k < m_triadBuffer.GetCount(); k++)
-	{
-		const b2ParticleTriad& triad = m_triadBuffer[k];
-		if (triad.flags & b2_elasticParticle)
-		{
-			int32 a = triad.indexA;
-			int32 b = triad.indexB;
-			int32 c = triad.indexC;
-			const b2Vec2& oa = triad.pa;
-			const b2Vec2& ob = triad.pb;
-			const b2Vec2& oc = triad.pc;
-			b2Vec2 pa = m_positionBuffer.data[a];
-			b2Vec2 pb = m_positionBuffer.data[b];
-			b2Vec2 pc = m_positionBuffer.data[c];
-			b2Vec2& va = m_velocityBuffer.data[a];
-			b2Vec2& vb = m_velocityBuffer.data[b];
-			b2Vec2& vc = m_velocityBuffer.data[c];
-			pa += step.dt * va;
-			pb += step.dt * vb;
-			pc += step.dt * vc;
-			b2Vec2 midPoint = (float32) 1 / 3 * (pa + pb + pc);
-			pa -= midPoint;
-			pb -= midPoint;
-			pc -= midPoint;
-			b2Rot r;
-			r.s = b2Cross(oa, pa) + b2Cross(ob, pb) + b2Cross(oc, pc);
-			r.c = b2Dot(oa, pa) + b2Dot(ob, pb) + b2Dot(oc, pc);
-			float32 r2 = r.s * r.s + r.c * r.c;
-			float32 invR = b2InvSqrt(r2);
-			r.s *= invR;
-			r.c *= invR;
-			float32 strength = elasticStrength * triad.strength;
-			va += strength * (b2Mul(r, oa) - pa);
-			vb += strength * (b2Mul(r, ob) - pb);
-			vc += strength * (b2Mul(r, oc) - pc);
-		}
-	}
-}
-
-void b2ParticleSystem::SolveSpring(const b2TimeStep& step)
-{
-	float32 springStrength = step.inv_dt * m_def.springStrength;
-	for (int32 k = 0; k < m_pairBuffer.GetCount(); k++)
-	{
-		const b2ParticlePair& pair = m_pairBuffer[k];
-		if (pair.flags & b2_springParticle)
-		{
-			int32 a = pair.indexA;
-			int32 b = pair.indexB;
-			b2Vec2 pa = m_positionBuffer.data[a];
-			b2Vec2 pb = m_positionBuffer.data[b];
-			b2Vec2& va = m_velocityBuffer.data[a];
-			b2Vec2& vb = m_velocityBuffer.data[b];
-			pa += step.dt * va;
-			pb += step.dt * vb;
-			b2Vec2 d = pb - pa;
-			float32 r0 = pair.distance;
-			float32 r1 = d.Length();
-			float32 strength = springStrength * pair.strength;
-			b2Vec2 f = strength * (r0 - r1) / r1 * d;
-			va -= f;
-			vb += f;
-		}
-	}
-}
-
-void b2ParticleSystem::SolveTensile(const b2TimeStep& step)
-{
-	b2Assert(m_accumulation2Buffer);
-	for (int32 i = 0; i < m_count; i++)
-	{
-		m_accumulation2Buffer[i] = b2Vec2_zero;
-	}
-	for (int32 k = 0; k < m_contactBuffer.GetCount(); k++)
-	{
-		const b2ParticleContact& contact = m_contactBuffer[k];
-		if (contact.GetFlags() & b2_tensileParticle)
-		{
-			int32 a = contact.GetIndexA();
-			int32 b = contact.GetIndexB();
-			float32 w = contact.GetWeight();
-			b2Vec2 n = contact.GetNormal();
-			b2Vec2 weightedNormal = (1 - w) * w * n;
-			m_accumulation2Buffer[a] -= weightedNormal;
-			m_accumulation2Buffer[b] += weightedNormal;
-		}
-	}
-	float32 criticalVelocity = GetCriticalVelocity(step);
-	float32 pressureStrength = m_def.surfaceTensionPressureStrength
-							 * criticalVelocity;
-	float32 normalStrength = m_def.surfaceTensionNormalStrength
-						   * criticalVelocity;
-	float32 maxVelocityVariation = b2_maxParticleForce * criticalVelocity;
-	for (int32 k = 0; k < m_contactBuffer.GetCount(); k++)
-	{
-		const b2ParticleContact& contact = m_contactBuffer[k];
-		if (contact.GetFlags() & b2_tensileParticle)
-		{
-			int32 a = contact.GetIndexA();
-			int32 b = contact.GetIndexB();
-			float32 w = contact.GetWeight();
-			b2Vec2 n = contact.GetNormal();
-			float32 h = m_weightBuffer[a] + m_weightBuffer[b];
-			b2Vec2 s = m_accumulation2Buffer[b] - m_accumulation2Buffer[a];
-			float32 fn = b2Min(
-					pressureStrength * (h - 2) + normalStrength * b2Dot(s, n),
-					maxVelocityVariation) * w;
-			b2Vec2 f = fn * n;
-			m_velocityBuffer.data[a] -= f;
-			m_velocityBuffer.data[b] += f;
-		}
-	}
-}
-
-void b2ParticleSystem::SolveViscous()
-{
-	float32 viscousStrength = m_def.viscousStrength;
-	for (int32 k = 0; k < m_bodyContactBuffer.GetCount(); k++)
-	{
-		const b2ParticleBodyContact& contact = m_bodyContactBuffer[k];
-		int32 a = contact.index;
-		if (m_flagsBuffer.data[a] & b2_viscousParticle)
-		{
-			b2Body* b = contact.body;
-			float32 w = contact.weight;
-			float32 m = contact.mass;
-			b2Vec2 p = m_positionBuffer.data[a];
-			b2Vec2 v = b->GetLinearVelocityFromWorldPoint(p) -
-					   m_velocityBuffer.data[a];
-			b2Vec2 f = viscousStrength * m * w * v;
-			m_velocityBuffer.data[a] += GetParticleInvMass() * f;
-			b->ApplyLinearImpulse(-f, p, true);
-		}
-	}
-	for (int32 k = 0; k < m_contactBuffer.GetCount(); k++)
-	{
-		const b2ParticleContact& contact = m_contactBuffer[k];
-		if (contact.GetFlags() & b2_viscousParticle)
-		{
-			int32 a = contact.GetIndexA();
-			int32 b = contact.GetIndexB();
-			float32 w = contact.GetWeight();
-			b2Vec2 v = m_velocityBuffer.data[b] - m_velocityBuffer.data[a];
-			b2Vec2 f = viscousStrength * w * v;
-			m_velocityBuffer.data[a] += f;
-			m_velocityBuffer.data[b] -= f;
-		}
-	}
-}
-
-void b2ParticleSystem::SolveRepulsive(const b2TimeStep& step)
-{
-	float32 repulsiveStrength =
-		m_def.repulsiveStrength * GetCriticalVelocity(step);
-	for (int32 k = 0; k < m_contactBuffer.GetCount(); k++)
-	{
-		const b2ParticleContact& contact = m_contactBuffer[k];
-		if (contact.GetFlags() & b2_repulsiveParticle)
-		{
-			int32 a = contact.GetIndexA();
-			int32 b = contact.GetIndexB();
-			if (m_groupBuffer[a] != m_groupBuffer[b])
-			{
-				float32 w = contact.GetWeight();
-				b2Vec2 n = contact.GetNormal();
-				b2Vec2 f = repulsiveStrength * w * n;
-				m_velocityBuffer.data[a] -= f;
-				m_velocityBuffer.data[b] += f;
-			}
-		}
-	}
-}
-
-void b2ParticleSystem::SolvePowder(const b2TimeStep& step)
-{
-	float32 powderStrength = m_def.powderStrength * GetCriticalVelocity(step);
-	float32 minWeight = 1.0f - b2_particleStride;
-	for (int32 k = 0; k < m_contactBuffer.GetCount(); k++)
-	{
-		const b2ParticleContact& contact = m_contactBuffer[k];
-		if (contact.GetFlags() & b2_powderParticle)
-		{
-			float32 w = contact.GetWeight();
-			if (w > minWeight)
-			{
-				int32 a = contact.GetIndexA();
-				int32 b = contact.GetIndexB();
-				b2Vec2 n = contact.GetNormal();
-				b2Vec2 f = powderStrength * (w - minWeight) * n;
-				m_velocityBuffer.data[a] -= f;
-				m_velocityBuffer.data[b] += f;
-			}
-		}
-	}
-}
-
-void b2ParticleSystem::SolveSolid(const b2TimeStep& step)
-{
-	// applies extra repulsive force from solid particle groups
-	b2Assert(m_depthBuffer);
-	float32 ejectionStrength = step.inv_dt * m_def.ejectionStrength;
-	for (int32 k = 0; k < m_contactBuffer.GetCount(); k++)
-	{
-		const b2ParticleContact& contact = m_contactBuffer[k];
-		int32 a = contact.GetIndexA();
-		int32 b = contact.GetIndexB();
-		if (m_groupBuffer[a] != m_groupBuffer[b])
-		{
-			float32 w = contact.GetWeight();
-			b2Vec2 n = contact.GetNormal();
-			float32 h = m_depthBuffer[a] + m_depthBuffer[b];
-			b2Vec2 f = ejectionStrength * h * w * n;
-			m_velocityBuffer.data[a] -= f;
-			m_velocityBuffer.data[b] += f;
-		}
-	}
-}
-
-void b2ParticleSystem::SolveForce(const b2TimeStep& step)
-{
-	float32 velocityPerForce = step.dt * GetParticleInvMass();
-	for (int32 i = 0; i < m_count; i++)
-	{
-		m_velocityBuffer.data[i] += velocityPerForce * m_forceBuffer[i];
-	}
-	m_hasForce = false;
-}
-
-void b2ParticleSystem::SolveColorMixing()
-{
-	// mixes color between contacting particles
-	b2Assert(m_colorBuffer.data);
-	const int32 colorMixing128 = (int32) (128 * m_def.colorMixingStrength);
-	if (colorMixing128) {
-		for (int32 k = 0; k < m_contactBuffer.GetCount(); k++)
-		{
-			const b2ParticleContact& contact = m_contactBuffer[k];
-			int32 a = contact.GetIndexA();
-			int32 b = contact.GetIndexB();
-			if (m_flagsBuffer.data[a] & m_flagsBuffer.data[b] &
-				b2_colorMixingParticle)
-			{
-				b2ParticleColor& colorA = m_colorBuffer.data[a];
-				b2ParticleColor& colorB = m_colorBuffer.data[b];
-				// Use the static method to ensure certain compilers inline
-				// this correctly.
-				b2ParticleColor::MixColors(&colorA, &colorB, colorMixing128);
-			}
-		}
-	}
-}
-
-void b2ParticleSystem::SolveZombie()
-{
-	// removes particles with zombie flag
-	int32 newCount = 0;
-	int32* newIndices = (int32*) m_world->m_stackAllocator.Allocate(
-		sizeof(int32) * m_count);
-	uint32 allParticleFlags = 0;
-	for (int32 i = 0; i < m_count; i++)
-	{
-		int32 flags = m_flagsBuffer.data[i];
-		if (flags & b2_zombieParticle)
-		{
-			b2DestructionListener * const destructionListener =
-				m_world->m_destructionListener;
-			if ((flags & b2_destructionListenerParticle) &&
-				destructionListener)
-			{
-				destructionListener->SayGoodbye(this, i);
-			}
-			// Destroy particle handle.
-			if (m_handleIndexBuffer.data)
-			{
-				b2ParticleHandle * const handle = m_handleIndexBuffer.data[i];
-				if (handle)
-				{
-					handle->SetIndex(b2_invalidParticleIndex);
-					m_handleIndexBuffer.data[i] = NULL;
-					m_handleAllocator.Free(handle);
-				}
-			}
-			newIndices[i] = b2_invalidParticleIndex;
-		}
-		else
-		{
-			newIndices[i] = newCount;
-			if (i != newCount)
-			{
-				// Update handle to reference new particle index.
-				if (m_handleIndexBuffer.data)
-				{
-					b2ParticleHandle * const handle =
-						m_handleIndexBuffer.data[i];
-					if (handle) handle->SetIndex(newCount);
-					m_handleIndexBuffer.data[newCount] = handle;
-				}
-				m_flagsBuffer.data[newCount] = m_flagsBuffer.data[i];
-				if (m_lastBodyContactStepBuffer.data)
-				{
-					m_lastBodyContactStepBuffer.data[newCount] =
-						m_lastBodyContactStepBuffer.data[i];
-				}
-				if (m_bodyContactCountBuffer.data)
-				{
-					m_bodyContactCountBuffer.data[newCount] =
-						m_bodyContactCountBuffer.data[i];
-				}
-				if (m_consecutiveContactStepsBuffer.data)
-				{
-					m_consecutiveContactStepsBuffer.data[newCount] =
-						m_consecutiveContactStepsBuffer.data[i];
-				}
-				m_positionBuffer.data[newCount] = m_positionBuffer.data[i];
-				m_velocityBuffer.data[newCount] = m_velocityBuffer.data[i];
-				m_groupBuffer[newCount] = m_groupBuffer[i];
-				if (m_hasForce)
-				{
-					m_forceBuffer[newCount] = m_forceBuffer[i];
-				}
-				if (m_staticPressureBuffer)
-				{
-					m_staticPressureBuffer[newCount] =
-						m_staticPressureBuffer[i];
-				}
-				if (m_depthBuffer)
-				{
-					m_depthBuffer[newCount] = m_depthBuffer[i];
-				}
-				if (m_colorBuffer.data)
-				{
-					m_colorBuffer.data[newCount] = m_colorBuffer.data[i];
-				}
-				if (m_userDataBuffer.data)
-				{
-					m_userDataBuffer.data[newCount] = m_userDataBuffer.data[i];
-				}
-				if (m_expirationTimeBuffer.data)
-				{
-					m_expirationTimeBuffer.data[newCount] =
-						m_expirationTimeBuffer.data[i];
-				}
-			}
-			newCount++;
-			allParticleFlags |= flags;
-		}
-	}
-
-	// predicate functions
-	struct Test
-	{
-		static bool IsProxyInvalid(const Proxy& proxy)
-		{
-			return proxy.index < 0;
-		}
-		static bool IsContactInvalid(const b2ParticleContact& contact)
-		{
-			return contact.GetIndexA() < 0 || contact.GetIndexB() < 0;
-		}
-		static bool IsBodyContactInvalid(const b2ParticleBodyContact& contact)
-		{
-			return contact.index < 0;
-		}
-		static bool IsPairInvalid(const b2ParticlePair& pair)
-		{
-			return pair.indexA < 0 || pair.indexB < 0;
-		}
-		static bool IsTriadInvalid(const b2ParticleTriad& triad)
-		{
-			return triad.indexA < 0 || triad.indexB < 0 || triad.indexC < 0;
-		}
-	};
-
-	// update proxies
-	for (int32 k = 0; k < m_proxyBuffer.GetCount(); k++)
-	{
-		Proxy& proxy = m_proxyBuffer.Begin()[k];
-		proxy.index = newIndices[proxy.index];
-	}
-	m_proxyBuffer.RemoveIf(Test::IsProxyInvalid);
-
-	// update contacts
-	for (int32 k = 0; k < m_contactBuffer.GetCount(); k++)
-	{
-		b2ParticleContact& contact = m_contactBuffer[k];
-		contact.SetIndices(newIndices[contact.GetIndexA()],
-						   newIndices[contact.GetIndexB()]);
-	}
-	m_contactBuffer.RemoveIf(Test::IsContactInvalid);
-
-	// update particle-body contacts
-	for (int32 k = 0; k < m_bodyContactBuffer.GetCount(); k++)
-	{
-		b2ParticleBodyContact& contact = m_bodyContactBuffer[k];
-		contact.index = newIndices[contact.index];
-	}
-	m_bodyContactBuffer.RemoveIf(Test::IsBodyContactInvalid);
-
-	// update pairs
-	for (int32 k = 0; k < m_pairBuffer.GetCount(); k++)
-	{
-		b2ParticlePair& pair = m_pairBuffer[k];
-		pair.indexA = newIndices[pair.indexA];
-		pair.indexB = newIndices[pair.indexB];
-	}
-	m_pairBuffer.RemoveIf(Test::IsPairInvalid);
-
-	// update triads
-	for (int32 k = 0; k < m_triadBuffer.GetCount(); k++)
-	{
-		b2ParticleTriad& triad = m_triadBuffer[k];
-		triad.indexA = newIndices[triad.indexA];
-		triad.indexB = newIndices[triad.indexB];
-		triad.indexC = newIndices[triad.indexC];
-	}
-	m_triadBuffer.RemoveIf(Test::IsTriadInvalid);
-
-	// Update lifetime indices.
-	if (m_indexByExpirationTimeBuffer.data)
-	{
-		int32 writeOffset = 0;
-		for (int32 readOffset = 0; readOffset < m_count; readOffset++)
-		{
-			const int32 newIndex = newIndices[
-				m_indexByExpirationTimeBuffer.data[readOffset]];
-			if (newIndex != b2_invalidParticleIndex)
-			{
-				m_indexByExpirationTimeBuffer.data[writeOffset++] = newIndex;
-			}
-		}
-	}
-
-	// update groups
-	for (b2ParticleGroup* group = m_groupList; group; group = group->GetNext())
-	{
-		int32 firstIndex = newCount;
-		int32 lastIndex = 0;
-		bool modified = false;
-		for (int32 i = group->m_firstIndex; i < group->m_lastIndex; i++)
-		{
-			int32 j = newIndices[i];
-			if (j >= 0) {
-				firstIndex = b2Min(firstIndex, j);
-				lastIndex = b2Max(lastIndex, j + 1);
-			} else {
-				modified = true;
-			}
-		}
-		if (firstIndex < lastIndex)
-		{
-			group->m_firstIndex = firstIndex;
-			group->m_lastIndex = lastIndex;
-			if (modified)
-			{
-				if (group->m_groupFlags & b2_solidParticleGroup)
-				{
-					SetGroupFlags(group,
-								  group->m_groupFlags |
-								  b2_particleGroupNeedsUpdateDepth);
-				}
-			}
-		}
-		else
-		{
-			group->m_firstIndex = 0;
-			group->m_lastIndex = 0;
-			if (!(group->m_groupFlags & b2_particleGroupCanBeEmpty))
-			{
-				SetGroupFlags(group,
-					group->m_groupFlags | b2_particleGroupWillBeDestroyed);
-			}
-		}
-	}
-
-	// update particle count
-	m_count = newCount;
-	m_world->m_stackAllocator.Free(newIndices);
-	m_allParticleFlags = allParticleFlags;
-	m_needsUpdateAllParticleFlags = false;
-
-	// destroy bodies with no particles
-	for (b2ParticleGroup* group = m_groupList; group;)
-	{
-		b2ParticleGroup* next = group->GetNext();
-		if (group->m_groupFlags & b2_particleGroupWillBeDestroyed)
-		{
-			DestroyParticleGroup(group);
-		}
-		group = next;
-	}
-}
-
-/// Destroy all particles which have outlived their lifetimes set by
-/// SetParticleLifetime().
-void b2ParticleSystem::SolveLifetimes(const b2TimeStep& step)
-{
-	b2Assert(m_expirationTimeBuffer.data);
-	b2Assert(m_indexByExpirationTimeBuffer.data);
-	// Update the time elapsed.
-	m_timeElapsed = LifetimeToExpirationTime(step.dt);
-	// Get the floor (non-fractional component) of the elapsed time.
-	const int32 quantizedTimeElapsed = GetQuantizedTimeElapsed();
-
-	const int32* const expirationTimes = m_expirationTimeBuffer.data;
-	int32* const expirationTimeIndices = m_indexByExpirationTimeBuffer.data;
-	const int32 particleCount = GetParticleCount();
-	// Sort the lifetime buffer if it's required.
-	if (m_expirationTimeBufferRequiresSorting)
-	{
-		const ExpirationTimeComparator expirationTimeComparator(
-			expirationTimes);
-		std::sort(expirationTimeIndices,
-				  expirationTimeIndices + particleCount,
-				  expirationTimeComparator);
-		m_expirationTimeBufferRequiresSorting = false;
-	}
-
-	// Destroy particles which have expired.
-	for (int32 i = particleCount - 1; i >= 0; --i)
-	{
-		const int32 particleIndex = expirationTimeIndices[i];
-		const int32 expirationTime = expirationTimes[particleIndex];
-		// If no particles need to be destroyed, skip this.
-		if (quantizedTimeElapsed < expirationTime || expirationTime <= 0)
-		{
-			break;
-		}
-		// Destroy this particle.
-		DestroyParticle(particleIndex);
-	}
-}
-
-void b2ParticleSystem::RotateBuffer(int32 start, int32 mid, int32 end)
-{
-	// move the particles assigned to the given group toward the end of array
-	if (start == mid || mid == end)
-	{
-		return;
-	}
-	b2Assert(mid >= start && mid <= end);
-	struct NewIndices
-	{
-		int32 operator[](int32 i) const
-		{
-			if (i < start)
-			{
-				return i;
-			}
-			else if (i < mid)
-			{
-				return i + end - mid;
-			}
-			else if (i < end)
-			{
-				return i + start - mid;
-			}
-			else
-			{
-				return i;
-			}
-		}
-		int32 start, mid, end;
-	} newIndices;
-	newIndices.start = start;
-	newIndices.mid = mid;
-	newIndices.end = end;
-
-	std::rotate(m_flagsBuffer.data + start, m_flagsBuffer.data + mid,
-				m_flagsBuffer.data + end);
-	if (m_lastBodyContactStepBuffer.data)
-	{
-		std::rotate(m_lastBodyContactStepBuffer.data + start,
-					m_lastBodyContactStepBuffer.data + mid,
-					m_lastBodyContactStepBuffer.data + end);
-	}
-	if (m_bodyContactCountBuffer.data)
-	{
-		std::rotate(m_bodyContactCountBuffer.data + start,
-					m_bodyContactCountBuffer.data + mid,
-					m_bodyContactCountBuffer.data + end);
-	}
-	if (m_consecutiveContactStepsBuffer.data)
-	{
-		std::rotate(m_consecutiveContactStepsBuffer.data + start,
-					m_consecutiveContactStepsBuffer.data + mid,
-					m_consecutiveContactStepsBuffer.data + end);
-	}
-	std::rotate(m_positionBuffer.data + start, m_positionBuffer.data + mid,
-				m_positionBuffer.data + end);
-	std::rotate(m_velocityBuffer.data + start, m_velocityBuffer.data + mid,
-				m_velocityBuffer.data + end);
-	std::rotate(m_groupBuffer + start, m_groupBuffer + mid,
-				m_groupBuffer + end);
-	if (m_hasForce)
-	{
-		std::rotate(m_forceBuffer + start, m_forceBuffer + mid,
-					m_forceBuffer + end);
-	}
-	if (m_staticPressureBuffer)
-	{
-		std::rotate(m_staticPressureBuffer + start,
-					m_staticPressureBuffer + mid,
-					m_staticPressureBuffer + end);
-	}
-	if (m_depthBuffer)
-	{
-		std::rotate(m_depthBuffer + start, m_depthBuffer + mid,
-					m_depthBuffer + end);
-	}
-	if (m_colorBuffer.data)
-	{
-		std::rotate(m_colorBuffer.data + start,
-					m_colorBuffer.data + mid, m_colorBuffer.data + end);
-	}
-	if (m_userDataBuffer.data)
-	{
-		std::rotate(m_userDataBuffer.data + start,
-					m_userDataBuffer.data + mid, m_userDataBuffer.data + end);
-	}
-
-	// Update handle indices.
-	if (m_handleIndexBuffer.data)
-	{
-		std::rotate(m_handleIndexBuffer.data + start,
-					m_handleIndexBuffer.data + mid,
-					m_handleIndexBuffer.data + end);
-		for (int32 i = start; i < end; ++i)
-		{
-			b2ParticleHandle * const handle = m_handleIndexBuffer.data[i];
-			if (handle) handle->SetIndex(newIndices[handle->GetIndex()]);
-		}
-	}
-
-	if (m_expirationTimeBuffer.data)
-	{
-		std::rotate(m_expirationTimeBuffer.data + start,
-					m_expirationTimeBuffer.data + mid,
-					m_expirationTimeBuffer.data + end);
-		// Update expiration time buffer indices.
-		const int32 particleCount = GetParticleCount();
-		int32* const indexByExpirationTime =
-			m_indexByExpirationTimeBuffer.data;
-		for (int32 i = 0; i < particleCount; ++i)
-		{
-			indexByExpirationTime[i] = newIndices[indexByExpirationTime[i]];
-		}
-	}
-
-	// update proxies
-	for (int32 k = 0; k < m_proxyBuffer.GetCount(); k++)
-	{
-		Proxy& proxy = m_proxyBuffer.Begin()[k];
-		proxy.index = newIndices[proxy.index];
-	}
-
-	// update contacts
-	for (int32 k = 0; k < m_contactBuffer.GetCount(); k++)
-	{
-		b2ParticleContact& contact = m_contactBuffer[k];
-		contact.SetIndices(newIndices[contact.GetIndexA()],
-						   newIndices[contact.GetIndexB()]);
-	}
-
-	// update particle-body contacts
-	for (int32 k = 0; k < m_bodyContactBuffer.GetCount(); k++)
-	{
-		b2ParticleBodyContact& contact = m_bodyContactBuffer[k];
-		contact.index = newIndices[contact.index];
-	}
-
-	// update pairs
-	for (int32 k = 0; k < m_pairBuffer.GetCount(); k++)
-	{
-		b2ParticlePair& pair = m_pairBuffer[k];
-		pair.indexA = newIndices[pair.indexA];
-		pair.indexB = newIndices[pair.indexB];
-	}
-
-	// update triads
-	for (int32 k = 0; k < m_triadBuffer.GetCount(); k++)
-	{
-		b2ParticleTriad& triad = m_triadBuffer[k];
-		triad.indexA = newIndices[triad.indexA];
-		triad.indexB = newIndices[triad.indexB];
-		triad.indexC = newIndices[triad.indexC];
-	}
-
-	// update groups
-	for (b2ParticleGroup* group = m_groupList; group; group = group->GetNext())
-	{
-		group->m_firstIndex = newIndices[group->m_firstIndex];
-		group->m_lastIndex = newIndices[group->m_lastIndex - 1] + 1;
-	}
-}
-
-/// Set the lifetime (in seconds) of a particle relative to the current
-/// time.
-void b2ParticleSystem::SetParticleLifetime(const int32 index,
-										   const float32 lifetime)
-{
-	b2Assert(ValidateParticleIndex(index));
-	const bool initializeExpirationTimes =
-		m_indexByExpirationTimeBuffer.data == NULL;
-	m_expirationTimeBuffer.data = RequestBuffer(
-		m_expirationTimeBuffer.data);
-	m_indexByExpirationTimeBuffer.data = RequestBuffer(
-		m_indexByExpirationTimeBuffer.data);
-
-	// Initialize the inverse mapping buffer.
-	if (initializeExpirationTimes)
-	{
-		const int32 particleCount = GetParticleCount();
-		for (int32 i = 0; i < particleCount; ++i)
-		{
-			m_indexByExpirationTimeBuffer.data[i] = i;
-		}
-	}
-	const int32 quantizedLifetime = (int32)(lifetime /
-											m_def.lifetimeGranularity);
-	// Use a negative lifetime so that it's possible to track which
-	// of the infinite lifetime particles are older.
-	const int32 newExpirationTime = quantizedLifetime > 0 ?
-		GetQuantizedTimeElapsed() + quantizedLifetime : quantizedLifetime;
-	if (newExpirationTime != m_expirationTimeBuffer.data[index])
-	{
-		m_expirationTimeBuffer.data[index] = newExpirationTime;
-		m_expirationTimeBufferRequiresSorting = true;
-	}
-}
-
-
-/// Convert a lifetime value in returned by GetExpirationTimeBuffer()
-/// to a value in seconds relative to the current simulation time.
-float32 b2ParticleSystem::ExpirationTimeToLifetime(
-	const int32 expirationTime) const
-{
-	return (float32)(expirationTime > 0 ?
-					 	expirationTime - GetQuantizedTimeElapsed() :
-					 	expirationTime) * m_def.lifetimeGranularity;
-}
-
-/// Get the lifetime (in seconds) of a particle relative to the current
-/// time.
-float32 b2ParticleSystem::GetParticleLifetime(const int32 index)
-{
-	b2Assert(ValidateParticleIndex(index));
-	return ExpirationTimeToLifetime(GetExpirationTimeBuffer()[index]);
-}
-
-/// Get the array of particle lifetimes indexed by particle index.
-/// GetParticleCount() items are in the returned array.
-const int32* b2ParticleSystem::GetExpirationTimeBuffer()
-{
-	m_expirationTimeBuffer.data = RequestBuffer(
-		m_expirationTimeBuffer.data);
-	return m_expirationTimeBuffer.data;
-}
-
-/// Get the array of particle indices ordered by lifetime.
-/// GetExpirationTimeBuffer(
-///    GetIndexByExpirationTimeBuffer()[index])
-/// is equivalent to GetParticleLifetime(index).
-/// GetParticleCount() items are in the returned array.
-const int32* b2ParticleSystem::GetIndexByExpirationTimeBuffer()
-{
-	// If particles are present, initialize / reinitialize the lifetime buffer.
-	if (GetParticleCount())
-	{
-		SetParticleLifetime(0, GetParticleLifetime(0));
-	}
-	else
-	{
-		m_indexByExpirationTimeBuffer.data = RequestBuffer(
-			m_indexByExpirationTimeBuffer.data);
-	}
-	return m_indexByExpirationTimeBuffer.data;
-}
-
-void b2ParticleSystem::SetDestructionByAge(const bool enable)
-{
-	if (enable)
-	{
-		GetExpirationTimeBuffer();
-	}
-	m_def.destroyByAge = enable;
-}
-
-/// Get the time elapsed in b2ParticleSystemDef::lifetimeGranularity.
-int32 b2ParticleSystem::GetQuantizedTimeElapsed() const
-{
-	return (int32)(m_timeElapsed >> 32);
-}
-
-/// Convert a lifetime in seconds to an expiration time.
-int64 b2ParticleSystem::LifetimeToExpirationTime(const float32 lifetime) const
-{
-	return m_timeElapsed + (int64)((lifetime / m_def.lifetimeGranularity) *
-								   (float32)(1LL << 32));
-}
-
-template <typename T> void b2ParticleSystem::SetUserOverridableBuffer(
-	UserOverridableBuffer<T>* buffer, T* newData, int32 newCapacity)
-{
-	b2Assert((newData && newCapacity) || (!newData && !newCapacity));
-	if (!buffer->userSuppliedCapacity && buffer->data)
-	{
-		m_world->m_blockAllocator.Free(
-			buffer->data, sizeof(T) * m_internalAllocatedCapacity);
-	}
-	buffer->data = newData;
-	buffer->userSuppliedCapacity = newCapacity;
-}
-
-void b2ParticleSystem::SetFlagsBuffer(uint32* buffer, int32 capacity)
-{
-	SetUserOverridableBuffer(&m_flagsBuffer, buffer, capacity);
-}
-
-void b2ParticleSystem::SetPositionBuffer(b2Vec2* buffer,
-												 int32 capacity)
-{
-	SetUserOverridableBuffer(&m_positionBuffer, buffer, capacity);
-}
-
-void b2ParticleSystem::SetVelocityBuffer(b2Vec2* buffer,
-												 int32 capacity)
-{
-	SetUserOverridableBuffer(&m_velocityBuffer, buffer, capacity);
-}
-
-void b2ParticleSystem::SetColorBuffer(b2ParticleColor* buffer,
-											  int32 capacity)
-{
-	SetUserOverridableBuffer(&m_colorBuffer, buffer, capacity);
-}
-
-void b2ParticleSystem::SetUserDataBuffer(void** buffer, int32 capacity)
-{
-	SetUserOverridableBuffer(&m_userDataBuffer, buffer, capacity);
-}
-
-void b2ParticleSystem::SetParticleFlags(int32 index, uint32 newFlags)
-{
-	uint32* oldFlags = &m_flagsBuffer.data[index];
-	if (*oldFlags & ~newFlags)
-	{
-		// If any flags might be removed
-		m_needsUpdateAllParticleFlags = true;
-	}
-	if (~m_allParticleFlags & newFlags)
-	{
-		// If any flags were added
-		if (newFlags & b2_tensileParticle)
-		{
-			m_accumulation2Buffer = RequestBuffer(
-				m_accumulation2Buffer);
-		}
-		if (newFlags & b2_colorMixingParticle)
-		{
-			m_colorBuffer.data = RequestBuffer(m_colorBuffer.data);
-		}
-		m_allParticleFlags |= newFlags;
-	}
-	*oldFlags = newFlags;
-}
-
-void b2ParticleSystem::SetGroupFlags(
-	b2ParticleGroup* group, uint32 newFlags)
-{
-	uint32* oldFlags = &group->m_groupFlags;
-	if ((*oldFlags ^ newFlags) & b2_solidParticleGroup)
-	{
-		// If the b2_solidParticleGroup flag changed schedule depth update.
-		newFlags |= b2_particleGroupNeedsUpdateDepth;
-	}
-	if (*oldFlags & ~newFlags)
-	{
-		// If any flags might be removed
-		m_needsUpdateAllGroupFlags = true;
-	}
-	if (~m_allGroupFlags & newFlags)
-	{
-		// If any flags were added
-		if (newFlags & b2_solidParticleGroup)
-		{
-			m_depthBuffer = RequestBuffer(m_depthBuffer);
-		}
-		m_allGroupFlags |= newFlags;
-	}
-	*oldFlags = newFlags;
-}
-
-static inline bool IsSignificantForce(const b2Vec2& force)
-{
-	return force.x != 0 || force.y != 0;
-}
-
-inline bool b2ParticleSystem::ForceCanBeApplied(uint32 flags) const
-{
-	return !(flags & b2_wallParticle);
-}
-
-inline void b2ParticleSystem::PrepareForceBuffer()
-{
-	if (!m_hasForce)
-	{
-		memset((void *)m_forceBuffer, 0, sizeof(*m_forceBuffer) * m_count);
-		m_hasForce = true;
-	}
-}
-
-void b2ParticleSystem::ApplyForce(int32 firstIndex, int32 lastIndex,
-								  const b2Vec2& force)
-{
-	// Ensure we're not trying to apply force to particles that can't move,
-	// such as wall particles.
-#if B2_ASSERT_ENABLED
-	uint32 flags = 0;
-	for (int32 i = firstIndex; i < lastIndex; i++)
-	{
-		flags |= m_flagsBuffer.data[i];
-	}
-	b2Assert(ForceCanBeApplied(flags));
-#endif
-
-	// Early out if force does nothing (optimization).
-	const b2Vec2 distributedForce = force / (float32)(lastIndex - firstIndex);
-	if (IsSignificantForce(distributedForce))
-	{
-		PrepareForceBuffer();
-
-		// Distribute the force over all the particles.
-		for (int32 i = firstIndex; i < lastIndex; i++)
-		{
-			m_forceBuffer[i] += distributedForce;
-		}
-	}
-}
-
-void b2ParticleSystem::ParticleApplyForce(int32 index, const b2Vec2& force)
-{
-	if (IsSignificantForce(force) &&
-		ForceCanBeApplied(m_flagsBuffer.data[index]))
-	{
-		PrepareForceBuffer();
-		m_forceBuffer[index] += force;
-	}
-}
-
-void b2ParticleSystem::ApplyLinearImpulse(int32 firstIndex, int32 lastIndex,
-										  const b2Vec2& impulse)
-{
-	const float32 numParticles = (float32)(lastIndex - firstIndex);
-	const float32 totalMass = numParticles * GetParticleMass();
-	const b2Vec2 velocityDelta = impulse / totalMass;
-	for (int32 i = firstIndex; i < lastIndex; i++)
-	{
-		m_velocityBuffer.data[i] += velocityDelta;
-	}
-}
-
-void b2ParticleSystem::QueryAABB(b2QueryCallback* callback,
-								 const b2AABB& aabb) const
-{
-	if (m_proxyBuffer.GetCount() == 0)
-	{
-		return;
-	}
-	const Proxy* beginProxy = m_proxyBuffer.Begin();
-	const Proxy* endProxy = m_proxyBuffer.End();
-	const Proxy* firstProxy = std::lower_bound(
-		beginProxy, endProxy,
-		computeTag(
-			m_inverseDiameter * aabb.lowerBound.x,
-			m_inverseDiameter * aabb.lowerBound.y));
-	const Proxy* lastProxy = std::upper_bound(
-		firstProxy, endProxy,
-		computeTag(
-			m_inverseDiameter * aabb.upperBound.x,
-			m_inverseDiameter * aabb.upperBound.y));
-	for (const Proxy* proxy = firstProxy; proxy < lastProxy; ++proxy)
-	{
-		int32 i = proxy->index;
-		const b2Vec2& p = m_positionBuffer.data[i];
-		if (aabb.lowerBound.x < p.x && p.x < aabb.upperBound.x &&
-			aabb.lowerBound.y < p.y && p.y < aabb.upperBound.y)
-		{
-			if (!callback->ReportParticle(this, i))
-			{
-				break;
-			}
-		}
-	}
-}
-
-void b2ParticleSystem::QueryShapeAABB(b2QueryCallback* callback,
-									  const b2Shape& shape,
-									  const b2Transform& xf) const
-{
-	b2AABB aabb;
-	shape.ComputeAABB(&aabb, xf, 0);
-	QueryAABB(callback, aabb);
-}
-
-void b2ParticleSystem::RayCast(b2RayCastCallback* callback,
-							   const b2Vec2& point1,
-							   const b2Vec2& point2) const
-{
-	if (m_proxyBuffer.GetCount() == 0)
-	{
-		return;
-	}
-	b2AABB aabb;
-	aabb.lowerBound = b2Min(point1, point2);
-	aabb.upperBound = b2Max(point1, point2);
-	float32 fraction = 1;
-	// solving the following equation:
-	// ((1-t)*point1+t*point2-position)^2=diameter^2
-	// where t is a potential fraction
-	b2Vec2 v = point2 - point1;
-	float32 v2 = b2Dot(v, v);
-	InsideBoundsEnumerator enumerator = GetInsideBoundsEnumerator(aabb);
-	int32 i;
-	while ((i = enumerator.GetNext()) >= 0)
-	{
-		b2Vec2 p = point1 - m_positionBuffer.data[i];
-		float32 pv = b2Dot(p, v);
-		float32 p2 = b2Dot(p, p);
-		float32 determinant = pv * pv - v2 * (p2 - m_squaredDiameter);
-		if (determinant >= 0)
-		{
-			float32 sqrtDeterminant = b2Sqrt(determinant);
-			// find a solution between 0 and fraction
-			float32 t = (-pv - sqrtDeterminant) / v2;
-			if (t > fraction)
-			{
-				continue;
-			}
-			if (t < 0)
-			{
-				t = (-pv + sqrtDeterminant) / v2;
-				if (t < 0 || t > fraction)
-				{
-					continue;
-				}
-			}
-			b2Vec2 n = p + t * v;
-			n.Normalize();
-			float32 f = callback->ReportParticle(this, i, point1 + t * v, n, t);
-			fraction = b2Min(fraction, f);
-			if (fraction <= 0)
-			{
-				break;
-			}
-		}
-	}
-}
-
-float32 b2ParticleSystem::ComputeCollisionEnergy() const
-{
-	float32 sum_v2 = 0;
-	for (int32 k = 0; k < m_contactBuffer.GetCount(); k++)
-	{
-		const b2ParticleContact& contact = m_contactBuffer[k];
-		int32 a = contact.GetIndexA();
-		int32 b = contact.GetIndexB();
-		b2Vec2 n = contact.GetNormal();
-		b2Vec2 v = m_velocityBuffer.data[b] - m_velocityBuffer.data[a];
-		float32 vn = b2Dot(v, n);
-		if (vn < 0)
-		{
-			sum_v2 += vn * vn;
-		}
-	}
-	return 0.5f * GetParticleMass() * sum_v2;
-}
-
-void b2ParticleSystem::SetStuckThreshold(int32 steps)
-{
-	m_stuckThreshold = steps;
-
-	if (steps > 0)
-	{
-		m_lastBodyContactStepBuffer.data = RequestBuffer(
-			m_lastBodyContactStepBuffer.data);
-		m_bodyContactCountBuffer.data = RequestBuffer(
-			m_bodyContactCountBuffer.data);
-		m_consecutiveContactStepsBuffer.data = RequestBuffer(
-			m_consecutiveContactStepsBuffer.data);
-	}
-}
-
-#if LIQUIDFUN_EXTERNAL_LANGUAGE_API
-
-b2ParticleSystem::b2ExceptionType b2ParticleSystem::IsBufCopyValid(
-	int startIndex, int numParticles, int copySize, int bufSize) const
-{
-	const int maxNumParticles = GetParticleCount();
-
-	// are we actually copying?
-	if (copySize == 0)
-	{
-		return b2_noExceptions;
-	}
-
-	// is the index out of bounds?
-	if (startIndex < 0 ||
-		startIndex >= maxNumParticles ||
-		numParticles < 0 ||
-		numParticles + startIndex > maxNumParticles)
-	{
-		return b2_particleIndexOutOfBounds;
-	}
-
-	// are we copying within the boundaries?
-	if (copySize > bufSize)
-	{
-		return b2_bufferTooSmall;
-	}
-
-	return b2_noExceptions;
-}
-
-#endif // LIQUIDFUN_EXTERNAL_LANGUAGE_API
+/*
+* Copyright (c) 2013 Google, Inc.
+*
+* This software is provided 'as-is', without any express or implied
+* warranty.  In no event will the authors be held liable for any damages
+* arising from the use of this software.
+* Permission is granted to anyone to use this software for any purpose,
+* including commercial applications, and to alter it and redistribute it
+* freely, subject to the following restrictions:
+* 1. The origin of this software must not be misrepresented; you must not
+* claim that you wrote the original software. If you use this software
+* in a product, an acknowledgment in the product documentation would be
+* appreciated but is not required.
+* 2. Altered source versions must be plainly marked as such, and must not be
+* misrepresented as being the original software.
+* 3. This notice may not be removed or altered from any source distribution.
+*/
+#include <Box2D/Particle/b2ParticleSystem.h>
+#include <Box2D/Particle/b2ParticleGroup.h>
+#include <Box2D/Particle/b2VoronoiDiagram.h>
+#include <Box2D/Particle/b2ParticleAssembly.h>
+#include <Box2D/Common/b2BlockAllocator.h>
+#include <Box2D/Dynamics/b2World.h>
+#include <Box2D/Dynamics/b2WorldCallbacks.h>
+#include <Box2D/Dynamics/b2Body.h>
+#include <Box2D/Dynamics/b2Fixture.h>
+#include <Box2D/Collision/Shapes/b2Shape.h>
+#include <Box2D/Collision/Shapes/b2EdgeShape.h>
+#include <Box2D/Collision/Shapes/b2ChainShape.h>
+#include <algorithm>
+
+#ifdef LIQUIDFUN_SIMD_NEON
+
+static uint32 hasNeon = 1;
+
+#if defined(ANDROID) && !defined(__ARM_NEON__)
+
+#include "cpu-features.h"
+static uint64_t cpuFeatures = 0;
+
+#endif
+
+#endif
+
+// Define LIQUIDFUN_SIMD_TEST_VS_REFERENCE to run both SIMD and reference
+// versions, and assert that the results are identical. This is useful when
+// modifying one of the functions, to help verify correctness.
+// #define LIQUIDFUN_SIMD_TEST_VS_REFERENCE
+
+// For ease of debugging, remove 'inline'. Then, when an assert hits in the
+// test-vs-reference functions, you can easily jump the instruction pointer
+// to the top of the function to re-run the test.
+#define LIQUIDFUN_SIMD_INLINE inline
+
+
+static const uint32 xTruncBits = 12;
+static const uint32 yTruncBits = 12;
+static const uint32 tagBits = 8u * sizeof(uint32);
+static const uint32 yOffset = 1u << (yTruncBits - 1u);
+static const uint32 yShift = tagBits - yTruncBits;
+static const uint32 xShift = tagBits - yTruncBits - xTruncBits;
+static const uint32 xScale = 1u << xShift;
+static const uint32 xOffset = xScale * (1u << (xTruncBits - 1u));
+static const uint32 yMask = ((1u << yTruncBits) - 1u) << yShift;
+static const uint32 xMask = ~yMask;
+static const uint32 relativeTagRight = 1u << xShift;
+
+#if defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wshift-negative-value"
+#endif //__clang__
+static const uint32 relativeTagBottomLeft = (uint32)((1 << yShift) +
+                                                    (-1 << xShift));
+#if defined(__clang__)
+#pragma GCC diagnostic pop
+#endif //__clang__
+
+static const uint32 relativeTagBottomRight = (1u << yShift) + (1u << xShift);
+
+// This functor is passed to std::remove_if in RemoveSpuriousBodyContacts
+// to implement the algorithm described there.  It was hoisted out and friended
+// as it would not compile with g++ 4.6.3 as a local class.  It is only used in
+// that function.
+class b2ParticleBodyContactRemovePredicate
+{
+public:
+	b2ParticleBodyContactRemovePredicate(b2ParticleSystem* system,
+										 int32* discarded)
+		: m_system(system), m_lastIndex(-1), m_currentContacts(0),
+		  m_discarded(discarded) {}
+
+	bool operator()(const b2ParticleBodyContact& contact)
+	{
+		// This implements the selection criteria described in
+		// RemoveSpuriousBodyContacts().
+		// This functor is iterating through a list of Body contacts per
+		// Particle, ordered from near to far.  For up to the maximum number of
+		// contacts we allow per point per step, we verify that the contact
+		// normal of the Body that genenerated the contact makes physical sense
+		// by projecting a point back along that normal and seeing if it
+		// intersects the fixture generating the contact.
+
+		if (contact.index != m_lastIndex)
+		{
+			m_currentContacts = 0;
+			m_lastIndex = contact.index;
+		}
+
+		if (m_currentContacts++ > k_maxContactsPerPoint)
+		{
+			++(*m_discarded);
+			return true;
+		}
+
+		// Project along inverse normal (as returned in the contact) to get the
+		// point to check.
+		b2Vec2 n = contact.normal;
+		// weight is 1-(inv(diameter) * distance)
+		n *= m_system->m_particleDiameter * (1 - contact.weight);
+		b2Vec2 pos = m_system->m_positionBuffer.data[contact.index] + n;
+
+		// pos is now a point projected back along the contact normal to the
+		// contact distance. If the surface makes sense for a contact, pos will
+		// now lie on or in the fixture generating
+		if (!contact.fixture->TestPoint(pos))
+		{
+			int32 childCount = contact.fixture->GetShape()->GetChildCount();
+			for (int32 childIndex = 0; childIndex < childCount; childIndex++)
+			{
+				float32 distance;
+				b2Vec2 normal;
+				contact.fixture->ComputeDistance(pos, &distance, &normal,
+																	childIndex);
+				if (distance < b2_linearSlop)
+				{
+					return false;
+				}
+			}
+			++(*m_discarded);
+			return true;
+		}
+
+		return false;
+	}
+private:
+	// Max number of contacts processed per particle, from nearest to farthest.
+	// This must be at least 2 for correctness with concave shapes; 3 was
+	// experimentally arrived at as looking reasonable.
+	static const int32 k_maxContactsPerPoint = 3;
+	const b2ParticleSystem* m_system;
+	// Index of last particle processed.
+	int32 m_lastIndex;
+	// Number of contacts processed for the current particle.
+	int32 m_currentContacts;
+	// Output the number of discarded contacts.
+	int32* m_discarded;
+};
+
+namespace {
+
+// Compares the expiration time of two particle indices.
+class ExpirationTimeComparator
+{
+public:
+	// Initialize the class with a pointer to an array of particle
+	// lifetimes.
+	ExpirationTimeComparator(const int32* const expirationTimes) :
+		m_expirationTimes(expirationTimes)
+	{
+	}
+	// Empty destructor.
+	~ExpirationTimeComparator() { }
+
+	// Compare the lifetime of particleIndexA and particleIndexB
+	// returning true if the lifetime of A is greater than B for particles
+	// that will expire.  If either particle's lifetime is infinite (<= 0.0f)
+	// this function return true if the lifetime of A is lesser than B.
+	// When used with std::sort() this results in an array of particle
+	// indicies sorted in reverse order by particle lifetime.
+	// For example, the set of lifetimes
+	// (1.0, 0.7, 0.3, 0.0, -1.0, -2.0)
+	// would be sorted as
+	// (0.0, -1.0, -2.0, 1.0, 0.7, 0.3)
+	bool operator() (const int32 particleIndexA,
+					 const int32 particleIndexB) const
+	{
+		const int32 expirationTimeA = m_expirationTimes[particleIndexA];
+		const int32 expirationTimeB = m_expirationTimes[particleIndexB];
+		const bool infiniteExpirationTimeA = expirationTimeA <= 0.0f;
+		const bool infiniteExpirationTimeB = expirationTimeB <= 0.0f;
+		return infiniteExpirationTimeA == infiniteExpirationTimeB ?
+			expirationTimeA > expirationTimeB : infiniteExpirationTimeA;
+	}
+
+private:
+	const int32* m_expirationTimes;
+};
+
+// *Very* lightweight pair implementation.
+template<typename A, typename B>
+struct LightweightPair
+{
+	A first;
+	B second;
+
+	// Compares the value of two FixtureParticle objects returning
+	// true if left is a smaller value than right.
+	static bool Compare(const LightweightPair& left,
+						const LightweightPair& right)
+	{
+		return left.first < right.first &&
+			left.second < right.second;
+	}
+
+};
+
+// Allocator for a fixed set of items.
+class FixedSetAllocator
+{
+public:
+	// Associate a memory allocator with this object.
+	FixedSetAllocator(b2StackAllocator* allocator);
+	// Deallocate storage for this class.
+	~FixedSetAllocator()
+	{
+		Clear();
+	}
+
+	// Allocate internal storage for this object returning the size.
+	int32 Allocate(const int32 itemSize, const int32 count);
+
+	// Deallocate the internal buffer if it's allocated.
+	void Clear();
+
+	// Get the number of items in the set.
+	int32 GetCount() const { return m_count; }
+
+	// Invalidate an item from the set by index.
+	void Invalidate(const int32 itemIndex)
+	{
+		b2Assert(m_valid);
+		m_valid[itemIndex] = 0;
+	}
+
+	// Get the buffer which indicates whether items are valid in the set.
+	const int8* GetValidBuffer() const { return m_valid; }
+
+protected:
+	// Get the internal buffer.
+	void* GetBuffer() const { return m_buffer; }
+	void* GetBuffer() { return m_buffer; }
+
+	// Reduce the number of items in the set.
+	void SetCount(int32 count)
+	{
+		b2Assert(count <= m_count);
+		m_count = count;
+	}
+
+private:
+	// Set buffer.
+	void* m_buffer;
+	// Array of size m_count which indicates whether an item is in the
+	// corresponding index of m_set (1) or the item is invalid (0).
+	int8* m_valid;
+	// Number of items in m_set.
+	int32 m_count;
+	// Allocator used to allocate / free the set.
+	b2StackAllocator* m_allocator;
+};
+
+// Allocator for a fixed set of objects.
+template<typename T>
+class TypedFixedSetAllocator : public FixedSetAllocator
+{
+public:
+	// Initialize members of this class.
+	TypedFixedSetAllocator(b2StackAllocator* allocator) :
+		FixedSetAllocator(allocator) { }
+
+	// Allocate a set of objects, returning the new size of the set.
+	int32 Allocate(const int32 numberOfObjects)
+	{
+		Clear();
+		return FixedSetAllocator::Allocate(sizeof(T), numberOfObjects);
+	}
+
+	// Get the index of an item in the set if it's valid return an index
+	// >= 0, -1 otherwise.
+	int32 GetIndex(const T* item) const
+	{
+		if (item)
+		{
+			b2Assert(item >= GetBuffer() &&
+					 item < GetBuffer() + GetCount());
+			const int32 index =
+				(int32)(((uint8*)item - (uint8*)GetBuffer()) /
+						sizeof(*item));
+			if (GetValidBuffer()[index])
+			{
+				return index;
+			}
+		}
+		return -1;
+	}
+
+	// Get the internal buffer.
+	const T* GetBuffer() const
+	{
+		return (const T*)FixedSetAllocator::GetBuffer();
+	}
+	T* GetBuffer() { return (T*)FixedSetAllocator::GetBuffer(); }
+};
+
+// Associates a fixture with a particle index.
+typedef LightweightPair<b2Fixture*,int32> FixtureParticle;
+
+// Associates a fixture with a particle index.
+typedef LightweightPair<int32,int32> ParticlePair;
+
+}  // namespace
+
+// Set of fixture / particle indices.
+class FixtureParticleSet :
+	public TypedFixedSetAllocator<FixtureParticle>
+{
+public:
+	// Initialize members of this class.
+	FixtureParticleSet(b2StackAllocator* allocator) :
+		TypedFixedSetAllocator<FixtureParticle>(allocator) { }
+
+
+	// Initialize from a set of particle / body contacts for particles
+	// that have the b2_fixtureContactListenerParticle flag set.
+	void Initialize(const b2ParticleBodyContact * const bodyContacts,
+					const int32 numBodyContacts,
+					const uint32 * const particleFlagsBuffer);
+
+	// Find the index of a particle / fixture pair in the set or -1
+	// if it's not present.
+	// NOTE: This was not written as a template function to avoid
+	// exposing any dependencies via this header.
+	int32 Find(const FixtureParticle& fixtureParticle) const;
+};
+
+// Set of particle / particle pairs.
+class b2ParticlePairSet : public TypedFixedSetAllocator<ParticlePair>
+{
+public:
+	// Initialize members of this class.
+	b2ParticlePairSet(b2StackAllocator* allocator) :
+		TypedFixedSetAllocator<ParticlePair>(allocator) { }
+
+	// Initialize from a set of particle contacts.
+	void Initialize(const b2ParticleContact * const contacts,
+					const int32 numContacts,
+					const uint32 * const particleFlagsBuffer);
+
+	// Find the index of a particle pair in the set or -1
+	// if it's not present.
+	// NOTE: This was not written as a template function to avoid
+	// exposing any dependencies via this header.
+	int32 Find(const ParticlePair& pair) const;
+};
+
+static inline uint32 computeTag(float32 x, float32 y)
+{
+	return ((uint32)(y + yOffset) << yShift) + (uint32)(xScale * x + xOffset);
+}
+
+static inline uint32 computeRelativeTag(uint32 tag, int32 x, int32 y)
+{
+	return tag + (y << yShift) + (x << xShift);
+}
+
+b2ParticleSystem::InsideBoundsEnumerator::InsideBoundsEnumerator(
+	uint32 lower, uint32 upper, const Proxy* first, const Proxy* last)
+{
+	m_xLower = lower & xMask;
+	m_xUpper = upper & xMask;
+	m_yLower = lower & yMask;
+	m_yUpper = upper & yMask;
+	m_first = first;
+	m_last = last;
+	b2Assert(m_first <= m_last);
+}
+
+int32 b2ParticleSystem::InsideBoundsEnumerator::GetNext()
+{
+	while (m_first < m_last)
+	{
+		uint32 xTag = m_first->tag & xMask;
+#if B2_ASSERT_ENABLED
+		uint32 yTag = m_first->tag & yMask;
+		b2Assert(yTag >= m_yLower);
+		b2Assert(yTag <= m_yUpper);
+#endif
+		if (xTag >= m_xLower && xTag <= m_xUpper)
+		{
+			return (m_first++)->index;
+		}
+		m_first++;
+	}
+	return b2_invalidParticleIndex;
+}
+
+b2ParticleSystem::b2ParticleSystem(const b2ParticleSystemDef* def,
+								   b2World* world) :
+	m_handleAllocator(b2_minParticleSystemBufferCapacity),
+	m_stuckParticleBuffer(world->m_blockAllocator),
+	m_proxyBuffer(world->m_blockAllocator),
+	m_contactBuffer(world->m_blockAllocator),
+	m_bodyContactBuffer(world->m_blockAllocator),
+	m_pairBuffer(world->m_blockAllocator),
+	m_triadBuffer(world->m_blockAllocator)
+{
+	b2Assert(def);
+	m_paused = false;
+	m_timestamp = 0;
+	m_allParticleFlags = 0;
+	m_needsUpdateAllParticleFlags = false;
+	m_allGroupFlags = 0;
+	m_needsUpdateAllGroupFlags = false;
+	m_hasForce = false;
+	m_iterationIndex = 0;
+
+	SetStrictContactCheck(def->strictContactCheck);
+	SetDensity(def->density);
+	SetGravityScale(def->gravityScale);
+	SetRadius(def->radius);
+	SetMaxParticleCount(def->maxCount);
+
+	m_count = 0;
+	m_internalAllocatedCapacity = 0;
+	m_forceBuffer = NULL;
+	m_weightBuffer = NULL;
+	m_staticPressureBuffer = NULL;
+	m_accumulationBuffer = NULL;
+	m_accumulation2Buffer = NULL;
+	m_depthBuffer = NULL;
+	m_groupBuffer = NULL;
+
+	m_groupCount = 0;
+	m_groupList = NULL;
+
+	b2Assert(def->lifetimeGranularity > 0.0f);
+	m_def = *def;
+
+	m_world = world;
+
+	m_stuckThreshold = 0;
+
+	m_timeElapsed = 0;
+	m_expirationTimeBufferRequiresSorting = false;
+
+	SetDestructionByAge(m_def.destroyByAge);
+
+#if defined(LIQUIDFUN_SIMD_NEON) && defined(ANDROID) && !defined(__ARM_NEON__)
+  if (cpuFeatures == 0 && hasNeon)
+  {
+    cpuFeatures = android_getCpuFeatures();
+    hasNeon = cpuFeatures & ANDROID_CPU_ARM_FEATURE_NEON;
+  }
+#endif
+}
+
+b2ParticleSystem::~b2ParticleSystem()
+{
+	while (m_groupList)
+	{
+		DestroyParticleGroup(m_groupList);
+	}
+
+	FreeUserOverridableBuffer(&m_handleIndexBuffer);
+	FreeUserOverridableBuffer(&m_flagsBuffer);
+	FreeUserOverridableBuffer(&m_lastBodyContactStepBuffer);
+	FreeUserOverridableBuffer(&m_bodyContactCountBuffer);
+	FreeUserOverridableBuffer(&m_consecutiveContactStepsBuffer);
+	FreeUserOverridableBuffer(&m_positionBuffer);
+	FreeUserOverridableBuffer(&m_velocityBuffer);
+	FreeUserOverridableBuffer(&m_colorBuffer);
+	FreeUserOverridableBuffer(&m_userDataBuffer);
+	FreeUserOverridableBuffer(&m_expirationTimeBuffer);
+	FreeUserOverridableBuffer(&m_indexByExpirationTimeBuffer);
+	FreeBuffer(&m_forceBuffer, m_internalAllocatedCapacity);
+	FreeBuffer(&m_weightBuffer, m_internalAllocatedCapacity);
+	FreeBuffer(&m_staticPressureBuffer, m_internalAllocatedCapacity);
+	FreeBuffer(&m_accumulationBuffer, m_internalAllocatedCapacity);
+	FreeBuffer(&m_accumulation2Buffer, m_internalAllocatedCapacity);
+	FreeBuffer(&m_depthBuffer, m_internalAllocatedCapacity);
+	FreeBuffer(&m_groupBuffer, m_internalAllocatedCapacity);
+}
+
+template <typename T> void b2ParticleSystem::FreeBuffer(T** b, int capacity)
+{
+	if (*b == NULL)
+		return;
+
+	m_world->m_blockAllocator.Free(*b, sizeof(**b) * capacity);
+	*b = NULL;
+}
+
+// Free buffer, if it was allocated with b2World's block allocator
+template <typename T> void b2ParticleSystem::FreeUserOverridableBuffer(
+	UserOverridableBuffer<T>* b)
+{
+	if (b->userSuppliedCapacity == 0)
+	{
+		FreeBuffer(&b->data, m_internalAllocatedCapacity);
+	}
+}
+
+// Reallocate a buffer
+template <typename T> T* b2ParticleSystem::ReallocateBuffer(
+	T* oldBuffer, int32 oldCapacity, int32 newCapacity)
+{
+	b2Assert(newCapacity > oldCapacity);
+	T* newBuffer = (T*) m_world->m_blockAllocator.Allocate(
+		sizeof(T) * newCapacity);
+	if (oldBuffer)
+	{
+		memcpy((void *)newBuffer, oldBuffer, sizeof(T) * oldCapacity);
+		m_world->m_blockAllocator.Free(oldBuffer, sizeof(T) * oldCapacity);
+	}
+	return newBuffer;
+}
+
+// Reallocate a buffer
+template <typename T> T* b2ParticleSystem::ReallocateBuffer(
+	T* buffer, int32 userSuppliedCapacity, int32 oldCapacity,
+	int32 newCapacity, bool deferred)
+{
+	b2Assert(newCapacity > oldCapacity);
+	// A 'deferred' buffer is reallocated only if it is not NULL.
+	// If 'userSuppliedCapacity' is not zero, buffer is user supplied and must
+	// be kept.
+	b2Assert(!userSuppliedCapacity || newCapacity <= userSuppliedCapacity);
+	if ((!deferred || buffer) && !userSuppliedCapacity)
+	{
+		buffer = ReallocateBuffer(buffer, oldCapacity, newCapacity);
+	}
+	return buffer;
+}
+
+// Reallocate a buffer
+template <typename T> T* b2ParticleSystem::ReallocateBuffer(
+	UserOverridableBuffer<T>* buffer, int32 oldCapacity, int32 newCapacity,
+	bool deferred)
+{
+	b2Assert(newCapacity > oldCapacity);
+	return ReallocateBuffer(buffer->data, buffer->userSuppliedCapacity,
+							oldCapacity, newCapacity, deferred);
+}
+
+/// Reallocate the handle / index map and schedule the allocation of a new
+/// pool for handle allocation.
+void b2ParticleSystem::ReallocateHandleBuffers(int32 newCapacity)
+{
+	b2Assert(newCapacity > m_internalAllocatedCapacity);
+	// Reallocate a new handle / index map buffer, copying old handle pointers
+	// is fine since they're kept around.
+	m_handleIndexBuffer.data = ReallocateBuffer(
+		&m_handleIndexBuffer, m_internalAllocatedCapacity, newCapacity,
+		true);
+	// Set the size of the next handle allocation.
+	m_handleAllocator.SetItemsPerSlab(newCapacity -
+									  m_internalAllocatedCapacity);
+}
+
+template <typename T> T* b2ParticleSystem::RequestBuffer(T* buffer)
+{
+	if (!buffer)
+	{
+		if (m_internalAllocatedCapacity == 0)
+		{
+			ReallocateInternalAllocatedBuffers(
+				b2_minParticleSystemBufferCapacity);
+		}
+		buffer = (T*) (m_world->m_blockAllocator.Allocate(
+						   sizeof(T) * m_internalAllocatedCapacity));
+		b2Assert(buffer);
+		memset((void *)buffer, 0, sizeof(T) * m_internalAllocatedCapacity);
+	}
+	return buffer;
+}
+
+b2ParticleColor* b2ParticleSystem::GetColorBuffer()
+{
+	m_colorBuffer.data = RequestBuffer(m_colorBuffer.data);
+	return m_colorBuffer.data;
+}
+
+void** b2ParticleSystem::GetUserDataBuffer()
+{
+	m_userDataBuffer.data = RequestBuffer(m_userDataBuffer.data);
+	return m_userDataBuffer.data;
+}
+
+static int32 LimitCapacity(int32 capacity, int32 maxCount)
+{
+	return maxCount && capacity > maxCount ? maxCount : capacity;
+}
+
+void b2ParticleSystem::ReallocateInternalAllocatedBuffers(int32 capacity)
+{
+	// Don't increase capacity beyond the smallest user-supplied buffer size.
+	capacity = LimitCapacity(capacity, m_def.maxCount);
+	capacity = LimitCapacity(capacity, m_flagsBuffer.userSuppliedCapacity);
+	capacity = LimitCapacity(capacity, m_positionBuffer.userSuppliedCapacity);
+	capacity = LimitCapacity(capacity, m_velocityBuffer.userSuppliedCapacity);
+	capacity = LimitCapacity(capacity, m_colorBuffer.userSuppliedCapacity);
+	capacity = LimitCapacity(capacity, m_userDataBuffer.userSuppliedCapacity);
+	if (m_internalAllocatedCapacity < capacity)
+	{
+		ReallocateHandleBuffers(capacity);
+		m_flagsBuffer.data = ReallocateBuffer(
+			&m_flagsBuffer, m_internalAllocatedCapacity, capacity, false);
+
+		// Conditionally defer these as they are optional if the feature is
+		// not enabled.
+		const bool stuck = m_stuckThreshold > 0;
+		m_lastBodyContactStepBuffer.data = ReallocateBuffer(
+			&m_lastBodyContactStepBuffer, m_internalAllocatedCapacity,
+			capacity, stuck);
+		m_bodyContactCountBuffer.data = ReallocateBuffer(
+			&m_bodyContactCountBuffer, m_internalAllocatedCapacity, capacity,
+			stuck);
+		m_consecutiveContactStepsBuffer.data = ReallocateBuffer(
+			&m_consecutiveContactStepsBuffer, m_internalAllocatedCapacity,
+			capacity, stuck);
+		m_positionBuffer.data = ReallocateBuffer(
+			&m_positionBuffer, m_internalAllocatedCapacity, capacity, false);
+		m_velocityBuffer.data = ReallocateBuffer(
+			&m_velocityBuffer, m_internalAllocatedCapacity, capacity, false);
+		m_forceBuffer = ReallocateBuffer(
+			m_forceBuffer, 0, m_internalAllocatedCapacity, capacity, false);
+		m_weightBuffer = ReallocateBuffer(
+			m_weightBuffer, 0, m_internalAllocatedCapacity, capacity, false);
+		m_staticPressureBuffer = ReallocateBuffer(
+			m_staticPressureBuffer, 0, m_internalAllocatedCapacity, capacity,
+			true);
+		m_accumulationBuffer = ReallocateBuffer(
+			m_accumulationBuffer, 0, m_internalAllocatedCapacity, capacity,
+			false);
+		m_accumulation2Buffer = ReallocateBuffer(
+			m_accumulation2Buffer, 0, m_internalAllocatedCapacity, capacity,
+			true);
+		m_depthBuffer = ReallocateBuffer(
+			m_depthBuffer, 0, m_internalAllocatedCapacity, capacity, true);
+		m_colorBuffer.data = ReallocateBuffer(
+			&m_colorBuffer, m_internalAllocatedCapacity, capacity, true);
+		m_groupBuffer = ReallocateBuffer(
+			m_groupBuffer, 0, m_internalAllocatedCapacity, capacity, false);
+		m_userDataBuffer.data = ReallocateBuffer(
+			&m_userDataBuffer, m_internalAllocatedCapacity, capacity, true);
+		m_expirationTimeBuffer.data = ReallocateBuffer(
+			&m_expirationTimeBuffer, m_internalAllocatedCapacity, capacity,
+			true);
+		m_indexByExpirationTimeBuffer.data = ReallocateBuffer(
+			&m_indexByExpirationTimeBuffer, m_internalAllocatedCapacity,
+			capacity, true);
+		m_internalAllocatedCapacity = capacity;
+	}
+}
+
+int32 b2ParticleSystem::CreateParticle(const b2ParticleDef& def)
+{
+	b2Assert(m_world->IsLocked() == false);
+	if (m_world->IsLocked())
+	{
+		return 0;
+	}
+
+	if (m_count >= m_internalAllocatedCapacity)
+	{
+		// Double the particle capacity.
+		int32 capacity =
+			m_count ? 2 * m_count : b2_minParticleSystemBufferCapacity;
+		ReallocateInternalAllocatedBuffers(capacity);
+	}
+	if (m_count >= m_internalAllocatedCapacity)
+	{
+		// If the oldest particle should be destroyed...
+		if (m_def.destroyByAge)
+		{
+			DestroyOldestParticle(0, false);
+			// Need to destroy this particle *now* so that it's possible to
+			// create a new particle.
+			SolveZombie();
+		}
+		else
+		{
+			return b2_invalidParticleIndex;
+		}
+	}
+	int32 index = m_count++;
+	m_flagsBuffer.data[index] = 0;
+	if (m_lastBodyContactStepBuffer.data)
+	{
+		m_lastBodyContactStepBuffer.data[index] = 0;
+	}
+	if (m_bodyContactCountBuffer.data)
+	{
+		m_bodyContactCountBuffer.data[index] = 0;
+	}
+	if (m_consecutiveContactStepsBuffer.data)
+	{
+		m_consecutiveContactStepsBuffer.data[index] = 0;
+	}
+	m_positionBuffer.data[index] = def.position;
+	m_velocityBuffer.data[index] = def.velocity;
+	m_weightBuffer[index] = 0;
+	m_forceBuffer[index] = b2Vec2_zero;
+	if (m_staticPressureBuffer)
+	{
+		m_staticPressureBuffer[index] = 0;
+	}
+	if (m_depthBuffer)
+	{
+		m_depthBuffer[index] = 0;
+	}
+	if (m_colorBuffer.data || !def.color.IsZero())
+	{
+		m_colorBuffer.data = RequestBuffer(m_colorBuffer.data);
+		m_colorBuffer.data[index] = def.color;
+	}
+	if (m_userDataBuffer.data || def.userData)
+	{
+		m_userDataBuffer.data= RequestBuffer(m_userDataBuffer.data);
+		m_userDataBuffer.data[index] = def.userData;
+	}
+	if (m_handleIndexBuffer.data)
+	{
+		m_handleIndexBuffer.data[index] = NULL;
+	}
+	Proxy& proxy = m_proxyBuffer.Append();
+
+	// If particle lifetimes are enabled or the lifetime is set in the particle
+	// definition, initialize the lifetime.
+	const bool finiteLifetime = def.lifetime > 0;
+	if (m_expirationTimeBuffer.data || finiteLifetime)
+	{
+		SetParticleLifetime(index, finiteLifetime ? def.lifetime :
+								ExpirationTimeToLifetime(
+									-GetQuantizedTimeElapsed()));
+		// Add a reference to the newly added particle to the end of the
+		// queue.
+		m_indexByExpirationTimeBuffer.data[index] = index;
+	}
+
+	proxy.index = index;
+	b2ParticleGroup* group = def.group;
+	m_groupBuffer[index] = group;
+	if (group)
+	{
+		if (group->m_firstIndex < group->m_lastIndex)
+		{
+			// Move particles in the group just before the new particle.
+			RotateBuffer(group->m_firstIndex, group->m_lastIndex, index);
+			b2Assert(group->m_lastIndex == index);
+			// Update the index range of the group to contain the new particle.
+			group->m_lastIndex = index + 1;
+		}
+		else
+		{
+			// If the group is empty, reset the index range to contain only the
+			// new particle.
+			group->m_firstIndex = index;
+			group->m_lastIndex = index + 1;
+		}
+	}
+	SetParticleFlags(index, def.flags);
+	return index;
+}
+
+/// Retrieve a handle to the particle at the specified index.
+const b2ParticleHandle* b2ParticleSystem::GetParticleHandleFromIndex(
+	const int32 index)
+{
+	b2Assert(index >= 0 && index < GetParticleCount() &&
+			 index != b2_invalidParticleIndex);
+	m_handleIndexBuffer.data = RequestBuffer(m_handleIndexBuffer.data);
+	b2ParticleHandle* handle = m_handleIndexBuffer.data[index];
+	if (handle)
+	{
+		return handle;
+	}
+	// Create a handle.
+	handle = m_handleAllocator.Allocate();
+	b2Assert(handle);
+	handle->SetIndex(index);
+	m_handleIndexBuffer.data[index] = handle;
+	return handle;
+}
+
+
+void b2ParticleSystem::DestroyParticle(
+	int32 index, bool callDestructionListener)
+{
+	uint32 flags = b2_zombieParticle;
+	if (callDestructionListener)
+	{
+		flags |= b2_destructionListenerParticle;
+	}
+	SetParticleFlags(index, m_flagsBuffer.data[index] | flags);
+}
+
+void b2ParticleSystem::DestroyOldestParticle(
+	const int32 index, const bool callDestructionListener)
+{
+	const int32 particleCount = GetParticleCount();
+	b2Assert(index >= 0 && index < particleCount);
+	// Make sure particle lifetime tracking is enabled.
+	b2Assert(m_indexByExpirationTimeBuffer.data);
+	// Destroy the oldest particle (preferring to destroy finite
+	// lifetime particles first) to free a slot in the buffer.
+	const int32 oldestFiniteLifetimeParticle =
+		m_indexByExpirationTimeBuffer.data[particleCount - (index + 1)];
+	const int32 oldestInfiniteLifetimeParticle =
+		m_indexByExpirationTimeBuffer.data[index];
+	DestroyParticle(
+		m_expirationTimeBuffer.data[oldestFiniteLifetimeParticle] > 0.0f ?
+			oldestFiniteLifetimeParticle : oldestInfiniteLifetimeParticle,
+		callDestructionListener);
+}
+
+int32 b2ParticleSystem::DestroyParticlesInShape(
+	const b2Shape& shape, const b2Transform& xf,
+	bool callDestructionListener)
+{
+	b2Assert(m_world->IsLocked() == false);
+	if (m_world->IsLocked())
+	{
+		return 0;
+	}
+
+	class DestroyParticlesInShapeCallback : public b2QueryCallback
+	{
+	public:
+		DestroyParticlesInShapeCallback(
+			b2ParticleSystem* system, const b2Shape& shape,
+			const b2Transform& xf, bool callDestructionListener)
+		{
+			m_system = system;
+			m_shape = &shape;
+			m_xf = xf;
+			m_callDestructionListener = callDestructionListener;
+			m_destroyed = 0;
+		}
+
+		bool ReportFixture(b2Fixture* fixture)
+		{
+			B2_NOT_USED(fixture);
+			return false;
+		}
+
+		bool ReportParticle(const b2ParticleSystem* particleSystem, int32 index)
+		{
+			if (particleSystem != m_system)
+				return false;
+
+			b2Assert(index >=0 && index < m_system->m_count);
+			if (m_shape->TestPoint(m_xf,
+								   m_system->m_positionBuffer.data[index]))
+			{
+				m_system->DestroyParticle(index, m_callDestructionListener);
+				m_destroyed++;
+			}
+			return true;
+		}
+
+		int32 Destroyed() { return m_destroyed; }
+
+	private:
+		b2ParticleSystem* m_system;
+		const b2Shape* m_shape;
+		b2Transform m_xf;
+		bool m_callDestructionListener;
+		int32 m_destroyed;
+	} callback(this, shape, xf, callDestructionListener);
+	b2AABB aabb;
+	shape.ComputeAABB(&aabb, xf, 0);
+	m_world->QueryAABB(&callback, aabb);
+	return callback.Destroyed();
+}
+
+int32 b2ParticleSystem::CreateParticleForGroup(
+	const b2ParticleGroupDef& groupDef, const b2Transform& xf, const b2Vec2& p)
+{
+	b2ParticleDef particleDef;
+	particleDef.flags = groupDef.flags;
+	particleDef.position = b2Mul(xf, p);
+	particleDef.velocity =
+		groupDef.linearVelocity +
+		b2Cross(groupDef.angularVelocity,
+				particleDef.position - groupDef.position);
+	particleDef.color = groupDef.color;
+	particleDef.lifetime = groupDef.lifetime;
+	particleDef.userData = groupDef.userData;
+	return CreateParticle(particleDef);
+}
+
+void b2ParticleSystem::CreateParticlesStrokeShapeForGroup(
+	const b2Shape *shape,
+	const b2ParticleGroupDef& groupDef, const b2Transform& xf)
+{
+	float32 stride = groupDef.stride;
+	if (stride == 0)
+	{
+		stride = GetParticleStride();
+	}
+	float32 positionOnEdge = 0;
+	int32 childCount = shape->GetChildCount();
+	for (int32 childIndex = 0; childIndex < childCount; childIndex++)
+	{
+		b2EdgeShape edge;
+		if (shape->GetType() == b2Shape::e_edge)
+		{
+			edge = *(b2EdgeShape*) shape;
+		}
+		else
+		{
+			b2Assert(shape->GetType() == b2Shape::e_chain);
+			((b2ChainShape*) shape)->GetChildEdge(&edge, childIndex);
+		}
+		b2Vec2 d = edge.m_vertex2 - edge.m_vertex1;
+		float32 edgeLength = d.Length();
+		while (positionOnEdge < edgeLength)
+		{
+			b2Vec2 p = edge.m_vertex1 + positionOnEdge / edgeLength * d;
+			CreateParticleForGroup(groupDef, xf, p);
+			positionOnEdge += stride;
+		}
+		positionOnEdge -= edgeLength;
+	}
+}
+
+void b2ParticleSystem::CreateParticlesFillShapeForGroup(
+	const b2Shape *shape,
+	const b2ParticleGroupDef& groupDef, const b2Transform& xf)
+{
+	float32 stride = groupDef.stride;
+	if (stride == 0)
+	{
+		stride = GetParticleStride();
+	}
+	b2Transform identity;
+	identity.SetIdentity();
+	b2AABB aabb;
+	b2Assert(shape->GetChildCount() == 1);
+	shape->ComputeAABB(&aabb, identity, 0);
+	for (float32 y = floorf(aabb.lowerBound.y / stride) * stride;
+		y < aabb.upperBound.y; y += stride)
+	{
+		for (float32 x = floorf(aabb.lowerBound.x / stride) * stride;
+			x < aabb.upperBound.x; x += stride)
+		{
+			b2Vec2 p(x, y);
+			if (shape->TestPoint(identity, p))
+			{
+				CreateParticleForGroup(groupDef, xf, p);
+			}
+		}
+	}
+}
+
+void b2ParticleSystem::CreateParticlesWithShapeForGroup(
+	const b2Shape* shape,
+	const b2ParticleGroupDef& groupDef, const b2Transform& xf)
+{
+	switch (shape->GetType()) {
+	case b2Shape::e_edge:
+	case b2Shape::e_chain:
+		CreateParticlesStrokeShapeForGroup(shape, groupDef, xf);
+		break;
+	case b2Shape::e_polygon:
+	case b2Shape::e_circle:
+		CreateParticlesFillShapeForGroup(shape, groupDef, xf);
+		break;
+	default:
+		b2Assert(false);
+		break;
+	}
+}
+
+void b2ParticleSystem::CreateParticlesWithShapesForGroup(
+	const b2Shape* const* shapes, int32 shapeCount,
+	const b2ParticleGroupDef& groupDef, const b2Transform& xf)
+{
+	class CompositeShape : public b2Shape
+	{
+	public:
+		CompositeShape(const b2Shape* const* shapes, int32 shapeCount)
+		{
+			m_shapes = shapes;
+			m_shapeCount = shapeCount;
+		}
+		b2Shape* Clone(b2BlockAllocator* allocator) const
+		{
+			b2Assert(false);
+			B2_NOT_USED(allocator);
+			return NULL;
+		}
+		int32 GetChildCount() const
+		{
+			return 1;
+		}
+		bool TestPoint(const b2Transform& xf, const b2Vec2& p) const
+		{
+			for (int32 i = 0; i < m_shapeCount; i++)
+			{
+				if (m_shapes[i]->TestPoint(xf, p))
+				{
+					return true;
+				}
+			}
+			return false;
+		}
+		void ComputeDistance(const b2Transform& xf, const b2Vec2& p,
+					float32* distance, b2Vec2* normal, int32 childIndex) const
+		{
+			b2Assert(false);
+			B2_NOT_USED(xf);
+			B2_NOT_USED(p);
+			B2_NOT_USED(distance);
+			B2_NOT_USED(normal);
+			B2_NOT_USED(childIndex);
+		}
+		bool RayCast(b2RayCastOutput* output, const b2RayCastInput& input,
+						const b2Transform& transform, int32 childIndex) const
+		{
+			b2Assert(false);
+			B2_NOT_USED(output);
+			B2_NOT_USED(input);
+			B2_NOT_USED(transform);
+			B2_NOT_USED(childIndex);
+			return false;
+		}
+		void ComputeAABB(
+				b2AABB* aabb, const b2Transform& xf, int32 childIndex) const
+		{
+			B2_NOT_USED(childIndex);
+			aabb->lowerBound.x = +FLT_MAX;
+			aabb->lowerBound.y = +FLT_MAX;
+			aabb->upperBound.x = -FLT_MAX;
+			aabb->upperBound.y = -FLT_MAX;
+			b2Assert(childIndex == 0);
+			for (int32 i = 0; i < m_shapeCount; i++)
+			{
+				int32 childCount = m_shapes[i]->GetChildCount();
+				for (int32 j = 0; j < childCount; j++)
+				{
+					b2AABB subaabb;
+					m_shapes[i]->ComputeAABB(&subaabb, xf, j);
+					aabb->Combine(subaabb);
+				}
+			}
+		}
+		void ComputeMass(b2MassData* massData, float32 density) const
+		{
+			b2Assert(false);
+			B2_NOT_USED(massData);
+			B2_NOT_USED(density);
+		}
+	private:
+		const b2Shape* const* m_shapes;
+		int32 m_shapeCount;
+	} compositeShape(shapes, shapeCount);
+	CreateParticlesFillShapeForGroup(&compositeShape, groupDef, xf);
+}
+
+b2ParticleGroup* b2ParticleSystem::CreateParticleGroup(
+	const b2ParticleGroupDef& groupDef)
+{
+	b2Assert(m_world->IsLocked() == false);
+	if (m_world->IsLocked())
+	{
+		return 0;
+	}
+
+	b2Transform transform;
+	transform.Set(groupDef.position, groupDef.angle);
+	int32 firstIndex = m_count;
+	if (groupDef.shape)
+	{
+		CreateParticlesWithShapeForGroup(groupDef.shape, groupDef, transform);
+	}
+	if (groupDef.shapes)
+	{
+		CreateParticlesWithShapesForGroup(
+					groupDef.shapes, groupDef.shapeCount, groupDef, transform);
+	}
+	if (groupDef.particleCount)
+	{
+		b2Assert(groupDef.positionData);
+		for (int32 i = 0; i < groupDef.particleCount; i++)
+		{
+			b2Vec2 p = groupDef.positionData[i];
+			CreateParticleForGroup(groupDef, transform, p);
+		}
+	}
+	int32 lastIndex = m_count;
+
+	void* mem = m_world->m_blockAllocator.Allocate(sizeof(b2ParticleGroup));
+	b2ParticleGroup* group = new (mem) b2ParticleGroup();
+	group->m_system = this;
+	group->m_firstIndex = firstIndex;
+	group->m_lastIndex = lastIndex;
+	group->m_strength = groupDef.strength;
+	group->m_userData = groupDef.userData;
+	group->m_transform = transform;
+	group->m_prev = NULL;
+	group->m_next = m_groupList;
+	if (m_groupList)
+	{
+		m_groupList->m_prev = group;
+	}
+	m_groupList = group;
+	++m_groupCount;
+	for (int32 i = firstIndex; i < lastIndex; i++)
+	{
+		m_groupBuffer[i] = group;
+	}
+	SetGroupFlags(group, groupDef.groupFlags);
+
+	// Create pairs and triads between particles in the group.
+	ConnectionFilter filter;
+	UpdateContacts(true);
+	UpdatePairsAndTriads(firstIndex, lastIndex, filter);
+
+	if (groupDef.group)
+	{
+		JoinParticleGroups(groupDef.group, group);
+		group = groupDef.group;
+	}
+
+	return group;
+}
+
+void b2ParticleSystem::JoinParticleGroups(b2ParticleGroup* groupA,
+										  b2ParticleGroup* groupB)
+{
+	b2Assert(m_world->IsLocked() == false);
+	if (m_world->IsLocked())
+	{
+		return;
+	}
+
+	b2Assert(groupA != groupB);
+	RotateBuffer(groupB->m_firstIndex, groupB->m_lastIndex, m_count);
+	b2Assert(groupB->m_lastIndex == m_count);
+	RotateBuffer(groupA->m_firstIndex, groupA->m_lastIndex,
+				 groupB->m_firstIndex);
+	b2Assert(groupA->m_lastIndex == groupB->m_firstIndex);
+
+	// Create pairs and triads connecting groupA and groupB.
+	class JoinParticleGroupsFilter : public ConnectionFilter
+	{
+		bool ShouldCreatePair(int32 a, int32 b) const
+		{
+			return
+				(a < m_threshold && m_threshold <= b) ||
+				(b < m_threshold && m_threshold <= a);
+		}
+		bool ShouldCreateTriad(int32 a, int32 b, int32 c) const
+		{
+			return
+				(a < m_threshold || b < m_threshold || c < m_threshold) &&
+				(m_threshold <= a || m_threshold <= b || m_threshold <= c);
+		}
+		int32 m_threshold;
+	public:
+		JoinParticleGroupsFilter(int32 threshold)
+		{
+			m_threshold = threshold;
+		}
+	} filter(groupB->m_firstIndex);
+	UpdateContacts(true);
+	UpdatePairsAndTriads(groupA->m_firstIndex, groupB->m_lastIndex, filter);
+
+	for (int32 i = groupB->m_firstIndex; i < groupB->m_lastIndex; i++)
+	{
+		m_groupBuffer[i] = groupA;
+	}
+	uint32 groupFlags = groupA->m_groupFlags | groupB->m_groupFlags;
+	SetGroupFlags(groupA, groupFlags);
+	groupA->m_lastIndex = groupB->m_lastIndex;
+	groupB->m_firstIndex = groupB->m_lastIndex;
+	DestroyParticleGroup(groupB);
+}
+
+void b2ParticleSystem::SplitParticleGroup(b2ParticleGroup* group)
+{
+	UpdateContacts(true);
+	int32 particleCount = group->GetParticleCount();
+	// We create several linked lists. Each list represents a set of connected
+	// particles.
+	ParticleListNode* nodeBuffer =
+		(ParticleListNode*) m_world->m_stackAllocator.Allocate(
+									sizeof(ParticleListNode) * particleCount);
+	InitializeParticleLists(group, nodeBuffer);
+	MergeParticleListsInContact(group, nodeBuffer);
+	ParticleListNode* survivingList =
+									FindLongestParticleList(group, nodeBuffer);
+	MergeZombieParticleListNodes(group, nodeBuffer, survivingList);
+	CreateParticleGroupsFromParticleList(group, nodeBuffer, survivingList);
+	UpdatePairsAndTriadsWithParticleList(group, nodeBuffer);
+	m_world->m_stackAllocator.Free(nodeBuffer);
+}
+
+void b2ParticleSystem::InitializeParticleLists(
+	const b2ParticleGroup* group, ParticleListNode* nodeBuffer)
+{
+	int32 bufferIndex = group->GetBufferIndex();
+	int32 particleCount = group->GetParticleCount();
+	for (int32 i = 0; i < particleCount; i++)
+	{
+		ParticleListNode* node = &nodeBuffer[i];
+		node->list = node;
+		node->next = NULL;
+		node->count = 1;
+		node->index = i + bufferIndex;
+	}
+}
+
+void b2ParticleSystem::MergeParticleListsInContact(
+	const b2ParticleGroup* group, ParticleListNode* nodeBuffer) const
+{
+	int32 bufferIndex = group->GetBufferIndex();
+	for (int32 k = 0; k < m_contactBuffer.GetCount(); k++)
+	{
+		const b2ParticleContact& contact = m_contactBuffer[k];
+		int32 a = contact.GetIndexA();
+		int32 b = contact.GetIndexB();
+		if (!group->ContainsParticle(a) || !group->ContainsParticle(b)) {
+			continue;
+		}
+		ParticleListNode* listA = nodeBuffer[a - bufferIndex].list;
+		ParticleListNode* listB = nodeBuffer[b - bufferIndex].list;
+		if (listA == listB) {
+			continue;
+		}
+		// To minimize the cost of insertion, make sure listA is longer than
+		// listB.
+		if (listA->count < listB->count)
+		{
+			b2Swap(listA, listB);
+		}
+		b2Assert(listA->count >= listB->count);
+		MergeParticleLists(listA, listB);
+	}
+}
+
+void b2ParticleSystem::MergeParticleLists(
+	ParticleListNode* listA, ParticleListNode* listB)
+{
+	// Insert listB between index 0 and 1 of listA
+	// Example:
+	//     listA => a1 => a2 => a3 => NULL
+	//     listB => b1 => b2 => NULL
+	// to
+	//     listA => listB => b1 => b2 => a1 => a2 => a3 => NULL
+	b2Assert(listA != listB);
+	for (ParticleListNode* b = listB;;)
+	{
+		b->list = listA;
+		ParticleListNode* nextB = b->next;
+		if (nextB)
+		{
+			b = nextB;
+		}
+		else
+		{
+			b->next = listA->next;
+			break;
+		}
+	}
+	listA->next = listB;
+	listA->count += listB->count;
+	listB->count = 0;
+}
+
+b2ParticleSystem::ParticleListNode* b2ParticleSystem::FindLongestParticleList(
+	const b2ParticleGroup* group, ParticleListNode* nodeBuffer)
+{
+	int32 particleCount = group->GetParticleCount();
+	ParticleListNode* result = nodeBuffer;
+	for (int32 i = 0; i < particleCount; i++)
+	{
+		ParticleListNode* node = &nodeBuffer[i];
+		if (result->count < node->count)
+		{
+			result = node;
+		}
+	}
+	return result;
+}
+
+void b2ParticleSystem::MergeZombieParticleListNodes(
+	const b2ParticleGroup* group, ParticleListNode* nodeBuffer,
+	ParticleListNode* survivingList) const
+{
+	int32 particleCount = group->GetParticleCount();
+	for (int32 i = 0; i < particleCount; i++)
+	{
+		ParticleListNode* node = &nodeBuffer[i];
+		if (node != survivingList &&
+			(m_flagsBuffer.data[node->index] & b2_zombieParticle))
+		{
+			MergeParticleListAndNode(survivingList, node);
+		}
+	}
+}
+
+void b2ParticleSystem::MergeParticleListAndNode(
+	ParticleListNode* list, ParticleListNode* node)
+{
+	// Insert node between index 0 and 1 of list
+	// Example:
+	//     list => a1 => a2 => a3 => NULL
+	//     node => NULL
+	// to
+	//     list => node => a1 => a2 => a3 => NULL
+	b2Assert(node != list);
+	b2Assert(node->list == node);
+	b2Assert(node->count == 1);
+	node->list = list;
+	node->next = list->next;
+	list->next = node;
+	list->count++;
+	node->count = 0;
+}
+
+void b2ParticleSystem::CreateParticleGroupsFromParticleList(
+	const b2ParticleGroup* group, ParticleListNode* nodeBuffer,
+	const ParticleListNode* survivingList)
+{
+	int32 particleCount = group->GetParticleCount();
+	b2ParticleGroupDef def;
+	def.groupFlags = group->GetGroupFlags();
+	def.userData = group->GetUserData();
+	for (int32 i = 0; i < particleCount; i++)
+	{
+		ParticleListNode* list = &nodeBuffer[i];
+		if (!list->count || list == survivingList)
+		{
+			continue;
+		}
+		b2Assert(list->list == list);
+		b2ParticleGroup* newGroup = CreateParticleGroup(def);
+		for (ParticleListNode* node = list; node; node = node->next)
+		{
+			int32 oldIndex = node->index;
+			uint32& flags = m_flagsBuffer.data[oldIndex];
+			b2Assert(!(flags & b2_zombieParticle));
+			int32 newIndex = CloneParticle(oldIndex, newGroup);
+			flags |= b2_zombieParticle;
+			node->index = newIndex;
+		}
+	}
+}
+
+void b2ParticleSystem::UpdatePairsAndTriadsWithParticleList(
+	const b2ParticleGroup* group, const ParticleListNode* nodeBuffer)
+{
+	int32 bufferIndex = group->GetBufferIndex();
+	// Update indices in pairs and triads. If an index belongs to the group,
+	// replace it with the corresponding value in nodeBuffer.
+	// Note that nodeBuffer is allocated only for the group and the index should
+	// be shifted by bufferIndex.
+	for (int32 k = 0; k < m_pairBuffer.GetCount(); k++)
+	{
+		b2ParticlePair& pair = m_pairBuffer[k];
+		int32 a = pair.indexA;
+		int32 b = pair.indexB;
+		if (group->ContainsParticle(a))
+		{
+			pair.indexA = nodeBuffer[a - bufferIndex].index;
+		}
+		if (group->ContainsParticle(b))
+		{
+			pair.indexB = nodeBuffer[b - bufferIndex].index;
+		}
+	}
+	for (int32 k = 0; k < m_triadBuffer.GetCount(); k++)
+	{
+		b2ParticleTriad& triad = m_triadBuffer[k];
+		int32 a = triad.indexA;
+		int32 b = triad.indexB;
+		int32 c = triad.indexC;
+		if (group->ContainsParticle(a))
+		{
+			triad.indexA = nodeBuffer[a - bufferIndex].index;
+		}
+		if (group->ContainsParticle(b))
+		{
+			triad.indexB = nodeBuffer[b - bufferIndex].index;
+		}
+		if (group->ContainsParticle(c))
+		{
+			triad.indexC = nodeBuffer[c - bufferIndex].index;
+		}
+	}
+}
+
+int32 b2ParticleSystem::CloneParticle(int32 oldIndex, b2ParticleGroup* group)
+{
+	b2ParticleDef def;
+	def.flags = m_flagsBuffer.data[oldIndex];
+	def.position = m_positionBuffer.data[oldIndex];
+	def.velocity = m_velocityBuffer.data[oldIndex];
+	if (m_colorBuffer.data)
+	{
+		def.color = m_colorBuffer.data[oldIndex];
+	}
+	if (m_userDataBuffer.data)
+	{
+		def.userData = m_userDataBuffer.data[oldIndex];
+	}
+	def.group = group;
+	int32 newIndex = CreateParticle(def);
+	if (m_handleIndexBuffer.data)
+	{
+		b2ParticleHandle* handle = m_handleIndexBuffer.data[oldIndex];
+		if (handle) handle->SetIndex(newIndex);
+		m_handleIndexBuffer.data[newIndex] = handle;
+		m_handleIndexBuffer.data[oldIndex] = NULL;
+	}
+	if (m_lastBodyContactStepBuffer.data)
+	{
+		m_lastBodyContactStepBuffer.data[newIndex] =
+			m_lastBodyContactStepBuffer.data[oldIndex];
+	}
+	if (m_bodyContactCountBuffer.data)
+	{
+		m_bodyContactCountBuffer.data[newIndex] =
+			m_bodyContactCountBuffer.data[oldIndex];
+	}
+	if (m_consecutiveContactStepsBuffer.data)
+	{
+		m_consecutiveContactStepsBuffer.data[newIndex] =
+			m_consecutiveContactStepsBuffer.data[oldIndex];
+	}
+	if (m_hasForce)
+	{
+		m_forceBuffer[newIndex] = m_forceBuffer[oldIndex];
+	}
+	if (m_staticPressureBuffer)
+	{
+		m_staticPressureBuffer[newIndex] = m_staticPressureBuffer[oldIndex];
+	}
+	if (m_depthBuffer)
+	{
+		m_depthBuffer[newIndex] = m_depthBuffer[oldIndex];
+	}
+	if (m_expirationTimeBuffer.data)
+	{
+		m_expirationTimeBuffer.data[newIndex] =
+			m_expirationTimeBuffer.data[oldIndex];
+	}
+	return newIndex;
+}
+
+void b2ParticleSystem::UpdatePairsAndTriadsWithReactiveParticles()
+{
+	class ReactiveFilter : public ConnectionFilter
+	{
+		bool IsNecessary(int32 index) const
+		{
+			return (m_flagsBuffer[index] & b2_reactiveParticle) != 0;
+		}
+		const uint32* m_flagsBuffer;
+	public:
+		ReactiveFilter(uint32* flagsBuffer)
+		{
+			m_flagsBuffer = flagsBuffer;
+		}
+	} filter(m_flagsBuffer.data);
+	UpdatePairsAndTriads(0, m_count, filter);
+
+	for (int32 i = 0; i < m_count; i++)
+	{
+		m_flagsBuffer.data[i] &= ~b2_reactiveParticle;
+	}
+	m_allParticleFlags &= ~b2_reactiveParticle;
+}
+
+static bool ParticleCanBeConnected(
+	uint32 flags, b2ParticleGroup* group)
+{
+	return
+		(flags & (b2_wallParticle | b2_springParticle | b2_elasticParticle)) ||
+		(group && group->GetGroupFlags() & b2_rigidParticleGroup);
+}
+
+void b2ParticleSystem::UpdatePairsAndTriads(
+	int32 firstIndex, int32 lastIndex, const ConnectionFilter& filter)
+{
+	// Create pairs or triads.
+	// All particles in each pair/triad should satisfy the following:
+	// * firstIndex <= index < lastIndex
+	// * don't have b2_zombieParticle
+	// * ParticleCanBeConnected returns true
+	// * ShouldCreatePair/ShouldCreateTriad returns true
+	// Any particles in each pair/triad should satisfy the following:
+	// * filter.IsNeeded returns true
+	// * have one of k_pairFlags/k_triadsFlags
+	b2Assert(firstIndex <= lastIndex);
+	uint32 particleFlags = 0;
+	for (int32 i = firstIndex; i < lastIndex; i++)
+	{
+		particleFlags |= m_flagsBuffer.data[i];
+	}
+	if (particleFlags & k_pairFlags)
+	{
+		for (int32 k = 0; k < m_contactBuffer.GetCount(); k++)
+		{
+			const b2ParticleContact& contact = m_contactBuffer[k];
+			int32 a = contact.GetIndexA();
+			int32 b = contact.GetIndexB();
+			uint32 af = m_flagsBuffer.data[a];
+			uint32 bf = m_flagsBuffer.data[b];
+			b2ParticleGroup* groupA = m_groupBuffer[a];
+			b2ParticleGroup* groupB = m_groupBuffer[b];
+			if (a >= firstIndex && a < lastIndex &&
+				b >= firstIndex && b < lastIndex &&
+				!((af | bf) & b2_zombieParticle) &&
+				((af | bf) & k_pairFlags) &&
+				(filter.IsNecessary(a) || filter.IsNecessary(b)) &&
+				ParticleCanBeConnected(af, groupA) &&
+				ParticleCanBeConnected(bf, groupB) &&
+				filter.ShouldCreatePair(a, b))
+			{
+				b2ParticlePair& pair = m_pairBuffer.Append();
+				pair.indexA = a;
+				pair.indexB = b;
+				pair.flags = contact.GetFlags();
+				pair.strength = b2Min(
+					groupA ? groupA->m_strength : 1,
+					groupB ? groupB->m_strength : 1);
+				pair.distance = b2Distance(m_positionBuffer.data[a],
+										   m_positionBuffer.data[b]);
+			}
+		}
+		std::stable_sort(
+			m_pairBuffer.Begin(), m_pairBuffer.End(), ComparePairIndices);
+		m_pairBuffer.Unique(MatchPairIndices);
+	}
+	if (particleFlags & k_triadFlags)
+	{
+		b2VoronoiDiagram diagram(
+			&m_world->m_stackAllocator, lastIndex - firstIndex);
+		for (int32 i = firstIndex; i < lastIndex; i++)
+		{
+			uint32 flags = m_flagsBuffer.data[i];
+			b2ParticleGroup* group = m_groupBuffer[i];
+			if (!(flags & b2_zombieParticle) &&
+				ParticleCanBeConnected(flags, group))
+			{
+				diagram.AddGenerator(
+					m_positionBuffer.data[i], i, filter.IsNecessary(i));
+			}
+		}
+		float32 stride = GetParticleStride();
+		diagram.Generate(stride / 2, stride * 2);
+		class UpdateTriadsCallback : public b2VoronoiDiagram::NodeCallback
+		{
+			void operator()(int32 a, int32 b, int32 c)
+			{
+				uint32 af = m_system->m_flagsBuffer.data[a];
+				uint32 bf = m_system->m_flagsBuffer.data[b];
+				uint32 cf = m_system->m_flagsBuffer.data[c];
+				if (((af | bf | cf) & k_triadFlags) &&
+					m_filter->ShouldCreateTriad(a, b, c))
+				{
+					const b2Vec2& pa = m_system->m_positionBuffer.data[a];
+					const b2Vec2& pb = m_system->m_positionBuffer.data[b];
+					const b2Vec2& pc = m_system->m_positionBuffer.data[c];
+					b2Vec2 dab = pa - pb;
+					b2Vec2 dbc = pb - pc;
+					b2Vec2 dca = pc - pa;
+					float32 maxDistanceSquared = b2_maxTriadDistanceSquared *
+												 m_system->m_squaredDiameter;
+					if (b2Dot(dab, dab) > maxDistanceSquared ||
+						b2Dot(dbc, dbc) > maxDistanceSquared ||
+						b2Dot(dca, dca) > maxDistanceSquared)
+					{
+						return;
+					}
+					b2ParticleGroup* groupA = m_system->m_groupBuffer[a];
+					b2ParticleGroup* groupB = m_system->m_groupBuffer[b];
+					b2ParticleGroup* groupC = m_system->m_groupBuffer[c];
+					b2ParticleTriad& triad = m_system->m_triadBuffer.Append();
+					triad.indexA = a;
+					triad.indexB = b;
+					triad.indexC = c;
+					triad.flags = af | bf | cf;
+					triad.strength = b2Min(b2Min(
+						groupA ? groupA->m_strength : 1,
+						groupB ? groupB->m_strength : 1),
+						groupC ? groupC->m_strength : 1);
+					b2Vec2 midPoint = (float32) 1 / 3 * (pa + pb + pc);
+					triad.pa = pa - midPoint;
+					triad.pb = pb - midPoint;
+					triad.pc = pc - midPoint;
+					triad.ka = -b2Dot(dca, dab);
+					triad.kb = -b2Dot(dab, dbc);
+					triad.kc = -b2Dot(dbc, dca);
+					triad.s = b2Cross(pa, pb) + b2Cross(pb, pc) + b2Cross(pc, pa);
+				}
+			}
+			b2ParticleSystem* m_system;
+			const ConnectionFilter* m_filter;
+		public:
+			UpdateTriadsCallback(
+				b2ParticleSystem* system, const ConnectionFilter* filter)
+			{
+				m_system = system;
+				m_filter = filter;
+			}
+		} callback(this, &filter);
+		diagram.GetNodes(callback);
+		std::stable_sort(
+			m_triadBuffer.Begin(), m_triadBuffer.End(), CompareTriadIndices);
+		m_triadBuffer.Unique(MatchTriadIndices);
+	}
+}
+
+bool b2ParticleSystem::ComparePairIndices(
+							const b2ParticlePair& a, const b2ParticlePair& b)
+{
+	int32 diffA = a.indexA - b.indexA;
+	if (diffA != 0) return diffA < 0;
+	return a.indexB < b.indexB;
+}
+
+bool b2ParticleSystem::MatchPairIndices(
+							const b2ParticlePair& a, const b2ParticlePair& b)
+{
+	return a.indexA == b.indexA && a.indexB == b.indexB;
+}
+
+bool b2ParticleSystem::CompareTriadIndices(
+							const b2ParticleTriad& a, const b2ParticleTriad& b)
+{
+	int32 diffA = a.indexA - b.indexA;
+	if (diffA != 0) return diffA < 0;
+	int32 diffB = a.indexB - b.indexB;
+	if (diffB != 0) return diffB < 0;
+	return a.indexC < b.indexC;
+}
+
+bool b2ParticleSystem::MatchTriadIndices(
+							const b2ParticleTriad& a, const b2ParticleTriad& b)
+{
+	return a.indexA == b.indexA && a.indexB == b.indexB && a.indexC == b.indexC;
+}
+
+// Only called from SolveZombie() or JoinParticleGroups().
+void b2ParticleSystem::DestroyParticleGroup(b2ParticleGroup* group)
+{
+	b2Assert(m_groupCount > 0);
+	b2Assert(group);
+
+	if (m_world->m_destructionListener)
+	{
+		m_world->m_destructionListener->SayGoodbye(group);
+	}
+
+	SetGroupFlags(group, 0);
+	for (int32 i = group->m_firstIndex; i < group->m_lastIndex; i++)
+	{
+		m_groupBuffer[i] = NULL;
+	}
+
+	if (group->m_prev)
+	{
+		group->m_prev->m_next = group->m_next;
+	}
+	if (group->m_next)
+	{
+		group->m_next->m_prev = group->m_prev;
+	}
+	if (group == m_groupList)
+	{
+		m_groupList = group->m_next;
+	}
+
+	--m_groupCount;
+	group->~b2ParticleGroup();
+	m_world->m_blockAllocator.Free(group, sizeof(b2ParticleGroup));
+}
+
+void b2ParticleSystem::ComputeWeight()
+{
+	// calculates the sum of contact-weights for each particle
+	// that means dimensionless density
+	memset(m_weightBuffer, 0, sizeof(*m_weightBuffer) * m_count);
+	for (int32 k = 0; k < m_bodyContactBuffer.GetCount(); k++)
+	{
+		const b2ParticleBodyContact& contact = m_bodyContactBuffer[k];
+		int32 a = contact.index;
+		float32 w = contact.weight;
+		m_weightBuffer[a] += w;
+	}
+	for (int32 k = 0; k < m_contactBuffer.GetCount(); k++)
+	{
+		const b2ParticleContact& contact = m_contactBuffer[k];
+		int32 a = contact.GetIndexA();
+		int32 b = contact.GetIndexB();
+		float32 w = contact.GetWeight();
+		m_weightBuffer[a] += w;
+		m_weightBuffer[b] += w;
+	}
+}
+
+void b2ParticleSystem::ComputeDepth()
+{
+	b2ParticleContact* contactGroups = (b2ParticleContact*) m_world->
+		m_stackAllocator.Allocate(sizeof(b2ParticleContact) * m_contactBuffer.GetCount());
+	int32 contactGroupsCount = 0;
+	for (int32 k = 0; k < m_contactBuffer.GetCount(); k++)
+	{
+		const b2ParticleContact& contact = m_contactBuffer[k];
+		int32 a = contact.GetIndexA();
+		int32 b = contact.GetIndexB();
+		const b2ParticleGroup* groupA = m_groupBuffer[a];
+		const b2ParticleGroup* groupB = m_groupBuffer[b];
+		if (groupA && groupA == groupB &&
+			(groupA->m_groupFlags & b2_particleGroupNeedsUpdateDepth))
+		{
+			contactGroups[contactGroupsCount++] = contact;
+		}
+	}
+	b2ParticleGroup** groupsToUpdate = (b2ParticleGroup**) m_world->
+		m_stackAllocator.Allocate(sizeof(b2ParticleGroup*) * m_groupCount);
+	int32 groupsToUpdateCount = 0;
+	for (b2ParticleGroup* group = m_groupList; group; group = group->GetNext())
+	{
+		if (group->m_groupFlags & b2_particleGroupNeedsUpdateDepth)
+		{
+			groupsToUpdate[groupsToUpdateCount++] = group;
+			SetGroupFlags(group,
+						  group->m_groupFlags &
+						  ~b2_particleGroupNeedsUpdateDepth);
+			for (int32 i = group->m_firstIndex; i < group->m_lastIndex; i++)
+			{
+				m_accumulationBuffer[i] = 0;
+			}
+		}
+	}
+	// Compute sum of weight of contacts except between different groups.
+	for (int32 k = 0; k < contactGroupsCount; k++)
+	{
+		const b2ParticleContact& contact = contactGroups[k];
+		int32 a = contact.GetIndexA();
+		int32 b = contact.GetIndexB();
+		float32 w = contact.GetWeight();
+		m_accumulationBuffer[a] += w;
+		m_accumulationBuffer[b] += w;
+	}
+	b2Assert(m_depthBuffer);
+	for (int32 i = 0; i < groupsToUpdateCount; i++)
+	{
+		const b2ParticleGroup* group = groupsToUpdate[i];
+		for (int32 j = group->m_firstIndex; j < group->m_lastIndex; j++)
+		{
+			float32 w = m_accumulationBuffer[j];
+			m_depthBuffer[j] = w < 0.8f ? 0 : b2_maxFloat;
+		}
+	}
+	// The number of iterations is equal to particle number from the deepest
+	// particle to the nearest surface particle, and in general it is smaller
+	// than sqrt of total particle number.
+	int32 iterationCount = (int32)b2Sqrt((float)m_count);
+	for (int32 t = 0; t < iterationCount; t++)
+	{
+		bool updated = false;
+		for (int32 k = 0; k < contactGroupsCount; k++)
+		{
+			const b2ParticleContact& contact = contactGroups[k];
+			int32 a = contact.GetIndexA();
+			int32 b = contact.GetIndexB();
+			float32 r = 1 - contact.GetWeight();
+			float32& ap0 = m_depthBuffer[a];
+			float32& bp0 = m_depthBuffer[b];
+			float32 ap1 = bp0 + r;
+			float32 bp1 = ap0 + r;
+			if (ap0 > ap1)
+			{
+				ap0 = ap1;
+				updated = true;
+			}
+			if (bp0 > bp1)
+			{
+				bp0 = bp1;
+				updated = true;
+			}
+		}
+		if (!updated)
+		{
+			break;
+		}
+	}
+	for (int32 i = 0; i < groupsToUpdateCount; i++)
+	{
+		const b2ParticleGroup* group = groupsToUpdate[i];
+		for (int32 j = group->m_firstIndex; j < group->m_lastIndex; j++)
+		{
+			float32& p = m_depthBuffer[j];
+			if (p < b2_maxFloat)
+			{
+				p *= m_particleDiameter;
+			}
+			else
+			{
+				p = 0;
+			}
+		}
+	}
+	m_world->m_stackAllocator.Free(groupsToUpdate);
+	m_world->m_stackAllocator.Free(contactGroups);
+}
+
+b2ParticleSystem::InsideBoundsEnumerator
+b2ParticleSystem::GetInsideBoundsEnumerator(const b2AABB& aabb) const
+{
+	uint32 lowerTag = computeTag(m_inverseDiameter * aabb.lowerBound.x - 1,
+								 m_inverseDiameter * aabb.lowerBound.y - 1);
+	uint32 upperTag = computeTag(m_inverseDiameter * aabb.upperBound.x + 1,
+								 m_inverseDiameter * aabb.upperBound.y + 1);
+	const Proxy* beginProxy = m_proxyBuffer.Begin();
+	const Proxy* endProxy = m_proxyBuffer.End();
+	const Proxy* firstProxy = std::lower_bound(beginProxy, endProxy, lowerTag);
+	const Proxy* lastProxy = std::upper_bound(firstProxy, endProxy, upperTag);
+	return InsideBoundsEnumerator(lowerTag, upperTag, firstProxy, lastProxy);
+}
+
+inline void b2ParticleSystem::AddContact(int32 a, int32 b,
+	b2GrowableBuffer<b2ParticleContact>& contacts) const
+{
+	b2Vec2 d = m_positionBuffer.data[b] - m_positionBuffer.data[a];
+	float32 distBtParticlesSq = b2Dot(d, d);
+	if (distBtParticlesSq < m_squaredDiameter)
+	{
+		float32 invD = b2InvSqrt(distBtParticlesSq);
+		b2ParticleContact& contact = contacts.Append();
+		contact.SetIndices(a, b);
+		contact.SetFlags(m_flagsBuffer.data[a] | m_flagsBuffer.data[b]);
+		// 1 - distBtParticles / diameter
+		contact.SetWeight(1 - distBtParticlesSq * invD * m_inverseDiameter);
+		contact.SetNormal(invD * d);
+	}
+}
+
+void b2ParticleSystem::FindContacts_Reference(
+	b2GrowableBuffer<b2ParticleContact>& contacts) const
+{
+	const Proxy* beginProxy = m_proxyBuffer.Begin();
+	const Proxy* endProxy = m_proxyBuffer.End();
+
+	contacts.SetCount(0);
+	for (const Proxy *a = beginProxy, *c = beginProxy; a < endProxy; a++)
+	{
+		uint32 rightTag = computeRelativeTag(a->tag, 1, 0);
+		for (const Proxy* b = a + 1; b < endProxy; b++)
+		{
+			if (rightTag < b->tag) break;
+			AddContact(a->index, b->index, contacts);
+		}
+		uint32 bottomLeftTag = computeRelativeTag(a->tag, -1, 1);
+		for (; c < endProxy; c++)
+		{
+			if (bottomLeftTag <= c->tag) break;
+		}
+		uint32 bottomRightTag = computeRelativeTag(a->tag, 1, 1);
+		for (const Proxy* b = c; b < endProxy; b++)
+		{
+			if (bottomRightTag < b->tag) break;
+			AddContact(a->index, b->index, contacts);
+		}
+	}
+}
+
+// Put the positions and indices in proxy-order. This allows us to process
+// particles with SIMD, since adjacent particles are adjacent in memory.
+void b2ParticleSystem::ReorderForFindContact(FindContactInput* reordered,
+	                                         int alignedCount) const
+{
+	int i = 0;
+	for (; i < m_count; ++i)
+	{
+		const int proxyIndex = m_proxyBuffer[i].index;
+		FindContactInput& r = reordered[i];
+		r.proxyIndex = proxyIndex;
+		r.position = m_positionBuffer.data[proxyIndex];
+	}
+
+	// We process multiple elements at a time, so we may read off the end of
+	// the array. Pad the array with a few elements, so we don't end up
+	// outputing spurious contacts.
+	for (; i < alignedCount; ++i)
+	{
+		FindContactInput& r = reordered[i];
+		r.proxyIndex = 0;
+		r.position = b2Vec2(b2_maxFloat, b2_maxFloat);
+	}
+}
+
+// Check particles to the right of 'startIndex', outputing FindContactChecks
+// until we find an index that is greater than 'bound'. We skip over the
+// indices NUM_V32_SLOTS at a time, because they are processed in groups
+// in the SIMD function.
+inline void b2ParticleSystem::GatherChecksOneParticle(
+	const uint32 bound,
+	const int startIndex,
+	const int particleIndex,
+	int* nextUncheckedIndex,
+	b2GrowableBuffer<FindContactCheck>& checks) const
+{
+	// The particles have to be heavily packed together in order for this
+	// loop to iterate more than once. In almost all situations, it will
+	// iterate less than twice.
+	for (int comparatorIndex = startIndex;
+		 comparatorIndex < m_count;
+	     comparatorIndex += NUM_V32_SLOTS)
+	{
+		if (m_proxyBuffer[comparatorIndex].tag > bound)
+			break;
+
+		FindContactCheck& out = checks.Append();
+		out.particleIndex = (uint16)particleIndex;
+		out.comparatorIndex = (uint16)comparatorIndex;
+
+		// This is faster inside the 'for' since there are so few iterations.
+		if (nextUncheckedIndex != NULL)
+		{
+			*nextUncheckedIndex = comparatorIndex + NUM_V32_SLOTS;
+		}
+	}
+}
+
+void b2ParticleSystem::GatherChecks(
+	b2GrowableBuffer<FindContactCheck>& checks) const
+{
+	int bottomLeftIndex = 0;
+	for (int particleIndex = 0; particleIndex < m_count; ++particleIndex)
+	{
+		const uint32 particleTag = m_proxyBuffer[particleIndex].tag;
+
+		// Add checks for particles to the right.
+		const uint32 rightBound = particleTag + relativeTagRight;
+		int nextUncheckedIndex = particleIndex + 1;
+		GatherChecksOneParticle(rightBound,
+								particleIndex + 1,
+								particleIndex,
+								&nextUncheckedIndex,
+								checks);
+
+		// Find comparator index below and to left of particle.
+		const uint32 bottomLeftTag = particleTag + relativeTagBottomLeft;
+		for (; bottomLeftIndex < m_count; ++bottomLeftIndex)
+		{
+			if (bottomLeftTag <= m_proxyBuffer[bottomLeftIndex].tag)
+				break;
+		}
+
+		// Add checks for particles below.
+		const uint32 bottomRightBound = particleTag + relativeTagBottomRight;
+		const int bottomStartIndex = b2Max(bottomLeftIndex, nextUncheckedIndex);
+		GatherChecksOneParticle(bottomRightBound,
+								bottomStartIndex,
+								particleIndex,
+								NULL,
+								checks);
+	}
+}
+
+#if defined(LIQUIDFUN_SIMD_NEON)
+void b2ParticleSystem::FindContacts_Simd(
+	b2GrowableBuffer<b2ParticleContact>& contacts) const
+{
+	contacts.SetCount(0);
+
+	const int alignedCount = m_count + NUM_V32_SLOTS;
+	FindContactInput* reordered = (FindContactInput*)
+		m_world->m_stackAllocator.Allocate(
+			sizeof(FindContactInput) * alignedCount);
+
+	// Put positions and indices into proxy-order.
+	// This allows us to efficiently check for contacts using SIMD.
+	ReorderForFindContact(reordered, alignedCount);
+
+	// Perform broad-band contact check using tags to approximate
+	// positions. This reduces the number of narrow-band contact checks
+	// that use actual positions.
+	static const int MAX_EXPECTED_CHECKS_PER_PARTICLE = 3;
+	b2GrowableBuffer<FindContactCheck> checks(m_world->m_blockAllocator);
+	checks.Reserve(MAX_EXPECTED_CHECKS_PER_PARTICLE * m_count);
+	GatherChecks(checks);
+
+	// Perform narrow-band contact checks using actual positions.
+	// Any particles whose centers are within one diameter of each other are
+	// considered contacting.
+	FindContactsFromChecks_Simd(reordered, checks.Data(), checks.GetCount(),
+								m_squaredDiameter, m_inverseDiameter,
+								m_flagsBuffer.data, contacts);
+
+	m_world->m_stackAllocator.Free(reordered);
+}
+#endif // defined(LIQUIDFUN_SIMD_NEON)
+
+LIQUIDFUN_SIMD_INLINE
+void b2ParticleSystem::FindContacts(
+	b2GrowableBuffer<b2ParticleContact>& contacts) const
+{
+	#if defined(LIQUIDFUN_SIMD_NEON)
+    if(hasNeon)
+    {
+      FindContacts_Simd(contacts);
+    }
+		else
+    {
+      FindContacts_Reference(contacts);
+    }
+	#else
+		FindContacts_Reference(contacts);
+	#endif
+
+	#if defined(LIQUIDFUN_SIMD_TEST_VS_REFERENCE)
+		b2GrowableBuffer<b2ParticleContact>
+			reference(m_world->m_blockAllocator);
+		FindContacts_Reference(reference);
+
+		b2Assert(contacts.GetCount() == reference.GetCount());
+		for (int32 i = 0; i < contacts.GetCount(); ++i)
+		{
+			b2Assert(contacts[i].ApproximatelyEqual(reference[i]));
+		}
+	#endif // defined(LIQUIDFUN_SIMD_TEST_VS_REFERENCE)
+}
+
+static inline bool b2ParticleContactIsZombie(const b2ParticleContact& contact)
+{
+	return (contact.GetFlags() & b2_zombieParticle) == b2_zombieParticle;
+}
+
+// Get the world's contact filter if any particles with the
+// b2_particleContactFilterParticle flag are present in the system.
+inline b2ContactFilter* b2ParticleSystem::GetParticleContactFilter() const
+{
+	return (m_allParticleFlags & b2_particleContactFilterParticle) ?
+		m_world->m_contactManager.m_contactFilter : NULL;
+}
+
+// Get the world's contact listener if any particles with the
+// b2_particleContactListenerParticle flag are present in the system.
+inline b2ContactListener* b2ParticleSystem::GetParticleContactListener() const
+{
+	return (m_allParticleFlags & b2_particleContactListenerParticle) ?
+		m_world->m_contactManager.m_contactListener : NULL;
+}
+
+// Recalculate 'tag' in proxies using m_positionBuffer.
+// The 'tag' is an approximation of position, in left-right, top-bottom order.
+void b2ParticleSystem::UpdateProxies_Reference(
+	b2GrowableBuffer<Proxy>& proxies) const
+{
+	const Proxy* const endProxy = proxies.End();
+	for (Proxy* proxy = proxies.Begin(); proxy < endProxy; ++proxy)
+	{
+		int32 i = proxy->index;
+		b2Vec2 p = m_positionBuffer.data[i];
+		proxy->tag = computeTag(m_inverseDiameter * p.x,
+								m_inverseDiameter * p.y);
+	}
+}
+
+#if defined(LIQUIDFUN_SIMD_NEON)
+// static
+void b2ParticleSystem::UpdateProxyTags(
+	const uint32* const tags,
+	b2GrowableBuffer<Proxy>& proxies)
+{
+	const Proxy* const endProxy = proxies.End();
+	for (Proxy* proxy = proxies.Begin(); proxy < endProxy; ++proxy)
+	{
+		proxy->tag = tags[proxy->index];
+	}
+}
+
+void b2ParticleSystem::UpdateProxies_Simd(
+	b2GrowableBuffer<Proxy>& proxies) const
+{
+	uint32* tags = (uint32*)
+		m_world->m_stackAllocator.Allocate(m_count * sizeof(uint32));
+
+	// Calculate tag for every position.
+	// 'tags' array is in position-order.
+	CalculateTags_Simd(m_positionBuffer.data, m_count,
+					   m_inverseDiameter, tags);
+
+	// Update 'tag' element in the 'proxies' array to the new values.
+	UpdateProxyTags(tags, proxies);
+
+	m_world->m_stackAllocator.Free(tags);
+}
+#endif // defined(LIQUIDFUN_SIMD_NEON)
+
+// static
+bool b2ParticleSystem::ProxyBufferHasIndex(
+	int32 index, const Proxy* const a, int count)
+{
+	for (int j = 0; j < count; ++j)
+	{
+		if (a[j].index == index)
+			return true;
+	}
+	return false;
+}
+
+// static
+int b2ParticleSystem::NumProxiesWithSameTag(
+	const Proxy* const a, const Proxy* const b, int count)
+{
+	const uint32 tag = a[0].tag;
+	for (int num = 0; num < count; ++num)
+	{
+		if (a[num].tag != tag || b[num].tag != tag)
+			return num;
+	}
+	return count;
+}
+
+// Precondition: both 'a' and 'b' should be sorted by tag, but don't need to be
+// sorted by index.
+// static
+bool b2ParticleSystem::AreProxyBuffersTheSame(const b2GrowableBuffer<Proxy>& a,
+								   			  const b2GrowableBuffer<Proxy>& b)
+{
+	if (a.GetCount() != b.GetCount())
+		return false;
+
+	// A given tag may have several indices. The order of these indices is
+	// not important, but the set must be equivalent.
+	for (int i = 0; i < a.GetCount();)
+	{
+		const int numWithSameTag = NumProxiesWithSameTag(
+			&a[i], &b[i], a.GetCount() - i);
+		if (numWithSameTag == 0)
+			return false;
+
+		for (int j = 0; j < numWithSameTag; ++j)
+		{
+			const bool hasIndex = ProxyBufferHasIndex(
+				a[i + j].index, &b[i], numWithSameTag);
+			if (!hasIndex)
+				return false;
+		}
+
+		i += numWithSameTag;
+	}
+	return true;
+}
+
+LIQUIDFUN_SIMD_INLINE
+void b2ParticleSystem::UpdateProxies(
+	b2GrowableBuffer<Proxy>& proxies) const
+{
+	#if defined(LIQUIDFUN_SIMD_TEST_VS_REFERENCE)
+		b2GrowableBuffer<Proxy> reference(proxies);
+	#endif
+
+	#if defined(LIQUIDFUN_SIMD_NEON)
+    if(hasNeon)
+    {
+      UpdateProxies_Simd(proxies);
+    }
+    else
+    {
+      UpdateProxies_Reference(proxies);
+    }
+	#else
+		UpdateProxies_Reference(proxies);
+	#endif
+
+	#if defined(LIQUIDFUN_SIMD_TEST_VS_REFERENCE)
+		UpdateProxies_Reference(reference);
+		b2Assert(AreProxyBuffersTheSame(proxies, reference));
+	#endif
+}
+
+
+// Sort the proxy array by 'tag'. This orders the particles into rows that
+// run left-to-right, top-to-bottom. The rows are spaced m_particleDiameter
+// apart, such that a particle in one row can only collide with the rows
+// immediately above and below it. This ordering makes collision computation
+// tractable.
+//
+// TODO OPT: The sort is a hot spot on the profiles. We could use SIMD to
+// speed this up. See http://www.vldb.org/pvldb/1/1454171.pdf for an excellent
+// explanation of a SIMD mergesort algorithm.
+void b2ParticleSystem::SortProxies(b2GrowableBuffer<Proxy>& proxies) const
+{
+	std::sort(proxies.Begin(), proxies.End());
+}
+
+class b2ParticleContactRemovePredicate
+{
+public:
+	b2ParticleContactRemovePredicate(
+		b2ParticleSystem* system,
+		b2ContactFilter* contactFilter) :
+		m_system(system),
+		m_contactFilter(contactFilter)
+	{}
+
+	bool operator()(const b2ParticleContact& contact)
+	{
+	    return (contact.GetFlags() & b2_particleContactFilterParticle)
+	        && !m_contactFilter->ShouldCollide(m_system, contact.GetIndexA(),
+	        								   contact.GetIndexB());
+	}
+
+private:
+	b2ParticleSystem* m_system;
+	b2ContactFilter* m_contactFilter;
+};
+
+// Only changes 'contacts', but the contact filter has a non-const 'this'
+// pointer, so this member function cannot be const.
+void b2ParticleSystem::FilterContacts(
+	b2GrowableBuffer<b2ParticleContact>& contacts)
+{
+	// Optionally filter the contact.
+	b2ContactFilter* const contactFilter = GetParticleContactFilter();
+	if (contactFilter == NULL)
+		return;
+
+	contacts.RemoveIf(b2ParticleContactRemovePredicate(this, contactFilter));
+}
+
+void b2ParticleSystem::NotifyContactListenerPreContact(
+	b2ParticlePairSet* particlePairs) const
+{
+	b2ContactListener* const contactListener = GetParticleContactListener();
+	if (contactListener == NULL)
+		return;
+
+	particlePairs->Initialize(m_contactBuffer.Begin(),
+							  m_contactBuffer.GetCount(),
+						      GetFlagsBuffer());
+}
+
+// Note: This function is not const because 'this' in BeginContact and
+// EndContact callbacks must be non-const. However, this function itself
+// does not change any internal data (though the callbacks might).
+void b2ParticleSystem::NotifyContactListenerPostContact(
+	b2ParticlePairSet& particlePairs)
+{
+	b2ContactListener* const contactListener = GetParticleContactListener();
+	if (contactListener == NULL)
+		return;
+
+	// Loop through all new contacts, reporting any new ones, and
+	// "invalidating" the ones that still exist.
+	const b2ParticleContact* const endContact = m_contactBuffer.End();
+	for (b2ParticleContact* contact = m_contactBuffer.Begin();
+		 contact < endContact; ++contact)
+	{
+		ParticlePair pair;
+		pair.first = contact->GetIndexA();
+		pair.second = contact->GetIndexB();
+		const int32 itemIndex = particlePairs.Find(pair);
+		if (itemIndex >= 0)
+		{
+			// Already touching, ignore this contact.
+			particlePairs.Invalidate(itemIndex);
+		}
+		else
+		{
+			// Just started touching, inform the listener.
+			contactListener->BeginContact(this, contact);
+		}
+	}
+
+	// Report particles that are no longer touching.
+	// That is, any pairs that were not invalidated above.
+	const int32 pairCount = particlePairs.GetCount();
+	const ParticlePair* const pairs = particlePairs.GetBuffer();
+	const int8* const valid = particlePairs.GetValidBuffer();
+	for (int32 i = 0; i < pairCount; ++i)
+	{
+		if (valid[i])
+		{
+			contactListener->EndContact(this, pairs[i].first,
+										pairs[i].second);
+		}
+	}
+}
+
+void b2ParticleSystem::UpdateContacts(bool exceptZombie)
+{
+	UpdateProxies(m_proxyBuffer);
+	SortProxies(m_proxyBuffer);
+
+	b2ParticlePairSet particlePairs(&m_world->m_stackAllocator);
+	NotifyContactListenerPreContact(&particlePairs);
+
+	FindContacts(m_contactBuffer);
+	FilterContacts(m_contactBuffer);
+
+	NotifyContactListenerPostContact(particlePairs);
+
+	if (exceptZombie)
+	{
+		m_contactBuffer.RemoveIf(b2ParticleContactIsZombie);
+	}
+}
+
+void b2ParticleSystem::DetectStuckParticle(int32 particle)
+{
+	// Detect stuck particles
+	//
+	// The basic algorithm is to allow the user to specify an optional
+	// threshold where we detect whenever a particle is contacting
+	// more than one fixture for more than threshold consecutive
+	// steps. This is considered to be "stuck", and these are put
+	// in a list the user can query per step, if enabled, to deal with
+	// such particles.
+
+	if (m_stuckThreshold <= 0)
+	{
+		return;
+	}
+
+	// Get the state variables for this particle.
+	int32 * const consecutiveCount =
+			&m_consecutiveContactStepsBuffer.data[particle];
+	int32 * const lastStep = &m_lastBodyContactStepBuffer.data[particle];
+	int32 * const bodyCount = &m_bodyContactCountBuffer.data[particle];
+
+	// This is only called when there is a body contact for this particle.
+	++(*bodyCount);
+
+	// We want to only trigger detection once per step, the first time we
+	// contact more than one fixture in a step for a given particle.
+	if (*bodyCount == 2)
+	{
+		++(*consecutiveCount);
+		if (*consecutiveCount > m_stuckThreshold)
+		{
+			int32& newStuckParticle = m_stuckParticleBuffer.Append();
+			newStuckParticle = particle;
+		}
+	}
+	*lastStep = m_timestamp;
+}
+
+// Get the world's contact listener if any particles with the
+// b2_fixtureContactListenerParticle flag are present in the system.
+inline b2ContactListener* b2ParticleSystem::GetFixtureContactListener() const
+{
+	return (m_allParticleFlags & b2_fixtureContactListenerParticle) ?
+		m_world->m_contactManager.m_contactListener : NULL;
+}
+
+// Get the world's contact filter if any particles with the
+// b2_fixtureContactFilterParticle flag are present in the system.
+inline b2ContactFilter* b2ParticleSystem::GetFixtureContactFilter() const
+{
+	return (m_allParticleFlags & b2_fixtureContactFilterParticle) ?
+		m_world->m_contactManager.m_contactFilter : NULL;
+}
+
+/// Compute the axis-aligned bounding box for all particles contained
+/// within this particle system.
+/// @param aabb Returns the axis-aligned bounding box of the system.
+void b2ParticleSystem::ComputeAABB(b2AABB* const aabb) const
+{
+	const int32 particleCount = GetParticleCount();
+	b2Assert(aabb);
+	aabb->lowerBound.x = +b2_maxFloat;
+	aabb->lowerBound.y = +b2_maxFloat;
+	aabb->upperBound.x = -b2_maxFloat;
+	aabb->upperBound.y = -b2_maxFloat;
+
+	for (int32 i = 0; i < particleCount; i++)
+	{
+		b2Vec2 p = m_positionBuffer.data[i];
+		aabb->lowerBound = b2Min(aabb->lowerBound, p);
+		aabb->upperBound = b2Max(aabb->upperBound, p);
+	}
+	aabb->lowerBound.x -= m_particleDiameter;
+	aabb->lowerBound.y -= m_particleDiameter;
+	aabb->upperBound.x += m_particleDiameter;
+	aabb->upperBound.y += m_particleDiameter;
+}
+
+// Associate a memory allocator with this object.
+FixedSetAllocator::FixedSetAllocator(
+		b2StackAllocator* allocator) :
+	m_buffer(NULL), m_valid(NULL), m_count(0), m_allocator(allocator)
+{
+	b2Assert(allocator);
+}
+
+// Allocate internal storage for this object.
+int32 FixedSetAllocator::Allocate(
+	const int32 itemSize, const int32 count)
+{
+	Clear();
+	if (count)
+	{
+		m_buffer = m_allocator->Allocate(
+			(itemSize + sizeof(*m_valid)) * count);
+		b2Assert(m_buffer);
+		m_valid = (int8*)m_buffer + (itemSize * count);
+		memset(m_valid, 1, sizeof(*m_valid) * count);
+		m_count = count;
+	}
+	return m_count;
+}
+
+// Deallocate the internal buffer if it's allocated.
+void FixedSetAllocator::Clear()
+{
+	if (m_buffer)
+	{
+		m_allocator->Free(m_buffer);
+		m_buffer = NULL;
+        m_count = 0;
+	}
+}
+
+// Search set for item returning the index of the item if it's found, -1
+// otherwise.
+template<typename T>
+static int32 FindItemIndexInFixedSet(const TypedFixedSetAllocator<T>& set,
+									 const T& item)
+{
+	if (set.GetCount())
+	{
+		const T* buffer = set.GetBuffer();
+		const T* last = buffer + set.GetCount();
+		const T* found = std::lower_bound( buffer, buffer + set.GetCount(),
+											item, T::Compare);
+		if( found != last )
+		{
+			return set.GetIndex( found );
+		}
+	}
+	return -1;
+}
+
+// Initialize from a set of particle / body contacts for particles
+// that have the b2_fixtureContactListenerParticle flag set.
+void FixtureParticleSet::Initialize(
+	const b2ParticleBodyContact * const bodyContacts,
+	const int32 numBodyContacts,
+	const uint32 * const particleFlagsBuffer)
+{
+	Clear();
+	if (Allocate(numBodyContacts))
+	{
+		FixtureParticle* set = GetBuffer();
+		int32 insertedContacts = 0;
+		for (int32 i = 0; i < numBodyContacts; ++i)
+		{
+			FixtureParticle* const fixtureParticle = &set[i];
+			const b2ParticleBodyContact& bodyContact = bodyContacts[i];
+			if (bodyContact.index == b2_invalidParticleIndex ||
+				!(particleFlagsBuffer[bodyContact.index] &
+				  b2_fixtureContactListenerParticle))
+			{
+				continue;
+			}
+			fixtureParticle->first = bodyContact.fixture;
+			fixtureParticle->second = bodyContact.index;
+			insertedContacts++;
+		}
+		SetCount(insertedContacts);
+		std::sort(set, set + insertedContacts, FixtureParticle::Compare);
+	}
+}
+
+// Find the index of a particle / fixture pair in the set or -1 if it's not
+// present.
+int32 FixtureParticleSet::Find(
+	const FixtureParticle& fixtureParticle) const
+{
+	return FindItemIndexInFixedSet(*this, fixtureParticle);
+}
+
+// Initialize from a set of particle contacts.
+void b2ParticlePairSet::Initialize(
+	const b2ParticleContact * const contacts, const int32 numContacts,
+	const uint32 * const particleFlagsBuffer)
+{
+	Clear();
+	if (Allocate(numContacts))
+	{
+		ParticlePair* set = GetBuffer();
+		int32 insertedContacts = 0;
+		for (int32 i = 0; i < numContacts; ++i)
+		{
+			ParticlePair* const pair = &set[i];
+			const b2ParticleContact& contact = contacts[i];
+			if (contact.GetIndexA() == b2_invalidParticleIndex ||
+				contact.GetIndexB() == b2_invalidParticleIndex ||
+				!((particleFlagsBuffer[contact.GetIndexA()] |
+				   particleFlagsBuffer[contact.GetIndexB()]) &
+				  b2_particleContactListenerParticle))
+			{
+				continue;
+			}
+			pair->first = contact.GetIndexA();
+			pair->second = contact.GetIndexB();
+			insertedContacts++;
+		}
+		SetCount(insertedContacts);
+		std::sort(set, set + insertedContacts, ParticlePair::Compare);
+	}
+}
+
+// Find the index of a particle pair in the set or -1 if it's not present.
+int32 b2ParticlePairSet::Find(const ParticlePair& pair) const
+{
+	int32 index = FindItemIndexInFixedSet(*this, pair);
+	if (index < 0)
+	{
+		ParticlePair swapped;
+		swapped.first = pair.second;
+		swapped.second = pair.first;
+		index = FindItemIndexInFixedSet(*this, swapped);
+	}
+	return index;
+}
+
+/// Callback class to receive pairs of fixtures and particles which may be
+/// overlapping. Used as an argument of b2World::QueryAABB.
+class b2FixtureParticleQueryCallback : public b2QueryCallback
+{
+public:
+	explicit b2FixtureParticleQueryCallback(b2ParticleSystem* system)
+	{
+		m_system = system;
+	}
+
+private:
+	// Skip reporting particles.
+	bool ShouldQueryParticleSystem(const b2ParticleSystem* system)
+	{
+		B2_NOT_USED(system);
+		return false;
+	}
+
+	// Receive a fixture and call ReportFixtureAndParticle() for each particle
+	// inside aabb of the fixture.
+	bool ReportFixture(b2Fixture* fixture)
+	{
+		if (fixture->IsSensor())
+		{
+			return true;
+		}
+		const b2Shape* shape = fixture->GetShape();
+		int32 childCount = shape->GetChildCount();
+		for (int32 childIndex = 0; childIndex < childCount; childIndex++)
+		{
+			b2AABB aabb = fixture->GetAABB(childIndex);
+			b2ParticleSystem::InsideBoundsEnumerator enumerator =
+								m_system->GetInsideBoundsEnumerator(aabb);
+			int32 index;
+			while ((index = enumerator.GetNext()) >= 0)
+			{
+				ReportFixtureAndParticle(fixture, childIndex, index);
+			}
+		}
+		return true;
+	}
+
+	// Receive a fixture and a particle which may be overlapping.
+	virtual void ReportFixtureAndParticle(
+						b2Fixture* fixture, int32 childIndex, int32 index) = 0;
+
+protected:
+	b2ParticleSystem* m_system;
+};
+
+void b2ParticleSystem::NotifyBodyContactListenerPreContact(
+	FixtureParticleSet* fixtureSet) const
+{
+	b2ContactListener* const contactListener = GetFixtureContactListener();
+	if (contactListener == NULL)
+		return;
+
+	fixtureSet->Initialize(m_bodyContactBuffer.Begin(),
+						   m_bodyContactBuffer.GetCount(),
+						   GetFlagsBuffer());
+}
+
+// If a contact listener is present and the contact is just starting
+// report the contact.  If the contact is already in progress invalid
+// the contact from m_fixtureSet.
+void b2ParticleSystem::NotifyBodyContactListenerPostContact(
+	FixtureParticleSet& fixtureSet)
+{
+	b2ContactListener* const contactListener = GetFixtureContactListener();
+	if (contactListener == NULL)
+		return;
+
+	// Loop through all new contacts, reporting any new ones, and
+	// "invalidating" the ones that still exist.
+	for (b2ParticleBodyContact* contact = m_bodyContactBuffer.Begin();
+		 contact != m_bodyContactBuffer.End(); ++contact)
+	{
+		b2Assert(contact);
+		FixtureParticle fixtureParticleToFind;
+		fixtureParticleToFind.first = contact->fixture;
+		fixtureParticleToFind.second = contact->index;
+		const int32 index = fixtureSet.Find(fixtureParticleToFind);
+		if (index >= 0)
+		{
+			// Already touching remove this from the set.
+			fixtureSet.Invalidate(index);
+		}
+		else
+		{
+			// Just started touching, report it!
+			contactListener->BeginContact(this, contact);
+		}
+	}
+
+	// If the contact listener is enabled, report all fixtures that are no
+	// longer in contact with particles.
+	const FixtureParticle* const fixtureParticles = fixtureSet.GetBuffer();
+	const int8* const fixtureParticlesValid = fixtureSet.GetValidBuffer();
+	const int32 fixtureParticleCount = fixtureSet.GetCount();
+	for (int32 i = 0; i < fixtureParticleCount; ++i)
+	{
+		if (fixtureParticlesValid[i])
+		{
+			const FixtureParticle* const fixtureParticle =
+				&fixtureParticles[i];
+			contactListener->EndContact(fixtureParticle->first, this,
+										fixtureParticle->second);
+		}
+	}
+}
+
+
+void b2ParticleSystem::UpdateBodyContacts()
+{
+	// If the particle contact listener is enabled, generate a set of
+	// fixture / particle contacts.
+	FixtureParticleSet fixtureSet(&m_world->m_stackAllocator);
+	NotifyBodyContactListenerPreContact(&fixtureSet);
+
+	if (m_stuckThreshold > 0)
+	{
+		const int32 particleCount = GetParticleCount();
+		for (int32 i = 0; i < particleCount; i++)
+		{
+			// Detect stuck particles, see comment in
+			// b2ParticleSystem::DetectStuckParticle()
+			m_bodyContactCountBuffer.data[i] = 0;
+			if (m_timestamp > (m_lastBodyContactStepBuffer.data[i] + 1))
+			{
+				m_consecutiveContactStepsBuffer.data[i] = 0;
+			}
+		}
+	}
+	m_bodyContactBuffer.SetCount(0);
+	m_stuckParticleBuffer.SetCount(0);
+
+	class UpdateBodyContactsCallback : public b2FixtureParticleQueryCallback
+	{
+		// Call the contact filter if it's set, to determine whether to
+		// filter this contact.  Returns true if contact calculations should
+		// be performed, false otherwise.
+		inline bool ShouldCollide(b2Fixture * const fixture,
+								  int32 particleIndex)
+		{
+			if (m_contactFilter)
+			{
+				const uint32* const flags = m_system->GetFlagsBuffer();
+				if (flags[particleIndex] & b2_fixtureContactFilterParticle)
+				{
+					return m_contactFilter->ShouldCollide(fixture, m_system,
+														  particleIndex);
+				}
+			}
+			return true;
+		}
+
+		void ReportFixtureAndParticle(
+								b2Fixture* fixture, int32 childIndex, int32 a)
+		{
+			b2Vec2 ap = m_system->m_positionBuffer.data[a];
+			float32 d;
+			b2Vec2 n;
+			fixture->ComputeDistance(ap, &d, &n, childIndex);
+			if (d < m_system->m_particleDiameter && ShouldCollide(fixture, a))
+			{
+				b2Body* b = fixture->GetBody();
+				b2Vec2 bp = b->GetWorldCenter();
+				float32 bm = b->GetMass();
+				float32 bI =
+					b->GetInertia() - bm * b->GetLocalCenter().LengthSquared();
+				float32 invBm = bm > 0 ? 1 / bm : 0;
+				float32 invBI = bI > 0 ? 1 / bI : 0;
+				float32 invAm =
+					m_system->m_flagsBuffer.data[a] &
+					b2_wallParticle ? 0 : m_system->GetParticleInvMass();
+				b2Vec2 rp = ap - bp;
+				float32 rpn = b2Cross(rp, n);
+				float32 invM = invAm + invBm + invBI * rpn * rpn;
+
+				b2ParticleBodyContact& contact =
+					m_system->m_bodyContactBuffer.Append();
+				contact.index = a;
+				contact.body = b;
+				contact.fixture = fixture;
+				contact.weight = 1 - d * m_system->m_inverseDiameter;
+				contact.normal = -n;
+				contact.mass = invM > 0 ? 1 / invM : 0;
+				m_system->DetectStuckParticle(a);
+			}
+		}
+
+		b2ContactFilter* m_contactFilter;
+
+	public:
+		UpdateBodyContactsCallback(
+			b2ParticleSystem* system, b2ContactFilter* contactFilter):
+			b2FixtureParticleQueryCallback(system)
+		{
+			m_contactFilter = contactFilter;
+		}
+	} callback(this, GetFixtureContactFilter());
+
+	b2AABB aabb;
+	ComputeAABB(&aabb);
+	m_world->QueryAABB(&callback, aabb);
+
+	if (m_def.strictContactCheck)
+	{
+		RemoveSpuriousBodyContacts();
+	}
+
+	NotifyBodyContactListenerPostContact(fixtureSet);
+}
+
+void b2ParticleSystem::RemoveSpuriousBodyContacts()
+{
+	// At this point we have a list of contact candidates based on AABB
+	// overlap.The AABB query that  generated this returns all collidable
+	// fixtures overlapping particle bounding boxes.  This breaks down around
+	// vertices where two shapes intersect, such as a "ground" surface made
+	// of multiple b2PolygonShapes; it potentially applies a lot of spurious
+	// impulses from normals that should not actually contribute.  See the
+	// Ramp example in Testbed.
+	//
+	// To correct for this, we apply this algorithm:
+	//   * sort contacts by particle and subsort by weight (nearest to farthest)
+	//   * for each contact per particle:
+	//      - project a point at the contact distance along the inverse of the
+	//        contact normal
+	//      - if this intersects the fixture that generated the contact, apply
+	//         it, otherwise discard as impossible
+	//      - repeat for up to n nearest contacts, currently we get good results
+	//        from n=3.
+	std::sort(m_bodyContactBuffer.Begin(), m_bodyContactBuffer.End(),
+				b2ParticleSystem::BodyContactCompare);
+
+	int32 discarded = 0;
+
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable : 4858)
+#else
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-result"
+#endif
+
+  std::remove_if(m_bodyContactBuffer.Begin(),
+					m_bodyContactBuffer.End(),
+					b2ParticleBodyContactRemovePredicate(this, &discarded));
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#else
+#pragma GCC diagnostic pop
+#endif
+
+	m_bodyContactBuffer.SetCount(m_bodyContactBuffer.GetCount() - discarded);
+}
+
+bool b2ParticleSystem::BodyContactCompare(const b2ParticleBodyContact &lhs,
+										  const b2ParticleBodyContact &rhs)
+{
+	if (lhs.index == rhs.index)
+	{
+		// Subsort by weight, decreasing.
+		return lhs.weight > rhs.weight;
+	}
+	return lhs.index < rhs.index;
+}
+
+
+void b2ParticleSystem::SolveCollision(const b2TimeStep& step)
+{
+	// This function detects particles which are crossing boundary of bodies
+	// and modifies velocities of them so that they will move just in front of
+	// boundary. This function function also applies the reaction force to
+	// bodies as precisely as the numerical stability is kept.
+	b2AABB aabb;
+	aabb.lowerBound.x = +b2_maxFloat;
+	aabb.lowerBound.y = +b2_maxFloat;
+	aabb.upperBound.x = -b2_maxFloat;
+	aabb.upperBound.y = -b2_maxFloat;
+	for (int32 i = 0; i < m_count; i++)
+	{
+		b2Vec2 v = m_velocityBuffer.data[i];
+		b2Vec2 p1 = m_positionBuffer.data[i];
+		b2Vec2 p2 = p1 + step.dt * v;
+		aabb.lowerBound = b2Min(aabb.lowerBound, b2Min(p1, p2));
+		aabb.upperBound = b2Max(aabb.upperBound, b2Max(p1, p2));
+	}
+	class SolveCollisionCallback : public b2FixtureParticleQueryCallback
+	{
+		void ReportFixtureAndParticle(
+								b2Fixture* fixture, int32 childIndex, int32 a)
+		{
+			b2Body* body = fixture->GetBody();
+			b2Vec2 ap = m_system->m_positionBuffer.data[a];
+			b2Vec2 av = m_system->m_velocityBuffer.data[a];
+			b2RayCastOutput output;
+			b2RayCastInput input;
+			if (m_system->m_iterationIndex == 0)
+			{
+				// Put 'ap' in the local space of the previous frame
+				b2Vec2 p1 = b2MulT(body->m_xf0, ap);
+				if (fixture->GetShape()->GetType() == b2Shape::e_circle)
+				{
+					// Make relative to the center of the circle
+					p1 -= body->GetLocalCenter();
+					// Re-apply rotation about the center of the
+					// circle
+					p1 = b2Mul(body->m_xf0.q, p1);
+					// Subtract rotation of the current frame
+					p1 = b2MulT(body->m_xf.q, p1);
+					// Return to local space
+					p1 += body->GetLocalCenter();
+				}
+				// Return to global space and apply rotation of current frame
+				input.p1 = b2Mul(body->m_xf, p1);
+			}
+			else
+			{
+				input.p1 = ap;
+			}
+			input.p2 = ap + m_step.dt * av;
+			input.maxFraction = 1;
+			if (fixture->RayCast(&output, input, childIndex))
+			{
+				b2Vec2 n = output.normal;
+				b2Vec2 p =
+					(1 - output.fraction) * input.p1 +
+					output.fraction * input.p2 +
+					b2_linearSlop * n;
+				b2Vec2 v = m_step.inv_dt * (p - ap);
+				m_system->m_velocityBuffer.data[a] = v;
+				b2Vec2 f = m_step.inv_dt *
+					m_system->GetParticleMass() * (av - v);
+				m_system->ParticleApplyForce(a, f);
+			}
+		}
+
+		b2TimeStep m_step;
+
+	public:
+		SolveCollisionCallback(
+			b2ParticleSystem* system, const b2TimeStep& step):
+			b2FixtureParticleQueryCallback(system)
+		{
+			m_step = step;
+		}
+	} callback(this, step);
+	m_world->QueryAABB(&callback, aabb);
+}
+
+void b2ParticleSystem::SolveBarrier(const b2TimeStep& step)
+{
+	// If a particle is passing between paired barrier particles,
+	// its velocity will be decelerated to avoid passing.
+	for (int32 i = 0; i < m_count; i++)
+	{
+		uint32 flags = m_flagsBuffer.data[i];
+		static const uint32 k_barrierWallFlags =
+										b2_barrierParticle | b2_wallParticle;
+		if ((flags & k_barrierWallFlags) == k_barrierWallFlags)
+		{
+			m_velocityBuffer.data[i].SetZero();
+		}
+	}
+	float32 tmax = b2_barrierCollisionTime * step.dt;
+	for (int32 k = 0; k < m_pairBuffer.GetCount(); k++)
+	{
+		const b2ParticlePair& pair = m_pairBuffer[k];
+		if (pair.flags & b2_barrierParticle)
+		{
+			int32 a = pair.indexA;
+			int32 b = pair.indexB;
+			b2Vec2 pa = m_positionBuffer.data[a];
+			b2Vec2 pb = m_positionBuffer.data[b];
+			b2AABB aabb;
+			aabb.lowerBound = b2Min(pa, pb);
+			aabb.upperBound = b2Max(pa, pb);
+			b2ParticleGroup *aGroup = m_groupBuffer[a];
+			b2ParticleGroup *bGroup = m_groupBuffer[b];
+			b2Vec2 va = GetLinearVelocity(aGroup, a, pa);
+			b2Vec2 vb = GetLinearVelocity(bGroup, b, pb);
+			b2Vec2 pba = pb - pa;
+			b2Vec2 vba = vb - va;
+			InsideBoundsEnumerator enumerator = GetInsideBoundsEnumerator(aabb);
+			int32 c;
+			while ((c = enumerator.GetNext()) >= 0)
+			{
+				b2Vec2 pc = m_positionBuffer.data[c];
+				b2ParticleGroup *cGroup = m_groupBuffer[c];
+				if (aGroup != cGroup && bGroup != cGroup)
+				{
+					b2Vec2 vc = GetLinearVelocity(cGroup, c, pc);
+					// Solve the equation below:
+					//   (1-s)*(pa+t*va)+s*(pb+t*vb) = pc+t*vc
+					// which expresses that the particle c will pass a line
+					// connecting the particles a and b at the time of t.
+					// if s is between 0 and 1, c will pass between a and b.
+					b2Vec2 pca = pc - pa;
+					b2Vec2 vca = vc - va;
+					float32 e2 = b2Cross(vba, vca);
+					float32 e1 = b2Cross(pba, vca) - b2Cross(pca, vba);
+					float32 e0 = b2Cross(pba, pca);
+					float32 s, t;
+					b2Vec2 qba, qca;
+					if (e2 == 0)
+					{
+						if (e1 == 0) continue;
+						t = - e0 / e1;
+						if (!(t >= 0 && t < tmax)) continue;
+						qba = pba + t * vba;
+						qca = pca + t * vca;
+						s = b2Dot(qba, qca) / b2Dot(qba, qba);
+						if (!(s >= 0 && s <= 1)) continue;
+					}
+					else
+					{
+						float32 det = e1 * e1 - 4 * e0 * e2;
+						if (det < 0) continue;
+						float32 sqrtDet = b2Sqrt(det);
+						float32 t1 = (- e1 - sqrtDet) / (2 * e2);
+						float32 t2 = (- e1 + sqrtDet) / (2 * e2);
+						if (t1 > t2) b2Swap(t1, t2);
+						t = t1;
+						qba = pba + t * vba;
+						qca = pca + t * vca;
+						s = b2Dot(qba, qca) / b2Dot(qba, qba);
+						if (!(t >= 0 && t < tmax && s >= 0 && s <= 1))
+						{
+							t = t2;
+							if (!(t >= 0 && t < tmax)) continue;
+							qba = pba + t * vba;
+							qca = pca + t * vca;
+							s = b2Dot(qba, qca) / b2Dot(qba, qba);
+							if (!(s >= 0 && s <= 1)) continue;
+						}
+					}
+					// Apply a force to particle c so that it will have the
+					// interpolated velocity at the collision point on line ab.
+					b2Vec2 dv = va + s * vba - vc;
+					b2Vec2 f = GetParticleMass() * dv;
+					if (IsRigidGroup(cGroup))
+					{
+						// If c belongs to a rigid group, the force will be
+						// distributed in the group.
+						float32 mass = cGroup->GetMass();
+						float32 inertia = cGroup->GetInertia();
+						if (mass > 0)
+						{
+							cGroup->m_linearVelocity += 1 / mass * f;
+						}
+						if (inertia > 0)
+						{
+							cGroup->m_angularVelocity +=
+								b2Cross(pc - cGroup->GetCenter(), f) / inertia;
+						}
+					}
+					else
+					{
+						m_velocityBuffer.data[c] += dv;
+					}
+					// Apply a reversed force to particle c after particle
+					// movement so that momentum will be preserved.
+					ParticleApplyForce(c, -step.inv_dt * f);
+				}
+			}
+		}
+	}
+}
+
+void b2ParticleSystem::Solve(const b2TimeStep& step)
+{
+	if (m_count == 0)
+	{
+		return;
+	}
+	// If particle lifetimes are enabled, destroy particles that are too old.
+	if (m_expirationTimeBuffer.data)
+	{
+		SolveLifetimes(step);
+	}
+	if (m_allParticleFlags & b2_zombieParticle)
+	{
+		SolveZombie();
+	}
+	if (m_needsUpdateAllParticleFlags)
+	{
+		UpdateAllParticleFlags();
+	}
+	if (m_needsUpdateAllGroupFlags)
+	{
+		UpdateAllGroupFlags();
+	}
+	if (m_paused)
+	{
+		return;
+	}
+	for (m_iterationIndex = 0;
+		m_iterationIndex < step.particleIterations;
+		m_iterationIndex++)
+	{
+		++m_timestamp;
+		b2TimeStep subStep = step;
+		subStep.dt /= step.particleIterations;
+		subStep.inv_dt *= step.particleIterations;
+		UpdateContacts(false);
+		UpdateBodyContacts();
+		ComputeWeight();
+		if (m_allGroupFlags & b2_particleGroupNeedsUpdateDepth)
+		{
+			ComputeDepth();
+		}
+		if (m_allParticleFlags & b2_reactiveParticle)
+		{
+			UpdatePairsAndTriadsWithReactiveParticles();
+		}
+		if (m_hasForce)
+		{
+			SolveForce(subStep);
+		}
+		if (m_allParticleFlags & b2_viscousParticle)
+		{
+			SolveViscous();
+		}
+		if (m_allParticleFlags & b2_repulsiveParticle)
+		{
+			SolveRepulsive(subStep);
+		}
+		if (m_allParticleFlags & b2_powderParticle)
+		{
+			SolvePowder(subStep);
+		}
+		if (m_allParticleFlags & b2_tensileParticle)
+		{
+			SolveTensile(subStep);
+		}
+		if (m_allGroupFlags & b2_solidParticleGroup)
+		{
+			SolveSolid(subStep);
+		}
+		if (m_allParticleFlags & b2_colorMixingParticle)
+		{
+			SolveColorMixing();
+		}
+		SolveGravity(subStep);
+		if (m_allParticleFlags & b2_staticPressureParticle)
+		{
+			SolveStaticPressure(subStep);
+		}
+		SolvePressure(subStep);
+		SolveDamping(subStep);
+		if (m_allParticleFlags & k_extraDampingFlags)
+		{
+			SolveExtraDamping();
+		}
+		// SolveElastic and SolveSpring refer the current velocities for
+		// numerical stability, they should be called as late as possible.
+		if (m_allParticleFlags & b2_elasticParticle)
+		{
+			SolveElastic(subStep);
+		}
+		if (m_allParticleFlags & b2_springParticle)
+		{
+			SolveSpring(subStep);
+		}
+		LimitVelocity(subStep);
+		if (m_allGroupFlags & b2_rigidParticleGroup)
+		{
+			SolveRigidDamping();
+		}
+		if (m_allParticleFlags & b2_barrierParticle)
+		{
+			SolveBarrier(subStep);
+		}
+		// SolveCollision, SolveRigid and SolveWall should be called after
+		// other force functions because they may require particles to have
+		// specific velocities.
+		SolveCollision(subStep);
+		if (m_allGroupFlags & b2_rigidParticleGroup)
+		{
+			SolveRigid(subStep);
+		}
+		if (m_allParticleFlags & b2_wallParticle)
+		{
+			SolveWall();
+		}
+		// The particle positions can be updated only at the end of substep.
+		for (int32 i = 0; i < m_count; i++)
+		{
+			m_positionBuffer.data[i] += subStep.dt * m_velocityBuffer.data[i];
+		}
+	}
+}
+
+void b2ParticleSystem::UpdateAllParticleFlags()
+{
+	m_allParticleFlags = 0;
+	for (int32 i = 0; i < m_count; i++)
+	{
+		m_allParticleFlags |= m_flagsBuffer.data[i];
+	}
+	m_needsUpdateAllParticleFlags = false;
+}
+
+void b2ParticleSystem::UpdateAllGroupFlags()
+{
+	m_allGroupFlags = 0;
+	for (const b2ParticleGroup* group = m_groupList; group;
+		 group = group->GetNext())
+	{
+		m_allGroupFlags |= group->m_groupFlags;
+	}
+	m_needsUpdateAllGroupFlags = false;
+}
+
+void b2ParticleSystem::LimitVelocity(const b2TimeStep& step)
+{
+	float32 criticalVelocitySquared = GetCriticalVelocitySquared(step);
+	for (int32 i = 0; i < m_count; i++)
+	{
+		b2Vec2& v = m_velocityBuffer.data[i];
+		float32 v2 = b2Dot(v, v);
+		if (v2 > criticalVelocitySquared)
+		{
+			v *= b2Sqrt(criticalVelocitySquared / v2);
+		}
+	}
+}
+
+void b2ParticleSystem::SolveGravity(const b2TimeStep& step)
+{
+	b2Vec2 gravity = step.dt * m_def.gravityScale * m_world->GetGravity();
+	for (int32 i = 0; i < m_count; i++)
+	{
+		m_velocityBuffer.data[i] += gravity;
+	}
+}
+
+void b2ParticleSystem::SolveStaticPressure(const b2TimeStep& step)
+{
+	m_staticPressureBuffer = RequestBuffer(m_staticPressureBuffer);
+	float32 criticalPressure = GetCriticalPressure(step);
+	float32 pressurePerWeight = m_def.staticPressureStrength * criticalPressure;
+	float32 maxPressure = b2_maxParticlePressure * criticalPressure;
+	float32 relaxation = m_def.staticPressureRelaxation;
+	/// Compute pressure satisfying the modified Poisson equation:
+	///     Sum_for_j((p_i - p_j) * w_ij) + relaxation * p_i =
+	///     pressurePerWeight * (w_i - b2_minParticleWeight)
+	/// by iterating the calculation:
+	///     p_i = (Sum_for_j(p_j * w_ij) + pressurePerWeight *
+	///           (w_i - b2_minParticleWeight)) / (w_i + relaxation)
+	/// where
+	///     p_i and p_j are static pressure of particle i and j
+	///     w_ij is contact weight between particle i and j
+	///     w_i is sum of contact weight of particle i
+	for (int32 t = 0; t < m_def.staticPressureIterations; t++)
+	{
+		memset(m_accumulationBuffer, 0,
+			   sizeof(*m_accumulationBuffer) * m_count);
+		for (int32 k = 0; k < m_contactBuffer.GetCount(); k++)
+		{
+			const b2ParticleContact& contact = m_contactBuffer[k];
+			if (contact.GetFlags() & b2_staticPressureParticle)
+			{
+				int32 a = contact.GetIndexA();
+				int32 b = contact.GetIndexB();
+				float32 w = contact.GetWeight();
+				m_accumulationBuffer[a] +=
+					w * m_staticPressureBuffer[b]; // a <- b
+				m_accumulationBuffer[b] +=
+					w * m_staticPressureBuffer[a]; // b <- a
+			}
+		}
+		for (int32 i = 0; i < m_count; i++)
+		{
+			float32 w = m_weightBuffer[i];
+			if (m_flagsBuffer.data[i] & b2_staticPressureParticle)
+			{
+				float32 wh = m_accumulationBuffer[i];
+				float32 h =
+					(wh + pressurePerWeight * (w - b2_minParticleWeight)) /
+					(w + relaxation);
+				m_staticPressureBuffer[i] = b2Clamp(h, 0.0f, maxPressure);
+			}
+			else
+			{
+				m_staticPressureBuffer[i] = 0;
+			}
+		}
+	}
+}
+
+void b2ParticleSystem::SolvePressure(const b2TimeStep& step)
+{
+	// calculates pressure as a linear function of density
+	float32 criticalPressure = GetCriticalPressure(step);
+	float32 pressurePerWeight = m_def.pressureStrength * criticalPressure;
+	float32 maxPressure = b2_maxParticlePressure * criticalPressure;
+	for (int32 i = 0; i < m_count; i++)
+	{
+		float32 w = m_weightBuffer[i];
+		float32 h = pressurePerWeight * b2Max(0.0f, w - b2_minParticleWeight);
+		m_accumulationBuffer[i] = b2Min(h, maxPressure);
+	}
+	// ignores particles which have their own repulsive force
+	if (m_allParticleFlags & k_noPressureFlags)
+	{
+		for (int32 i = 0; i < m_count; i++)
+		{
+			if (m_flagsBuffer.data[i] & k_noPressureFlags)
+			{
+				m_accumulationBuffer[i] = 0;
+			}
+		}
+	}
+	// static pressure
+	if (m_allParticleFlags & b2_staticPressureParticle)
+	{
+		b2Assert(m_staticPressureBuffer);
+		for (int32 i = 0; i < m_count; i++)
+		{
+			if (m_flagsBuffer.data[i] & b2_staticPressureParticle)
+			{
+				m_accumulationBuffer[i] += m_staticPressureBuffer[i];
+			}
+		}
+	}
+	// applies pressure between each particles in contact
+	float32 velocityPerPressure = step.dt / (m_def.density * m_particleDiameter);
+	for (int32 k = 0; k < m_bodyContactBuffer.GetCount(); k++)
+	{
+		const b2ParticleBodyContact& contact = m_bodyContactBuffer[k];
+		int32 a = contact.index;
+		b2Body* b = contact.body;
+		float32 w = contact.weight;
+		float32 m = contact.mass;
+		b2Vec2 n = contact.normal;
+		b2Vec2 p = m_positionBuffer.data[a];
+		float32 h = m_accumulationBuffer[a] + pressurePerWeight * w;
+		b2Vec2 f = velocityPerPressure * w * m * h * n;
+		m_velocityBuffer.data[a] -= GetParticleInvMass() * f;
+		b->ApplyLinearImpulse(f, p, true);
+	}
+	for (int32 k = 0; k < m_contactBuffer.GetCount(); k++)
+	{
+		const b2ParticleContact& contact = m_contactBuffer[k];
+		int32 a = contact.GetIndexA();
+		int32 b = contact.GetIndexB();
+		float32 w = contact.GetWeight();
+		b2Vec2 n = contact.GetNormal();
+		float32 h = m_accumulationBuffer[a] + m_accumulationBuffer[b];
+		b2Vec2 f = velocityPerPressure * w * h * n;
+		m_velocityBuffer.data[a] -= f;
+		m_velocityBuffer.data[b] += f;
+	}
+}
+
+void b2ParticleSystem::SolveDamping(const b2TimeStep& step)
+{
+	// reduces normal velocity of each contact
+	float32 linearDamping = m_def.dampingStrength;
+	float32 quadraticDamping = 1 / GetCriticalVelocity(step);
+	for (int32 k = 0; k < m_bodyContactBuffer.GetCount(); k++)
+	{
+		const b2ParticleBodyContact& contact = m_bodyContactBuffer[k];
+		int32 a = contact.index;
+		b2Body* b = contact.body;
+		float32 w = contact.weight;
+		float32 m = contact.mass;
+		b2Vec2 n = contact.normal;
+		b2Vec2 p = m_positionBuffer.data[a];
+		b2Vec2 v = b->GetLinearVelocityFromWorldPoint(p) -
+				   m_velocityBuffer.data[a];
+		float32 vn = b2Dot(v, n);
+		if (vn < 0)
+		{
+			float32 damping =
+				b2Max(linearDamping * w, b2Min(- quadraticDamping * vn, 0.5f));
+			b2Vec2 f = damping * m * vn * n;
+			m_velocityBuffer.data[a] += GetParticleInvMass() * f;
+			b->ApplyLinearImpulse(-f, p, true);
+		}
+	}
+	for (int32 k = 0; k < m_contactBuffer.GetCount(); k++)
+	{
+		const b2ParticleContact& contact = m_contactBuffer[k];
+		int32 a = contact.GetIndexA();
+		int32 b = contact.GetIndexB();
+		float32 w = contact.GetWeight();
+		b2Vec2 n = contact.GetNormal();
+		b2Vec2 v = m_velocityBuffer.data[b] - m_velocityBuffer.data[a];
+		float32 vn = b2Dot(v, n);
+		if (vn < 0)
+		{
+			float32 damping =
+				b2Max(linearDamping * w, b2Min(- quadraticDamping * vn, 0.5f));
+			b2Vec2 f = damping * vn * n;
+			m_velocityBuffer.data[a] += f;
+			m_velocityBuffer.data[b] -= f;
+		}
+	}
+}
+
+inline bool b2ParticleSystem::IsRigidGroup(b2ParticleGroup *group) const
+{
+	return group && (group->m_groupFlags & b2_rigidParticleGroup);
+}
+
+inline b2Vec2 b2ParticleSystem::GetLinearVelocity(
+	b2ParticleGroup *group, int32 particleIndex,
+	const b2Vec2 &point) const
+{
+	if (IsRigidGroup(group))
+	{
+		return group->GetLinearVelocityFromWorldPoint(point);
+	}
+	else
+	{
+		return m_velocityBuffer.data[particleIndex];
+	}
+}
+
+inline void b2ParticleSystem::InitDampingParameter(
+	float32* invMass, float32* invInertia, float32* tangentDistance,
+	float32 mass, float32 inertia, const b2Vec2& center,
+	const b2Vec2& point, const b2Vec2& normal) const
+{
+	*invMass = mass > 0 ? 1 / mass : 0;
+	*invInertia = inertia > 0 ? 1 / inertia : 0;
+	*tangentDistance = b2Cross(point - center, normal);
+}
+
+inline void b2ParticleSystem::InitDampingParameterWithRigidGroupOrParticle(
+	float32* invMass, float32* invInertia, float32* tangentDistance,
+	bool isRigidGroup, b2ParticleGroup* group, int32 particleIndex,
+	const b2Vec2& point, const b2Vec2& normal) const
+{
+	if (isRigidGroup)
+	{
+		InitDampingParameter(
+			invMass, invInertia, tangentDistance,
+			group->GetMass(), group->GetInertia(), group->GetCenter(),
+			point, normal);
+	}
+	else
+	{
+		uint32 flags = m_flagsBuffer.data[particleIndex];
+		InitDampingParameter(
+			invMass, invInertia, tangentDistance,
+			flags & b2_wallParticle ? 0 : GetParticleMass(), 0, point,
+			point, normal);
+	}
+}
+
+inline float32 b2ParticleSystem::ComputeDampingImpulse(
+	float32 invMassA, float32 invInertiaA, float32 tangentDistanceA,
+	float32 invMassB, float32 invInertiaB, float32 tangentDistanceB,
+	float32 normalVelocity) const
+{
+	float32 invMass =
+		invMassA + invInertiaA * tangentDistanceA * tangentDistanceA +
+		invMassB + invInertiaB * tangentDistanceB * tangentDistanceB;
+	return invMass > 0 ? normalVelocity / invMass : 0;
+}
+
+inline void b2ParticleSystem::ApplyDamping(
+	float32 invMass, float32 invInertia, float32 tangentDistance,
+	bool isRigidGroup, b2ParticleGroup* group, int32 particleIndex,
+	float32 impulse, const b2Vec2& normal)
+{
+	if (isRigidGroup)
+	{
+		group->m_linearVelocity += impulse * invMass * normal;
+		group->m_angularVelocity += impulse * tangentDistance * invInertia;
+	}
+	else
+	{
+		m_velocityBuffer.data[particleIndex] += impulse * invMass * normal;
+	}
+}
+
+void b2ParticleSystem::SolveRigidDamping()
+{
+	// Apply impulse to rigid particle groups colliding with other objects
+	// to reduce relative velocity at the colliding point.
+	float32 damping = m_def.dampingStrength;
+	for (int32 k = 0; k < m_bodyContactBuffer.GetCount(); k++)
+	{
+		const b2ParticleBodyContact& contact = m_bodyContactBuffer[k];
+		int32 a = contact.index;
+		b2ParticleGroup* aGroup = m_groupBuffer[a];
+		if (IsRigidGroup(aGroup))
+		{
+			b2Body* b = contact.body;
+			b2Vec2 n = contact.normal;
+			float32 w = contact.weight;
+			b2Vec2 p = m_positionBuffer.data[a];
+			b2Vec2 v = b->GetLinearVelocityFromWorldPoint(p) -
+					   aGroup->GetLinearVelocityFromWorldPoint(p);
+			float32 vn = b2Dot(v, n);
+			if (vn < 0)
+			// The group's average velocity at particle position 'p' is pushing
+			// the particle into the body.
+			{
+				float32 invMassA, invInertiaA, tangentDistanceA;
+				float32 invMassB, invInertiaB, tangentDistanceB;
+				InitDampingParameterWithRigidGroupOrParticle(
+					&invMassA, &invInertiaA, &tangentDistanceA,
+					true, aGroup, a, p, n);
+				InitDampingParameter(
+					&invMassB, &invInertiaB, &tangentDistanceB,
+					b->GetMass(),
+					// Calculate b->m_I from public functions of b2Body.
+					b->GetInertia() -
+							b->GetMass() * b->GetLocalCenter().LengthSquared(),
+					b->GetWorldCenter(),
+					p, n);
+				float32 f = damping * b2Min(w, 1.0f) * ComputeDampingImpulse(
+					invMassA, invInertiaA, tangentDistanceA,
+					invMassB, invInertiaB, tangentDistanceB,
+					vn);
+				ApplyDamping(
+					invMassA, invInertiaA, tangentDistanceA,
+					true, aGroup, a, f, n);
+				b->ApplyLinearImpulse(-f * n, p, true);
+			}
+		}
+	}
+	for (int32 k = 0; k < m_contactBuffer.GetCount(); k++)
+	{
+		const b2ParticleContact& contact = m_contactBuffer[k];
+		int32 a = contact.GetIndexA();
+		int32 b = contact.GetIndexB();
+		b2Vec2 n = contact.GetNormal();
+		float32 w = contact.GetWeight();
+		b2ParticleGroup* aGroup = m_groupBuffer[a];
+		b2ParticleGroup* bGroup = m_groupBuffer[b];
+		bool aRigid = IsRigidGroup(aGroup);
+		bool bRigid = IsRigidGroup(bGroup);
+		if (aGroup != bGroup && (aRigid || bRigid))
+		{
+			b2Vec2 p =
+				0.5f * (m_positionBuffer.data[a] + m_positionBuffer.data[b]);
+			b2Vec2 v =
+				GetLinearVelocity(bGroup, b, p) -
+				GetLinearVelocity(aGroup, a, p);
+			float32 vn = b2Dot(v, n);
+			if (vn < 0)
+			{
+				float32 invMassA, invInertiaA, tangentDistanceA;
+				float32 invMassB, invInertiaB, tangentDistanceB;
+				InitDampingParameterWithRigidGroupOrParticle(
+					&invMassA, &invInertiaA, &tangentDistanceA,
+					aRigid, aGroup, a,
+					p, n);
+				InitDampingParameterWithRigidGroupOrParticle(
+					&invMassB, &invInertiaB, &tangentDistanceB,
+					bRigid, bGroup, b,
+					p, n);
+				float32 f = damping * w * ComputeDampingImpulse(
+					invMassA, invInertiaA, tangentDistanceA,
+					invMassB, invInertiaB, tangentDistanceB,
+					vn);
+				ApplyDamping(
+					invMassA, invInertiaA, tangentDistanceA,
+					aRigid, aGroup, a, f, n);
+				ApplyDamping(
+					invMassB, invInertiaB, tangentDistanceB,
+					bRigid, bGroup, b, -f, n);
+			}
+		}
+	}
+}
+
+void b2ParticleSystem::SolveExtraDamping()
+{
+	// Applies additional damping force between bodies and particles which can
+	// produce strong repulsive force. Applying damping force multiple times
+	// is effective in suppressing vibration.
+	for (int32 k = 0; k < m_bodyContactBuffer.GetCount(); k++)
+	{
+		const b2ParticleBodyContact& contact = m_bodyContactBuffer[k];
+		int32 a = contact.index;
+		if (m_flagsBuffer.data[a] & k_extraDampingFlags)
+		{
+			b2Body* b = contact.body;
+			float32 m = contact.mass;
+			b2Vec2 n = contact.normal;
+			b2Vec2 p = m_positionBuffer.data[a];
+			b2Vec2 v =
+				b->GetLinearVelocityFromWorldPoint(p) -
+				m_velocityBuffer.data[a];
+			float32 vn = b2Dot(v, n);
+			if (vn < 0)
+			{
+				b2Vec2 f = 0.5f * m * vn * n;
+				m_velocityBuffer.data[a] += GetParticleInvMass() * f;
+				b->ApplyLinearImpulse(-f, p, true);
+			}
+		}
+	}
+}
+
+void b2ParticleSystem::SolveWall()
+{
+	for (int32 i = 0; i < m_count; i++)
+	{
+		if (m_flagsBuffer.data[i] & b2_wallParticle)
+		{
+			m_velocityBuffer.data[i].SetZero();
+		}
+	}
+}
+
+void b2ParticleSystem::SolveRigid(const b2TimeStep& step)
+{
+	for (b2ParticleGroup* group = m_groupList; group; group = group->GetNext())
+	{
+		if (group->m_groupFlags & b2_rigidParticleGroup)
+		{
+			group->UpdateStatistics();
+			b2Rot rotation(step.dt * group->m_angularVelocity);
+			b2Transform transform(
+				group->m_center + step.dt * group->m_linearVelocity -
+				b2Mul(rotation, group->m_center), rotation);
+			group->m_transform = b2Mul(transform, group->m_transform);
+			b2Transform velocityTransform;
+			velocityTransform.p.x = step.inv_dt * transform.p.x;
+			velocityTransform.p.y = step.inv_dt * transform.p.y;
+			velocityTransform.q.s = step.inv_dt * transform.q.s;
+			velocityTransform.q.c = step.inv_dt * (transform.q.c - 1);
+			for (int32 i = group->m_firstIndex; i < group->m_lastIndex; i++)
+			{
+				m_velocityBuffer.data[i] = b2Mul(velocityTransform,
+												 m_positionBuffer.data[i]);
+			}
+		}
+	}
+}
+
+void b2ParticleSystem::SolveElastic(const b2TimeStep& step)
+{
+	float32 elasticStrength = step.inv_dt * m_def.elasticStrength;
+	for (int32 k = 0; k < m_triadBuffer.GetCount(); k++)
+	{
+		const b2ParticleTriad& triad = m_triadBuffer[k];
+		if (triad.flags & b2_elasticParticle)
+		{
+			int32 a = triad.indexA;
+			int32 b = triad.indexB;
+			int32 c = triad.indexC;
+			const b2Vec2& oa = triad.pa;
+			const b2Vec2& ob = triad.pb;
+			const b2Vec2& oc = triad.pc;
+			b2Vec2 pa = m_positionBuffer.data[a];
+			b2Vec2 pb = m_positionBuffer.data[b];
+			b2Vec2 pc = m_positionBuffer.data[c];
+			b2Vec2& va = m_velocityBuffer.data[a];
+			b2Vec2& vb = m_velocityBuffer.data[b];
+			b2Vec2& vc = m_velocityBuffer.data[c];
+			pa += step.dt * va;
+			pb += step.dt * vb;
+			pc += step.dt * vc;
+			b2Vec2 midPoint = (float32) 1 / 3 * (pa + pb + pc);
+			pa -= midPoint;
+			pb -= midPoint;
+			pc -= midPoint;
+			b2Rot r;
+			r.s = b2Cross(oa, pa) + b2Cross(ob, pb) + b2Cross(oc, pc);
+			r.c = b2Dot(oa, pa) + b2Dot(ob, pb) + b2Dot(oc, pc);
+			float32 r2 = r.s * r.s + r.c * r.c;
+			float32 invR = b2InvSqrt(r2);
+			r.s *= invR;
+			r.c *= invR;
+			float32 strength = elasticStrength * triad.strength;
+			va += strength * (b2Mul(r, oa) - pa);
+			vb += strength * (b2Mul(r, ob) - pb);
+			vc += strength * (b2Mul(r, oc) - pc);
+		}
+	}
+}
+
+void b2ParticleSystem::SolveSpring(const b2TimeStep& step)
+{
+	float32 springStrength = step.inv_dt * m_def.springStrength;
+	for (int32 k = 0; k < m_pairBuffer.GetCount(); k++)
+	{
+		const b2ParticlePair& pair = m_pairBuffer[k];
+		if (pair.flags & b2_springParticle)
+		{
+			int32 a = pair.indexA;
+			int32 b = pair.indexB;
+			b2Vec2 pa = m_positionBuffer.data[a];
+			b2Vec2 pb = m_positionBuffer.data[b];
+			b2Vec2& va = m_velocityBuffer.data[a];
+			b2Vec2& vb = m_velocityBuffer.data[b];
+			pa += step.dt * va;
+			pb += step.dt * vb;
+			b2Vec2 d = pb - pa;
+			float32 r0 = pair.distance;
+			float32 r1 = d.Length();
+			float32 strength = springStrength * pair.strength;
+			b2Vec2 f = strength * (r0 - r1) / r1 * d;
+			va -= f;
+			vb += f;
+		}
+	}
+}
+
+void b2ParticleSystem::SolveTensile(const b2TimeStep& step)
+{
+	b2Assert(m_accumulation2Buffer);
+	for (int32 i = 0; i < m_count; i++)
+	{
+		m_accumulation2Buffer[i] = b2Vec2_zero;
+	}
+	for (int32 k = 0; k < m_contactBuffer.GetCount(); k++)
+	{
+		const b2ParticleContact& contact = m_contactBuffer[k];
+		if (contact.GetFlags() & b2_tensileParticle)
+		{
+			int32 a = contact.GetIndexA();
+			int32 b = contact.GetIndexB();
+			float32 w = contact.GetWeight();
+			b2Vec2 n = contact.GetNormal();
+			b2Vec2 weightedNormal = (1 - w) * w * n;
+			m_accumulation2Buffer[a] -= weightedNormal;
+			m_accumulation2Buffer[b] += weightedNormal;
+		}
+	}
+	float32 criticalVelocity = GetCriticalVelocity(step);
+	float32 pressureStrength = m_def.surfaceTensionPressureStrength
+							 * criticalVelocity;
+	float32 normalStrength = m_def.surfaceTensionNormalStrength
+						   * criticalVelocity;
+	float32 maxVelocityVariation = b2_maxParticleForce * criticalVelocity;
+	for (int32 k = 0; k < m_contactBuffer.GetCount(); k++)
+	{
+		const b2ParticleContact& contact = m_contactBuffer[k];
+		if (contact.GetFlags() & b2_tensileParticle)
+		{
+			int32 a = contact.GetIndexA();
+			int32 b = contact.GetIndexB();
+			float32 w = contact.GetWeight();
+			b2Vec2 n = contact.GetNormal();
+			float32 h = m_weightBuffer[a] + m_weightBuffer[b];
+			b2Vec2 s = m_accumulation2Buffer[b] - m_accumulation2Buffer[a];
+			float32 fn = b2Min(
+					pressureStrength * (h - 2) + normalStrength * b2Dot(s, n),
+					maxVelocityVariation) * w;
+			b2Vec2 f = fn * n;
+			m_velocityBuffer.data[a] -= f;
+			m_velocityBuffer.data[b] += f;
+		}
+	}
+}
+
+void b2ParticleSystem::SolveViscous()
+{
+	float32 viscousStrength = m_def.viscousStrength;
+	for (int32 k = 0; k < m_bodyContactBuffer.GetCount(); k++)
+	{
+		const b2ParticleBodyContact& contact = m_bodyContactBuffer[k];
+		int32 a = contact.index;
+		if (m_flagsBuffer.data[a] & b2_viscousParticle)
+		{
+			b2Body* b = contact.body;
+			float32 w = contact.weight;
+			float32 m = contact.mass;
+			b2Vec2 p = m_positionBuffer.data[a];
+			b2Vec2 v = b->GetLinearVelocityFromWorldPoint(p) -
+					   m_velocityBuffer.data[a];
+			b2Vec2 f = viscousStrength * m * w * v;
+			m_velocityBuffer.data[a] += GetParticleInvMass() * f;
+			b->ApplyLinearImpulse(-f, p, true);
+		}
+	}
+	for (int32 k = 0; k < m_contactBuffer.GetCount(); k++)
+	{
+		const b2ParticleContact& contact = m_contactBuffer[k];
+		if (contact.GetFlags() & b2_viscousParticle)
+		{
+			int32 a = contact.GetIndexA();
+			int32 b = contact.GetIndexB();
+			float32 w = contact.GetWeight();
+			b2Vec2 v = m_velocityBuffer.data[b] - m_velocityBuffer.data[a];
+			b2Vec2 f = viscousStrength * w * v;
+			m_velocityBuffer.data[a] += f;
+			m_velocityBuffer.data[b] -= f;
+		}
+	}
+}
+
+void b2ParticleSystem::SolveRepulsive(const b2TimeStep& step)
+{
+	float32 repulsiveStrength =
+		m_def.repulsiveStrength * GetCriticalVelocity(step);
+	for (int32 k = 0; k < m_contactBuffer.GetCount(); k++)
+	{
+		const b2ParticleContact& contact = m_contactBuffer[k];
+		if (contact.GetFlags() & b2_repulsiveParticle)
+		{
+			int32 a = contact.GetIndexA();
+			int32 b = contact.GetIndexB();
+			if (m_groupBuffer[a] != m_groupBuffer[b])
+			{
+				float32 w = contact.GetWeight();
+				b2Vec2 n = contact.GetNormal();
+				b2Vec2 f = repulsiveStrength * w * n;
+				m_velocityBuffer.data[a] -= f;
+				m_velocityBuffer.data[b] += f;
+			}
+		}
+	}
+}
+
+void b2ParticleSystem::SolvePowder(const b2TimeStep& step)
+{
+	float32 powderStrength = m_def.powderStrength * GetCriticalVelocity(step);
+	float32 minWeight = 1.0f - b2_particleStride;
+	for (int32 k = 0; k < m_contactBuffer.GetCount(); k++)
+	{
+		const b2ParticleContact& contact = m_contactBuffer[k];
+		if (contact.GetFlags() & b2_powderParticle)
+		{
+			float32 w = contact.GetWeight();
+			if (w > minWeight)
+			{
+				int32 a = contact.GetIndexA();
+				int32 b = contact.GetIndexB();
+				b2Vec2 n = contact.GetNormal();
+				b2Vec2 f = powderStrength * (w - minWeight) * n;
+				m_velocityBuffer.data[a] -= f;
+				m_velocityBuffer.data[b] += f;
+			}
+		}
+	}
+}
+
+void b2ParticleSystem::SolveSolid(const b2TimeStep& step)
+{
+	// applies extra repulsive force from solid particle groups
+	b2Assert(m_depthBuffer);
+	float32 ejectionStrength = step.inv_dt * m_def.ejectionStrength;
+	for (int32 k = 0; k < m_contactBuffer.GetCount(); k++)
+	{
+		const b2ParticleContact& contact = m_contactBuffer[k];
+		int32 a = contact.GetIndexA();
+		int32 b = contact.GetIndexB();
+		if (m_groupBuffer[a] != m_groupBuffer[b])
+		{
+			float32 w = contact.GetWeight();
+			b2Vec2 n = contact.GetNormal();
+			float32 h = m_depthBuffer[a] + m_depthBuffer[b];
+			b2Vec2 f = ejectionStrength * h * w * n;
+			m_velocityBuffer.data[a] -= f;
+			m_velocityBuffer.data[b] += f;
+		}
+	}
+}
+
+void b2ParticleSystem::SolveForce(const b2TimeStep& step)
+{
+	float32 velocityPerForce = step.dt * GetParticleInvMass();
+	for (int32 i = 0; i < m_count; i++)
+	{
+		m_velocityBuffer.data[i] += velocityPerForce * m_forceBuffer[i];
+	}
+	m_hasForce = false;
+}
+
+void b2ParticleSystem::SolveColorMixing()
+{
+	// mixes color between contacting particles
+	b2Assert(m_colorBuffer.data);
+	const int32 colorMixing128 = (int32) (128 * m_def.colorMixingStrength);
+	if (colorMixing128) {
+		for (int32 k = 0; k < m_contactBuffer.GetCount(); k++)
+		{
+			const b2ParticleContact& contact = m_contactBuffer[k];
+			int32 a = contact.GetIndexA();
+			int32 b = contact.GetIndexB();
+			if (m_flagsBuffer.data[a] & m_flagsBuffer.data[b] &
+				b2_colorMixingParticle)
+			{
+				b2ParticleColor& colorA = m_colorBuffer.data[a];
+				b2ParticleColor& colorB = m_colorBuffer.data[b];
+				// Use the static method to ensure certain compilers inline
+				// this correctly.
+				b2ParticleColor::MixColors(&colorA, &colorB, colorMixing128);
+			}
+		}
+	}
+}
+
+void b2ParticleSystem::SolveZombie()
+{
+	// removes particles with zombie flag
+	int32 newCount = 0;
+	int32* newIndices = (int32*) m_world->m_stackAllocator.Allocate(
+		sizeof(int32) * m_count);
+	uint32 allParticleFlags = 0;
+	for (int32 i = 0; i < m_count; i++)
+	{
+		int32 flags = m_flagsBuffer.data[i];
+		if (flags & b2_zombieParticle)
+		{
+			b2DestructionListener * const destructionListener =
+				m_world->m_destructionListener;
+			if ((flags & b2_destructionListenerParticle) &&
+				destructionListener)
+			{
+				destructionListener->SayGoodbye(this, i);
+			}
+			// Destroy particle handle.
+			if (m_handleIndexBuffer.data)
+			{
+				b2ParticleHandle * const handle = m_handleIndexBuffer.data[i];
+				if (handle)
+				{
+					handle->SetIndex(b2_invalidParticleIndex);
+					m_handleIndexBuffer.data[i] = NULL;
+					m_handleAllocator.Free(handle);
+				}
+			}
+			newIndices[i] = b2_invalidParticleIndex;
+		}
+		else
+		{
+			newIndices[i] = newCount;
+			if (i != newCount)
+			{
+				// Update handle to reference new particle index.
+				if (m_handleIndexBuffer.data)
+				{
+					b2ParticleHandle * const handle =
+						m_handleIndexBuffer.data[i];
+					if (handle) handle->SetIndex(newCount);
+					m_handleIndexBuffer.data[newCount] = handle;
+				}
+				m_flagsBuffer.data[newCount] = m_flagsBuffer.data[i];
+				if (m_lastBodyContactStepBuffer.data)
+				{
+					m_lastBodyContactStepBuffer.data[newCount] =
+						m_lastBodyContactStepBuffer.data[i];
+				}
+				if (m_bodyContactCountBuffer.data)
+				{
+					m_bodyContactCountBuffer.data[newCount] =
+						m_bodyContactCountBuffer.data[i];
+				}
+				if (m_consecutiveContactStepsBuffer.data)
+				{
+					m_consecutiveContactStepsBuffer.data[newCount] =
+						m_consecutiveContactStepsBuffer.data[i];
+				}
+				m_positionBuffer.data[newCount] = m_positionBuffer.data[i];
+				m_velocityBuffer.data[newCount] = m_velocityBuffer.data[i];
+				m_groupBuffer[newCount] = m_groupBuffer[i];
+				if (m_hasForce)
+				{
+					m_forceBuffer[newCount] = m_forceBuffer[i];
+				}
+				if (m_staticPressureBuffer)
+				{
+					m_staticPressureBuffer[newCount] =
+						m_staticPressureBuffer[i];
+				}
+				if (m_depthBuffer)
+				{
+					m_depthBuffer[newCount] = m_depthBuffer[i];
+				}
+				if (m_colorBuffer.data)
+				{
+					m_colorBuffer.data[newCount] = m_colorBuffer.data[i];
+				}
+				if (m_userDataBuffer.data)
+				{
+					m_userDataBuffer.data[newCount] = m_userDataBuffer.data[i];
+				}
+				if (m_expirationTimeBuffer.data)
+				{
+					m_expirationTimeBuffer.data[newCount] =
+						m_expirationTimeBuffer.data[i];
+				}
+			}
+			newCount++;
+			allParticleFlags |= flags;
+		}
+	}
+
+	// predicate functions
+	struct Test
+	{
+		static bool IsProxyInvalid(const Proxy& proxy)
+		{
+			return proxy.index < 0;
+		}
+		static bool IsContactInvalid(const b2ParticleContact& contact)
+		{
+			return contact.GetIndexA() < 0 || contact.GetIndexB() < 0;
+		}
+		static bool IsBodyContactInvalid(const b2ParticleBodyContact& contact)
+		{
+			return contact.index < 0;
+		}
+		static bool IsPairInvalid(const b2ParticlePair& pair)
+		{
+			return pair.indexA < 0 || pair.indexB < 0;
+		}
+		static bool IsTriadInvalid(const b2ParticleTriad& triad)
+		{
+			return triad.indexA < 0 || triad.indexB < 0 || triad.indexC < 0;
+		}
+	};
+
+	// update proxies
+	for (int32 k = 0; k < m_proxyBuffer.GetCount(); k++)
+	{
+		Proxy& proxy = m_proxyBuffer.Begin()[k];
+		proxy.index = newIndices[proxy.index];
+	}
+	m_proxyBuffer.RemoveIf(Test::IsProxyInvalid);
+
+	// update contacts
+	for (int32 k = 0; k < m_contactBuffer.GetCount(); k++)
+	{
+		b2ParticleContact& contact = m_contactBuffer[k];
+		contact.SetIndices(newIndices[contact.GetIndexA()],
+						   newIndices[contact.GetIndexB()]);
+	}
+	m_contactBuffer.RemoveIf(Test::IsContactInvalid);
+
+	// update particle-body contacts
+	for (int32 k = 0; k < m_bodyContactBuffer.GetCount(); k++)
+	{
+		b2ParticleBodyContact& contact = m_bodyContactBuffer[k];
+		contact.index = newIndices[contact.index];
+	}
+	m_bodyContactBuffer.RemoveIf(Test::IsBodyContactInvalid);
+
+	// update pairs
+	for (int32 k = 0; k < m_pairBuffer.GetCount(); k++)
+	{
+		b2ParticlePair& pair = m_pairBuffer[k];
+		pair.indexA = newIndices[pair.indexA];
+		pair.indexB = newIndices[pair.indexB];
+	}
+	m_pairBuffer.RemoveIf(Test::IsPairInvalid);
+
+	// update triads
+	for (int32 k = 0; k < m_triadBuffer.GetCount(); k++)
+	{
+		b2ParticleTriad& triad = m_triadBuffer[k];
+		triad.indexA = newIndices[triad.indexA];
+		triad.indexB = newIndices[triad.indexB];
+		triad.indexC = newIndices[triad.indexC];
+	}
+	m_triadBuffer.RemoveIf(Test::IsTriadInvalid);
+
+	// Update lifetime indices.
+	if (m_indexByExpirationTimeBuffer.data)
+	{
+		int32 writeOffset = 0;
+		for (int32 readOffset = 0; readOffset < m_count; readOffset++)
+		{
+			const int32 newIndex = newIndices[
+				m_indexByExpirationTimeBuffer.data[readOffset]];
+			if (newIndex != b2_invalidParticleIndex)
+			{
+				m_indexByExpirationTimeBuffer.data[writeOffset++] = newIndex;
+			}
+		}
+	}
+
+	// update groups
+	for (b2ParticleGroup* group = m_groupList; group; group = group->GetNext())
+	{
+		int32 firstIndex = newCount;
+		int32 lastIndex = 0;
+		bool modified = false;
+		for (int32 i = group->m_firstIndex; i < group->m_lastIndex; i++)
+		{
+			int32 j = newIndices[i];
+			if (j >= 0) {
+				firstIndex = b2Min(firstIndex, j);
+				lastIndex = b2Max(lastIndex, j + 1);
+			} else {
+				modified = true;
+			}
+		}
+		if (firstIndex < lastIndex)
+		{
+			group->m_firstIndex = firstIndex;
+			group->m_lastIndex = lastIndex;
+			if (modified)
+			{
+				if (group->m_groupFlags & b2_solidParticleGroup)
+				{
+					SetGroupFlags(group,
+								  group->m_groupFlags |
+								  b2_particleGroupNeedsUpdateDepth);
+				}
+			}
+		}
+		else
+		{
+			group->m_firstIndex = 0;
+			group->m_lastIndex = 0;
+			if (!(group->m_groupFlags & b2_particleGroupCanBeEmpty))
+			{
+				SetGroupFlags(group,
+					group->m_groupFlags | b2_particleGroupWillBeDestroyed);
+			}
+		}
+	}
+
+	// update particle count
+	m_count = newCount;
+	m_world->m_stackAllocator.Free(newIndices);
+	m_allParticleFlags = allParticleFlags;
+	m_needsUpdateAllParticleFlags = false;
+
+	// destroy bodies with no particles
+	for (b2ParticleGroup* group = m_groupList; group;)
+	{
+		b2ParticleGroup* next = group->GetNext();
+		if (group->m_groupFlags & b2_particleGroupWillBeDestroyed)
+		{
+			DestroyParticleGroup(group);
+		}
+		group = next;
+	}
+}
+
+/// Destroy all particles which have outlived their lifetimes set by
+/// SetParticleLifetime().
+void b2ParticleSystem::SolveLifetimes(const b2TimeStep& step)
+{
+	b2Assert(m_expirationTimeBuffer.data);
+	b2Assert(m_indexByExpirationTimeBuffer.data);
+	// Update the time elapsed.
+	m_timeElapsed = LifetimeToExpirationTime(step.dt);
+	// Get the floor (non-fractional component) of the elapsed time.
+	const int32 quantizedTimeElapsed = GetQuantizedTimeElapsed();
+
+	const int32* const expirationTimes = m_expirationTimeBuffer.data;
+	int32* const expirationTimeIndices = m_indexByExpirationTimeBuffer.data;
+	const int32 particleCount = GetParticleCount();
+	// Sort the lifetime buffer if it's required.
+	if (m_expirationTimeBufferRequiresSorting)
+	{
+		const ExpirationTimeComparator expirationTimeComparator(
+			expirationTimes);
+		std::sort(expirationTimeIndices,
+				  expirationTimeIndices + particleCount,
+				  expirationTimeComparator);
+		m_expirationTimeBufferRequiresSorting = false;
+	}
+
+	// Destroy particles which have expired.
+	for (int32 i = particleCount - 1; i >= 0; --i)
+	{
+		const int32 particleIndex = expirationTimeIndices[i];
+		const int32 expirationTime = expirationTimes[particleIndex];
+		// If no particles need to be destroyed, skip this.
+		if (quantizedTimeElapsed < expirationTime || expirationTime <= 0)
+		{
+			break;
+		}
+		// Destroy this particle.
+		DestroyParticle(particleIndex);
+	}
+}
+
+void b2ParticleSystem::RotateBuffer(int32 start, int32 mid, int32 end)
+{
+	// move the particles assigned to the given group toward the end of array
+	if (start == mid || mid == end)
+	{
+		return;
+	}
+	b2Assert(mid >= start && mid <= end);
+	struct NewIndices
+	{
+		int32 operator[](int32 i) const
+		{
+			if (i < start)
+			{
+				return i;
+			}
+			else if (i < mid)
+			{
+				return i + end - mid;
+			}
+			else if (i < end)
+			{
+				return i + start - mid;
+			}
+			else
+			{
+				return i;
+			}
+		}
+		int32 start, mid, end;
+	} newIndices;
+	newIndices.start = start;
+	newIndices.mid = mid;
+	newIndices.end = end;
+
+	std::rotate(m_flagsBuffer.data + start, m_flagsBuffer.data + mid,
+				m_flagsBuffer.data + end);
+	if (m_lastBodyContactStepBuffer.data)
+	{
+		std::rotate(m_lastBodyContactStepBuffer.data + start,
+					m_lastBodyContactStepBuffer.data + mid,
+					m_lastBodyContactStepBuffer.data + end);
+	}
+	if (m_bodyContactCountBuffer.data)
+	{
+		std::rotate(m_bodyContactCountBuffer.data + start,
+					m_bodyContactCountBuffer.data + mid,
+					m_bodyContactCountBuffer.data + end);
+	}
+	if (m_consecutiveContactStepsBuffer.data)
+	{
+		std::rotate(m_consecutiveContactStepsBuffer.data + start,
+					m_consecutiveContactStepsBuffer.data + mid,
+					m_consecutiveContactStepsBuffer.data + end);
+	}
+	std::rotate(m_positionBuffer.data + start, m_positionBuffer.data + mid,
+				m_positionBuffer.data + end);
+	std::rotate(m_velocityBuffer.data + start, m_velocityBuffer.data + mid,
+				m_velocityBuffer.data + end);
+	std::rotate(m_groupBuffer + start, m_groupBuffer + mid,
+				m_groupBuffer + end);
+	if (m_hasForce)
+	{
+		std::rotate(m_forceBuffer + start, m_forceBuffer + mid,
+					m_forceBuffer + end);
+	}
+	if (m_staticPressureBuffer)
+	{
+		std::rotate(m_staticPressureBuffer + start,
+					m_staticPressureBuffer + mid,
+					m_staticPressureBuffer + end);
+	}
+	if (m_depthBuffer)
+	{
+		std::rotate(m_depthBuffer + start, m_depthBuffer + mid,
+					m_depthBuffer + end);
+	}
+	if (m_colorBuffer.data)
+	{
+		std::rotate(m_colorBuffer.data + start,
+					m_colorBuffer.data + mid, m_colorBuffer.data + end);
+	}
+	if (m_userDataBuffer.data)
+	{
+		std::rotate(m_userDataBuffer.data + start,
+					m_userDataBuffer.data + mid, m_userDataBuffer.data + end);
+	}
+
+	// Update handle indices.
+	if (m_handleIndexBuffer.data)
+	{
+		std::rotate(m_handleIndexBuffer.data + start,
+					m_handleIndexBuffer.data + mid,
+					m_handleIndexBuffer.data + end);
+		for (int32 i = start; i < end; ++i)
+		{
+			b2ParticleHandle * const handle = m_handleIndexBuffer.data[i];
+			if (handle) handle->SetIndex(newIndices[handle->GetIndex()]);
+		}
+	}
+
+	if (m_expirationTimeBuffer.data)
+	{
+		std::rotate(m_expirationTimeBuffer.data + start,
+					m_expirationTimeBuffer.data + mid,
+					m_expirationTimeBuffer.data + end);
+		// Update expiration time buffer indices.
+		const int32 particleCount = GetParticleCount();
+		int32* const indexByExpirationTime =
+			m_indexByExpirationTimeBuffer.data;
+		for (int32 i = 0; i < particleCount; ++i)
+		{
+			indexByExpirationTime[i] = newIndices[indexByExpirationTime[i]];
+		}
+	}
+
+	// update proxies
+	for (int32 k = 0; k < m_proxyBuffer.GetCount(); k++)
+	{
+		Proxy& proxy = m_proxyBuffer.Begin()[k];
+		proxy.index = newIndices[proxy.index];
+	}
+
+	// update contacts
+	for (int32 k = 0; k < m_contactBuffer.GetCount(); k++)
+	{
+		b2ParticleContact& contact = m_contactBuffer[k];
+		contact.SetIndices(newIndices[contact.GetIndexA()],
+						   newIndices[contact.GetIndexB()]);
+	}
+
+	// update particle-body contacts
+	for (int32 k = 0; k < m_bodyContactBuffer.GetCount(); k++)
+	{
+		b2ParticleBodyContact& contact = m_bodyContactBuffer[k];
+		contact.index = newIndices[contact.index];
+	}
+
+	// update pairs
+	for (int32 k = 0; k < m_pairBuffer.GetCount(); k++)
+	{
+		b2ParticlePair& pair = m_pairBuffer[k];
+		pair.indexA = newIndices[pair.indexA];
+		pair.indexB = newIndices[pair.indexB];
+	}
+
+	// update triads
+	for (int32 k = 0; k < m_triadBuffer.GetCount(); k++)
+	{
+		b2ParticleTriad& triad = m_triadBuffer[k];
+		triad.indexA = newIndices[triad.indexA];
+		triad.indexB = newIndices[triad.indexB];
+		triad.indexC = newIndices[triad.indexC];
+	}
+
+	// update groups
+	for (b2ParticleGroup* group = m_groupList; group; group = group->GetNext())
+	{
+		group->m_firstIndex = newIndices[group->m_firstIndex];
+		group->m_lastIndex = newIndices[group->m_lastIndex - 1] + 1;
+	}
+}
+
+/// Set the lifetime (in seconds) of a particle relative to the current
+/// time.
+void b2ParticleSystem::SetParticleLifetime(const int32 index,
+										   const float32 lifetime)
+{
+	b2Assert(ValidateParticleIndex(index));
+	const bool initializeExpirationTimes =
+		m_indexByExpirationTimeBuffer.data == NULL;
+	m_expirationTimeBuffer.data = RequestBuffer(
+		m_expirationTimeBuffer.data);
+	m_indexByExpirationTimeBuffer.data = RequestBuffer(
+		m_indexByExpirationTimeBuffer.data);
+
+	// Initialize the inverse mapping buffer.
+	if (initializeExpirationTimes)
+	{
+		const int32 particleCount = GetParticleCount();
+		for (int32 i = 0; i < particleCount; ++i)
+		{
+			m_indexByExpirationTimeBuffer.data[i] = i;
+		}
+	}
+	const int32 quantizedLifetime = (int32)(lifetime /
+											m_def.lifetimeGranularity);
+	// Use a negative lifetime so that it's possible to track which
+	// of the infinite lifetime particles are older.
+	const int32 newExpirationTime = quantizedLifetime > 0 ?
+		GetQuantizedTimeElapsed() + quantizedLifetime : quantizedLifetime;
+	if (newExpirationTime != m_expirationTimeBuffer.data[index])
+	{
+		m_expirationTimeBuffer.data[index] = newExpirationTime;
+		m_expirationTimeBufferRequiresSorting = true;
+	}
+}
+
+
+/// Convert a lifetime value in returned by GetExpirationTimeBuffer()
+/// to a value in seconds relative to the current simulation time.
+float32 b2ParticleSystem::ExpirationTimeToLifetime(
+	const int32 expirationTime) const
+{
+	return (float32)(expirationTime > 0 ?
+					 	expirationTime - GetQuantizedTimeElapsed() :
+					 	expirationTime) * m_def.lifetimeGranularity;
+}
+
+/// Get the lifetime (in seconds) of a particle relative to the current
+/// time.
+float32 b2ParticleSystem::GetParticleLifetime(const int32 index)
+{
+	b2Assert(ValidateParticleIndex(index));
+	return ExpirationTimeToLifetime(GetExpirationTimeBuffer()[index]);
+}
+
+/// Get the array of particle lifetimes indexed by particle index.
+/// GetParticleCount() items are in the returned array.
+const int32* b2ParticleSystem::GetExpirationTimeBuffer()
+{
+	m_expirationTimeBuffer.data = RequestBuffer(
+		m_expirationTimeBuffer.data);
+	return m_expirationTimeBuffer.data;
+}
+
+/// Get the array of particle indices ordered by lifetime.
+/// GetExpirationTimeBuffer(
+///    GetIndexByExpirationTimeBuffer()[index])
+/// is equivalent to GetParticleLifetime(index).
+/// GetParticleCount() items are in the returned array.
+const int32* b2ParticleSystem::GetIndexByExpirationTimeBuffer()
+{
+	// If particles are present, initialize / reinitialize the lifetime buffer.
+	if (GetParticleCount())
+	{
+		SetParticleLifetime(0, GetParticleLifetime(0));
+	}
+	else
+	{
+		m_indexByExpirationTimeBuffer.data = RequestBuffer(
+			m_indexByExpirationTimeBuffer.data);
+	}
+	return m_indexByExpirationTimeBuffer.data;
+}
+
+void b2ParticleSystem::SetDestructionByAge(const bool enable)
+{
+	if (enable)
+	{
+		GetExpirationTimeBuffer();
+	}
+	m_def.destroyByAge = enable;
+}
+
+/// Get the time elapsed in b2ParticleSystemDef::lifetimeGranularity.
+int32 b2ParticleSystem::GetQuantizedTimeElapsed() const
+{
+	return (int32)(m_timeElapsed >> 32);
+}
+
+/// Convert a lifetime in seconds to an expiration time.
+int64 b2ParticleSystem::LifetimeToExpirationTime(const float32 lifetime) const
+{
+	return m_timeElapsed + (int64)((lifetime / m_def.lifetimeGranularity) *
+								   (float32)(1LL << 32));
+}
+
+template <typename T> void b2ParticleSystem::SetUserOverridableBuffer(
+	UserOverridableBuffer<T>* buffer, T* newData, int32 newCapacity)
+{
+	b2Assert((newData && newCapacity) || (!newData && !newCapacity));
+	if (!buffer->userSuppliedCapacity && buffer->data)
+	{
+		m_world->m_blockAllocator.Free(
+			buffer->data, sizeof(T) * m_internalAllocatedCapacity);
+	}
+	buffer->data = newData;
+	buffer->userSuppliedCapacity = newCapacity;
+}
+
+void b2ParticleSystem::SetFlagsBuffer(uint32* buffer, int32 capacity)
+{
+	SetUserOverridableBuffer(&m_flagsBuffer, buffer, capacity);
+}
+
+void b2ParticleSystem::SetPositionBuffer(b2Vec2* buffer,
+												 int32 capacity)
+{
+	SetUserOverridableBuffer(&m_positionBuffer, buffer, capacity);
+}
+
+void b2ParticleSystem::SetVelocityBuffer(b2Vec2* buffer,
+												 int32 capacity)
+{
+	SetUserOverridableBuffer(&m_velocityBuffer, buffer, capacity);
+}
+
+void b2ParticleSystem::SetColorBuffer(b2ParticleColor* buffer,
+											  int32 capacity)
+{
+	SetUserOverridableBuffer(&m_colorBuffer, buffer, capacity);
+}
+
+void b2ParticleSystem::SetUserDataBuffer(void** buffer, int32 capacity)
+{
+	SetUserOverridableBuffer(&m_userDataBuffer, buffer, capacity);
+}
+
+void b2ParticleSystem::SetParticleFlags(int32 index, uint32 newFlags)
+{
+	uint32* oldFlags = &m_flagsBuffer.data[index];
+	if (*oldFlags & ~newFlags)
+	{
+		// If any flags might be removed
+		m_needsUpdateAllParticleFlags = true;
+	}
+	if (~m_allParticleFlags & newFlags)
+	{
+		// If any flags were added
+		if (newFlags & b2_tensileParticle)
+		{
+			m_accumulation2Buffer = RequestBuffer(
+				m_accumulation2Buffer);
+		}
+		if (newFlags & b2_colorMixingParticle)
+		{
+			m_colorBuffer.data = RequestBuffer(m_colorBuffer.data);
+		}
+		m_allParticleFlags |= newFlags;
+	}
+	*oldFlags = newFlags;
+}
+
+void b2ParticleSystem::SetGroupFlags(
+	b2ParticleGroup* group, uint32 newFlags)
+{
+	uint32* oldFlags = &group->m_groupFlags;
+	if ((*oldFlags ^ newFlags) & b2_solidParticleGroup)
+	{
+		// If the b2_solidParticleGroup flag changed schedule depth update.
+		newFlags |= b2_particleGroupNeedsUpdateDepth;
+	}
+	if (*oldFlags & ~newFlags)
+	{
+		// If any flags might be removed
+		m_needsUpdateAllGroupFlags = true;
+	}
+	if (~m_allGroupFlags & newFlags)
+	{
+		// If any flags were added
+		if (newFlags & b2_solidParticleGroup)
+		{
+			m_depthBuffer = RequestBuffer(m_depthBuffer);
+		}
+		m_allGroupFlags |= newFlags;
+	}
+	*oldFlags = newFlags;
+}
+
+static inline bool IsSignificantForce(const b2Vec2& force)
+{
+	return force.x != 0 || force.y != 0;
+}
+
+inline bool b2ParticleSystem::ForceCanBeApplied(uint32 flags) const
+{
+	return !(flags & b2_wallParticle);
+}
+
+inline void b2ParticleSystem::PrepareForceBuffer()
+{
+	if (!m_hasForce)
+	{
+		memset((void *)m_forceBuffer, 0, sizeof(*m_forceBuffer) * m_count);
+		m_hasForce = true;
+	}
+}
+
+void b2ParticleSystem::ApplyForce(int32 firstIndex, int32 lastIndex,
+								  const b2Vec2& force)
+{
+	// Ensure we're not trying to apply force to particles that can't move,
+	// such as wall particles.
+#if B2_ASSERT_ENABLED
+	uint32 flags = 0;
+	for (int32 i = firstIndex; i < lastIndex; i++)
+	{
+		flags |= m_flagsBuffer.data[i];
+	}
+	b2Assert(ForceCanBeApplied(flags));
+#endif
+
+	// Early out if force does nothing (optimization).
+	const b2Vec2 distributedForce = force / (float32)(lastIndex - firstIndex);
+	if (IsSignificantForce(distributedForce))
+	{
+		PrepareForceBuffer();
+
+		// Distribute the force over all the particles.
+		for (int32 i = firstIndex; i < lastIndex; i++)
+		{
+			m_forceBuffer[i] += distributedForce;
+		}
+	}
+}
+
+void b2ParticleSystem::ParticleApplyForce(int32 index, const b2Vec2& force)
+{
+	if (IsSignificantForce(force) &&
+		ForceCanBeApplied(m_flagsBuffer.data[index]))
+	{
+		PrepareForceBuffer();
+		m_forceBuffer[index] += force;
+	}
+}
+
+void b2ParticleSystem::ApplyLinearImpulse(int32 firstIndex, int32 lastIndex,
+										  const b2Vec2& impulse)
+{
+	const float32 numParticles = (float32)(lastIndex - firstIndex);
+	const float32 totalMass = numParticles * GetParticleMass();
+	const b2Vec2 velocityDelta = impulse / totalMass;
+	for (int32 i = firstIndex; i < lastIndex; i++)
+	{
+		m_velocityBuffer.data[i] += velocityDelta;
+	}
+}
+
+void b2ParticleSystem::QueryAABB(b2QueryCallback* callback,
+								 const b2AABB& aabb) const
+{
+	if (m_proxyBuffer.GetCount() == 0)
+	{
+		return;
+	}
+	const Proxy* beginProxy = m_proxyBuffer.Begin();
+	const Proxy* endProxy = m_proxyBuffer.End();
+	const Proxy* firstProxy = std::lower_bound(
+		beginProxy, endProxy,
+		computeTag(
+			m_inverseDiameter * aabb.lowerBound.x,
+			m_inverseDiameter * aabb.lowerBound.y));
+	const Proxy* lastProxy = std::upper_bound(
+		firstProxy, endProxy,
+		computeTag(
+			m_inverseDiameter * aabb.upperBound.x,
+			m_inverseDiameter * aabb.upperBound.y));
+	for (const Proxy* proxy = firstProxy; proxy < lastProxy; ++proxy)
+	{
+		int32 i = proxy->index;
+		const b2Vec2& p = m_positionBuffer.data[i];
+		if (aabb.lowerBound.x < p.x && p.x < aabb.upperBound.x &&
+			aabb.lowerBound.y < p.y && p.y < aabb.upperBound.y)
+		{
+			if (!callback->ReportParticle(this, i))
+			{
+				break;
+			}
+		}
+	}
+}
+
+void b2ParticleSystem::QueryShapeAABB(b2QueryCallback* callback,
+									  const b2Shape& shape,
+									  const b2Transform& xf) const
+{
+	b2AABB aabb;
+	shape.ComputeAABB(&aabb, xf, 0);
+	QueryAABB(callback, aabb);
+}
+
+void b2ParticleSystem::RayCast(b2RayCastCallback* callback,
+							   const b2Vec2& point1,
+							   const b2Vec2& point2) const
+{
+	if (m_proxyBuffer.GetCount() == 0)
+	{
+		return;
+	}
+	b2AABB aabb;
+	aabb.lowerBound = b2Min(point1, point2);
+	aabb.upperBound = b2Max(point1, point2);
+	float32 fraction = 1;
+	// solving the following equation:
+	// ((1-t)*point1+t*point2-position)^2=diameter^2
+	// where t is a potential fraction
+	b2Vec2 v = point2 - point1;
+	float32 v2 = b2Dot(v, v);
+	InsideBoundsEnumerator enumerator = GetInsideBoundsEnumerator(aabb);
+	int32 i;
+	while ((i = enumerator.GetNext()) >= 0)
+	{
+		b2Vec2 p = point1 - m_positionBuffer.data[i];
+		float32 pv = b2Dot(p, v);
+		float32 p2 = b2Dot(p, p);
+		float32 determinant = pv * pv - v2 * (p2 - m_squaredDiameter);
+		if (determinant >= 0)
+		{
+			float32 sqrtDeterminant = b2Sqrt(determinant);
+			// find a solution between 0 and fraction
+			float32 t = (-pv - sqrtDeterminant) / v2;
+			if (t > fraction)
+			{
+				continue;
+			}
+			if (t < 0)
+			{
+				t = (-pv + sqrtDeterminant) / v2;
+				if (t < 0 || t > fraction)
+				{
+					continue;
+				}
+			}
+			b2Vec2 n = p + t * v;
+			n.Normalize();
+			float32 f = callback->ReportParticle(this, i, point1 + t * v, n, t);
+			fraction = b2Min(fraction, f);
+			if (fraction <= 0)
+			{
+				break;
+			}
+		}
+	}
+}
+
+float32 b2ParticleSystem::ComputeCollisionEnergy() const
+{
+	float32 sum_v2 = 0;
+	for (int32 k = 0; k < m_contactBuffer.GetCount(); k++)
+	{
+		const b2ParticleContact& contact = m_contactBuffer[k];
+		int32 a = contact.GetIndexA();
+		int32 b = contact.GetIndexB();
+		b2Vec2 n = contact.GetNormal();
+		b2Vec2 v = m_velocityBuffer.data[b] - m_velocityBuffer.data[a];
+		float32 vn = b2Dot(v, n);
+		if (vn < 0)
+		{
+			sum_v2 += vn * vn;
+		}
+	}
+	return 0.5f * GetParticleMass() * sum_v2;
+}
+
+void b2ParticleSystem::SetStuckThreshold(int32 steps)
+{
+	m_stuckThreshold = steps;
+
+	if (steps > 0)
+	{
+		m_lastBodyContactStepBuffer.data = RequestBuffer(
+			m_lastBodyContactStepBuffer.data);
+		m_bodyContactCountBuffer.data = RequestBuffer(
+			m_bodyContactCountBuffer.data);
+		m_consecutiveContactStepsBuffer.data = RequestBuffer(
+			m_consecutiveContactStepsBuffer.data);
+	}
+}
+
+#if LIQUIDFUN_EXTERNAL_LANGUAGE_API
+
+b2ParticleSystem::b2ExceptionType b2ParticleSystem::IsBufCopyValid(
+	int startIndex, int numParticles, int copySize, int bufSize) const
+{
+	const int maxNumParticles = GetParticleCount();
+
+	// are we actually copying?
+	if (copySize == 0)
+	{
+		return b2_noExceptions;
+	}
+
+	// is the index out of bounds?
+	if (startIndex < 0 ||
+		startIndex >= maxNumParticles ||
+		numParticles < 0 ||
+		numParticles + startIndex > maxNumParticles)
+	{
+		return b2_particleIndexOutOfBounds;
+	}
+
+	// are we copying within the boundaries?
+	if (copySize > bufSize)
+	{
+		return b2_bufferTooSmall;
+	}
+
+	return b2_noExceptions;
+}
+
+#endif // LIQUIDFUN_EXTERNAL_LANGUAGE_API
diff --git a/LiquidFun-1.1.0/src/liquidfun/Box2D/CMakeLists.txt b/LiquidFun-1.1.0/src/liquidfun/Box2D/CMakeLists.txt
index 365d6c60..eb5eb4fe 100644
--- a/LiquidFun-1.1.0/src/liquidfun/Box2D/CMakeLists.txt
+++ b/LiquidFun-1.1.0/src/liquidfun/Box2D/CMakeLists.txt
@@ -23,8 +23,8 @@ option(BOX2D_INSTALL "Install Box2D libs, includes, and CMake scripts" ${BOX2D_I
 option(BOX2D_INSTALL_DOC "Install Box2D documentation" OFF)
 option(BOX2D_BUILD_SHARED "Build Box2D shared libraries" OFF)
 option(BOX2D_BUILD_STATIC "Build Box2D static libraries" ON)
-option(BOX2D_BUILD_EXAMPLES "Build Box2D examples" ON)
-option(BOX2D_BUILD_UNITTESTS "Build Box2D Unit Tests" ON)
+option(BOX2D_BUILD_EXAMPLES "Build Box2D examples" OFF)
+option(BOX2D_BUILD_UNITTESTS "Build Box2D Unit Tests" OFF)
 # NOTE: Code coverage only works on Linux & OSX.
 option(BOX2D_CODE_COVERAGE "Enable the code coverage build option." OFF)
 
diff --git a/LiquidFun-1.1.0/src/liquidfun/Box2D/build-emscripten.bat b/LiquidFun-1.1.0/src/liquidfun/Box2D/build-emscripten.bat
new file mode 100644
index 00000000..d875ce07
--- /dev/null
+++ b/LiquidFun-1.1.0/src/liquidfun/Box2D/build-emscripten.bat
@@ -0,0 +1,7 @@
+@echo off
+
+cmd /c "emcmake cmake -DCMAKE_BUILD_TYPE=Release -G "MinGW Makefiles" ."
+cmd /c "emmake make -j"
+
+mkdir ..\..\..\lib\web
+move Box2D\libliquidfun.a ..\..\..\lib\web