b2ParticleGroup.h

Go to the documentation of this file.

/*
* 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_GROUP
#define B2_PARTICLE_GROUP

#include <Box2D/Particle/b2Particle.h>

class b2Shape;
class b2World;
class b2ParticleSystem;
class b2ParticleGroup;
class b2ParticleColor;
#if LIQUIDFUN_EXTERNAL_LANGUAGE_API
class b2CircleShape;
#endif // LIQUIDFUN_EXTERNAL_LANGUAGE_API


enum b2ParticleGroupFlag
{
    b2_solidParticleGroup = 1 << 0,
    b2_rigidParticleGroup = 1 << 1,
    b2_particleGroupCanBeEmpty = 1 << 2,
    b2_particleGroupWillBeDestroyed = 1 << 3,
    b2_particleGroupNeedsUpdateDepth = 1 << 4,
    b2_particleGroupInternalMask =
        b2_particleGroupWillBeDestroyed |
        b2_particleGroupNeedsUpdateDepth,
};

struct b2ParticleGroupDef
{

    b2ParticleGroupDef()
    {
        flags = 0;
        groupFlags = 0;
        position = b2Vec2_zero;
        angle = 0;
        linearVelocity = b2Vec2_zero;
        angularVelocity = 0;
        color = b2ParticleColor_zero;
        strength = 1;
        shape = NULL;
        shapes = NULL;
        shapeCount = 0;
        stride = 0;
        particleCount = 0;
        positionData = NULL;
        lifetime = 0.0f;
        userData = NULL;
        group = NULL;

#if LIQUIDFUN_EXTERNAL_LANGUAGE_API
        circleShapes = NULL;
        ownShapesArray = false;
#endif // LIQUIDFUN_EXTERNAL_LANGUAGE_API
    }

    ~b2ParticleGroupDef()
    {
#if LIQUIDFUN_EXTERNAL_LANGUAGE_API
        FreeShapesMemory();
#endif // LIQUIDFUN_EXTERNAL_LANGUAGE_API
    }

    uint32 flags;

    uint32 groupFlags;

    b2Vec2 position;

    float32 angle;

    b2Vec2 linearVelocity;

    float32 angularVelocity;

    b2ParticleColor color;

    float32 strength;

    const b2Shape* shape;

    const b2Shape* const* shapes;

    int32 shapeCount;

    float32 stride;

    int32 particleCount;

    const b2Vec2* positionData;

    float32 lifetime;

    void* userData;

    b2ParticleGroup* group;

#if LIQUIDFUN_EXTERNAL_LANGUAGE_API
    const b2CircleShape* circleShapes;

    bool ownShapesArray;

    void FreeShapesMemory();

    void SetCircleShapesFromVertexList(void* inBuf,
                                       int numShapes,
                                       float radius);

    void SetPosition(float32 x, float32 y);

    void SetColor(int32 r, int32 g, int32 b, int32 a);
#endif // LIQUIDFUN_EXTERNAL_LANGUAGE_API
};

class b2ParticleGroup
{

public:

    b2ParticleGroup* GetNext();
    const b2ParticleGroup* GetNext() const;

    b2ParticleSystem* GetParticleSystem();
    const b2ParticleSystem* GetParticleSystem() const;

    int32 GetParticleCount() const;

    int32 GetBufferIndex() const;

    bool ContainsParticle(int32 index) const;

    uint32 GetAllParticleFlags() const;

    uint32 GetGroupFlags() const;

    void SetGroupFlags(uint32 flags);

    float32 GetMass() const;

    float32 GetInertia() const;

    b2Vec2 GetCenter() const;

    b2Vec2 GetLinearVelocity() const;

    float32 GetAngularVelocity() const;

    const b2Transform& GetTransform() const;

    const b2Vec2& GetPosition() const;

    float32 GetAngle() const;

    b2Vec2 GetLinearVelocityFromWorldPoint(const b2Vec2& worldPoint) const;

    void* GetUserData() const;

    void SetUserData(void* data);

    void ApplyForce(const b2Vec2& force);

    void ApplyLinearImpulse(const b2Vec2& impulse);

    void DestroyParticles(bool callDestructionListener);

    void DestroyParticles();

private:

    friend class b2ParticleSystem;

    b2ParticleSystem* m_system;
    int32 m_firstIndex, m_lastIndex;
    uint32 m_groupFlags;
    float32 m_strength;
    b2ParticleGroup* m_prev;
    b2ParticleGroup* m_next;

    mutable int32 m_timestamp;
    mutable float32 m_mass;
    mutable float32 m_inertia;
    mutable b2Vec2 m_center;
    mutable b2Vec2 m_linearVelocity;
    mutable float32 m_angularVelocity;
    mutable b2Transform m_transform;

    void* m_userData;

    b2ParticleGroup();
    ~b2ParticleGroup();
    void UpdateStatistics() const;

};

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

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

inline b2ParticleSystem* b2ParticleGroup::GetParticleSystem()
{
    return m_system;
}

inline const b2ParticleSystem* b2ParticleGroup::GetParticleSystem() const
{
    return m_system;
}

inline int32 b2ParticleGroup::GetParticleCount() const
{
    return m_lastIndex - m_firstIndex;
}

inline bool b2ParticleGroup::ContainsParticle(int32 index) const
{
    return m_firstIndex <= index && index < m_lastIndex;
}

inline b2ParticleGroup::~b2ParticleGroup()
{
}

inline int32 b2ParticleGroup::GetBufferIndex() const
{
  return m_firstIndex;
}

inline uint32 b2ParticleGroup::GetGroupFlags() const
{
    return m_groupFlags & ~b2_particleGroupInternalMask;
}

inline float32 b2ParticleGroup::GetMass() const
{
    UpdateStatistics();
    return m_mass;
}

inline float32 b2ParticleGroup::GetInertia() const
{
    UpdateStatistics();
    return m_inertia;
}

inline b2Vec2 b2ParticleGroup::GetCenter() const
{
    UpdateStatistics();
    return m_center;
}

inline b2Vec2 b2ParticleGroup::GetLinearVelocity() const
{
    UpdateStatistics();
    return m_linearVelocity;
}

inline float32 b2ParticleGroup::GetAngularVelocity() const
{
    UpdateStatistics();
    return m_angularVelocity;
}

inline const b2Transform& b2ParticleGroup::GetTransform() const
{
    return m_transform;
}

inline const b2Vec2& b2ParticleGroup::GetPosition() const
{
    return m_transform.p;
}

inline float32 b2ParticleGroup::GetAngle() const
{
    return m_transform.q.GetAngle();
}

inline b2Vec2 b2ParticleGroup::GetLinearVelocityFromWorldPoint(
                                                const b2Vec2& worldPoint) const
{
    UpdateStatistics();
    return m_linearVelocity + b2Cross(m_angularVelocity, worldPoint - m_center);
}

inline void* b2ParticleGroup::GetUserData() const
{
    return m_userData;
}

inline void b2ParticleGroup::SetUserData(void* data)
{
    m_userData = data;
}

inline void b2ParticleGroup::DestroyParticles()
{
    DestroyParticles(false);
}

#if LIQUIDFUN_EXTERNAL_LANGUAGE_API
inline void b2ParticleGroupDef::SetPosition(float32 x, float32 y)
{
    position.Set(x, y);
}

inline void b2ParticleGroupDef::SetColor(int32 r, int32 g, int32 b, int32 a)
{
    color.Set((uint8)r, (uint8)g, (uint8)b, (uint8)a);
}
#endif // LIQUIDFUN_EXTERNAL_LANGUAGE_API


#endif