[1] | 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 | std::vector<ParticleEmitter*>::iterator i; |
---|
| 612 | for (i = mEmitters.begin(); i != mEmitters.end(); ++i) |
---|
| 613 | { |
---|
| 614 | delete (*i); |
---|
| 615 | } |
---|
| 616 | |
---|
| 617 | mEmitters.clear(); |
---|
| 618 | |
---|
| 619 | } |
---|
| 620 | //----------------------------------------------------------------------- |
---|
| 621 | void ParticleEmitterFactory::destroyEmitter(ParticleEmitter* e) |
---|
| 622 | { |
---|
| 623 | std::vector<ParticleEmitter*>::iterator i; |
---|
| 624 | for (i = mEmitters.begin(); i != mEmitters.end(); ++i) |
---|
| 625 | { |
---|
| 626 | if ((*i) == e) |
---|
| 627 | { |
---|
| 628 | mEmitters.erase(i); |
---|
| 629 | delete e; |
---|
| 630 | break; |
---|
| 631 | } |
---|
| 632 | } |
---|
| 633 | } |
---|
| 634 | |
---|
| 635 | //----------------------------------------------------------------------- |
---|
| 636 | |
---|
| 637 | } |
---|
| 638 | |
---|