b2Particle.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
#define B2_PARTICLE

#include <Box2D/Common/b2Math.h>
#include <Box2D/Common/b2Settings.h>
#include <Box2D/Common/b2IntrusiveList.h>

struct b2Color;
class b2ParticleGroup;


enum b2ParticleFlag
{
    b2_waterParticle = 0,
    b2_zombieParticle = 1 << 1,
    b2_wallParticle = 1 << 2,
    b2_springParticle = 1 << 3,
    b2_elasticParticle = 1 << 4,
    b2_viscousParticle = 1 << 5,
    b2_powderParticle = 1 << 6,
    b2_tensileParticle = 1 << 7,
    b2_colorMixingParticle = 1 << 8,
    b2_destructionListenerParticle = 1 << 9,
    b2_barrierParticle = 1 << 10,
    b2_staticPressureParticle = 1 << 11,
    b2_reactiveParticle = 1 << 12,
    b2_repulsiveParticle = 1 << 13,
    b2_fixtureContactListenerParticle = 1 << 14,
    b2_particleContactListenerParticle = 1 << 15,
    b2_fixtureContactFilterParticle = 1 << 16,
    b2_particleContactFilterParticle = 1 << 17,
};

class b2ParticleColor
{
public:
    b2ParticleColor() {}
    b2Inline b2ParticleColor(uint8 r, uint8 g, uint8 b, uint8 a)
    {
        Set(r, g, b, a);
    }

    b2ParticleColor(const b2Color& color);

    bool IsZero() const
    {
        return !r && !g && !b && !a;
    }

    b2Color GetColor() const;

    b2Inline void Set(uint8 r_, uint8 g_, uint8 b_, uint8 a_)
    {
        r = r_;
        g = g_;
        b = b_;
        a = a_;
    }

    void Set(const b2Color& color);

    b2ParticleColor& operator = (const b2ParticleColor &color)
    {
        Set(color.r, color.g, color.b, color.a);
        return *this;
    }

    b2ParticleColor& operator *= (float32 s)
    {
        Set((uint8)(r * s), (uint8)(g * s), (uint8)(b * s), (uint8)(a * s));
        return *this;
    }

    b2ParticleColor& operator *= (uint8 s)
    {
        // 1..256 to maintain the complete dynamic range.
        const int32 scale = (int32)s + 1;
        Set((uint8)(((int32)r * scale) >> k_bitsPerComponent),
            (uint8)(((int32)g * scale) >> k_bitsPerComponent),
            (uint8)(((int32)b * scale) >> k_bitsPerComponent),
            (uint8)(((int32)a * scale) >> k_bitsPerComponent));
        return *this;
    }

    b2ParticleColor operator * (float32 s) const
    {
        return MultiplyByScalar(s);
    }

    b2ParticleColor operator * (uint8 s) const
    {
        return MultiplyByScalar(s);
    }

    b2Inline b2ParticleColor& operator += (const b2ParticleColor &color)
    {
        r += color.r;
        g += color.g;
        b += color.b;
        a += color.a;
        return *this;
    }

    b2ParticleColor operator + (const b2ParticleColor &color) const
    {
        b2ParticleColor newColor(*this);
        newColor += color;
        return newColor;
    }

    b2Inline b2ParticleColor& operator -= (const b2ParticleColor &color)
    {
        r -= color.r;
        g -= color.g;
        b -= color.b;
        a -= color.a;
        return *this;
    }

    b2ParticleColor operator - (const b2ParticleColor &color) const
    {
        b2ParticleColor newColor(*this);
        newColor -= color;
        return newColor;
    }

    bool operator == (const b2ParticleColor &color) const
    {
        return r == color.r && g == color.g && b == color.b && a == color.a;
    }

    b2Inline void Mix(b2ParticleColor * const mixColor, const int32 strength)
    {
        MixColors(this, mixColor, strength);
    }

    static b2Inline void MixColors(b2ParticleColor * const colorA,
                             b2ParticleColor * const colorB,
                             const int32 strength)
    {
        const uint8 dr = (uint8)((strength * (colorB->r - colorA->r)) >>
                                 k_bitsPerComponent);
        const uint8 dg = (uint8)((strength * (colorB->g - colorA->g)) >>
                                 k_bitsPerComponent);
        const uint8 db = (uint8)((strength * (colorB->b - colorA->b)) >>
                                 k_bitsPerComponent);
        const uint8 da = (uint8)((strength * (colorB->a - colorA->a)) >>
                                 k_bitsPerComponent);
        colorA->r += dr;
        colorA->g += dg;
        colorA->b += db;
        colorA->a += da;
        colorB->r -= dr;
        colorB->g -= dg;
        colorB->b -= db;
        colorB->a -= da;
    }

private:
    template <typename T>
    b2ParticleColor MultiplyByScalar(T s) const
    {
        b2ParticleColor color(*this);
        color *= s;
        return color;
    }

public:
    uint8 r, g, b, a;

protected:
    static const float32 k_maxValue;
    static const float32 k_inverseMaxValue;
    static const uint8 k_bitsPerComponent;
};

extern b2ParticleColor b2ParticleColor_zero;

struct b2ParticleDef
{
    b2ParticleDef()
    {
        flags = 0;
        position = b2Vec2_zero;
        velocity = b2Vec2_zero;
        color = b2ParticleColor_zero;
        lifetime = 0.0f;
        userData = NULL;
        group = NULL;
    }

#if LIQUIDFUN_EXTERNAL_LANGUAGE_API
    void SetPosition(float32 x, float32 y);

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

    uint32 flags;

    b2Vec2 position;

    b2Vec2 velocity;

    b2ParticleColor color;

    float32 lifetime;

    void* userData;

    b2ParticleGroup* group;

};

int32 b2CalculateParticleIterations(
    float32 gravity, float32 radius, float32 timeStep);

class b2ParticleHandle : public b2TypedIntrusiveListNode<b2ParticleHandle>
{
    // Allow b2ParticleSystem to use SetIndex() to associate particle handles
    // with particle indices.
    friend class b2ParticleSystem;

public:
    b2ParticleHandle() : m_index(b2_invalidParticleIndex) { }
    ~b2ParticleHandle() { }

    int32 GetIndex() const { return m_index; }

private:
    void SetIndex(int32 index) { m_index = index; }

private:
    // Index of the particle within the particle system.
    int32 m_index;
};

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

inline void b2ParticleDef::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