#include <particleemitter.h>

Public Member Functions
	ParticleEmitter (const xmlNode const emitterNode, Particle const target, Map *const map, const int rotation, const std::string &dyePalettes)

	ParticleEmitter (const ParticleEmitter &o)

ParticleEmitter &	operator= (const ParticleEmitter &o)

	~ParticleEmitter ()

void	createParticles (const int tick, std::vector< Particle * > &newParticles)

void	setTarget (Particle *const target)

void	adjustSize (const int w, const int h)

Static Private Member Functions
template<typename T >
static ParticleEmitterProp< T >	readParticleEmitterProp (xmlNode *const propertyNode, T def)

static ImageSet *	getImageSet (xmlNode *const node)

Private Attributes
ParticleEmitterProp< float >	mParticlePosX

ParticleEmitterProp< float >	mParticlePosY

ParticleEmitterProp< float >	mParticlePosZ

ParticleEmitterProp< float >	mParticleAngleHorizontal

ParticleEmitterProp< float >	mParticleAngleVertical

ParticleEmitterProp< float >	mParticlePower

ParticleEmitterProp< float >	mParticleGravity

ParticleEmitterProp< int >	mParticleRandomness

ParticleEmitterProp< float >	mParticleBounce

Particle *	mParticleTarget

ParticleEmitterProp< float >	mParticleAcceleration

ParticleEmitterProp< float >	mParticleDieDistance

ParticleEmitterProp< float >	mParticleMomentum

ParticleEmitterProp< int >	mParticleLifetime

ParticleEmitterProp< int >	mParticleFadeOut

ParticleEmitterProp< int >	mParticleFadeIn

Map *	mMap

ParticleEmitterProp< int >	mOutput

ParticleEmitterProp< int >	mOutputPause

Image *	mParticleImage

Animation	mParticleAnimation

Animation	mParticleRotation

ParticleEmitterProp< float >	mParticleAlpha

std::string	mDeathEffect

std::list< ParticleEmitter >	mParticleChildEmitters

std::vector< ImageSet * >	mTempSets

int	mOutputPauseLeft

signed char	mDeathEffectConditions

bool	mParticleFollow

Detailed Description

Every Particle can have one or more particle emitters that create new particles when they are updated

Definition at line 44 of file particleemitter.h.

Constructor & Destructor Documentation

◆ ParticleEmitter() [1/2]

ParticleEmitter::ParticleEmitter	(	const xmlNode *const	emitterNode,
		Particle *const	target,
		Map *const	map,
		const int	rotation,
		const std::string &	dyePalettes
	)

Definition at line 54 of file particleemitter.cpp.

                                                                :
     mParticleTarget(target),
     mMap(map),
     mOutput(),
     mOutputPause(),
     mParticleImage(nullptr),
     mParticleAnimation("particle animation"),
     mParticleRotation("particle rotation"),
     mParticleAlpha(),
     mDeathEffect(),
     mParticleChildEmitters(),
     mTempSets(),
     mOutputPauseLeft(0),
     mDeathEffectConditions(0),
     mParticleFollow(false)
 {
     // Initializing default values
     mParticlePosX.set(0.0F);
     mParticlePosY.set(0.0F);
     mParticlePosZ.set(0.0F);
     mParticleAngleHorizontal.set(0.0F);
     mParticleAngleVertical.set(0.0F);
     mParticlePower.set(0.0F);
     mParticleGravity.set(0.0F);
     mParticleRandomness.set(0);
     mParticleBounce.set(0.0F);
     mParticleAcceleration.set(0.0F);
     mParticleDieDistance.set(-1.0F);
     mParticleMomentum.set(1.0F);
     mParticleLifetime.set(-1);
     mParticleFadeOut.set(0);
     mParticleFadeIn.set(0);
     mOutput.set(1);
     mOutputPause.set(0);
     mParticleAlpha.set(1.0F);
  
     if (emitterNode == nullptr)
         return;
     for_each_xml_child_node(propertyNode, emitterNode)
     {
         if (xmlNameEqual(propertyNode, "property"))
         {
             const std::string name = XML::getProperty(
                 propertyNode, "name", "");
  
             if (name == "position-x")
             {
                 mParticlePosX = readParticleEmitterProp(propertyNode, 0.0F);
             }
             else if (name == "position-y")
             {
                 mParticlePosY = readParticleEmitterProp(propertyNode, 0.0F);
                 mParticlePosY.minVal *= SIN45;
                 mParticlePosY.maxVal *= SIN45;
                 mParticlePosY.changeAmplitude *= SIN45;
             }
             else if (name == "position-z")
             {
                 mParticlePosZ = readParticleEmitterProp(propertyNode, 0.0F);
                 mParticlePosZ.minVal *= SIN45;
                 mParticlePosZ.maxVal *= SIN45;
                 mParticlePosZ.changeAmplitude *= SIN45;
             }
             else if (name == "image")
             {
                 std::string image = XML::getProperty(
                     propertyNode, "value", "");
                 // Don't leak when multiple images are defined
                 if (!image.empty() && (mParticleImage == nullptr))
                 {
                     if (!dyePalettes.empty())
                         Dye::instantiate(image, dyePalettes);
                     mParticleImage = Loader::getImage(image);
                 }
             }
             else if (name == "subimage")
             {
                 std::string image = XML::getProperty(
                     propertyNode, "value", "");
                 // Don't leak when multiple images are defined
                 if (!image.empty() && (mParticleImage == nullptr))
                 {
                     if (!dyePalettes.empty())
                         Dye::instantiate(image, dyePalettes);
                     Image *img = Loader::getImage(image);
                     if (img != nullptr)
                     {
                         mParticleImage = Loader::getSubImage(img,
                             XML::getProperty(propertyNode, "x", 0),
                             XML::getProperty(propertyNode, "y", 0),
                             XML::getProperty(propertyNode, "width", 0),
                             XML::getProperty(propertyNode, "height", 0));
                         img->decRef();
                     }
                     else
                     {
                         mParticleImage = nullptr;
                     }
                 }
             }
             else if (name == "horizontal-angle")
             {
                 mParticleAngleHorizontal =
                     readParticleEmitterProp(propertyNode, 0.0F);
                 mParticleAngleHorizontal.minVal
                     += static_cast<float>(rotation);
                 mParticleAngleHorizontal.minVal *= DEG_RAD_FACTOR;
                 mParticleAngleHorizontal.maxVal
                     += static_cast<float>(rotation);
                 mParticleAngleHorizontal.maxVal *= DEG_RAD_FACTOR;
                 mParticleAngleHorizontal.changeAmplitude *= DEG_RAD_FACTOR;
             }
             else if (name == "vertical-angle")
             {
                 mParticleAngleVertical =
                     readParticleEmitterProp(propertyNode, 0.0F);
                 mParticleAngleVertical.minVal *= DEG_RAD_FACTOR;
                 mParticleAngleVertical.maxVal *= DEG_RAD_FACTOR;
                 mParticleAngleVertical.changeAmplitude *= DEG_RAD_FACTOR;
             }
             else if (name == "power")
             {
                 mParticlePower = readParticleEmitterProp(propertyNode, 0.0F);
             }
             else if (name == "gravity")
             {
                 mParticleGravity = readParticleEmitterProp(propertyNode, 0.0F);
             }
             else if (name == "randomnes"
                      || name == "randomness")  // legacy bug
             {
                 mParticleRandomness = readParticleEmitterProp(propertyNode, 0);
             }
             else if (name == "bounce")
             {
                 mParticleBounce = readParticleEmitterProp(propertyNode, 0.0F);
             }
             else if (name == "lifetime")
             {
                 mParticleLifetime = readParticleEmitterProp(propertyNode, 0);
                 mParticleLifetime.minVal += 1;
             }
             else if (name == "output")
             {
                 mOutput = readParticleEmitterProp(propertyNode, 0);
                 mOutput.maxVal += 1;
             }
             else if (name == "output-pause")
             {
                 mOutputPause = readParticleEmitterProp(propertyNode, 0);
                 mOutputPauseLeft = mOutputPause.value(0);
             }
             else if (name == "acceleration")
             {
                 mParticleAcceleration = readParticleEmitterProp(
                     propertyNode, 0.0F);
             }
             else if (name == "die-distance")
             {
                 mParticleDieDistance = readParticleEmitterProp(
                     propertyNode, 0.0F);
             }
             else if (name == "momentum")
             {
                 mParticleMomentum = readParticleEmitterProp(
                     propertyNode, 1.0F);
             }
             else if (name == "fade-out")
             {
                 mParticleFadeOut = readParticleEmitterProp(propertyNode, 0);
             }
             else if (name == "fade-in")
             {
                 mParticleFadeIn = readParticleEmitterProp(propertyNode, 0);
             }
             else if (name == "alpha")
             {
                 mParticleAlpha = readParticleEmitterProp(propertyNode, 1.0F);
             }
             else if (name == "follow-parent")
             {
                 const std::string value = XML::getProperty(propertyNode,
                     "value", "0");
                 if (value == "1" || value == "true")
                     mParticleFollow = true;
             }
             else
             {
                 logger->log("Particle Engine: Warning, "
                             "unknown emitter property \"%s\"",
                             name.c_str());
             }
         }
         else if (xmlNameEqual(propertyNode, "emitter"))
         {
             ParticleEmitter newEmitter(propertyNode, mParticleTarget, map,
                                        rotation, dyePalettes);
             mParticleChildEmitters.push_back(newEmitter);
         }
         else if (xmlNameEqual(propertyNode, "rotation")
                  || xmlNameEqual(propertyNode, "animation"))
         {
             ImageSet *const imageset = getImageSet(propertyNode);
             if (imageset == nullptr)
             {
                 logger->log1("Error: no valid imageset");
                 continue;
             }
             mTempSets.push_back(imageset);
  
             Animation &animation = (xmlNameEqual(propertyNode, "rotation")) !=
                 0 ? mParticleRotation : mParticleAnimation;
  
             // Get animation frames
             for_each_xml_child_node(frameNode, propertyNode)
             {
                 const int delay = XML::getIntProperty(
                     frameNode, "delay", 0, 0, 100000);
                 const int offsetX = XML::getProperty(frameNode, "offsetX", 0)
                     - imageset->getWidth() / 2 + mapTileSize / 2;
                 const int offsetY = XML::getProperty(frameNode, "offsetY", 0)
                     - imageset->getHeight() + mapTileSize;
                 const int rand = XML::getIntProperty(
                     frameNode, "rand", 100, 0, 100);
  
                 if (xmlNameEqual(frameNode, "frame"))
                 {
                     const int index = XML::getProperty(frameNode, "index", -1);
  
                     if (index < 0)
                     {
                         logger->log1("No valid value for 'index'");
                         continue;
                     }
  
                     Image *const img = imageset->get(index);
  
                     if (img == nullptr)
                     {
                         logger->log("No image at index %d", index);
                         continue;
                     }
  
                     animation.addFrame(img, delay,
                         offsetX, offsetY, rand);
                 }
                 else if (xmlNameEqual(frameNode, "sequence"))
                 {
                     int start = XML::getProperty(frameNode, "start", -1);
                     const int end = XML::getProperty(frameNode, "end", -1);
  
                     if (start < 0 || end < 0)
                     {
                         logger->log1("No valid value for 'start' or 'end'");
                         continue;
                     }
  
                     while (end >= start)
                     {
                         Image *const img = imageset->get(start);
                         if (img == nullptr)
                         {
                             logger->log("No image at index %d", start);
                             continue;
                         }
  
                         animation.addFrame(img, delay,
                             offsetX, offsetY, rand);
                         start ++;
                     }
                 }
                 else if (xmlNameEqual(frameNode, "end"))
                 {
                     animation.addTerminator(rand);
                 }
             }  // for frameNode
         }
         else if (xmlNameEqual(propertyNode, "deatheffect"))
         {
             if (!XmlHaveChildContent(propertyNode))
                 continue;
             mDeathEffect = XmlChildContent(propertyNode);
             mDeathEffectConditions = 0x00;
             if (XML::getBoolProperty(propertyNode, "on-floor", true))
             {
                 mDeathEffectConditions += CAST_S8(
                     AliveStatus::DEAD_FLOOR);
             }
             if (XML::getBoolProperty(propertyNode, "on-sky", true))
             {
                 mDeathEffectConditions += CAST_S8(
                     AliveStatus::DEAD_SKY);
             }
             if (XML::getBoolProperty(propertyNode, "on-other", false))
             {
                 mDeathEffectConditions += CAST_S8(
                     AliveStatus::DEAD_OTHER);
             }
             if (XML::getBoolProperty(propertyNode, "on-impact", true))
             {
                 mDeathEffectConditions += CAST_S8(
                     AliveStatus::DEAD_IMPACT);
             }
             if (XML::getBoolProperty(propertyNode, "on-timeout", true))
             {
                 mDeathEffectConditions += CAST_S8(
                     AliveStatus::DEAD_TIMEOUT);
             }
         }
     }
 }

References Animation::addFrame(), Animation::addTerminator(), CAST_S8, ParticleEmitterProp< T >::changeAmplitude, AliveStatus::DEAD_FLOOR, AliveStatus::DEAD_IMPACT, AliveStatus::DEAD_OTHER, AliveStatus::DEAD_SKY, AliveStatus::DEAD_TIMEOUT, DEG_RAD_FACTOR, for_each_xml_child_node, ImageSet::get(), XML::getBoolProperty(), ImageSet::getHeight(), Loader::getImage(), getImageSet(), XML::getIntProperty(), XML::getProperty(), Loader::getSubImage(), ImageSet::getWidth(), Dye::instantiate(), Logger::log(), Logger::log1(), logger, mapTileSize, ParticleEmitterProp< T >::maxVal, mDeathEffect, mDeathEffectConditions, ParticleEmitterProp< T >::minVal, mOutput, mOutputPause, mOutputPauseLeft, mParticleAcceleration, mParticleAlpha, mParticleAngleHorizontal, mParticleAngleVertical, mParticleAnimation, mParticleBounce, mParticleChildEmitters, mParticleDieDistance, mParticleFadeIn, mParticleFadeOut, mParticleFollow, mParticleGravity, mParticleImage, mParticleLifetime, mParticleMomentum, mParticlePosX, mParticlePosY, mParticlePosZ, mParticlePower, mParticleRandomness, mParticleRotation, mParticleTarget, mTempSets, readParticleEmitterProp(), ParticleEmitterProp< T >::set(), SIN45, anonymous_namespace{stringutils.cpp}::start, and ParticleEmitterProp< T >::value().

Referenced by createParticles().

◆ ParticleEmitter() [2/2]

ParticleEmitter::ParticleEmitter ( const ParticleEmitter & o )

Copy Constructor (necessary for reference counting of particle images)

Definition at line 369 of file particleemitter.cpp.

 {
     *this = o;
 }

◆ ~ParticleEmitter()

ParticleEmitter::~ParticleEmitter ( )

Destructor.

Definition at line 456 of file particleemitter.cpp.

 {
     FOR_EACH (ImageSetVectorCIter, i, mTempSets)
     {
         if (*i != nullptr)
             (*i)->decRef();
     }
     mTempSets.clear();
  
     if (mParticleImage != nullptr)
     {
         mParticleImage->decRef();
         mParticleImage = nullptr;
     }
 }

References FOR_EACH, mParticleImage, and mTempSets.

Member Function Documentation

◆ adjustSize()

void ParticleEmitter::adjustSize	(	const int	w,
		const int	h
	)

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

Definition at line 606 of file particleemitter.cpp.

 {
     if (w == 0 || h == 0)
         return;  // new dimensions are illegal
  
     // calculate the old rectangle
     const int oldArea = CAST_S32(
         mParticlePosX.maxVal - mParticlePosX.minVal) * CAST_S32(
         mParticlePosX.maxVal - mParticlePosY.minVal);
     if (oldArea == 0)
     {
         // when the effect has no dimension it is
         // not designed to be resizeable
         return;
     }
  
     // set the new dimensions
     mParticlePosX.set(0, static_cast<float>(w));
     mParticlePosY.set(0, static_cast<float>(h));
     const int newArea = w * h;
     // adjust the output so that the particle density stays the same
     const float outputFactor = static_cast<float>(newArea)
         / static_cast<float>(oldArea);
     mOutput.minVal = CAST_S32(static_cast<float>(
         mOutput.minVal) * outputFactor);
     mOutput.maxVal = CAST_S32(static_cast<float>(
         mOutput.maxVal) * outputFactor);
 }

References CAST_S32, ParticleEmitterProp< T >::maxVal, ParticleEmitterProp< T >::minVal, mOutput, mParticlePosX, mParticlePosY, and ParticleEmitterProp< T >::set().

◆ createParticles()

void ParticleEmitter::createParticles	(	const int	tick,
		std::vector< Particle * > &	newParticles
	)

Spawns new particles

Definition at line 514 of file particleemitter.cpp.

 {
     if (mOutputPauseLeft > 0)
     {
         mOutputPauseLeft --;
         return;
     }
     mOutputPauseLeft = mOutputPause.value(tick);
  
     for (int i = mOutput.value(tick); i > 0; i--)
     {
         // Limit maximum particles
         if (ParticleEngine::particleCount > ParticleEngine::maxCount)
             break;
  
         Particle *newParticle = nullptr;
         if (mParticleImage != nullptr)
         {
             const std::string &name = mParticleImage->mIdPath;
             if (ImageParticle::imageParticleCountByName.find(name) ==
                 ImageParticle::imageParticleCountByName.end())
             {
                 ImageParticle::imageParticleCountByName[name] = 0;
             }
  
             if (ImageParticle::imageParticleCountByName[name] > 200)
                 break;
  
             newParticle = new ImageParticle(mParticleImage);
             newParticle->setMap(mMap);
         }
         else if (!mParticleRotation.mFrames.empty())
         {
             Animation *const newAnimation = new Animation(mParticleRotation);
             newParticle = new RotationalParticle(newAnimation);
             newParticle->setMap(mMap);
         }
         else if (!mParticleAnimation.mFrames.empty())
         {
             Animation *const newAnimation = new Animation(mParticleAnimation);
             newParticle = new AnimationParticle(newAnimation);
             newParticle->setMap(mMap);
         }
         else
         {
             newParticle = new Particle;
             newParticle->setMap(mMap);
         }
  
         const Vector position(mParticlePosX.value(tick),
             mParticlePosY.value(tick),
             mParticlePosZ.value(tick));
         newParticle->moveTo(position);
  
         const float angleH = mParticleAngleHorizontal.value(tick);
         const float cosAngleH = static_cast<float>(cos(angleH));
         const float sinAngleH = static_cast<float>(sin(angleH));
         const float angleV = mParticleAngleVertical.value(tick);
         const float cosAngleV = static_cast<float>(cos(angleV));
         const float sinAngleV = static_cast<float>(sin(angleV));
         const float power = mParticlePower.value(tick);
         newParticle->setVelocity(cosAngleH * cosAngleV * power,
             sinAngleH * cosAngleV * power,
             sinAngleV * power);
  
         newParticle->setRandomness(mParticleRandomness.value(tick));
         newParticle->setGravity(mParticleGravity.value(tick));
         newParticle->setBounce(mParticleBounce.value(tick));
         newParticle->setFollow(mParticleFollow);
  
         newParticle->setDestination(mParticleTarget,
             mParticleAcceleration.value(tick),
             mParticleMomentum.value(tick));
  
         newParticle->setDieDistance(mParticleDieDistance.value(tick));
  
         newParticle->setLifetime(mParticleLifetime.value(tick));
         newParticle->setFadeOut(mParticleFadeOut.value(tick));
         newParticle->setFadeIn(mParticleFadeIn.value(tick));
         newParticle->setAlpha(mParticleAlpha.value(tick));
  
         FOR_EACH (ParticleEmitterListCIter, it,  mParticleChildEmitters)
             newParticle->addEmitter(new ParticleEmitter(*it));
  
         if (!mDeathEffect.empty())
             newParticle->setDeathEffect(mDeathEffect, mDeathEffectConditions);
  
         newParticles.push_back(newParticle);
     }
 }

References Particle::addEmitter(), ParticleType::Animation, AttributesEnum::find(), FOR_EACH, ImageParticle::imageParticleCountByName, ParticleEngine::maxCount, mDeathEffect, mDeathEffectConditions, Animation::mFrames, mMap, mOutput, mOutputPause, mOutputPauseLeft, Particle::moveTo(), mParticleAcceleration, mParticleAlpha, mParticleAngleHorizontal, mParticleAngleVertical, mParticleAnimation, mParticleBounce, mParticleChildEmitters, mParticleDieDistance, mParticleFadeIn, mParticleFadeOut, mParticleFollow, mParticleGravity, mParticleImage, mParticleLifetime, mParticleMomentum, mParticlePosX, mParticlePosY, mParticlePosZ, mParticlePower, mParticleRandomness, mParticleRotation, mParticleTarget, ParticleEngine::particleCount, ParticleEmitter(), Particle::setAlpha(), Particle::setBounce(), Particle::setDeathEffect(), Particle::setDestination(), Particle::setDieDistance(), Particle::setFadeIn(), Particle::setFadeOut(), Particle::setFollow(), Particle::setGravity(), Particle::setLifetime(), Actor::setMap(), Particle::setRandomness(), Particle::setVelocity(), and ParticleEmitterProp< T >::value().

◆ getImageSet()

ImageSet * ParticleEmitter::getImageSet ( xmlNode *const node )

staticprivate

Definition at line 374 of file particleemitter.cpp.

 {
     ImageSet *imageset = nullptr;
     const int subX = XML::getProperty(node, "subX", -1);
     if (subX != -1)
     {
         Image *const img = Loader::getImage(XML::getProperty(
             node, "imageset", ""));
         if (img == nullptr)
             return nullptr;
  
         Image *const img2 = Loader::getSubImage(img, subX,
             XML::getProperty(node, "subY", 0),
             XML::getProperty(node, "subWidth", 0),
             XML::getProperty(node, "subHeight", 0));
         if (img2 == nullptr)
         {
             img->decRef();
             return nullptr;
         }
  
         imageset = Loader::getSubImageSet(img2,
             XML::getProperty(node, "width", 0),
             XML::getProperty(node, "height", 0));
         img2->decRef();
         img->decRef();
     }
     else
     {
         imageset = Loader::getImageSet(
             XML::getProperty(node, "imageset", ""),
             XML::getProperty(node, "width", 0),
             XML::getProperty(node, "height", 0));
     }
     return imageset;
 }

References Loader::getImage(), Loader::getImageSet(), XML::getProperty(), Loader::getSubImage(), and Loader::getSubImageSet().

Referenced by ParticleEmitter().

◆ operator=()

ParticleEmitter & ParticleEmitter::operator= ( const ParticleEmitter & o )

Assignment operator that calls the copy constructor

Definition at line 411 of file particleemitter.cpp.

 {
     mParticlePosX = o.mParticlePosX;
     mParticlePosY = o.mParticlePosY;
     mParticlePosZ = o.mParticlePosZ;
     mParticleAngleHorizontal = o.mParticleAngleHorizontal;
     mParticleAngleVertical = o.mParticleAngleVertical;
     mParticlePower = o.mParticlePower;
     mParticleGravity = o.mParticleGravity;
     mParticleRandomness = o.mParticleRandomness;
     mParticleBounce = o.mParticleBounce;
     mParticleFollow = o.mParticleFollow;
     mParticleTarget = o.mParticleTarget;
     mParticleAcceleration = o.mParticleAcceleration;
     mParticleDieDistance = o.mParticleDieDistance;
     mParticleMomentum = o.mParticleMomentum;
     mParticleLifetime = o.mParticleLifetime;
     mParticleFadeOut = o.mParticleFadeOut;
     mParticleFadeIn = o.mParticleFadeIn;
     mParticleAlpha = o.mParticleAlpha;
     mMap = o.mMap;
     mOutput = o.mOutput;
     mOutputPause = o.mOutputPause;
     mParticleImage = o.mParticleImage;
     mParticleAnimation = o.mParticleAnimation;
     mParticleRotation = o.mParticleRotation;
     mParticleChildEmitters = o.mParticleChildEmitters;
     mDeathEffectConditions = o.mDeathEffectConditions;
     mDeathEffect = o.mDeathEffect;
     mTempSets = o.mTempSets;
  
     FOR_EACH (ImageSetVectorCIter, i, mTempSets)
     {
         if (*i != nullptr)
             (*i)->incRef();
     }
  
     mOutputPauseLeft = 0;
  
     if (mParticleImage != nullptr)
         mParticleImage->incRef();
  
     return *this;
 }

References FOR_EACH, mDeathEffect, mDeathEffectConditions, mMap, mOutput, mOutputPause, mOutputPauseLeft, mParticleAcceleration, mParticleAlpha, mParticleAngleHorizontal, mParticleAngleVertical, mParticleAnimation, mParticleBounce, mParticleChildEmitters, mParticleDieDistance, mParticleFadeIn, mParticleFadeOut, mParticleFollow, mParticleGravity, mParticleImage, mParticleLifetime, mParticleMomentum, mParticlePosX, mParticlePosY, mParticlePosZ, mParticlePower, mParticleRandomness, mParticleRotation, mParticleTarget, and mTempSets.

◆ readParticleEmitterProp()

template<typename T >

ParticleEmitterProp< T > ParticleEmitter::readParticleEmitterProp	(	xmlNode *const	propertyNode,
		T	def
	)

staticprivate

Definition at line 473 of file particleemitter.cpp.

 {
     ParticleEmitterProp<T> retval;
  
     def = static_cast<T>(XML::getDoubleProperty(propertyNode, "value",
         static_cast<double>(def)));
     retval.set(static_cast<T>(XML::getDoubleProperty(propertyNode, "min",
         static_cast<double>(def))), static_cast<T>(XML::getDoubleProperty(
         propertyNode, "max", static_cast<double>(def))));
  
     const std::string change = XML::getProperty(
         propertyNode, "change-func", "none");
     T amplitude = static_cast<T>(XML::getDoubleProperty(propertyNode,
         "change-amplitude", 0.0));
  
     const int period = XML::getProperty(propertyNode, "change-period", 0);
     const int phase = XML::getProperty(propertyNode, "change-phase", 0);
     if (change == "saw" || change == "sawtooth")
     {
         retval.setFunction(ParticleChangeFunc::FUNC_SAW,
             amplitude, period, phase);
     }
     else if (change == "sine" || change == "sinewave")
     {
         retval.setFunction(ParticleChangeFunc::FUNC_SINE,
             amplitude, period, phase);
     }
     else if (change == "triangle")
     {
         retval.setFunction(ParticleChangeFunc::FUNC_TRIANGLE,
             amplitude, period, phase);
     }
     else if (change == "square")
     {
         retval.setFunction(ParticleChangeFunc::FUNC_SQUARE,
             amplitude, period, phase);
     }
  
     return retval;
 }