Particle Class Reference

#include <particle.h>

Inheritance diagram for Particle:

Public Member Functions
	Particle ()
	~Particle ()
void	clear ()
bool	update ()
void	draw (Graphics *const graphics, const int offsetX, const int offsetY) const
int	getPixelY () const
int	getSortPixelY () const
Particle *	addEffect (const std::string &particleEffectFile, const int pixelX, const int pixelY, const int rotation)
void	addEmitter (ParticleEmitter *const emitter)
void	moveTo (const Vector &pos)
void	moveTo (const float x, const float y)
void	moveBy (const Vector &change)
void	setLifetime (const int lifetime)
void	setFadeOut (const int fadeOut)
void	setFadeIn (const int fadeIn)
void	setVelocity (const float x, const float y, const float z)
void	setGravity (const float gravity)
void	setRandomness (const int r)
void	setBounce (const float bouncieness)
void	setFollow (const bool follow)
bool	doesFollow () const
void	setDestination (Particle *const target, const float accel, const float moment)
void	setDieDistance (const float dist)
void	adjustEmitterSize (const int w, const int h)
void	setAllowSizeAdjust (const bool adjust)
bool	isAlive () const
void	prepareToDie ()
bool	isExtinct () const
void	kill ()
void	disableAutoDelete ()
int	getNumberOfLayers () const
float	getAlpha () const
void	setAlpha (const float alpha)
virtual void	setDeathEffect (const std::string &effectFile, const signed char conditions)
void	setActor (const BeingId actor)
Public Member Functions inherited from Actor
virtual	~Actor ()
virtual int	getWidth () const
virtual int	getHeight () const
const Vector &	getPixelPositionF () const
virtual void	setPixelPositionF (const Vector &pos)
int	getPixelX () const
virtual int	getTileX () const
virtual int	getTileY () const
virtual void	setMap (Map *const map)
const Map *	getMap () const

Protected Member Functions
void	updateSelf ()
Protected Member Functions inherited from Actor
	Actor ()

Protected Attributes
float	mAlpha
int	mLifetimeLeft
int	mLifetimePast
int	mFadeOut
int	mFadeIn
Vector	mVelocity
AliveStatusT	mAlive
ParticleTypeT	mType
SimpleAnimation *	mAnimation
Image *	mImage
BeingId	mActor
Protected Attributes inherited from Actor
Map *	mMap
Vector	mPos
int	mYDiff

Private Attributes
Emitters	mChildEmitters
Particles	mChildParticles
Particles	mChildMoveParticles
std::string	mDeathEffect
float	mGravity
float	mBounce
float	mAcceleration
float	mInvDieDistance
float	mMomentum
Particle *	mTarget
int	mRandomness
signed char	mDeathEffectConditions
bool	mAutoDelete
bool	mAllowSizeAdjust
bool	mFollow

Friends
class	ParticleEngine

Additional Inherited Members
Data Fields inherited from Actor
int	mPixelX
int	mPixelY

Detailed Description

A particle spawned by a ParticleEmitter.

Definition at line 45 of file particle.h.

Constructor & Destructor Documentation

Particle()

Particle::Particle

(

)

Definition at line 59 of file particle.cpp.

                   :
    Actor(),
    mAlpha(1.0F),
    mLifetimeLeft(-1),
    mLifetimePast(0),
    mFadeOut(0),
    mFadeIn(0),
    mVelocity(),
    mAlive(AliveStatus::ALIVE),
    mType(ParticleType::Normal),
    mAnimation(nullptr),
    mImage(nullptr),
    mActor(BeingId_zero),
    mChildEmitters(),
    mChildParticles(),
    mChildMoveParticles(),
    mDeathEffect(),
    mGravity(0.0F),
    mBounce(0.0F),
    mAcceleration(0.0F),
    mInvDieDistance(-1.0F),
    mMomentum(1.0F),
    mTarget(nullptr),
    mRandomness(0),
    mDeathEffectConditions(0x00),
    mAutoDelete(true),
    mAllowSizeAdjust(false),
    mFollow(false)
{
    ParticleEngine::particleCount++;
}

References ParticleEngine::particleCount.

~Particle()

Particle::~Particle

(

)

Destructor.

Definition at line 91 of file particle.cpp.

{
    if (mActor != BeingId_zero &&
        (actorManager != nullptr))
    {
        ActorSprite *const actor = actorManager->findActor(mActor);
        if (actor != nullptr)
            actor->controlParticleDeleted(this);
    }
    // Delete child emitters and child particles
    clear();
    delete2(mAnimation)
    if (mImage != nullptr)
    {
        if (mType == ParticleType::Image)
        {
            const std::string &restrict name = mImage->mIdPath;
            StringIntMapIter it
                = ImageParticle::imageParticleCountByName.find(name);
            if (it != ImageParticle::imageParticleCountByName.end())
            {
                int &cnt = (*it).second;
                if (cnt > 0)
                    cnt --;
            }
            mImage->decRef();
        }
        mImage = nullptr;
    }
 
    ParticleEngine::particleCount--;
}

References actorManager, BeingId_zero, clear(), ActorSprite::controlParticleDeleted(), delete2, ActorManager::findActor(), ParticleType::Image, ImageParticle::imageParticleCountByName, mActor, mAnimation, mImage, mType, ParticleEngine::particleCount, and restrict.

Member Function Documentation

addEffect()

Particle * Particle::addEffect	(	const std::string &	particleEffectFile,
		const int	pixelX,
		const int	pixelY,
		const int	rotation
	)

Creates a child particle that hosts some emitters described in the particleEffectFile.

Definition at line 411 of file particle.cpp.

{
    Particle *newParticle = nullptr;
 
    const size_t pos = particleEffectFile.find('|');
    const std::string dyePalettes = (pos != std::string::npos)
        ? particleEffectFile.substr(pos + 1) : "";
    XML::Document *doc = Loader::getXml(particleEffectFile.substr(0, pos),
        UseVirtFs_true,
        SkipError_false);
    if (doc == nullptr)
        return nullptr;
    XmlNodeConstPtrConst rootNode = doc->rootNode();
 
    if ((rootNode == nullptr) || !xmlNameEqual(rootNode, "effect"))
    {
        logger->log("Error loading particle: %s", particleEffectFile.c_str());
        doc->decRef();
        return nullptr;
    }
 
    // Parse particles
    for_each_xml_child_node(effectChildNode, rootNode)
    {
        // We're only interested in particles
        if (!xmlNameEqual(effectChildNode, "particle"))
            continue;
 
        // Determine the exact particle type
        XmlNodePtr node;
 
        // Animation
        if ((node = XML::findFirstChildByName(effectChildNode, "animation")) !=
            nullptr)
        {
            newParticle = new AnimationParticle(node, dyePalettes);
            newParticle->setMap(mMap);
        }
        // Rotational
        else if ((node = XML::findFirstChildByName(
                 effectChildNode, "rotation")) != nullptr)
        {
            newParticle = new RotationalParticle(node, dyePalettes);
            newParticle->setMap(mMap);
        }
        // Image
        else if ((node = XML::findFirstChildByName(effectChildNode,
                 "image")) != nullptr)
        {
            std::string imageSrc;
            if (XmlHaveChildContent(node))
                imageSrc = XmlChildContent(node);
            if (!imageSrc.empty() && !dyePalettes.empty())
                Dye::instantiate(imageSrc, dyePalettes);
            Image *const img = Loader::getImage(imageSrc);
 
            newParticle = new ImageParticle(img);
            newParticle->setMap(mMap);
        }
        // Other
        else
        {
            newParticle = new Particle;
            newParticle->setMap(mMap);
        }
 
        // Read and set the basic properties of the particle
        const float offsetX = XML::getFloatProperty(
            effectChildNode, "position-x", 0);
        const float offsetY = XML::getFloatProperty(
            effectChildNode, "position-y", 0);
        const float offsetZ = XML::getFloatProperty(
            effectChildNode, "position-z", 0);
        const Vector position(mPos.x + static_cast<float>(pixelX) + offsetX,
            mPos.y + static_cast<float>(pixelY) + offsetY,
            mPos.z + offsetZ);
        newParticle->moveTo(position);
 
        const int lifetime = XML::getProperty(effectChildNode, "lifetime", -1);
        newParticle->setLifetime(lifetime);
        const bool resizeable = "false" != XML::getProperty(effectChildNode,
            "size-adjustable", "false");
 
        newParticle->setAllowSizeAdjust(resizeable);
 
        // Look for additional emitters for this particle
        for_each_xml_child_node(emitterNode, effectChildNode)
        {
            if (xmlNameEqual(emitterNode, "emitter"))
            {
                ParticleEmitter *restrict const newEmitter =
                    new ParticleEmitter(
                    emitterNode,
                    newParticle,
                    mMap,
                    rotation,
                    dyePalettes);
                newParticle->addEmitter(newEmitter);
            }
            else if (xmlNameEqual(emitterNode, "deatheffect"))
            {
                std::string deathEffect;
                if ((node != nullptr) && XmlHaveChildContent(node))
                    deathEffect = XmlChildContent(emitterNode);
 
                char deathEffectConditions = 0x00;
                if (XML::getBoolProperty(emitterNode, "on-floor", true))
                {
                    deathEffectConditions += CAST_S8(
                        AliveStatus::DEAD_FLOOR);
                }
                if (XML::getBoolProperty(emitterNode, "on-sky", true))
                {
                    deathEffectConditions += CAST_S8(
                        AliveStatus::DEAD_SKY);
                }
                if (XML::getBoolProperty(emitterNode, "on-other", false))
                {
                    deathEffectConditions += CAST_S8(
                        AliveStatus::DEAD_OTHER);
                }
                if (XML::getBoolProperty(emitterNode, "on-impact", true))
                {
                    deathEffectConditions += CAST_S8(
                        AliveStatus::DEAD_IMPACT);
                }
                if (XML::getBoolProperty(emitterNode, "on-timeout", true))
                {
                    deathEffectConditions += CAST_S8(
                        AliveStatus::DEAD_TIMEOUT);
                }
                newParticle->setDeathEffect(
                    deathEffect, deathEffectConditions);
            }
        }
 
        mChildParticles.push_back(newParticle);
    }
 
    doc->decRef();
    return newParticle;
}

References addEmitter(), CAST_S8, AliveStatus::DEAD_FLOOR, AliveStatus::DEAD_IMPACT, AliveStatus::DEAD_OTHER, AliveStatus::DEAD_SKY, AliveStatus::DEAD_TIMEOUT, Resource::decRef(), XML::findFirstChildByName(), for_each_xml_child_node, XML::getBoolProperty(), XML::getFloatProperty(), Loader::getImage(), XML::getProperty(), Loader::getXml(), Dye::instantiate(), Logger::log(), logger, Ea::GameRecv::mMap, moveTo(), anonymous_namespace{mrand.cpp}::mPos, restrict, XML::Document::rootNode(), setAllowSizeAdjust(), setDeathEffect(), setLifetime(), Actor::setMap(), SkipError_false, and UseVirtFs_true.

addEmitter()

void Particle::addEmitter ( ParticleEmitter *const  emitter )

inline

Adds an emitter to the particle.

Definition at line 101 of file particle.h.

        { mChildEmitters.push_back(emitter); }

References mChildEmitters.

Referenced by addEffect(), ParticleEngine::addEffect(), and ParticleEmitter::createParticles().

adjustEmitterSize()

void Particle::adjustEmitterSize	(	const int	w,
		const int	h
	)

Changes the size of the emitters so that the effect fills a rectangle of this size

Definition at line 556 of file particle.cpp.

{
    if (mAllowSizeAdjust)
    {
        FOR_EACH (EmitterConstIterator, e, mChildEmitters)
            (*e)->adjustSize(w, h);
    }
}

References FOR_EACH.

Referenced by Map::initializeParticleEffects().

clear()

void Particle::clear

(

)

Deletes all child particles and emitters.

Definition at line 582 of file particle.cpp.

{
    delete_all(mChildEmitters);
    mChildEmitters.clear();
 
    delete_all(mChildParticles);
    mChildParticles.clear();
 
    mChildMoveParticles.clear();
}

References delete_all(), mChildEmitters, mChildMoveParticles, and mChildParticles.

Referenced by ~Particle().

disableAutoDelete()

void Particle::disableAutoDelete ( )

inline

After calling this function the particle will only request deletion when kill() is called

Definition at line 227 of file particle.h.

        { mAutoDelete = false; }

References mAutoDelete.

Referenced by ActorSprite::controlCustomParticle(), and ParticleVector::setLocally().

doesFollow()

bool Particle::doesFollow ( ) const

inline

Gets the flag if the particle is supposed to be moved by its parent

Definition at line 176 of file particle.h.

        { return mFollow; }

References mFollow.

draw()

void Particle::draw ( Graphics *const  graphics, const int  offsetX, const int  offsetY  ) const

virtual

Draws the particle image.

Implements Actor.

Reimplemented in TextParticle.

Definition at line 124 of file particle.cpp.

{
}

getAlpha()

float Particle::getAlpha ( ) const

inlinevirtual

Returns the current alpha value used to draw the actor.

Implements Actor.

Definition at line 234 of file particle.h.

        { return 1.0F; }

getNumberOfLayers()

int Particle::getNumberOfLayers ( ) const

inlinevirtual

We consider particles (at least for now) to be one layer-sprites

Reimplemented from Actor.

Definition at line 231 of file particle.h.

        { return 1; }

getPixelY()

int Particle::getPixelY ( ) const

inlinevirtual

Necessary for sorting with the other sprites.

Reimplemented from Actor.

Reimplemented in TextParticle.

Definition at line 80 of file particle.h.

        { return CAST_S32(mPos.y) - 16; }

References CAST_S32, Actor::mPos, and Vector::y.

getSortPixelY()

int Particle::getSortPixelY ( ) const

inlinevirtual

Necessary for sorting with the other sprites for sorting only.

Reimplemented from Actor.

Reimplemented in TextParticle.

Definition at line 86 of file particle.h.

        { return CAST_S32(mPos.y) - 16; }

References CAST_S32, Actor::mPos, and Vector::y.

isAlive()

bool Particle::isAlive ( ) const

inline

Definition at line 206 of file particle.h.

        { return mAlive == AliveStatus::ALIVE; }

References AliveStatus::ALIVE, and mAlive.

Referenced by isExtinct().

isExtinct()

bool Particle::isExtinct ( ) const

inline

Determines whether the particle and its children are all dead

Definition at line 214 of file particle.h.

        { return !isAlive() && mChildParticles.empty(); }

References isAlive(), and mChildParticles.

Referenced by ParticleList::moveTo(), and ParticleVector::moveTo().

kill()

void Particle::kill ( )

inline

Manually marks the particle for deletion.

Definition at line 220 of file particle.h.

        { mAlive = AliveStatus::DEAD_OTHER; mAutoDelete = true; }

References AliveStatus::DEAD_OTHER, mAlive, and mAutoDelete.

Referenced by EffectManager::clear(), ParticleVector::delLocally(), EffectManager::logic(), ParticleList::moveTo(), ParticleVector::moveTo(), and ParticleList::removeLocally().

moveBy()

void Particle::moveBy

(

const Vector &

change

)

Changes the particle position relative

Definition at line 397 of file particle.cpp.

{
    mPos += change;
    FOR_EACH (ParticleConstIterator, p, mChildMoveParticles)
    {
        (*p)->moveBy(change);
    }
}

References FOR_EACH, and anonymous_namespace{mrand.cpp}::mPos.

Referenced by moveTo(), and updateSelf().

moveTo() [1/2]

void Particle::moveTo	(	const float	x,
		const float	y
	)

Sets the position in 2 dimensional space in pixels relative to map.

Definition at line 406 of file particle.cpp.

{
    moveTo(Vector(x, y, mPos.z));
}

References anonymous_namespace{mrand.cpp}::mPos, x, and y.

moveTo() [2/2]

void Particle::moveTo ( const Vector &  pos )

inline

Sets the position in 3 dimensional space in pixels relative to map.

Definition at line 107 of file particle.h.

        { moveBy(pos - mPos); }

References moveBy(), and Actor::mPos.

Referenced by addEffect(), ParticleEngine::addEffect(), ParticleEngine::addTextRiseFadeOutEffect(), ParticleEngine::addTextSplashEffect(), ParticleEmitter::createParticles(), ParticleList::moveTo(), and ParticleVector::moveTo().

prepareToDie()

void Particle::prepareToDie

(

)

Definition at line 565 of file particle.cpp.

{
    FOR_EACH (ParticleIterator, p, mChildParticles)
    {
        Particle *restrict const particle = *p;
        if (particle == nullptr)
            continue;
        particle->prepareToDie();
        if (particle->isAlive() &&
            particle->mLifetimeLeft == -1 &&
            particle->mAutoDelete)
        {
            particle->kill();
        }
    }
}

References FOR_EACH, mChildParticles, and restrict.

Referenced by ParticleList::removeLocally().

setActor()

void Particle::setActor ( const BeingId  actor )

inline

Definition at line 244 of file particle.h.

        { mActor = actor; }

References mActor.

Referenced by ActorSprite::controlAutoParticle().

setAllowSizeAdjust()

void Particle::setAllowSizeAdjust ( const bool  adjust )

inline

Definition at line 203 of file particle.h.

        { mAllowSizeAdjust = adjust; }

References mAllowSizeAdjust.

Referenced by addEffect(), and ParticleEngine::addEffect().

setAlpha()

void Particle::setAlpha ( const float  alpha )

inlinevirtual

Sets the alpha value used to draw the actor.

Implements Actor.

Definition at line 237 of file particle.h.

        { }

Referenced by ParticleEmitter::createParticles().

setBounce()

void Particle::setBounce ( const float  bouncieness )

inline

Sets the ammount of velocity particles retain after hitting the ground.

Definition at line 164 of file particle.h.

        { mBounce = bouncieness; }

References mBounce.

Referenced by ParticleEngine::addTextSplashEffect(), and ParticleEmitter::createParticles().

setDeathEffect()

virtual void Particle::setDeathEffect ( const std::string &  effectFile, const signed char  conditions  )

inlinevirtual

Definition at line 240 of file particle.h.

        { mDeathEffect = effectFile; mDeathEffectConditions = conditions; }

References mDeathEffect, and mDeathEffectConditions.

Referenced by addEffect(), ParticleEngine::addEffect(), and ParticleEmitter::createParticles().

setDestination()

void Particle::setDestination ( Particle *const  target, const float  accel, const float  moment  )

inline

Makes the particle move toward another particle with a given acceleration and momentum

Definition at line 183 of file particle.h.

        { mTarget = target; mAcceleration = accel; mMomentum = moment; }

References mAcceleration, mMomentum, and mTarget.

Referenced by ParticleEmitter::createParticles().

setDieDistance()

void Particle::setDieDistance ( const float  dist )

inline

Sets the distance in pixel the particle can come near the target particle before it is destroyed. Does only make sense after a target particle has been set using setDestination.

Definition at line 194 of file particle.h.

        { mInvDieDistance = 1.0F / dist; }

References mInvDieDistance.

Referenced by ParticleEmitter::createParticles().

setFadeIn()

void Particle::setFadeIn ( const int  fadeIn )

inline

Sets the remaining particle lifetime where the particle starts to fade out.

Definition at line 137 of file particle.h.

        { mFadeIn = fadeIn; }

References mFadeIn.

Referenced by ParticleEngine::addTextRiseFadeOutEffect(), and ParticleEmitter::createParticles().

setFadeOut()

void Particle::setFadeOut ( const int  fadeOut )

inline

Sets the age of the pixel in game ticks where the particle has faded in completely.

Definition at line 130 of file particle.h.

        { mFadeOut = fadeOut; }

References mFadeOut.

Referenced by ParticleEngine::addTextRiseFadeOutEffect(), ParticleEngine::addTextSplashEffect(), and ParticleEmitter::createParticles().

setFollow()

void Particle::setFollow ( const bool  follow )

inline

Sets the flag if the particle is supposed to be moved by its parent

Definition at line 170 of file particle.h.

        { mFollow = follow; }

References Actions::follow(), and mFollow.

Referenced by ParticleEmitter::createParticles().

setGravity()

void Particle::setGravity ( const float  gravity )

inline

Sets the downward acceleration.

Definition at line 151 of file particle.h.

        { mGravity = gravity; }

References mGravity.

Referenced by ParticleEngine::addTextRiseFadeOutEffect(), ParticleEngine::addTextSplashEffect(), and ParticleEmitter::createParticles().

setLifetime()

void Particle::setLifetime ( const int  lifetime )

inline

Sets the time in game ticks until the particle is destroyed.

Definition at line 123 of file particle.h.

        { mLifetimeLeft = lifetime; mLifetimePast = 0; }

References mLifetimeLeft, and mLifetimePast.

Referenced by addEffect(), ParticleEngine::addEffect(), ParticleEngine::addTextRiseFadeOutEffect(), ParticleEngine::addTextSplashEffect(), and ParticleEmitter::createParticles().

setRandomness()

void Particle::setRandomness ( const int  r )

inline

Sets the ammount of random vector changes

Definition at line 157 of file particle.h.

        { mRandomness = r; }

References mRandomness.

Referenced by ParticleEmitter::createParticles().

setVelocity()

void Particle::setVelocity ( const float  x, const float  y, const float  z  )

inline

Sets the current velocity in 3 dimensional space.

Definition at line 143 of file particle.h.

        { mVelocity.x = x; mVelocity.y = y; mVelocity.z = z; }

References mVelocity, x, Vector::x, y, Vector::y, and Vector::z.

Referenced by ParticleEngine::addTextRiseFadeOutEffect(), ParticleEngine::addTextSplashEffect(), and ParticleEmitter::createParticles().

update()

bool Particle::update

(

)

Updates particle position, returns false when the particle should be deleted.

Definition at line 254 of file particle.cpp.

{
    if (A_LIKELY(mAlive == AliveStatus::ALIVE))
    {
        if (A_UNLIKELY(mLifetimeLeft == 0))
        {
            mAlive = AliveStatus::DEAD_TIMEOUT;
            if (mChildParticles.empty())
            {
                if (mAutoDelete)
                    return false;
                return true;
            }
        }
        else
        {
            if (mAnimation != nullptr)
            {
                if (mType == ParticleType::Animation)
                {
                    // particle engine is updated every 10ms
                    mAnimation->update(10);
                }
                else  // ParticleType::Rotational
                {
                    // TODO: cache velocities to avoid spamming atan2()
                    const int size = mAnimation->getLength();
                    if (size == 0)
                        return false;
 
                    float rad = static_cast<float>(atan2(mVelocity.x,
                        mVelocity.y));
                    if (rad < 0)
                        rad = PI2 + rad;
 
                    const float range = static_cast<float>(PI / size);
 
                    // Determines which frame the particle should play
                    if (A_UNLIKELY(rad < range || rad > PI2 - range))
                    {
                        mAnimation->setFrame(0);
                    }
                    else
                    {
                        const float range2 = 2 * range;
                        // +++ need move condition outside of for
                        for (int c = 1; c < size; c++)
                        {
                            const float cRange = static_cast<float>(c) *
                                range2;
                            if (cRange - range < rad &&
                                rad < cRange + range)
                            {
                                mAnimation->setFrame(c);
                                break;
                            }
                        }
                    }
                }
                mImage = mAnimation->getCurrentImage();
            }
            const Vector oldPos = mPos;
 
            updateSelf();
 
            const Vector change = mPos - oldPos;
            if (mChildParticles.empty())
            {
                if (mAlive != AliveStatus::ALIVE &&
                    mAutoDelete)
                {
                    return false;
                }
                return true;
            }
            for (ParticleIterator p = mChildMoveParticles.begin(),
                 fp2 = mChildMoveParticles.end(); p != fp2; )
            {
                // move particle with its parent if desired
                (*p)->moveBy(change);
                ++p;
            }
        }
 
        // Update child particles
        for (ParticleIterator p = mChildParticles.begin(),
             fp2 = mChildParticles.end(); p != fp2; )
        {
            Particle *restrict const particle = *p;
            // update particle
            if (A_LIKELY(particle->update()))
            {
                ++p;
            }
            else
            {
                mChildMoveParticles.remove(*p);
                delete particle;
                p = mChildParticles.erase(p);
            }
        }
        if (A_UNLIKELY(mAlive != AliveStatus::ALIVE &&
            mChildParticles.empty() &&
            mAutoDelete))
        {
            return false;
        }
    }
    else
    {
        if (mChildParticles.empty())
        {
            if (mAutoDelete)
                return false;
            return true;
        }
        // Update child particles
        for (ParticleIterator p = mChildParticles.begin(),
             fp2 = mChildParticles.end(); p != fp2; )
        {
            Particle *restrict const particle = *p;
            // update particle
            if (A_LIKELY(particle->update()))
            {
                ++p;
            }
            else
            {
                mChildMoveParticles.remove(*p);
                delete particle;
                p = mChildParticles.erase(p);
            }
        }
        if (A_UNLIKELY(mChildParticles.empty() &&
            mAutoDelete))
        {
            return false;
        }
    }
 
    return true;
}

References A_LIKELY, A_UNLIKELY, AliveStatus::ALIVE, ParticleType::Animation, AliveStatus::DEAD_TIMEOUT, SimpleAnimation::getCurrentImage(), SimpleAnimation::getLength(), mAlive, mAnimation, mAutoDelete, mChildMoveParticles, mChildParticles, mImage, mLifetimeLeft, Actor::mPos, mType, mVelocity, PI, PI2, restrict, SimpleAnimation::setFrame(), EmoteDB::size(), SimpleAnimation::update(), updateSelf(), Vector::x, and Vector::y.

updateSelf()

void Particle::updateSelf ( )

protected

Definition at line 130 of file particle.cpp.

{
    // calculate particle movement
    if (A_LIKELY(mMomentum != 1.0F))
        mVelocity *= mMomentum;
 
    if ((mTarget != nullptr) && mAcceleration != 0.0F)
    {
        Vector dist = mPos - mTarget->mPos;
        dist.x *= SIN45;
        float invHypotenuse;
 
        switch (ParticleEngine::fastPhysics)
        {
            case ParticlePhysics::Normal:
                invHypotenuse = fastInvSqrt(
                    dist.x * dist.x + dist.y * dist.y + dist.z * dist.z);
                break;
            case ParticlePhysics::Fast:
                if (dist.x == 0.0F)
                {
                    invHypotenuse = 0;
                    break;
                }
 
                invHypotenuse = 2.0F / (static_cast<float>(fabs(dist.x))
                                + static_cast<float>(fabs(dist.y))
                                + static_cast<float>(fabs(dist.z)));
                break;
            case ParticlePhysics::Best:
            default:
                invHypotenuse = 1.0F / static_cast<float>(sqrt(
                    dist.x * dist.x + dist.y * dist.y + dist.z * dist.z));
                break;
        }
 
        if (invHypotenuse != 0.0F)
        {
            if (mInvDieDistance > 0.0F && invHypotenuse > mInvDieDistance)
                mAlive = AliveStatus::DEAD_IMPACT;
            const float accFactor = invHypotenuse * mAcceleration;
            mVelocity -= dist * accFactor;
        }
    }
 
    if (A_LIKELY(mRandomness >= 10))  // reduce useless calculations
    {
        const int rand2 = mRandomness * 2;
        mVelocity.x += static_cast<float>(mrand() % rand2 - mRandomness)
            / 1000.0F;
        mVelocity.y += static_cast<float>(mrand() % rand2 - mRandomness)
            / 1000.0F;
        mVelocity.z += static_cast<float>(mrand() % rand2 - mRandomness)
            / 1000.0F;
    }
 
    mVelocity.z -= mGravity;
 
    // Update position
    mPos.x += mVelocity.x;
    mPos.y += mVelocity.y * SIN45;
    mPos.z += mVelocity.z * SIN45;
 
    // Update other stuff
    if (A_LIKELY(mLifetimeLeft > 0))
        mLifetimeLeft--;
 
    mLifetimePast++;
 
    if (mPos.z < 0.0F)
    {
        if (mBounce > 0.0F)
        {
            mPos.z *= -mBounce;
            mVelocity *= mBounce;
            mVelocity.z = -mVelocity.z;
        }
        else
        {
            mAlive = AliveStatus::DEAD_FLOOR;
        }
    }
    else if (mPos.z > ParticleEngine::PARTICLE_SKY)
    {
        mAlive = AliveStatus::DEAD_SKY;
    }
 
    // Update child emitters
    if ((ParticleEngine::emitterSkip != 0) &&
        (mLifetimePast - 1) % ParticleEngine::emitterSkip == 0)
    {
        FOR_EACH (EmitterConstIterator, e, mChildEmitters)
        {
            STD_VECTOR<Particle*> newParticles;
            (*e)->createParticles(mLifetimePast, newParticles);
            FOR_EACH (STD_VECTOR<Particle*>::const_iterator,
                      it,
                      newParticles)
            {
                Particle *const p = *it;
                p->moveBy(mPos);
                mChildParticles.push_back(p);
                if (p->mFollow)
                    mChildMoveParticles.push_back(p);
            }
        }
    }
 
    // create death effect when the particle died
    if (A_UNLIKELY(mAlive != AliveStatus::ALIVE &&
        mAlive != AliveStatus::DEAD_LONG_AGO))
    {
        if ((CAST_U32(mAlive) & mDeathEffectConditions)
            > 0x00  && !mDeathEffect.empty())
        {
            Particle *restrict const deathEffect = particleEngine->addEffect(
                mDeathEffect, 0, 0, 0);
            if (deathEffect != nullptr)
                deathEffect->moveBy(mPos);
        }
        mAlive = AliveStatus::DEAD_LONG_AGO;
    }
}

References A_LIKELY, A_UNLIKELY, ParticleEngine::addEffect(), AliveStatus::ALIVE, ParticlePhysics::Best, CAST_U32, AliveStatus::DEAD_FLOOR, AliveStatus::DEAD_IMPACT, AliveStatus::DEAD_LONG_AGO, AliveStatus::DEAD_SKY, ParticleEngine::emitterSkip, ParticlePhysics::Fast, fastInvSqrt(), ParticleEngine::fastPhysics, FOR_EACH, mAcceleration, mAlive, mBounce, mChildEmitters, mChildMoveParticles, mChildParticles, mDeathEffect, mDeathEffectConditions, mFollow, mGravity, mInvDieDistance, mLifetimeLeft, mLifetimePast, mMomentum, moveBy(), Actor::mPos, mrand(), mRandomness, mTarget, mVelocity, ParticlePhysics::Normal, ParticleEngine::PARTICLE_SKY, particleEngine, restrict, SIN45, Vector::x, Vector::y, and Vector::z.

Referenced by update().

Friends And Related Function Documentation

ParticleEngine

friend class ParticleEngine

friend

Definition at line 48 of file particle.h.

Field Documentation

mAcceleration

float Particle::mAcceleration

private

Definition at line 301 of file particle.h.

Referenced by setDestination(), and updateSelf().

mActor

BeingId Particle::mActor

protected

Definition at line 279 of file particle.h.

Referenced by setActor(), and ~Particle().

mAlive

AliveStatusT Particle::mAlive

protected

Definition at line 269 of file particle.h.

Referenced by isAlive(), kill(), update(), and updateSelf().

mAllowSizeAdjust

bool Particle::mAllowSizeAdjust

private

Definition at line 324 of file particle.h.

Referenced by setAllowSizeAdjust().

mAlpha

float Particle::mAlpha

protected

Definition at line 251 of file particle.h.

Referenced by ImageParticle::setAlpha().

mAnimation

SimpleAnimation* Particle::mAnimation

protected

The image used for this particle.

Definition at line 274 of file particle.h.

Referenced by AnimationParticle::AnimationParticle(), RotationalParticle::RotationalParticle(), update(), and ~Particle().

mAutoDelete

bool Particle::mAutoDelete

private

Definition at line 321 of file particle.h.

Referenced by disableAutoDelete(), kill(), and update().

mBounce

float Particle::mBounce

private

Definition at line 298 of file particle.h.

Referenced by setBounce(), and updateSelf().

mChildEmitters

Emitters Particle::mChildEmitters

private

Definition at line 283 of file particle.h.

Referenced by addEmitter(), clear(), and updateSelf().

mChildMoveParticles

Particles Particle::mChildMoveParticles

private

Definition at line 288 of file particle.h.

Referenced by clear(), update(), and updateSelf().

mChildParticles

Particles Particle::mChildParticles

private

Definition at line 286 of file particle.h.

Referenced by clear(), isExtinct(), prepareToDie(), update(), and updateSelf().

mDeathEffect

std::string Particle::mDeathEffect

private

Definition at line 291 of file particle.h.

Referenced by setDeathEffect(), and updateSelf().

mDeathEffectConditions

signed char Particle::mDeathEffectConditions

private

Definition at line 318 of file particle.h.

Referenced by setDeathEffect(), and updateSelf().

mFadeIn

int Particle::mFadeIn

protected

Definition at line 263 of file particle.h.

Referenced by setFadeIn().

mFadeOut

int Particle::mFadeOut

protected

Definition at line 260 of file particle.h.

Referenced by setFadeOut().

mFollow

bool Particle::mFollow

private

Definition at line 327 of file particle.h.

Referenced by doesFollow(), setFollow(), and updateSelf().

mGravity

float Particle::mGravity

private

Definition at line 295 of file particle.h.

Referenced by setGravity(), and updateSelf().

mImage

Image* Particle::mImage

protected

Definition at line 277 of file particle.h.

Referenced by ImageParticle::ImageParticle(), update(), and ~Particle().

mInvDieDistance

float Particle::mInvDieDistance

private

Definition at line 305 of file particle.h.

Referenced by setDieDistance(), and updateSelf().

mLifetimeLeft

int Particle::mLifetimeLeft

protected

Definition at line 254 of file particle.h.

Referenced by setLifetime(), update(), and updateSelf().

mLifetimePast

int Particle::mLifetimePast

protected

Definition at line 257 of file particle.h.

Referenced by setLifetime(), and updateSelf().

mMomentum

float Particle::mMomentum

private

Definition at line 308 of file particle.h.

Referenced by setDestination(), and updateSelf().

mRandomness

int Particle::mRandomness

private

Definition at line 314 of file particle.h.

Referenced by setRandomness(), and updateSelf().

mTarget

Particle* Particle::mTarget

private

Definition at line 311 of file particle.h.

Referenced by setDestination(), and updateSelf().

mType

ParticleTypeT Particle::mType

protected

Used animation for this particle

Definition at line 271 of file particle.h.

Referenced by AnimationParticle::AnimationParticle(), ImageParticle::ImageParticle(), RotationalParticle::RotationalParticle(), TextParticle::TextParticle(), update(), and ~Particle().

mVelocity

Vector Particle::mVelocity

protected

Definition at line 266 of file particle.h.

Referenced by setVelocity(), update(), and updateSelf().

---

The documentation for this class was generated from the following files:

• src/particle/particle.h (986a3bf)
• src/particle/particle.cpp (986a3bf)