b2ParticleSystem.h

/*
* 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.
*/
#ifndef B2_PARTICLE_SYSTEM_H
#define B2_PARTICLE_SYSTEM_H

#include <Box2D/Common/b2SlabAllocator.h>
#include <Box2D/Common/b2GrowableBuffer.h>
#include <Box2D/Particle/b2Particle.h>
#include <Box2D/Dynamics/b2TimeStep.h>

#if LIQUIDFUN_UNIT_TESTS
#include <gtest/gtest.h>
#endif // LIQUIDFUN_UNIT_TESTS

#if LIQUIDFUN_EXTERNAL_LANGUAGE_API
#include <cstring>
#endif // LIQUIDFUN_EXTERNAL_LANGUAGE_API

class b2World;
class b2Body;
class b2Shape;
class b2ParticleGroup;
class b2BlockAllocator;
class b2StackAllocator;
class b2QueryCallback;
class b2RayCastCallback;
class b2Fixture;
class b2ContactFilter;
class b2ContactListener;
class b2ParticlePairSet;
class FixtureParticleSet;
struct b2ParticleGroupDef;
struct b2Vec2;
struct b2AABB;
struct FindContactInput;
struct FindContactCheck;

struct b2ParticleContact
{
private:
    // 16-bit particle indices consume less memory and thus improve
    // performance. We iterate through m_contactBuffer many times during
    // b2ParticleSystem::Solve, so reducing the amount of data we churn
    // through speeds things up. Also, FindContactsFromChecks_Simd takes
    // advantage of the reduced size for specific optimizations.
    #ifdef B2_USE_16_BIT_PARTICLE_INDICES
        typedef int16 b2ParticleIndex;
    #else
        typedef int32 b2ParticleIndex;
    #endif

    b2ParticleIndex indexA, indexB;

    float32 weight;

    b2Vec2 normal;

    uint32 flags;

public:
    void SetIndices(int32 a, int32 b);
    void SetWeight(float32 w) { weight = w; }
    void SetNormal(const b2Vec2& n) { normal = n; }
    void SetFlags(uint32 f) { flags = f; }

    int32 GetIndexA() const { return indexA; }
    int32 GetIndexB() const { return indexB; }
    float32 GetWeight() const { return weight; }
    const b2Vec2& GetNormal() const { return normal; }
    uint32 GetFlags() const { return flags; }

    bool operator==(const b2ParticleContact& rhs) const;
    bool operator!=(const b2ParticleContact& rhs) const { return !operator==(rhs); }
    bool ApproximatelyEqual(const b2ParticleContact& rhs) const;
};

struct b2ParticleBodyContact
{
    int32 index;

    b2Body* body;

    b2Fixture* fixture;

    float32 weight;

    b2Vec2 normal;

    float32 mass;
};

struct b2ParticlePair
{
    int32 indexA, indexB;

    uint32 flags;

    float32 strength;

    float32 distance;
};

struct b2ParticleTriad
{
    int32 indexA, indexB, indexC;

    uint32 flags;

    float32 strength;

    b2Vec2 pa, pb, pc;
    float32 ka, kb, kc, s;
};

struct b2ParticleSystemDef
{
    b2ParticleSystemDef()
    {
        strictContactCheck = false;
        density = 1.0f;
        gravityScale = 1.0f;
        radius = 1.0f;
        maxCount = 0;

        // Initialize physical coefficients to the maximum values that
        // maintain numerical stability.
        pressureStrength = 0.05f;
        dampingStrength = 1.0f;
        elasticStrength = 0.25f;
        springStrength = 0.25f;
        viscousStrength = 0.25f;
        surfaceTensionPressureStrength = 0.2f;
        surfaceTensionNormalStrength = 0.2f;
        repulsiveStrength = 1.0f;
        powderStrength = 0.5f;
        ejectionStrength = 0.5f;
        staticPressureStrength = 0.2f;
        staticPressureRelaxation = 0.2f;
        staticPressureIterations = 8;
        colorMixingStrength = 0.5f;
        destroyByAge = true;
        lifetimeGranularity = 1.0f / 60.0f;
    }

    bool strictContactCheck;

    float32 density;

    float32 gravityScale;

    float32 radius;

    int32 maxCount;

    float32 pressureStrength;

    float32 dampingStrength;

    float32 elasticStrength;

    float32 springStrength;

    float32 viscousStrength;

    float32 surfaceTensionPressureStrength;

    float32 surfaceTensionNormalStrength;

    float32 repulsiveStrength;

    float32 powderStrength;

    float32 ejectionStrength;

    float32 staticPressureStrength;

    float32 staticPressureRelaxation;

    int32 staticPressureIterations;

    float32 colorMixingStrength;

    bool destroyByAge;

    float32 lifetimeGranularity;
};


class b2ParticleSystem
{
public:
    int32 CreateParticle(const b2ParticleDef& def);

    const b2ParticleHandle* GetParticleHandleFromIndex(const int32 index);

    void DestroyParticle(int32 index)
    {
        DestroyParticle(index, false);
    }

    void DestroyParticle(int32 index, bool callDestructionListener);

    void DestroyOldestParticle(const int32 index,
                               const bool callDestructionListener);

    int32 DestroyParticlesInShape(const b2Shape& shape, const b2Transform& xf)
    {
        return DestroyParticlesInShape(shape, xf, false);
    }

    int32 DestroyParticlesInShape(const b2Shape& shape, const b2Transform& xf,
                                  bool callDestructionListener);

    b2ParticleGroup* CreateParticleGroup(const b2ParticleGroupDef& def);

    void JoinParticleGroups(b2ParticleGroup* groupA, b2ParticleGroup* groupB);

    void SplitParticleGroup(b2ParticleGroup* group);

    b2ParticleGroup* GetParticleGroupList();
    const b2ParticleGroup* GetParticleGroupList() const;

    int32 GetParticleGroupCount() const;

    int32 GetParticleCount() const;

    int32 GetMaxParticleCount() const;

    void SetMaxParticleCount(int32 count);

    uint32 GetAllParticleFlags() const;

    uint32 GetAllGroupFlags() const;

    void SetPaused(bool paused);

    bool GetPaused() const;

    void SetDensity(float32 density);

    float32 GetDensity() const;

    void SetGravityScale(float32 gravityScale);

    float32 GetGravityScale() const;

    void SetDamping(float32 damping);

    float32 GetDamping() const;

    void SetStaticPressureIterations(int32 iterations);

    int32 GetStaticPressureIterations() const;

    void SetRadius(float32 radius);

    float32 GetRadius() const;

    b2Vec2* GetPositionBuffer();
    const b2Vec2* GetPositionBuffer() const;

    b2Vec2* GetVelocityBuffer();
    const b2Vec2* GetVelocityBuffer() const;

    b2ParticleColor* GetColorBuffer();
    const b2ParticleColor* GetColorBuffer() const;

    b2ParticleGroup* const* GetGroupBuffer();
    const b2ParticleGroup* const* GetGroupBuffer() const;

    float32* GetWeightBuffer();
    const float32* GetWeightBuffer() const;

    void** GetUserDataBuffer();
    void* const* GetUserDataBuffer() const;

    const uint32* GetFlagsBuffer() const;

    void SetParticleFlags(int32 index, uint32 flags);
    uint32 GetParticleFlags(const int32 index);

    void SetFlagsBuffer(uint32* buffer, int32 capacity);
    void SetPositionBuffer(b2Vec2* buffer, int32 capacity);
    void SetVelocityBuffer(b2Vec2* buffer, int32 capacity);
    void SetColorBuffer(b2ParticleColor* buffer, int32 capacity);
    void SetUserDataBuffer(void** buffer, int32 capacity);

    const b2ParticleContact* GetContacts() const;
    int32 GetContactCount() const;

    const b2ParticleBodyContact* GetBodyContacts() const;
    int32 GetBodyContactCount() const;

    const b2ParticlePair* GetPairs() const;
    int32 GetPairCount() const;

    const b2ParticleTriad* GetTriads() const;
    int32 GetTriadCount() const;

    void SetStuckThreshold(int32 iterations);

    const int32* GetStuckCandidates() const;

    int32 GetStuckCandidateCount() const;

    float32 ComputeCollisionEnergy() const;

    void SetStrictContactCheck(bool enabled);
    bool GetStrictContactCheck() const;

    void SetParticleLifetime(const int32 index, const float32 lifetime);
    float32 GetParticleLifetime(const int32 index);

    void SetDestructionByAge(const bool enable);
    bool GetDestructionByAge() const;

    const int32* GetExpirationTimeBuffer();
    float32 ExpirationTimeToLifetime(const int32 expirationTime) const;
    const int32* GetIndexByExpirationTimeBuffer();

    void ParticleApplyLinearImpulse(int32 index, const b2Vec2& impulse);

    void ApplyLinearImpulse(int32 firstIndex, int32 lastIndex,
                            const b2Vec2& impulse);

    void ParticleApplyForce(int32 index, const b2Vec2& force);

    void ApplyForce(int32 firstIndex, int32 lastIndex, const b2Vec2& force);

    b2ParticleSystem* GetNext();
    const b2ParticleSystem* GetNext() const;

    void QueryAABB(b2QueryCallback* callback, const b2AABB& aabb) const;

    void QueryShapeAABB(b2QueryCallback* callback, const b2Shape& shape,
                        const b2Transform& xf) const;

    void RayCast(b2RayCastCallback* callback, const b2Vec2& point1,
                 const b2Vec2& point2) const;

    void ComputeAABB(b2AABB* const aabb) const;

#if LIQUIDFUN_EXTERNAL_LANGUAGE_API
public:
    enum b2ExceptionType
    {
        b2_bufferTooSmall,
        b2_particleIndexOutOfBounds,
        b2_numErrors,
        b2_noExceptions,
    };

    void SetParticleVelocity(int32 index, float32 vx, float32 vy);

    float GetParticlePositionX(int32 index) const;

    float GetParticlePositionY(int32 index) const;

    int CopyPositionBuffer(int startIndex, int numParticles, void* outBuf,
                           int size) const;

    int CopyColorBuffer(int startIndex, int numParticles, void* outBuf,
                        int size) const;

    int CopyWeightBuffer(int startIndex, int numParticles, void* outBuf,
                         int size) const;

private:
    int CopyBuffer(int startIndex, int numParticles, void* inBufWithOffset,
                   void* outBuf, int outBufSize, int copySize) const;

    b2ExceptionType IsBufCopyValid(int startIndex, int numParticles,
                                   int copySize, int bufSize) const;
#endif // LIQUIDFUN_EXTERNAL_LANGUAGE_API

private:
    friend class b2World;
    friend class b2ParticleGroup;
    friend class b2ParticleBodyContactRemovePredicate;
    friend class b2FixtureParticleQueryCallback;
#ifdef LIQUIDFUN_UNIT_TESTS
    FRIEND_TEST(FunctionTests, GetParticleMass);
    FRIEND_TEST(FunctionTests, AreProxyBuffersTheSame);
#endif // LIQUIDFUN_UNIT_TESTS

    template <typename T>
    struct UserOverridableBuffer
    {
        UserOverridableBuffer()
        {
            data = NULL;
            userSuppliedCapacity = 0;
        }
        T* data;
        int32 userSuppliedCapacity;
    };

    struct Proxy
    {
        int32 index;
        uint32 tag;
        friend inline bool operator<(const Proxy &a, const Proxy &b)
        {
            return a.tag < b.tag;
        }
        friend inline bool operator<(uint32 a, const Proxy &b)
        {
            return a < b.tag;
        }
        friend inline bool operator<(const Proxy &a, uint32 b)
        {
            return a.tag < b;
        }
    };

    class ConnectionFilter
    {
    public:
        virtual ~ConnectionFilter() {}
        virtual bool IsNecessary(int32 index) const
        {
            B2_NOT_USED(index);
            return true;
        }
        virtual bool ShouldCreatePair(int32 a, int32 b) const
        {
            B2_NOT_USED(a);
            B2_NOT_USED(b);
            return true;
        }
        virtual bool ShouldCreateTriad(int32 a, int32 b, int32 c) const
        {
            B2_NOT_USED(a);
            B2_NOT_USED(b);
            B2_NOT_USED(c);
            return true;
        }
    };

    class InsideBoundsEnumerator
    {
    public:
        InsideBoundsEnumerator(
            uint32 lower, uint32 upper,
            const Proxy* first, const Proxy* last);

        int32 GetNext();
    private:
        uint32 m_xLower, m_xUpper;
        uint32 m_yLower, m_yUpper;
        const Proxy* m_first;
        const Proxy* m_last;
    };

    struct ParticleListNode
    {
        ParticleListNode* list;
        ParticleListNode* next;
        int32 count;
        int32 index;
    };

    static const int32 k_pairFlags =
        b2_springParticle |
        b2_barrierParticle;
    static const int32 k_triadFlags =
        b2_elasticParticle;
    static const int32 k_noPressureFlags =
        b2_powderParticle |
        b2_tensileParticle;
    static const int32 k_extraDampingFlags =
        b2_staticPressureParticle;

    b2ParticleSystem(const b2ParticleSystemDef* def, b2World* world);
    ~b2ParticleSystem();

    template <typename T> void FreeBuffer(T** b, int capacity);
    template <typename T> void FreeUserOverridableBuffer(
        UserOverridableBuffer<T>* b);
    template <typename T> T* ReallocateBuffer(T* buffer, int32 oldCapacity,
                                              int32 newCapacity);
    template <typename T> T* ReallocateBuffer(
        T* buffer, int32 userSuppliedCapacity, int32 oldCapacity,
        int32 newCapacity, bool deferred);
    template <typename T> T* ReallocateBuffer(
        UserOverridableBuffer<T>* buffer, int32 oldCapacity, int32 newCapacity,
        bool deferred);
    template <typename T> T* RequestBuffer(T* buffer);

    void ReallocateHandleBuffers(int32 newCapacity);

    void ReallocateInternalAllocatedBuffers(int32 capacity);
    int32 CreateParticleForGroup(
        const b2ParticleGroupDef& groupDef,
        const b2Transform& xf, const b2Vec2& position);
    void CreateParticlesStrokeShapeForGroup(
        const b2Shape* shape,
        const b2ParticleGroupDef& groupDef, const b2Transform& xf);
    void CreateParticlesFillShapeForGroup(
        const b2Shape* shape,
        const b2ParticleGroupDef& groupDef, const b2Transform& xf);
    void CreateParticlesWithShapeForGroup(
        const b2Shape* shape,
        const b2ParticleGroupDef& groupDef, const b2Transform& xf);
    void CreateParticlesWithShapesForGroup(
        const b2Shape* const* shapes, int32 shapeCount,
        const b2ParticleGroupDef& groupDef, const b2Transform& xf);
    int32 CloneParticle(int32 index, b2ParticleGroup* group);
    void DestroyParticleGroup(b2ParticleGroup* group);

    void UpdatePairsAndTriads(
        int32 firstIndex, int32 lastIndex, const ConnectionFilter& filter);
    void UpdatePairsAndTriadsWithReactiveParticles();
    static bool ComparePairIndices(const b2ParticlePair& a, const b2ParticlePair& b);
    static bool MatchPairIndices(const b2ParticlePair& a, const b2ParticlePair& b);
    static bool CompareTriadIndices(const b2ParticleTriad& a, const b2ParticleTriad& b);
    static bool MatchTriadIndices(const b2ParticleTriad& a, const b2ParticleTriad& b);

    static void InitializeParticleLists(
        const b2ParticleGroup* group, ParticleListNode* nodeBuffer);
    void MergeParticleListsInContact(
        const b2ParticleGroup* group, ParticleListNode* nodeBuffer) const;
    static void MergeParticleLists(
        ParticleListNode* listA, ParticleListNode* listB);
    static ParticleListNode* FindLongestParticleList(
        const b2ParticleGroup* group, ParticleListNode* nodeBuffer);
    void MergeZombieParticleListNodes(
        const b2ParticleGroup* group, ParticleListNode* nodeBuffer,
        ParticleListNode* survivingList) const;
    static void MergeParticleListAndNode(
        ParticleListNode* list, ParticleListNode* node);
    void CreateParticleGroupsFromParticleList(
        const b2ParticleGroup* group, ParticleListNode* nodeBuffer,
        const ParticleListNode* survivingList);
    void UpdatePairsAndTriadsWithParticleList(
        const b2ParticleGroup* group, const ParticleListNode* nodeBuffer);

    void ComputeDepth();

    InsideBoundsEnumerator GetInsideBoundsEnumerator(const b2AABB& aabb) const;

    void UpdateAllParticleFlags();
    void UpdateAllGroupFlags();
    void AddContact(int32 a, int32 b,
        b2GrowableBuffer<b2ParticleContact>& contacts) const;
    void FindContacts_Reference(
        b2GrowableBuffer<b2ParticleContact>& contacts) const;
    void ReorderForFindContact(FindContactInput* reordered,
                               int alignedCount) const;
    void GatherChecksOneParticle(
        const uint32 bound,
        const int startIndex,
        const int particleIndex,
        int* nextUncheckedIndex,
        b2GrowableBuffer<FindContactCheck>& checks) const;
    void GatherChecks(b2GrowableBuffer<FindContactCheck>& checks) const;
    void FindContacts_Simd(
        b2GrowableBuffer<b2ParticleContact>& contacts) const;
    void FindContacts(
        b2GrowableBuffer<b2ParticleContact>& contacts) const;
    static void UpdateProxyTags(
        const uint32* const tags,
        b2GrowableBuffer<Proxy>& proxies);
    static bool ProxyBufferHasIndex(
        int32 index, const Proxy* const a, int count);
    static int NumProxiesWithSameTag(
        const Proxy* const a, const Proxy* const b, int count);
    static bool AreProxyBuffersTheSame(const b2GrowableBuffer<Proxy>& a,
                                       const b2GrowableBuffer<Proxy>& b);
    void UpdateProxies_Reference(b2GrowableBuffer<Proxy>& proxies) const;
    void UpdateProxies_Simd(b2GrowableBuffer<Proxy>& proxies) const;
    void UpdateProxies(b2GrowableBuffer<Proxy>& proxies) const;
    void SortProxies(b2GrowableBuffer<Proxy>& proxies) const;
    void FilterContacts(b2GrowableBuffer<b2ParticleContact>& contacts);
    void NotifyContactListenerPreContact(
        b2ParticlePairSet* particlePairs) const;
    void NotifyContactListenerPostContact(b2ParticlePairSet& particlePairs);
    void UpdateContacts(bool exceptZombie);
    void NotifyBodyContactListenerPreContact(
        FixtureParticleSet* fixtureSet) const;
    void NotifyBodyContactListenerPostContact(FixtureParticleSet& fixtureSet);
    void UpdateBodyContacts();

    void Solve(const b2TimeStep& step);
    void SolveCollision(const b2TimeStep& step);
    void LimitVelocity(const b2TimeStep& step);
    void SolveGravity(const b2TimeStep& step);
    void SolveBarrier(const b2TimeStep& step);
    void SolveStaticPressure(const b2TimeStep& step);
    void ComputeWeight();
    void SolvePressure(const b2TimeStep& step);
    void SolveDamping(const b2TimeStep& step);
    void SolveRigidDamping();
    void SolveExtraDamping();
    void SolveWall();
    void SolveRigid(const b2TimeStep& step);
    void SolveElastic(const b2TimeStep& step);
    void SolveSpring(const b2TimeStep& step);
    void SolveTensile(const b2TimeStep& step);
    void SolveViscous();
    void SolveRepulsive(const b2TimeStep& step);
    void SolvePowder(const b2TimeStep& step);
    void SolveSolid(const b2TimeStep& step);
    void SolveForce(const b2TimeStep& step);
    void SolveColorMixing();
    void SolveZombie();
    void SolveLifetimes(const b2TimeStep& step);
    void RotateBuffer(int32 start, int32 mid, int32 end);

    float32 GetCriticalVelocity(const b2TimeStep& step) const;
    float32 GetCriticalVelocitySquared(const b2TimeStep& step) const;
    float32 GetCriticalPressure(const b2TimeStep& step) const;
    float32 GetParticleStride() const;
    float32 GetParticleMass() const;
    float32 GetParticleInvMass() const;

    // Get the world's contact filter if any particles with the
    // b2_contactFilterParticle flag are present in the system.
    b2ContactFilter* GetFixtureContactFilter() const;

    // Get the world's contact filter if any particles with the
    // b2_particleContactFilterParticle flag are present in the system.
    b2ContactFilter* GetParticleContactFilter() const;

    // Get the world's contact listener if any particles with the
    // b2_fixtureContactListenerParticle flag are present in the system.
    b2ContactListener* GetFixtureContactListener() const;

    // Get the world's contact listener if any particles with the
    // b2_particleContactListenerParticle flag are present in the system.
    b2ContactListener* GetParticleContactListener() const;

    template <typename T> void SetUserOverridableBuffer(
        UserOverridableBuffer<T>* buffer, T* newBufferData, int32 newCapacity);

    void SetGroupFlags(b2ParticleGroup* group, uint32 flags);

    void RemoveSpuriousBodyContacts();
    static bool BodyContactCompare(const b2ParticleBodyContact& lhs,
                                   const b2ParticleBodyContact& rhs);

    void DetectStuckParticle(int32 particle);

    bool ValidateParticleIndex(const int32 index) const;

    int32 GetQuantizedTimeElapsed() const;
    int64 LifetimeToExpirationTime(const float32 lifetime) const;

    bool ForceCanBeApplied(uint32 flags) const;
    void PrepareForceBuffer();

    bool IsRigidGroup(b2ParticleGroup *group) const;
    b2Vec2 GetLinearVelocity(
        b2ParticleGroup *group, int32 particleIndex,
        const b2Vec2 &point) const;
    void InitDampingParameter(
        float32* invMass, float32* invInertia, float32* tangentDistance,
        float32 mass, float32 inertia, const b2Vec2& center,
        const b2Vec2& point, const b2Vec2& normal) const;
    void InitDampingParameterWithRigidGroupOrParticle(
        float32* invMass, float32* invInertia, float32* tangentDistance,
        bool isRigidGroup, b2ParticleGroup* group, int32 particleIndex,
        const b2Vec2& point, const b2Vec2& normal) const;
    float32 ComputeDampingImpulse(
        float32 invMassA, float32 invInertiaA, float32 tangentDistanceA,
        float32 invMassB, float32 invInertiaB, float32 tangentDistanceB,
        float32 normalVelocity) const;
    void ApplyDamping(
        float32 invMass, float32 invInertia, float32 tangentDistance,
        bool isRigidGroup, b2ParticleGroup* group, int32 particleIndex,
        float32 impulse, const b2Vec2& normal);

    bool m_paused;
    int32 m_timestamp;
    int32 m_allParticleFlags;
    bool m_needsUpdateAllParticleFlags;
    int32 m_allGroupFlags;
    bool m_needsUpdateAllGroupFlags;
    bool m_hasForce;
    int32 m_iterationIndex;
    float32 m_inverseDensity;
    float32 m_particleDiameter;
    float32 m_inverseDiameter;
    float32 m_squaredDiameter;

    int32 m_count;
    int32 m_internalAllocatedCapacity;
    b2SlabAllocator<b2ParticleHandle> m_handleAllocator;
    UserOverridableBuffer<b2ParticleHandle*> m_handleIndexBuffer;
    UserOverridableBuffer<uint32> m_flagsBuffer;
    UserOverridableBuffer<b2Vec2> m_positionBuffer;
    UserOverridableBuffer<b2Vec2> m_velocityBuffer;
    b2Vec2* m_forceBuffer;
    float32* m_weightBuffer;
    float32* m_staticPressureBuffer;
    float32* m_accumulationBuffer;
    b2Vec2* m_accumulation2Buffer;
    float32* m_depthBuffer;
    UserOverridableBuffer<b2ParticleColor> m_colorBuffer;
    b2ParticleGroup** m_groupBuffer;
    UserOverridableBuffer<void*> m_userDataBuffer;

    int32 m_stuckThreshold;
    UserOverridableBuffer<int32> m_lastBodyContactStepBuffer;
    UserOverridableBuffer<int32> m_bodyContactCountBuffer;
    UserOverridableBuffer<int32> m_consecutiveContactStepsBuffer;
    b2GrowableBuffer<int32> m_stuckParticleBuffer;
    b2GrowableBuffer<Proxy> m_proxyBuffer;
    b2GrowableBuffer<b2ParticleContact> m_contactBuffer;
    b2GrowableBuffer<b2ParticleBodyContact> m_bodyContactBuffer;
    b2GrowableBuffer<b2ParticlePair> m_pairBuffer;
    b2GrowableBuffer<b2ParticleTriad> m_triadBuffer;

    UserOverridableBuffer<int32> m_expirationTimeBuffer;
    UserOverridableBuffer<int32> m_indexByExpirationTimeBuffer;
    int64 m_timeElapsed;
    bool m_expirationTimeBufferRequiresSorting;

    int32 m_groupCount;
    b2ParticleGroup* m_groupList;

    b2ParticleSystemDef m_def;

    b2World* m_world;
    b2ParticleSystem* m_prev;
    b2ParticleSystem* m_next;
};

inline void b2ParticleContact::SetIndices(int32 a, int32 b)
{
    b2Assert(a <= b2_maxParticleIndex && b <= b2_maxParticleIndex);
    indexA = (b2ParticleIndex)a;
    indexB = (b2ParticleIndex)b;
}


inline bool b2ParticleContact::operator==(
    const b2ParticleContact& rhs) const
{
    return indexA == rhs.indexA
        && indexB == rhs.indexB
        && flags == rhs.flags
        && weight == rhs.weight
        && normal == rhs.normal;
}

// The reciprocal sqrt function differs between SIMD and non-SIMD, but they
// should create approximately equal results.
inline bool b2ParticleContact::ApproximatelyEqual(
    const b2ParticleContact& rhs) const
{
    static const float MAX_WEIGHT_DIFF = 0.01f; // Weight 0 ~ 1, so about 1%
    static const float MAX_NORMAL_DIFF = 0.01f; // Normal length = 1, so 1%
    return indexA == rhs.indexA
        && indexB == rhs.indexB
        && flags == rhs.flags
        && b2Abs(weight - rhs.weight) < MAX_WEIGHT_DIFF
        && (normal - rhs.normal).Length() < MAX_NORMAL_DIFF;
}

inline b2ParticleGroup* b2ParticleSystem::GetParticleGroupList()
{
    return m_groupList;
}

inline const b2ParticleGroup* b2ParticleSystem::GetParticleGroupList() const
{
    return m_groupList;
}

inline int32 b2ParticleSystem::GetParticleGroupCount() const
{
    return m_groupCount;
}

inline int32 b2ParticleSystem::GetParticleCount() const
{
    return m_count;
}

inline void b2ParticleSystem::SetPaused(bool paused)
{
    m_paused = paused;
}

inline bool b2ParticleSystem::GetPaused() const
{
    return m_paused;
}

inline const b2ParticleContact* b2ParticleSystem::GetContacts() const
{
    return m_contactBuffer.Data();
}

inline int32 b2ParticleSystem::GetContactCount() const
{
    return m_contactBuffer.GetCount();
}

inline const b2ParticleBodyContact* b2ParticleSystem::GetBodyContacts() const
{
    return m_bodyContactBuffer.Data();
}

inline int32 b2ParticleSystem::GetBodyContactCount() const
{
    return m_bodyContactBuffer.GetCount();
}

inline const b2ParticlePair* b2ParticleSystem::GetPairs() const
{
    return m_pairBuffer.Data();
}

inline int32 b2ParticleSystem::GetPairCount() const
{
    return m_pairBuffer.GetCount();
}

inline const b2ParticleTriad* b2ParticleSystem::GetTriads() const
{
    return m_triadBuffer.Data();
}

inline int32 b2ParticleSystem::GetTriadCount() const
{
    return m_triadBuffer.GetCount();
}

inline b2ParticleSystem* b2ParticleSystem::GetNext()
{
    return m_next;
}

inline const b2ParticleSystem* b2ParticleSystem::GetNext() const
{
    return m_next;
}

inline const int32* b2ParticleSystem::GetStuckCandidates() const
{
    return m_stuckParticleBuffer.Data();
}

inline int32 b2ParticleSystem::GetStuckCandidateCount() const
{
    return m_stuckParticleBuffer.GetCount();
}

inline void b2ParticleSystem::SetStrictContactCheck(bool enabled)
{
    m_def.strictContactCheck = enabled;
}

inline bool b2ParticleSystem::GetStrictContactCheck() const
{
    return m_def.strictContactCheck;
}

inline void b2ParticleSystem::SetRadius(float32 radius)
{
    m_particleDiameter = 2 * radius;
    m_squaredDiameter = m_particleDiameter * m_particleDiameter;
    m_inverseDiameter = 1 / m_particleDiameter;
}

inline void b2ParticleSystem::SetDensity(float32 density)
{
    m_def.density = density;
    m_inverseDensity =  1 / m_def.density;
}

inline float32 b2ParticleSystem::GetDensity() const
{
    return m_def.density;
}

inline void b2ParticleSystem::SetGravityScale(float32 gravityScale)
{
    m_def.gravityScale = gravityScale;
}

inline float32 b2ParticleSystem::GetGravityScale() const
{
    return m_def.gravityScale;
}

inline void b2ParticleSystem::SetDamping(float32 damping)
{
    m_def.dampingStrength = damping;
}

inline float32 b2ParticleSystem::GetDamping() const
{
    return m_def.dampingStrength;
}

inline void b2ParticleSystem::SetStaticPressureIterations(int32 iterations)
{
    m_def.staticPressureIterations = iterations;
}

inline int32 b2ParticleSystem::GetStaticPressureIterations() const
{
    return m_def.staticPressureIterations;
}

inline float32 b2ParticleSystem::GetRadius() const
{
    return m_particleDiameter / 2;
}

inline float32 b2ParticleSystem::GetCriticalVelocity(const b2TimeStep& step) const
{
    return m_particleDiameter * step.inv_dt;
}

inline float32 b2ParticleSystem::GetCriticalVelocitySquared(
    const b2TimeStep& step) const
{
    float32 velocity = GetCriticalVelocity(step);
    return velocity * velocity;
}

inline float32 b2ParticleSystem::GetCriticalPressure(const b2TimeStep& step) const
{
    return m_def.density * GetCriticalVelocitySquared(step);
}

inline float32 b2ParticleSystem::GetParticleStride() const
{
    return b2_particleStride * m_particleDiameter;
}

inline float32 b2ParticleSystem::GetParticleMass() const
{
    float32 stride = GetParticleStride();
    return m_def.density * stride * stride;
}

inline float32 b2ParticleSystem::GetParticleInvMass() const
{
    // mass = density * stride^2, so we take the inverse of this.
    float32 inverseStride = m_inverseDiameter * (1.0f / b2_particleStride);
    return m_inverseDensity * inverseStride * inverseStride;
}

inline b2Vec2* b2ParticleSystem::GetPositionBuffer()
{
    return m_positionBuffer.data;
}

inline b2Vec2* b2ParticleSystem::GetVelocityBuffer()
{
    return m_velocityBuffer.data;
}

inline float32* b2ParticleSystem::GetWeightBuffer()
{
    return m_weightBuffer;
}

inline int32 b2ParticleSystem::GetMaxParticleCount() const
{
    return m_def.maxCount;
}

inline void b2ParticleSystem::SetMaxParticleCount(int32 count)
{
    b2Assert(m_count <= count);
    m_def.maxCount = count;
}

inline uint32 b2ParticleSystem::GetAllParticleFlags() const
{
    return m_allParticleFlags;
}

inline uint32 b2ParticleSystem::GetAllGroupFlags() const
{
    return m_allGroupFlags;
}

inline const uint32* b2ParticleSystem::GetFlagsBuffer() const
{
    return m_flagsBuffer.data;
}

inline const b2Vec2* b2ParticleSystem::GetPositionBuffer() const
{
    return m_positionBuffer.data;
}

inline const b2Vec2* b2ParticleSystem::GetVelocityBuffer() const
{
    return m_velocityBuffer.data;
}

inline const b2ParticleColor* b2ParticleSystem::GetColorBuffer() const
{
    return ((b2ParticleSystem*) this)->GetColorBuffer();
}

inline const b2ParticleGroup* const* b2ParticleSystem::GetGroupBuffer() const
{
    return m_groupBuffer;
}

inline const float32* b2ParticleSystem::GetWeightBuffer() const
{
    return m_weightBuffer;
}

inline void* const* b2ParticleSystem::GetUserDataBuffer() const
{
    return ((b2ParticleSystem*) this)->GetUserDataBuffer();
}

inline b2ParticleGroup* const* b2ParticleSystem::GetGroupBuffer()
{
    return m_groupBuffer;
}

inline uint32 b2ParticleSystem::GetParticleFlags(int32 index)
{
    return GetFlagsBuffer()[index];
}

inline bool b2ParticleSystem::ValidateParticleIndex(const int32 index) const
{
    return index >= 0 && index < GetParticleCount() &&
        index != b2_invalidParticleIndex;
}

inline bool b2ParticleSystem::GetDestructionByAge() const
{
    return m_def.destroyByAge;
}

inline void b2ParticleSystem::ParticleApplyLinearImpulse(int32 index,
                                                         const b2Vec2& impulse)
{
    ApplyLinearImpulse(index, index + 1, impulse);
}


// Note: These functions must go in the header so the unit tests will compile
// them. b2ParticleSystem.cpp does not compile with this #define.
#if LIQUIDFUN_EXTERNAL_LANGUAGE_API

inline void b2ParticleSystem::SetParticleVelocity(int32 index,
                                                  float32 vx,
                                                  float32 vy)
{
    b2Vec2& v = GetVelocityBuffer()[index];
    v.x = vx;
    v.y = vy;
}

inline float b2ParticleSystem::GetParticlePositionX(int32 index) const
{
    return GetPositionBuffer()[index].x;
}

inline float b2ParticleSystem::GetParticlePositionY(int32 index) const
{
    return GetPositionBuffer()[index].y;
}

inline int b2ParticleSystem::CopyPositionBuffer(int startIndex,
                                                int numParticles,
                                                void* outBuf,
                                                int size) const
{
    int copySize = numParticles * sizeof(b2Vec2);
    void* inBufWithOffset = (void*) (GetPositionBuffer() + startIndex);
    return CopyBuffer(startIndex, numParticles, inBufWithOffset, outBuf, size,
                      copySize);
}

inline int b2ParticleSystem::CopyColorBuffer(int startIndex,
                                             int numParticles,
                                             void* outBuf,
                                             int size) const
{
    int copySize = numParticles * sizeof(b2ParticleColor);
    void* inBufWithOffset = (void*) (GetColorBuffer() + startIndex);
    return CopyBuffer(startIndex, numParticles, inBufWithOffset, outBuf, size,
                      copySize);
}

inline int b2ParticleSystem::CopyWeightBuffer(int startIndex,
                                              int numParticles,
                                              void* outBuf,
                                              int size) const
{
    int copySize = numParticles * sizeof(float32);
    void* inBufWithOffset = (void*) (GetWeightBuffer() + startIndex);
    return CopyBuffer(startIndex, numParticles, inBufWithOffset, outBuf, size,
                      copySize);
}

inline int b2ParticleSystem::CopyBuffer(int startIndex, int numParticles,
                                        void* inBufWithOffset, void* outBuf,
                                        int outBufSize, int copySize) const
{
    b2ExceptionType exception = IsBufCopyValid(startIndex, numParticles,
                                               copySize, outBufSize);
    if (exception != b2_noExceptions)
    {
        return exception;
    }

    memcpy(outBuf, inBufWithOffset, copySize);
    return b2_noExceptions;
}

#endif // LIQUIDFUN_EXTERNAL_LANGUAGE_API

#endif