components/scene/ParticleSysComponent.cpp

Go to the documentation of this file.

// /////////////////////////////////////////////////////////////////////////////
//
// Name:            ParticleSysComponent.cpp
// Author:          Michael Bartsch (ZCCdark203)
//
// Desc :           Component wrapper of Irrlicht's IParticleSystemSceneNode.
//
// License:         Copyright (C) 2009 Michael Bartsch and Contributors
//
//                  This program is free software: you can redistribute it
//                  and/or modify it under the terms of the zlib/libpng License.
//                  See main.cpp for conditions of distribution and use.
//
// /////////////////////////////////////////////////////////////////////////////

// Include files
#include "ParticleSysComponent.h"
#include "../../core/GameManager.h"


// ParticleSysComponent class
// ParticleSysComponent constructor (default).
ParticleSysComponent::ParticleSysComponent(Entity *parent, const vector3df &rotation,
                         const vector3df &scale)
: SceneComponent(parent, true)
{
    // Get pointers to needed sub-systems of the Game Manager.
    ISceneManager *pSceneMgr = GameManager::Instance()->getSceneManager();

    // Create the s32ernal scene node.
    mParticleSystemSN = pSceneMgr->addParticleSystemSceneNode(true, 0, parent->getID(),
                                                              parent->getPosition(), rotation,
                                                              scale);
    mSceneNode = mParticleSystemSN;

    // Set-up s32ernal mechanism for collision detection.
    mTriSelector = NULL;
    mMetaSelector = pSceneMgr->createMetaTriangleSelector();
}

// ParticleSysComponent deconstructor.
ParticleSysComponent::~ParticleSysComponent()
{
    mParticleSystemSN->remove();
    mSceneNode = NULL;
}

// AngelScript: Will be used to instanciate objects of this class.
ParticleSysComponent* ParticleSysComponent::refFactory(Entity *parent, const vector3df &rotation,
                                                       const vector3df &scale)
{
    return new ParticleSysComponent(parent, rotation, scale);
}

// Returns a direct pointer to the IParticleSystemSceneNode.
IParticleSystemSceneNode* ParticleSysComponent::getParticleSystemSceneNode()
{
    return mParticleSystemSN;
}

// Adds a new particle effector to the particle system.
void ParticleSysComponent::addAffector(IParticleAffector *affector)
{
    mParticleSystemSN->addAffector(affector);
}

// Adds a point attraction affector.
void ParticleSysComponent::addAttractionAffector(const vector3df &point, f32 speed, bool attract,
                                                 bool affectX, bool affectY, bool affectZ)
{
    IParticleAffector *affector = mParticleSystemSN->createAttractionAffector(point, speed, attract,
                                    affectX, affectY, affectZ);
    mParticleSystemSN->addAffector(affector);
    affector->drop();
}

// Adds a fade out particle affector.
void ParticleSysComponent::addFadeOutParticleAffector(const SColor &targetColor,
                                                      u32 timeNeededToFadeOut)
{
    IParticleAffector *affector = mParticleSystemSN->createFadeOutParticleAffector(targetColor,
                                    timeNeededToFadeOut);
    mParticleSystemSN->addAffector(affector);
    affector->drop();
}

// Adds a gravity affector.
void ParticleSysComponent::addGravityAffector(const vector3df &gravity, u32 timeForceLost)
{
    IParticleAffector *affector = mParticleSystemSN->createGravityAffector(gravity, timeForceLost);
    mParticleSystemSN->addAffector(affector);
    affector->drop();
}

// Adds a rotation affector.
void ParticleSysComponent::addRotationAffector(const vector3df &speed, const vector3df &pivotPoint)
{
    IParticleAffector *affector = mParticleSystemSN->createRotationAffector(speed, pivotPoint);
    mParticleSystemSN->addAffector(affector);
    affector->drop();
}

// Adds a scale particle affector.
void ParticleSysComponent::addScaleParticleAffector(const dimension2df &scaleTo)
{
    IParticleAffector *affector = mParticleSystemSN->createScaleParticleAffector(scaleTo);
    mParticleSystemSN->addAffector(affector);
    affector->drop();
}

// Removes all affectors.
void ParticleSysComponent::removeAffectors()
{
    mParticleSystemSN->removeAllAffectors();
}

// Gets the particle emitter, which creates the particles.
IParticleEmitter* ParticleSysComponent::getEmitter()
{
    return mParticleSystemSN->getEmitter();
}

// Sets a particle emitter for the loaded animated mesh component.
void ParticleSysComponent::setAnimatedMeshSceneNodeEmitter(const std::string &fileName,
                                                           bool useNormalDirection,
                                                           const vector3df &direction,
                                                           f32 normalDirectionModifier,
                                                           bool everyMeshVertex,
                                                           u32 minParticlesPerSecond,
                                                           u32 maxParticlesPerSecond,
                                                           const SColor &minStartColor,
                                                           const SColor &maxStartColor,
                                                           u32 lifeTimeMin, u32 lifeTimeMax,
                                                           s32 maxAngleDegrees,
                                                           const dimension2df &minStartSize,
                                                           const dimension2df &maxStartSize)
{
    ISceneManager *pSceneMgr = GameManager::Instance()->getSceneManager();

    IAnimatedMeshSceneNode *node = pSceneMgr->addAnimatedMeshSceneNode(pSceneMgr->getMesh(
                                   fileName.c_str()), 0, pParent->getID());
    if(node)
    {
      IParticleEmitter *emitter = mParticleSystemSN->createAnimatedMeshSceneNodeEmitter(node,
                                    useNormalDirection,
                                    direction, normalDirectionModifier, -1, everyMeshVertex,
                                    minParticlesPerSecond, maxParticlesPerSecond, minStartColor,
                                    maxStartColor, lifeTimeMin, lifeTimeMax, maxAngleDegrees,
                                    minStartSize, maxStartSize);
      mParticleSystemSN->setEmitter(emitter);
      emitter->drop();
    }
}

// Creates a particle emitter for an animated mesh component.
void ParticleSysComponent::setAnimatedMeshSceneNodeEmitter(IAnimatedMeshSceneNode *node,
                                                           bool useNormalDirection,
                                                           const vector3df &direction,
                                                           f32 normalDirectionModifier,
                                                           bool everyMeshVertex,
                                                           u32 minParticlesPerSecond,
                                                           u32 maxParticlesPerSecond,
                                                           const SColor &minStartColor,
                                                           const SColor &maxStartColor,
                                                           u32 lifeTimeMin, u32 lifeTimeMax,
                                                           s32 maxAngleDegrees,
                                                           const dimension2df &minStartSize,
                                                           const dimension2df &maxStartSize)
{
    IParticleEmitter *emitter = mParticleSystemSN->createAnimatedMeshSceneNodeEmitter(node,
                                  useNormalDirection, direction, normalDirectionModifier, -1,
                                  everyMeshVertex, minParticlesPerSecond, maxParticlesPerSecond,
                                  minStartColor, maxStartColor, lifeTimeMin, lifeTimeMax,
                                  maxAngleDegrees, minStartSize, maxStartSize);
    mParticleSystemSN->setEmitter(emitter);
    emitter->drop();
}

// Sets a box particle emitter.
void ParticleSysComponent::setBoxEmitter(const aabbox3df &box, const vector3df &direction,
                                         u32 minParticlesPerSecond, u32 maxParticlesPerSecond,
                                         const SColor &minStartColor, const SColor &maxStartColor,
                                         u32 lifeTimeMin, u32 lifeTimeMax, s32 maxAngleDegrees,
                                         const dimension2df &minStartSize,
                                         const dimension2df &maxStartSize)
{
    IParticleEmitter *emitter = mParticleSystemSN->createBoxEmitter(box, direction,
                                  minParticlesPerSecond, maxParticlesPerSecond, minStartColor,
                                  maxStartColor, lifeTimeMin, lifeTimeMax, maxAngleDegrees,
                                  minStartSize, maxStartSize);
    mParticleSystemSN->setEmitter(emitter);
    emitter->drop();
}

// Sets a particle emitter for emitting from a cylinder.
void ParticleSysComponent::setCylinderEmitter(const vector3df &center, f32 radius,
                                              const vector3df &normal, f32 length,
                                              bool outlineOnly, const vector3df &direction,
                                              u32 minParticlesPerSecond, u32 maxParticlesPerSecond,
                                              const SColor &minStartColor,
                                              const SColor &maxStartColor,
                                              u32 lifeTimeMin, u32 lifeTimeMax, s32 maxAngleDegrees,
                                              const dimension2df &minStartSize,
                                              const dimension2df &maxStartSize)
{
    IParticleEmitter *emitter = mParticleSystemSN->createCylinderEmitter(center, radius, normal,
                                  length, outlineOnly, direction, minParticlesPerSecond,
                                  maxParticlesPerSecond, minStartColor, maxStartColor, lifeTimeMin,
                                  lifeTimeMax, maxAngleDegrees, minStartSize, maxStartSize);
    mParticleSystemSN->setEmitter(emitter);
    emitter->drop();
}

// Sets the particle emitter, which creates the particles.
void ParticleSysComponent::setEmitter(IParticleEmitter *emitter)
{
    mParticleSystemSN->setEmitter(emitter);
}

// Sets a particle emitter for the loaded mesh.
void ParticleSysComponent::setMeshEmitter(const std::string &fileName, bool useNormalDirection,
                                          const vector3df &direction, f32 normalDirectionModifier,
                                          bool everyMeshVertex, u32 minParticlesPerSecond,
                                          u32 maxParticlesPerSecond, const SColor &minStartColor,
                                          const SColor &maxStartColor, u32 lifeTimeMin,
                                          u32 lifeTimeMax, s32 maxAngleDegrees,
                                          const dimension2df &minStartSize,
                                          const dimension2df &maxStartSize)
{
    IMesh *mesh = GameManager::Instance()->getSceneManager()->getMesh(fileName.c_str());

    if(mesh)
    {
       IParticleEmitter *emitter = mParticleSystemSN->createMeshEmitter(mesh, useNormalDirection,
                                  direction, normalDirectionModifier, -1, everyMeshVertex,
                                  minParticlesPerSecond, maxParticlesPerSecond,
                                  minStartColor, maxStartColor, lifeTimeMin, lifeTimeMax,
                                  maxAngleDegrees, minStartSize, maxStartSize);
       mParticleSystemSN->setEmitter(emitter);
       emitter->drop();
    }
}

// Sets a particle emitter for the loaded mesh.
void ParticleSysComponent::setMeshEmitter(IMesh *mesh, bool useNormalDirection,
                                          const vector3df &direction,
                                          f32 normalDirectionModifier, bool everyMeshVertex,
                                          u32 minParticlesPerSecond, u32 maxParticlesPerSecond,
                                          const SColor &minStartColor, const SColor &maxStartColor,
                                          u32 lifeTimeMin, u32 lifeTimeMax, s32 maxAngleDegrees,
                                          const dimension2df &minStartSize,
                                          const dimension2df &maxStartSize)
{
    IParticleEmitter *emitter = mParticleSystemSN->createMeshEmitter(mesh, useNormalDirection,
                                  direction, normalDirectionModifier, -1, everyMeshVertex,
                                  minParticlesPerSecond, maxParticlesPerSecond,
                                  minStartColor, maxStartColor, lifeTimeMin, lifeTimeMax,
                                  maxAngleDegrees, minStartSize, maxStartSize);
    mParticleSystemSN->setEmitter(emitter);
    emitter->drop();
}

// Sets a point particle emitter.
void ParticleSysComponent::setPointEmitter(const vector3df &direction,
                                           u32 minParticlesPerSecond, u32 maxParticlesPerSecond,
                                           const SColor &minStartColor, const SColor &maxStartColor,
                                           u32 lifeTimeMin, u32 lifeTimeMax, s32 maxAngleDegrees,
                                           const dimension2df &minStartSize,
                                           const dimension2df &maxStartSize)
{
    IParticleEmitter *emitter = mParticleSystemSN->createPointEmitter(direction,
                                  minParticlesPerSecond, maxParticlesPerSecond, minStartColor,
                                  maxStartColor, lifeTimeMin, lifeTimeMax, maxAngleDegrees,
                                  minStartSize, maxStartSize);
    mParticleSystemSN->setEmitter(emitter);
    emitter->drop();
}

// Sets a ring particle emitter.
void ParticleSysComponent::setRingEmitter(const vector3df &center, f32 radius,
                                          f32 ringThickness, const vector3df &direction,
                                          u32 minParticlesPerSecond, u32 maxParticlesPerSecond,
                                          const SColor &minStartColor, const SColor &maxStartColor,
                                          u32 lifeTimeMin, u32 lifeTimeMax, s32 maxAngleDegrees,
                                          const dimension2df &minStartSize,
                                          const dimension2df &maxStartSize)
{
    IParticleEmitter *emitter = mParticleSystemSN->createRingEmitter(center, radius, ringThickness,
                                  direction, minParticlesPerSecond, maxParticlesPerSecond,
                                  minStartColor, maxStartColor, lifeTimeMin, lifeTimeMax,
                                  maxAngleDegrees, minStartSize, maxStartSize);
    mParticleSystemSN->setEmitter(emitter);
    emitter->drop();
}

// Sets a sphere particle emitter.
void ParticleSysComponent::setSphereEmitter(const vector3df &center, f32 radius,
                                            const vector3df &direction,
                                            u32 minParticlesPerSecond, u32 maxParticlesPerSecond,
                                            const SColor &minStartColor,
                                            const SColor &maxStartColor,
                                            u32 lifeTimeMin, u32 lifeTimeMax, s32 maxAngleDegrees,
                                            const dimension2df &minStartSize,
                                            const dimension2df &maxStartSize)
{
    IParticleEmitter *emitter = mParticleSystemSN->createSphereEmitter(center, radius, direction,
                                  minParticlesPerSecond, maxParticlesPerSecond, minStartColor,
                                  maxStartColor, lifeTimeMin, lifeTimeMax, maxAngleDegrees,
                                  minStartSize, maxStartSize);
    mParticleSystemSN->setEmitter(emitter);
    emitter->drop();
}

// Sets if the particles should be global.
void ParticleSysComponent::setParticlesAreGlobal(bool value)
{
    mParticleSystemSN->setParticlesAreGlobal(value);
}

// Sets the size of all particles.
void ParticleSysComponent::setParticleSize(const dimension2df &size)
{
    mParticleSystemSN->setParticleSize(size);
}


// ParticleSysComponent Angelscript binding.
void bindParticleSysComponent(asIScriptEngine *engine)
{
    // Forward declarations.
    int r;

    // Bind ParticleSysComponent class.
    r = engine->RegisterObjectType("ParticleSysComponent", sizeof(ParticleSysComponent), asOBJ_REF); assert(r >= 0);

    // Bind inherited functions.
    bindSceneComponentBase<ParticleSysComponent>(engine, "ParticleSysComponent");

    // Set SkyboxComponent behaviour.
    r = engine->RegisterObjectBehaviour("ParticleSysComponent", asBEHAVE_FACTORY, "ParticleSysComponent@ f(Entity @, " \
                                        "const vector3df &in, const vector3df &in)",
                                        asFUNCTIONPR(ParticleSysComponent::refFactory, (Entity*, const vector3df&,
                                        const vector3df&), ParticleSysComponent*), asCALL_CDECL); assert(r >= 0);

    // Bind ParticleSysComponent class methods.
    r = engine->RegisterObjectMethod("ParticleSysComponent", "void addAttractionAffector(const vector3df &in, f32, " \
                                     "bool, bool, bool, bool)", asMETHOD(ParticleSysComponent, addAttractionAffector),
                                     asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("ParticleSysComponent", "void addFadeOutParticleAffector(const SColor &in, u32)",
                                     asMETHOD(ParticleSysComponent, addFadeOutParticleAffector), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("ParticleSysComponent", "void addGravityAffector(const vector3df &in, u32)",
                                     asMETHOD(ParticleSysComponent, addGravityAffector), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("ParticleSysComponent", "void addRotationAffector(const vector3df &in, const vector3df &in)",
                                     asMETHOD(ParticleSysComponent, addRotationAffector), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("ParticleSysComponent", "void addScaleParticleAffector(const dimension2df &in)",
                                     asMETHOD(ParticleSysComponent, addScaleParticleAffector), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("ParticleSysComponent", "void removeAffectors()",
                                     asMETHOD(ParticleSysComponent, removeAffectors), asCALL_THISCALL); assert(r >= 0);

    r = engine->RegisterObjectMethod("ParticleSysComponent", "void setAnimatedMeshSceneNodeEmitter(const string &, " \
                                     "bool, const vector3df &in, f32, bool, u32, u32, const SColor &in, " \
                                     "const SColor &in, u32, u32, s32, const dimension2df &in, const dimension2df &in)",
                                     asMETHODPR(ParticleSysComponent, setAnimatedMeshSceneNodeEmitter,
                                     (const std::string&, bool, const vector3df&, f32, bool, u32, u32,
                                     const SColor&, const SColor&, u32, u32, s32,const dimension2df&,
                                     const dimension2df &), void), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("ParticleSysComponent", "void setBoxEmitter(const aabbox3df &in, const vector3df &in, " \
                                     "u32, u32, const SColor &in, const SColor &in, u32, u32, s32, " \
                                     "const dimension2df &in, const dimension2df &in)",
                                     asMETHOD(ParticleSysComponent, setBoxEmitter), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("ParticleSysComponent", "void setCylinderEmitter(const vector3df &in, f32, " \
                                     "const vector3df &in, f32, bool, const vector3df &in, u32, u32, " \
                                     "const SColor &in, const SColor &in, u32, u32, s32, const dimension2df &in, " \
                                     "const dimension2df &in)", asMETHOD(ParticleSysComponent, setCylinderEmitter),
                                     asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("ParticleSysComponent", "void setMeshEmitter(const string&, bool, " \
                                     "const vector3df &in, f32, bool, u32, u32, const SColor &in, const SColor &in, " \
                                     "u32, u32, s32, const dimension2df &in, const dimension2df &in)",
                                     asMETHODPR(ParticleSysComponent, setMeshEmitter, (const std::string&, bool,
                                     const vector3df&, f32, bool, u32, u32, const SColor&, const SColor&, u32, u32, s32,
                                     const dimension2df&, const dimension2df&), void), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("ParticleSysComponent", "void setPointEmitter(const vector3df &in, u32, u32, " \
                                     "const SColor &in, const SColor &in, u32, u32, s32, const dimension2df &in, " \
                                     "const dimension2df &in)", asMETHOD(ParticleSysComponent, setPointEmitter),
                                     asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("ParticleSysComponent", "void setRingEmitter(const vector3df &in, f32, f32, " \
                                     "const vector3df &in, u32, u32, const SColor &in, const SColor &in, " \
                                     "u32, u32, s32, const dimension2df &in, const dimension2df &in)",
                                     asMETHOD(ParticleSysComponent, setRingEmitter), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("ParticleSysComponent", "void setSphereEmitter(const vector3df &in, f32, " \
                                     "const vector3df &in, u32, u32, const SColor &in, const SColor &in, " \
                                     "u32, u32, s32, const dimension2df &in, const dimension2df &in)",
                                     asMETHOD(ParticleSysComponent, setSphereEmitter), asCALL_THISCALL); assert(r >= 0);

    r = engine->RegisterObjectMethod("ParticleSysComponent", "void setParticlesAreGlobal()",
                                     asMETHOD(ParticleSysComponent, setParticlesAreGlobal), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("ParticleSysComponent", "void setParticlesAreGlobal(bool)",
                                     asMETHOD(ParticleSysComponent, setParticlesAreGlobal), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("ParticleSysComponent", "void setParticleSize(const dimension2df &in)",
                                     asMETHOD(ParticleSysComponent, setParticleSize), asCALL_THISCALL); assert(r >= 0);
}

// End of File

---