OgreMain/src/OgreParticleEmitter.cpp

   1 /*
   2 -----------------------------------------------------------------------------
   3 This source file is part of OGRE
   4         (Object-oriented Graphics Rendering Engine)
   5 For the latest info, see http://www.ogre3d.org/
   6
   7 Copyright (c) 2000-2006 Torus Knot Software Ltd
   8 Also see acknowledgements in Readme.html
   9
  10 This program is free software; you can redistribute it and/or modify it under
  11 the terms of the GNU Lesser General Public License as published by the Free Software
  12 Foundation; either version 2 of the License, or (at your option) any later
  13 version.
  14
  15 This program is distributed in the hope that it will be useful, but WITHOUT
  16 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  17 FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
  18
  19 You should have received a copy of the GNU Lesser General Public License along with
  20 this program; if not, write to the Free Software Foundation, Inc., 59 Temple
  21 Place - Suite 330, Boston, MA 02111-1307, USA, or go to
  22 http://www.gnu.org/copyleft/lesser.txt.
  23
  24 You may alternatively use this source under the terms of a specific version of
  25 the OGRE Unrestricted License provided you have obtained such a license from
  26 Torus Knot Software Ltd.
  27 -----------------------------------------------------------------------------
  28 */
  29 #include "OgreStableHeaders.h"
  30
  31 #include "OgreParticleEmitter.h"
  32 #include "OgreParticleEmitterFactory.h"
  33
  34 namespace Ogre
  35 {
  36         // Define static members
  37     EmitterCommands::CmdAngle ParticleEmitter::msAngleCmd;
  38     EmitterCommands::CmdColour ParticleEmitter::msColourCmd;
  39     EmitterCommands::CmdColourRangeStart ParticleEmitter::msColourRangeStartCmd;
  40     EmitterCommands::CmdColourRangeEnd ParticleEmitter::msColourRangeEndCmd;
  41     EmitterCommands::CmdDirection ParticleEmitter::msDirectionCmd;
  42     EmitterCommands::CmdEmissionRate ParticleEmitter::msEmissionRateCmd;
  43     EmitterCommands::CmdMaxTTL ParticleEmitter::msMaxTTLCmd;
  44     EmitterCommands::CmdMaxVelocity ParticleEmitter::msMaxVelocityCmd;
  45     EmitterCommands::CmdMinTTL ParticleEmitter::msMinTTLCmd;
  46     EmitterCommands::CmdMinVelocity ParticleEmitter::msMinVelocityCmd;
  47     EmitterCommands::CmdPosition ParticleEmitter::msPositionCmd;
  48     EmitterCommands::CmdTTL ParticleEmitter::msTTLCmd;
  49     EmitterCommands::CmdVelocity ParticleEmitter::msVelocityCmd;
  50     EmitterCommands::CmdDuration ParticleEmitter::msDurationCmd;
  51     EmitterCommands::CmdMinDuration ParticleEmitter::msMinDurationCmd;
  52     EmitterCommands::CmdMaxDuration ParticleEmitter::msMaxDurationCmd;
  53     EmitterCommands::CmdRepeatDelay ParticleEmitter::msRepeatDelayCmd;
  54     EmitterCommands::CmdMinRepeatDelay ParticleEmitter::msMinRepeatDelayCmd;
  55     EmitterCommands::CmdMaxRepeatDelay ParticleEmitter::msMaxRepeatDelayCmd;
  56     EmitterCommands::CmdName ParticleEmitter::msNameCmd;
  57     EmitterCommands::CmdEmittedEmitter ParticleEmitter::msEmittedEmitterCmd;
  58
  59
  60     //-----------------------------------------------------------------------
  61     ParticleEmitter::ParticleEmitter(ParticleSystem* psys)
  62       : mParent(psys),
  63         mStartTime(0),
  64         mDurationMin(0),
  65         mDurationMax(0),
  66         mDurationRemain(0),
  67         mRepeatDelayMin(0),
  68         mRepeatDelayMax(0),
  69         mRepeatDelayRemain(0)
  70     {
  71
  72         // Reasonable defaults
  73         mAngle = 0;
  74         setDirection(Vector3::UNIT_X);
  75         mEmissionRate = 10;
  76         mMaxSpeed = mMinSpeed = 1;
  77         mMaxTTL = mMinTTL = 5;
  78         mPosition = Vector3::ZERO;
  79         mColourRangeStart = mColourRangeEnd = ColourValue::White;
  80         mEnabled = true;
  81         mRemainder = 0;
  82                 mName = StringUtil::BLANK;
  83                 mEmittedEmitter = StringUtil::BLANK;
  84                 mEmitted = false;
  85     }
  86     //-----------------------------------------------------------------------
  87     ParticleEmitter::~ParticleEmitter()
  88     {
  89     }
  90     //-----------------------------------------------------------------------
  91     void ParticleEmitter::setPosition(const Vector3& pos)
  92     {
  93         mPosition = pos;
  94     }
  95     //-----------------------------------------------------------------------
  96     const Vector3& ParticleEmitter::getPosition(void) const
  97     {
  98         return mPosition;
  99     }
 100     //-----------------------------------------------------------------------
 101     void ParticleEmitter::setDirection(const Vector3& direction)
 102     {
 103         mDirection = direction;
 104         mDirection.normalise();
 105         // Generate an up vector (any will do)
 106         mUp = mDirection.perpendicular();
 107         mUp.normalise();
 108     }
 109     //-----------------------------------------------------------------------
 110     const Vector3& ParticleEmitter::getDirection(void) const
 111     {
 112         return mDirection;
 113     }
 114     //-----------------------------------------------------------------------
 115     void ParticleEmitter::setAngle(const Radian& angle)
 116     {
 117         // Store as radians for efficiency
 118         mAngle = angle;
 119     }
 120     //-----------------------------------------------------------------------
 121     const Radian& ParticleEmitter::getAngle(void) const
 122     {
 123         return mAngle;
 124     }
 125     //-----------------------------------------------------------------------
 126     void ParticleEmitter::setParticleVelocity(Real speed)
 127     {
 128         mMinSpeed = mMaxSpeed = speed;
 129     }
 130     //-----------------------------------------------------------------------
 131     void ParticleEmitter::setParticleVelocity(Real min, Real max)
 132     {
 133         mMinSpeed = min;
 134         mMaxSpeed = max;
 135     }
 136     //-----------------------------------------------------------------------
 137     void ParticleEmitter::setEmissionRate(Real particlesPerSecond)
 138     {
 139         mEmissionRate = particlesPerSecond;
 140     }
 141     //-----------------------------------------------------------------------
 142     Real ParticleEmitter::getEmissionRate(void) const
 143     {
 144         return mEmissionRate;
 145     }
 146     //-----------------------------------------------------------------------
 147     void ParticleEmitter::setTimeToLive(Real ttl)
 148     {
 149         mMinTTL = mMaxTTL = ttl;
 150     }
 151     //-----------------------------------------------------------------------
 152     void ParticleEmitter::setTimeToLive(Real minTtl, Real maxTtl)
 153     {
 154         mMinTTL = minTtl;
 155         mMaxTTL = maxTtl;
 156     }
 157     //-----------------------------------------------------------------------
 158     void ParticleEmitter::setColour(const ColourValue& colour)
 159     {
 160         mColourRangeStart = mColourRangeEnd = colour;
 161     }
 162     //-----------------------------------------------------------------------
 163     void ParticleEmitter::setColour(const ColourValue& colourStart, const ColourValue& colourEnd)
 164     {
 165         mColourRangeStart = colourStart;
 166         mColourRangeEnd = colourEnd;
 167     }
 168         //-----------------------------------------------------------------------
 169     const String& ParticleEmitter::getName(void) const
 170     {
 171         return mName;
 172     }
 173         //-----------------------------------------------------------------------
 174     void ParticleEmitter::setName(const String& newName)
 175     {
 176                 mName = newName;
 177     }
 178         //-----------------------------------------------------------------------
 179     const String& ParticleEmitter::getEmittedEmitter(void) const
 180     {
 181         return mEmittedEmitter;
 182     }
 183         //-----------------------------------------------------------------------
 184     void ParticleEmitter::setEmittedEmitter(const String& emittedEmitter)
 185     {
 186         mEmittedEmitter = emittedEmitter;
 187     }
 188         //-----------------------------------------------------------------------
 189         bool ParticleEmitter::isEmitted(void) const
 190     {
 191                 return mEmitted;
 192     }
 193         //-----------------------------------------------------------------------
 194         void ParticleEmitter::setEmitted(bool emitted)
 195     {
 196         mEmitted = emitted;
 197     }
 198     //-----------------------------------------------------------------------
 199     void ParticleEmitter::genEmissionDirection(Vector3& destVector)
 200     {
 201         if (mAngle != Radian(0))
 202         {
 203             // Randomise angle
 204             Radian angle = Math::UnitRandom() * mAngle;
 205
 206             // Randomise direction
 207             destVector = mDirection.randomDeviant(angle, mUp);
 208         }
 209         else
 210         {
 211             // Constant angle
 212             destVector = mDirection;
 213         }
 214
 215         // Don't normalise, we can assume that it will still be a unit vector since
 216         // both direction and 'up' are.
 217
 218     }
 219     //-----------------------------------------------------------------------
 220     void ParticleEmitter::genEmissionVelocity(Vector3& destVector)
 221     {
 222         Real scalar;
 223         if (mMinSpeed != mMaxSpeed)
 224         {
 225             scalar = mMinSpeed + (Math::UnitRandom() * (mMaxSpeed - mMinSpeed));
 226         }
 227         else
 228         {
 229             scalar = mMinSpeed;
 230         }
 231
 232         destVector *= scalar;
 233     }
 234     //-----------------------------------------------------------------------
 235     Real ParticleEmitter::genEmissionTTL(void)
 236     {
 237         if (mMaxTTL != mMinTTL)
 238         {
 239             return mMinTTL + (Math::UnitRandom() * (mMaxTTL - mMinTTL));
 240         }
 241         else
 242         {
 243             return mMinTTL;
 244         }
 245     }
 246     //-----------------------------------------------------------------------
 247     unsigned short ParticleEmitter::genConstantEmissionCount(Real timeElapsed)
 248     {
 249         unsigned short intRequest;
 250
 251         if (mEnabled)
 252         {
 253             // Keep fractions, otherwise a high frame rate will result in zero emissions!
 254             mRemainder += mEmissionRate * timeElapsed;
 255             intRequest = (unsigned short)mRemainder;
 256             mRemainder -= intRequest;
 257
 258             // Check duration
 259             if (mDurationMax)
 260             {
 261                 mDurationRemain -= timeElapsed;
 262                 if (mDurationRemain <= 0)
 263                 {
 264                     // Disable, duration is out (takes effect next time)
 265                     setEnabled(false);
 266                 }
 267             }
 268             return intRequest;
 269         }
 270         else
 271         {
 272             // Check repeat
 273             if (mRepeatDelayMax)
 274             {
 275                 mRepeatDelayRemain -= timeElapsed;
 276                 if (mRepeatDelayRemain <= 0)
 277                 {
 278                     // Enable, repeat delay is out (takes effect next time)
 279                     setEnabled(true);
 280                 }
 281             }
 282             if(mStartTime)
 283             {
 284                 mStartTime -= timeElapsed;
 285                 if(mStartTime <= 0)
 286                 {
 287                     setEnabled(true);
 288                     mStartTime = 0;
 289                 }
 290             }
 291             return 0;
 292         }
 293
 294     }
 295     //-----------------------------------------------------------------------
 296     void ParticleEmitter::genEmissionColour(ColourValue& destColour)
 297     {
 298         if (mColourRangeStart != mColourRangeEnd)
 299         {
 300             // Randomise
 301             //Real t = Math::UnitRandom();
 302             destColour.r = mColourRangeStart.r + (Math::UnitRandom() * (mColourRangeEnd.r - mColourRangeStart.r));
 303             destColour.g = mColourRangeStart.g + (Math::UnitRandom() * (mColourRangeEnd.g - mColourRangeStart.g));
 304             destColour.b = mColourRangeStart.b + (Math::UnitRandom() * (mColourRangeEnd.b - mColourRangeStart.b));
 305             destColour.a = mColourRangeStart.a + (Math::UnitRandom() * (mColourRangeEnd.a - mColourRangeStart.a));
 306         }
 307         else
 308         {
 309             destColour = mColourRangeStart;
 310         }
 311     }
 312     //-----------------------------------------------------------------------
 313     void ParticleEmitter::addBaseParameters(void)
 314     {
 315         ParamDictionary* dict = getParamDictionary();
 316
 317         dict->addParameter(ParameterDef("angle",
 318             "The angle up to which particles may vary in their initial direction "
 319             "from the emitters direction, in degrees." , PT_REAL),
 320             &msAngleCmd);
 321
 322         dict->addParameter(ParameterDef("colour",
 323             "The colour of emitted particles.", PT_COLOURVALUE),
 324             &msColourCmd);
 325
 326         dict->addParameter(ParameterDef("colour_range_start",
 327             "The start of a range of colours to be assigned to emitted particles.", PT_COLOURVALUE),
 328             &msColourRangeStartCmd);
 329
 330         dict->addParameter(ParameterDef("colour_range_end",
 331             "The end of a range of colours to be assigned to emitted particles.", PT_COLOURVALUE),
 332             &msColourRangeEndCmd);
 333
 334         dict->addParameter(ParameterDef("direction",
 335             "The base direction of the emitter." , PT_VECTOR3),
 336             &msDirectionCmd);
 337
 338         dict->addParameter(ParameterDef("emission_rate",
 339             "The number of particles emitted per second." , PT_REAL),
 340             &msEmissionRateCmd);
 341
 342         dict->addParameter(ParameterDef("position",
 343             "The position of the emitter relative to the particle system center." , PT_VECTOR3),
 344             &msPositionCmd);
 345
 346         dict->addParameter(ParameterDef("velocity",
 347             "The initial velocity to be assigned to every particle, in world units per second." , PT_REAL),
 348             &msVelocityCmd);
 349
 350         dict->addParameter(ParameterDef("velocity_min",
 351             "The minimum initial velocity to be assigned to each particle." , PT_REAL),
 352             &msMinVelocityCmd);
 353
 354         dict->addParameter(ParameterDef("velocity_max",
 355             "The maximum initial velocity to be assigned to each particle." , PT_REAL),
 356             &msMaxVelocityCmd);
 357
 358         dict->addParameter(ParameterDef("time_to_live",
 359             "The lifetime of each particle in seconds." , PT_REAL),
 360             &msTTLCmd);
 361
 362         dict->addParameter(ParameterDef("time_to_live_min",
 363             "The minimum lifetime of each particle in seconds." , PT_REAL),
 364             &msMinTTLCmd);
 365
 366         dict->addParameter(ParameterDef("time_to_live_max",
 367             "The maximum lifetime of each particle in seconds." , PT_REAL),
 368             &msMaxTTLCmd);
 369
 370         dict->addParameter(ParameterDef("duration",
 371             "The length of time in seconds which an emitter stays enabled for." , PT_REAL),
 372             &msDurationCmd);
 373
 374         dict->addParameter(ParameterDef("duration_min",
 375             "The minimum length of time in seconds which an emitter stays enabled for." , PT_REAL),
 376             &msMinDurationCmd);
 377
 378         dict->addParameter(ParameterDef("duration_max",
 379             "The maximum length of time in seconds which an emitter stays enabled for." , PT_REAL),
 380             &msMaxDurationCmd);
 381
 382         dict->addParameter(ParameterDef("repeat_delay",
 383             "If set, after disabling an emitter will repeat (reenable) after this many seconds." , PT_REAL),
 384             &msRepeatDelayCmd);
 385
 386         dict->addParameter(ParameterDef("repeat_delay_min",
 387             "If set, after disabling an emitter will repeat (reenable) after this minimum number of seconds." , PT_REAL),
 388             &msMinRepeatDelayCmd);
 389
 390         dict->addParameter(ParameterDef("repeat_delay_max",
 391             "If set, after disabling an emitter will repeat (reenable) after this maximum number of seconds." , PT_REAL),
 392             &msMaxRepeatDelayCmd);
 393
 394                 dict->addParameter(ParameterDef("name",
 395                         "This is the name of the emitter" , PT_STRING),
 396                         &msNameCmd);
 397
 398                 dict->addParameter(ParameterDef("emit_emitter",
 399                         "If set, this emitter will emit other emitters instead of visual particles" , PT_STRING),
 400                         &msEmittedEmitterCmd);
 401     }
 402     //-----------------------------------------------------------------------
 403     Real ParticleEmitter::getParticleVelocity(void) const
 404     {
 405         return mMinSpeed;
 406     }
 407     //-----------------------------------------------------------------------
 408     Real ParticleEmitter::getMinParticleVelocity(void) const
 409     {
 410         return mMinSpeed;
 411     }
 412     //-----------------------------------------------------------------------
 413     Real ParticleEmitter::getMaxParticleVelocity(void) const
 414     {
 415         return mMaxSpeed;
 416     }
 417     //-----------------------------------------------------------------------
 418     void ParticleEmitter::setMinParticleVelocity(Real min)
 419     {
 420         mMinSpeed = min;
 421     }
 422     //-----------------------------------------------------------------------
 423     void ParticleEmitter::setMaxParticleVelocity(Real max)
 424     {
 425         mMaxSpeed = max;
 426     }
 427     //-----------------------------------------------------------------------
 428     Real ParticleEmitter::getTimeToLive(void) const
 429     {
 430         return mMinTTL;
 431     }
 432     //-----------------------------------------------------------------------
 433     Real ParticleEmitter::getMinTimeToLive(void) const
 434     {
 435         return mMinTTL;
 436     }
 437     //-----------------------------------------------------------------------
 438     Real ParticleEmitter::getMaxTimeToLive(void) const
 439     {
 440         return mMaxTTL;
 441     }
 442     //-----------------------------------------------------------------------
 443     void ParticleEmitter::setMinTimeToLive(Real min)
 444     {
 445         mMinTTL = min;
 446     }
 447     //-----------------------------------------------------------------------
 448     void ParticleEmitter::setMaxTimeToLive(Real max)
 449     {
 450         mMaxTTL = max;
 451     }
 452     //-----------------------------------------------------------------------
 453     const ColourValue& ParticleEmitter::getColour(void) const
 454     {
 455         return mColourRangeStart;
 456     }
 457     //-----------------------------------------------------------------------
 458     const ColourValue& ParticleEmitter::getColourRangeStart(void) const
 459     {
 460         return mColourRangeStart;
 461     }
 462     //-----------------------------------------------------------------------
 463     const ColourValue& ParticleEmitter::getColourRangeEnd(void) const
 464     {
 465         return mColourRangeEnd;
 466     }
 467     //-----------------------------------------------------------------------
 468     void ParticleEmitter::setColourRangeStart(const ColourValue& val)
 469     {
 470         mColourRangeStart = val;
 471     }
 472     //-----------------------------------------------------------------------
 473     void ParticleEmitter::setColourRangeEnd(const ColourValue& val )
 474     {
 475         mColourRangeEnd = val;
 476     }
 477     //-----------------------------------------------------------------------
 478     void ParticleEmitter::setEnabled(bool enabled)
 479     {
 480         mEnabled = enabled;
 481         // Reset duration & repeat
 482         initDurationRepeat();
 483     }
 484     //-----------------------------------------------------------------------
 485     bool ParticleEmitter::getEnabled(void) const
 486     {
 487         return mEnabled;
 488     }
 489     //-----------------------------------------------------------------------
 490     void ParticleEmitter::setStartTime(Real startTime)
 491     {
 492         setEnabled(false);
 493         mStartTime = startTime;
 494     }
 495     //-----------------------------------------------------------------------
 496     Real ParticleEmitter::getStartTime(void) const
 497     {
 498         return mStartTime;
 499     }
 500     //-----------------------------------------------------------------------
 501     void ParticleEmitter::setDuration(Real duration)
 502     {
 503         setDuration(duration, duration);
 504     }
 505     //-----------------------------------------------------------------------
 506     Real ParticleEmitter::getDuration(void) const
 507     {
 508         return mDurationMin;
 509     }
 510     //-----------------------------------------------------------------------
 511     void ParticleEmitter::setDuration(Real min, Real max)
 512     {
 513         mDurationMin = min;
 514         mDurationMax = max;
 515         initDurationRepeat();
 516     }
 517     //-----------------------------------------------------------------------
 518     void ParticleEmitter::setMinDuration(Real min)
 519     {
 520         mDurationMin = min;
 521         initDurationRepeat();
 522     }
 523     //-----------------------------------------------------------------------
 524     void ParticleEmitter::setMaxDuration(Real max)
 525     {
 526         mDurationMax = max;
 527         initDurationRepeat();
 528     }
 529     //-----------------------------------------------------------------------
 530     void ParticleEmitter::initDurationRepeat(void)
 531     {
 532         if (mEnabled)
 533         {
 534             if (mDurationMin == mDurationMax)
 535             {
 536                 mDurationRemain = mDurationMin;
 537             }
 538             else
 539             {
 540                 mDurationRemain = Math::RangeRandom(mDurationMin, mDurationMax);
 541             }
 542         }
 543         else
 544         {
 545             // Reset repeat
 546             if (mRepeatDelayMin == mRepeatDelayMax)
 547             {
 548                 mRepeatDelayRemain = mRepeatDelayMin;
 549             }
 550             else
 551             {
 552                 mRepeatDelayRemain = Math::RangeRandom(mRepeatDelayMax, mRepeatDelayMin);
 553             }
 554
 555         }
 556     }
 557     //-----------------------------------------------------------------------
 558     void ParticleEmitter::setRepeatDelay(Real delay)
 559     {
 560         setRepeatDelay(delay, delay);
 561     }
 562     //-----------------------------------------------------------------------
 563     Real ParticleEmitter::getRepeatDelay(void) const
 564     {
 565         return mRepeatDelayMin;
 566     }
 567     //-----------------------------------------------------------------------
 568     void ParticleEmitter::setRepeatDelay(Real min, Real max)
 569     {
 570         mRepeatDelayMin = min;
 571         mRepeatDelayMax = max;
 572         initDurationRepeat();
 573     }
 574     //-----------------------------------------------------------------------
 575     void ParticleEmitter::setMinRepeatDelay(Real min)
 576     {
 577         mRepeatDelayMin = min;
 578         initDurationRepeat();
 579     }
 580     //-----------------------------------------------------------------------
 581     void ParticleEmitter::setMaxRepeatDelay(Real max)
 582     {
 583         mRepeatDelayMax = max;
 584         initDurationRepeat();
 585     }
 586     //-----------------------------------------------------------------------
 587     Real ParticleEmitter::getMinDuration(void) const
 588     {
 589         return mDurationMin;
 590     }
 591     //-----------------------------------------------------------------------
 592     Real ParticleEmitter::getMaxDuration(void) const
 593     {
 594         return mDurationMax;
 595     }
 596     //-----------------------------------------------------------------------
 597     Real ParticleEmitter::getMinRepeatDelay(void) const
 598     {
 599         return mRepeatDelayMin;
 600     }
 601     //-----------------------------------------------------------------------
 602     Real ParticleEmitter::getMaxRepeatDelay(void) const
 603     {
 604         return mRepeatDelayMax;
 605     }
 606
 607     //-----------------------------------------------------------------------
 608     ParticleEmitterFactory::~ParticleEmitterFactory()
 609     {
 610         // Destroy all emitters
 611         vector<ParticleEmitter*>::type::iterator i;
 612         for (i = mEmitters.begin(); i != mEmitters.end(); ++i)
 613         {
 614             OGRE_DELETE (*i);
 615         }
 616
 617         mEmitters.clear();
 618
 619     }
 620     //-----------------------------------------------------------------------
 621     void ParticleEmitterFactory::destroyEmitter(ParticleEmitter* e)
 622     {
 623         vector<ParticleEmitter*>::type::iterator i;
 624         for (i = mEmitters.begin(); i != mEmitters.end(); ++i)
 625         {
 626             if ((*i) == e)
 627             {
 628                 mEmitters.erase(i);
 629                 OGRE_DELETE e;
 630                 break;
 631             }
 632         }
 633     }
 634
 635     //-----------------------------------------------------------------------
 636
 637 }
 638