?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Show bonus/malus timer text if available
[ryzomcore.git] / nel / src / 3d / ps_emitter.cpp
blob240be6f516860039e839abe2a351cf9fbf53eda2
1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
2 // Copyright (C) 2010 Winch Gate Property Limited
3 //
4 // This program is free software: you can redistribute it and/or modify
5 // it under the terms of the GNU Affero General Public License as
6 // published by the Free Software Foundation, either version 3 of the
7 // License, or (at your option) any later version.
8 //
9 // This program is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 // GNU Affero General Public License for more details.
13 //
14 // You should have received a copy of the GNU Affero General Public License
15 // along with this program. If not, see <http://www.gnu.org/licenses/>.
16
17 #include "std3d.h"
18
19 #include "nel/3d/ps_emitter.h"
20 #include "nel/3d/material.h"
21 #include "nel/misc/line.h"
22 #include "nel/3d/dru.h"
23 #include "nel/3d/particle_system.h"
24
25 #ifdef DEBUG_NEW
26 #define new DEBUG_NEW
27 #endif
28
29 namespace NL3D {
30
31
32
33
34 static const uint EMITTER_BUFF_SIZE = 512; // number of emitter to be processed at once
35 static const float EMIT_PERIOD_THRESHOLD = 1.f / 75.f; // assuming the same behaviour than with a 75 hz rendering
36 bool CPSEmitter::_BypassEmitOnDeath = false;
37
38
39 //////////////////////
40 // STATIC FUNCTIONS //
41 //////////////////////
42 /** In an arrey of float, all value that are 0.f are replaced by EMIT_PERIOD_THRESHOLD
43 * A period of 0 is allowed for emitter and means "emit at each frame"
44 * This is deprecated now, and this helps to avoid that behaviour
45 */
46 static void replaceNullPeriodsByThreshold(float *tab, uint numElem)
47 {
48 NL_PS_FUNC(replaceNullPeriodsByThreshold)
49 const float *endTab = tab + numElem;
50 while (tab != endTab)
51 {
52 if (*tab == 0.f) *tab = EMIT_PERIOD_THRESHOLD;
53 ++ tab;
54 }
55 }
56
57 ///////////////////////////////
58 // CPSEmitter implementation //
59 ///////////////////////////////
60 CPSEmitter::CPSEmitter() : _EmittedType(NULL),
61 _SpeedInheritanceFactor(0.f),
62 _EmissionType(regular),
63 _Period(0.02f),
64 _PeriodScheme(NULL),
65 _GenNb(1),
66 _GenNbScheme(NULL),
67 _EmitDelay(0),
68 _MaxEmissionCount(0),
69 _SpeedBasisEmission(false),
70 _ConsistentEmission(true),
71 _BypassAutoLOD(false),
72 _UserMatrixModeForEmissionDirection(false),
73 _EmitTrigger(false),
74 _UserDirectionMatrixMode(PSFXWorldMatrix)
75 {
76 NL_PS_FUNC(CPSEmitter_CPSEmitter)
77 }
78
79
80 ///==========================================================================
81 CPSEmitter::~CPSEmitter()
82 {
83 NL_PS_FUNC(CPSEmitter_CPSEmitterDtor)
84 delete _PeriodScheme;
85 delete _GenNbScheme;
86 // if a located is emitted, unregister us as an observer
87 if (_EmittedType)
88 {
89 _EmittedType->unregisterDtorObserver(this);
90 }
91 }
92
93 ///==========================================================================
94 void CPSEmitter::releaseRefTo(const CParticleSystemProcess *other)
95 {
96 NL_PS_FUNC(CPSEmitter_releaseRefTo)
97 if (_EmittedType == other)
98 {
99 setEmittedType(NULL);
100 }
101 }
102
103 void CPSEmitter::releaseAllRef()
104 {
105 NL_PS_FUNC(CPSEmitter_releaseAllRef)
106 setEmittedType(NULL);
107 }
108
109
110 ///==========================================================================
111 void CPSEmitter::setOwner(CPSLocated *psl)
112 {
113 NL_PS_FUNC(CPSEmitter_setOwner)
114 CPSLocatedBindable::setOwner(psl);
115 updateMaxCountVect();
116 }
117
118
119 ///==========================================================================
120 inline void CPSEmitter::processEmit(uint32 index, sint nbToGenerate)
121 {
122 NL_PS_FUNC(CPSEmitter_processEmit)
123 NLMISC::CVector speed, pos;
124 nlassert(_Owner);
125 if (!_SpeedBasisEmission)
126 {
127 if (_SpeedInheritanceFactor == 0.f)
128 {
129 if (!_UserMatrixModeForEmissionDirection)
130 {
131 while (nbToGenerate > 0)
132 {
133 nbToGenerate --;
134 emit(_Owner->getPos()[index], index, pos, speed);
135 _EmittedType->postNewElement(pos, speed, *this->_Owner, index, _Owner->getMatrixMode(), 0.f);
136 }
137 }
138 else
139 {
140 while (nbToGenerate > 0)
141 {
142 nbToGenerate --;
143 emit(_Owner->getPos()[index], index, pos, speed);
144 _EmittedType->postNewElement(pos, speed, *this->_Owner, index, _UserDirectionMatrixMode, 0.f);
145 }
146 }
147 }
148 else
149 {
150 while (nbToGenerate --)
151 {
152 emit(_Owner->getPos()[index], index, pos, speed);
153 _EmittedType->postNewElement(pos, speed + _SpeedInheritanceFactor * _Owner->getSpeed()[index], *this->_Owner, 0, _Owner->getMatrixMode(), 0.f);
154 }
155 }
156 }
157 else
158 {
159 NLMISC::CMatrix m;
160 CPSUtil::buildSchmidtBasis(_Owner->getSpeed()[index], m);
161 if (_SpeedInheritanceFactor == 0.f)
162 {
163 while (nbToGenerate > 0)
164 {
165 nbToGenerate --;
166 emit(_Owner->getPos()[index], index, pos, speed);
167 _EmittedType->postNewElement(pos, m * speed, *this->_Owner, index, _Owner->getMatrixMode(), 0.f);
168 }
169 }
170 else
171 {
172 while (nbToGenerate --)
173 {
174 emit(_Owner->getPos()[index], index, pos, speed);
175 _EmittedType->postNewElement(pos, m * speed + _SpeedInheritanceFactor * _Owner->getSpeed()[index], *this->_Owner, index, _Owner->getMatrixMode(), 0.f);
176 }
177 }
178 }
179 }
180
181
182 ///==========================================================================
183 void CPSEmitter::processEmitOutsideSimLoop(uint32 index,sint nbToGenerate)
184 {
185 NL_PS_FUNC(CPSEmitter_processEmitOutsideSimLoop)
186 NLMISC::CVector speed, pos;
187 nlassert(_Owner);
188 if (!_SpeedBasisEmission)
189 {
190 if (_SpeedInheritanceFactor == 0.f)
191 {
192 if (!_UserMatrixModeForEmissionDirection)
193 {
194 while (nbToGenerate > 0)
195 {
196 nbToGenerate --;
197 emit(_Owner->getPos()[index], index, pos, speed);
198 _EmittedType->newElement(pos, speed, this->_Owner, index, _Owner->getMatrixMode(), true);
199 }
200 }
201 else
202 {
203 while (nbToGenerate > 0)
204 {
205 nbToGenerate --;
206 emit(_Owner->getPos()[index], index, pos, speed);
207 _EmittedType->newElement(pos, speed, this->_Owner, index, _UserDirectionMatrixMode);
208 }
209 }
210 }
211 else
212 {
213 while (nbToGenerate --)
214 {
215 emit(_Owner->getPos()[index], index, pos, speed);
216 _EmittedType->newElement(pos, speed + _SpeedInheritanceFactor * _Owner->getSpeed()[index], this->_Owner, 0, _Owner->getMatrixMode(), true);
217 }
218 }
219 }
220 else
221 {
222 NLMISC::CMatrix m;
223 CPSUtil::buildSchmidtBasis(_Owner->getSpeed()[index], m);
224 if (_SpeedInheritanceFactor == 0.f)
225 {
226 while (nbToGenerate > 0)
227 {
228 nbToGenerate --;
229 emit(_Owner->getPos()[index], index, pos, speed);
230 _EmittedType->newElement(pos, m * speed, this->_Owner, index, _Owner->getMatrixMode(), true);
231 }
232 }
233 else
234 {
235 while (nbToGenerate --)
236 {
237 emit(_Owner->getPos()[index], index, pos, speed);
238 _EmittedType->newElement(pos, m * speed + _SpeedInheritanceFactor * _Owner->getSpeed()[index], this->_Owner, index, _Owner->getMatrixMode(), true);
239 }
240 }
241 }
242 }
243
244 ///==========================================================================
245 inline void CPSEmitter::processEmitConsistent(const NLMISC::CVector &emitterPos,
246 uint32 index,
247 sint nbToGenerate,
248 TAnimationTime deltaT)
249 {
250 NL_PS_FUNC(CPSEmitter_processEmitConsistent)
251 static NLMISC::CVector speed, pos; /// speed and pos of emittee
252 nlassert(_Owner);
253 if (!_SpeedBasisEmission)
254 {
255 if (_SpeedInheritanceFactor == 0.f)
256 {
257 if (!_UserMatrixModeForEmissionDirection)
258 {
259 while (nbToGenerate > 0)
260 {
261 nbToGenerate --;
262 emit(emitterPos, index, pos, speed);
263 _EmittedType->postNewElement(pos, speed, *this->_Owner, index, _Owner->getMatrixMode(), deltaT);
264 }
265 }
266 else
267 {
268 while (nbToGenerate > 0)
269 {
270 nbToGenerate --;
271 emit(emitterPos, index, pos, speed);
272 _EmittedType->postNewElement(pos, speed, *this->_Owner, index, _UserDirectionMatrixMode, deltaT);
273 }
274 }
275 }
276 else
277 {
278 while (nbToGenerate --)
279 {
280 emit(emitterPos, index, pos, speed);
281 _EmittedType->postNewElement(pos, speed + _SpeedInheritanceFactor * _Owner->getSpeed()[index], *this->_Owner, index, _Owner->getMatrixMode(), deltaT);
282 }
283 }
284 }
285 else
286 {
287 NLMISC::CMatrix m;
288 CPSUtil::buildSchmidtBasis(_Owner->getSpeed()[index], m);
289 if (_SpeedInheritanceFactor == 0.f)
290 {
291 while (nbToGenerate > 0)
292 {
293 nbToGenerate --;
294 emit(emitterPos, index, pos, speed);
295 _EmittedType->postNewElement(pos, m * speed, *this->_Owner, index, _Owner->getMatrixMode(), deltaT);
296 }
297 }
298 else
299 {
300 while (nbToGenerate --)
301 {
302 emit(emitterPos, index, pos, speed);
303 _EmittedType->postNewElement(pos, m * speed + _SpeedInheritanceFactor * _Owner->getSpeed()[index], *this->_Owner, index, _Owner->getMatrixMode(), deltaT);
304 }
305 }
306 }
307 }
308
309
310 ///==========================================================================
311 bool CPSEmitter::setEmissionType(TEmissionType freqType)
312 {
313 NL_PS_FUNC(CPSEmitter_setEmissionType)
314 if (_Owner && _Owner->getOwner())
315 {
316 CParticleSystem *ps = _Owner->getOwner();
317 if (ps->getBypassMaxNumIntegrationSteps())
318 {
319 if (!_Owner)
320 {
321 nlwarning("<CPSEmitter::setEmissionType> The emitter should be inserted in a CPSLocated instance");
322 nlassert(0);
323 }
324 // check if the new value is valid
325 TEmissionType oldType = _EmissionType;
326 _EmissionType = freqType;
327 if (testEmitForever() == true)
328 {
329 _EmissionType = oldType;
330 std::string mess = "<CPSEmitter::setEmissionType> can't set emission type to '" +
331 NLMISC::toString(freqType) +
332 "' with the current configuration : the system has been flagged with \
333 'BypassMaxNumIntegrationSteps', and should have a finite duration. \
334 The flag is not set";
335 nlwarning(mess.c_str());
336 return false;
337
338 }
339 }
340 ps->systemDurationChanged();
341 }
342 _EmissionType = freqType;
343 return true;
344 }
345
346 ///==========================================================================
347 bool CPSEmitter::setEmittedType(CPSLocated *et)
348 {
349 NL_PS_FUNC(CPSEmitter_setEmittedType)
350 if (_EmittedType)
351 {
352 _EmittedType->unregisterDtorObserver(this);
353 }
354 if (et)
355 {
356 et->registerDtorObserver(this);
357 }
358 CPSLocated *oldType = _EmittedType;
359 _EmittedType = et;
360 if (_Owner && _Owner->getOwner())
361 {
362 CParticleSystem *ps = _Owner->getOwner();
363 if (_EmittedType)
364 {
365 bool ok = true;
366 if (ps->getBypassMaxNumIntegrationSteps())
367 {
368 ok = ps->canFinish();
369 }
370 else
371 {
372 ok = !ps->hasLoop();
373 }
374 if (!ok)
375 {
376 setEmittedType(oldType);
377 nlwarning("<CPSLocated::setEmittedType> Can't set new emitted type : this causes the system to last forever, and it has been flagged with 'BypassMaxNumIntegrationSteps'. New emitted type is not set");
378 return false;
379 }
380 }
381 ps->systemDurationChanged();
382 }
383 return true;
384 }
385
386 ///==========================================================================
387 void CPSEmitter::notifyTargetRemoved(CPSLocated *ptr)
388 {
389 NL_PS_FUNC(CPSEmitter_notifyTargetRemoved)
390 nlassert(ptr == _EmittedType && _EmittedType);
391 setEmittedType(NULL);
392 }
393
394 ///==========================================================================
395 void CPSEmitter::setPeriod(float period)
396 {
397 NL_PS_FUNC(CPSEmitter_setPeriod)
398 if (_PeriodScheme)
399 {
400 delete _PeriodScheme;
401 _PeriodScheme = NULL;
402 }
403 _Period = period;
404 if (_Owner && _Owner->getOwner())
405 {
406 _Owner->getOwner()->systemDurationChanged();
407 }
408 }
409
410 ///==========================================================================
411 void CPSEmitter::setPeriodScheme(CPSAttribMaker<float> *scheme)
412 {
413 NL_PS_FUNC(CPSEmitter_setPeriodScheme)
414 delete _PeriodScheme;
415 _PeriodScheme = scheme;
416 if (_Owner && scheme->hasMemory()) scheme->resize(_Owner->getMaxSize(), _Owner->getSize());
417 if (_Owner && _Owner->getOwner())
418 {
419 _Owner->getOwner()->systemDurationChanged();
420 }
421 }
422
423 ///==========================================================================
424 void CPSEmitter::setGenNb(uint32 genNb)
425 {
426 NL_PS_FUNC(CPSEmitter_setGenNb)
427 if (_GenNbScheme)
428 {
429 delete _GenNbScheme;
430 _GenNbScheme = NULL;
431 }
432 _GenNb = genNb;
433 }
434
435 ///==========================================================================
436 void CPSEmitter::setGenNbScheme(CPSAttribMaker<uint32> *scheme)
437 {
438 NL_PS_FUNC(CPSEmitter_setGenNbScheme)
439 delete _GenNbScheme;
440 _GenNbScheme = scheme;
441 if (_Owner && scheme->hasMemory()) scheme->resize(_Owner->getMaxSize(), _Owner->getSize());
442 }
443
444 ///==========================================================================
445 void CPSEmitter::showTool(void)
446 {
447 NL_PS_FUNC(CPSEmitter_showTool)
448 uint32 size = _Owner->getSize();
449 if (!size) return;
450 setupDriverModelMatrix();
451
452 const CVector I = computeI();
453 const CVector K = computeK();
454
455 // ugly slow code, but not for runtime
456 for (uint k = 0; k < size; ++k)
457 {
458 // center of the current particle
459 const CVector p = _Owner->getPos()[k];
460 const float sSize =0.1f;
461 std::vector<NLMISC::CLine> lines;
462 NLMISC::CLine l;
463 l.V0 = p - sSize * I; l.V1 = p + sSize * I; lines.push_back(l);
464 l.V0 = p - sSize * K; l.V1 = p + sSize * K; lines.push_back(l);
465 l.V0 = p - sSize * (I + K); l.V1 = p + sSize * (I + K); lines.push_back(l);
466 l.V0 = p - sSize * (I - K); l.V1 = p + sSize * (I - K); lines.push_back(l);
467
468 CMaterial mat;
469 mat.setBlendFunc(CMaterial::one, CMaterial::one);
470 mat.setZWrite(false);
471 mat.setLighting(false);
472 mat.setBlend(true);
473 mat.setZFunc(CMaterial::less);
474
475
476 CPSLocated *loc;
477 uint32 index;
478 CPSLocatedBindable *lb;
479 _Owner->getOwner()->getCurrentEditedElement(loc, index, lb);
480
481 mat.setColor((lb == NULL || this == lb) && loc == _Owner && index == k ? CRGBA::Red : CRGBA(127, 127, 127));
482
483
484 CDRU::drawLinesUnlit(lines, mat, *getDriver() );
485 }
486 }
487
488 ///==========================================================================
489 void CPSEmitter::singleEmit(uint32 index, uint quantity)
490 {
491 NL_PS_FUNC(CPSEmitter_singleEmit)
492 nlassert(_Owner);
493 const uint32 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner,0) : _GenNb;
494 processEmitOutsideSimLoop(index, quantity * nbToGenerate);
495 }
496
497
498
499 ///==========================================================================
500 void CPSEmitter::processRegularEmissionWithNoLOD(uint firstInstanceIndex)
501 {
502 NL_PS_FUNC(CPSEmitter_processRegularEmissionWithNoLOD)
503 nlassert(_Owner);
504 nlassert(_Owner->getOwner());
505 //
506 const bool emitThreshold = _Owner->getOwner()->isEmitThresholdEnabled();
507 //
508 const uint size = _Owner->getSize();
509 nlassert(firstInstanceIndex < size);
510 uint leftToDo = size - firstInstanceIndex, toProcess;
511 float emitPeriod[EMITTER_BUFF_SIZE];
512 const float *currEmitPeriod;
513 uint currEmitPeriodPtrInc = _PeriodScheme ? 1 : 0;
514 sint32 nbToGenerate;
515
516 TPSAttribTime::iterator phaseIt = _Phase.begin() + firstInstanceIndex, endPhaseIt;
517 TPSAttribUInt8::iterator numEmitIt = _NumEmission.begin() + firstInstanceIndex;
518
519 // we don't use an iterator here
520 // because it could be invalidated if size change (a located could generate itself)
521 do
522 {
523 toProcess = leftToDo < EMITTER_BUFF_SIZE ? leftToDo : EMITTER_BUFF_SIZE;
524
525
526 if (_PeriodScheme)
527 {
528 // compute period
529 // NB : we ask to clamp entry because life counter of emitter are incremented, then spawn is called, and only after that dead emitters are removed
530 // so we may have a life counter that is > to 1
531 currEmitPeriod = (float *) (_PeriodScheme->make(_Owner, size - leftToDo, emitPeriod, sizeof(float), toProcess, true, 1 << 16, true));
532 if (emitThreshold)
533 {
534
535 /** Test if 'make' filled our buffer. If this is not the case, we assume that values where precomputed, and that
536 * all null period have already been replaced by the threshold
537 */
538 if (currEmitPeriod == emitPeriod)
539 {
540 // if there possibility to have 0 in the scheme ?
541 if (_PeriodScheme->getMinValue() <= 0.f && _PeriodScheme->getMaxValue() >= 0.f)
542 {
543 replaceNullPeriodsByThreshold(emitPeriod, toProcess);
544 }
545 }
546 }
547 }
548 else
549 {
550 if (_Period != 0.f || !emitThreshold)
551 {
552 currEmitPeriod = &_Period;
553 }
554 else
555 {
556 currEmitPeriod = &EMIT_PERIOD_THRESHOLD;
557 }
558 }
559
560 endPhaseIt = phaseIt + toProcess;
561
562 if (_MaxEmissionCount == 0) // no emission count limit
563 {
564 /// is there an emission delay ?
565 if (_EmitDelay == 0.f) // no emission delay
566 {
567 do
568 {
569 *phaseIt += CParticleSystem::EllapsedTime;
570 if ( *phaseIt >= *currEmitPeriod) // phase is greater than period -> must emit
571 {
572 if (*currEmitPeriod != 0)
573 {
574 *phaseIt -= ::floorf(*phaseIt / *currEmitPeriod) * *currEmitPeriod;
575 }
576 const uint32 k = (uint32)(phaseIt - _Phase.begin());
577 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, k) : _GenNb;
578 processEmit(k, nbToGenerate);
579 }
580
581 ++phaseIt;
582 currEmitPeriod += currEmitPeriodPtrInc;
583 }
584 while (phaseIt != endPhaseIt);
585 }
586 else // there's an emission delay
587 {
588 do
589 {
590 *phaseIt += CParticleSystem::EllapsedTime;
591 if ( *phaseIt >= *currEmitPeriod + _EmitDelay) // phase is greater than period -> must emit
592 {
593 if (*currEmitPeriod != 0)
594 {
595 *phaseIt -= ::floorf((*phaseIt - _EmitDelay) / *currEmitPeriod) * *currEmitPeriod;
596 }
597 const uint32 k = (uint32)(phaseIt - _Phase.begin());
598 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, k) : _GenNb;
599 processEmit(k, nbToGenerate);
600 }
601
602 ++phaseIt;
603 currEmitPeriod += currEmitPeriodPtrInc;
604 }
605 while (phaseIt != endPhaseIt);
606 }
607 }
608 else // there's an emission count limit
609 {
610 /// is there an emission delay ?
611 if (_EmitDelay == 0.f) // no emission delay
612 {
613 do
614 {
615 if (*numEmitIt < _MaxEmissionCount)
616 {
617 *phaseIt += CParticleSystem::EllapsedTime;
618 if ( *phaseIt >= *currEmitPeriod) // phase is greater than period -> must emit
619 {
620 if (*currEmitPeriod != 0)
621 {
622 *phaseIt -= ::floorf(*phaseIt / *currEmitPeriod) * *currEmitPeriod;
623 }
624 const uint32 k = (uint32)(phaseIt - _Phase.begin());
625 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, k) : _GenNb;
626 processEmit(k, nbToGenerate);
627 ++*numEmitIt;
628 }
629 }
630 ++phaseIt;
631 currEmitPeriod += currEmitPeriodPtrInc;
632 ++ numEmitIt;
633 }
634 while (phaseIt != endPhaseIt);
635 }
636 else // there's an emission delay
637 {
638 do
639 {
640 if (*numEmitIt < _MaxEmissionCount)
641 {
642 *phaseIt += CParticleSystem::EllapsedTime;
643 if ( *phaseIt >= *currEmitPeriod + _EmitDelay) // phase is greater than period -> must emit
644 {
645 if (*currEmitPeriod != 0)
646 {
647 *phaseIt -= ::floorf((*phaseIt - _EmitDelay) / *currEmitPeriod) * *currEmitPeriod;
648 }
649 const uint32 k = (uint32)(phaseIt - _Phase.begin());
650 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, k) : _GenNb;
651 processEmit(k, nbToGenerate);
652 ++*numEmitIt;
653 }
654 }
655 ++phaseIt;
656 currEmitPeriod += currEmitPeriodPtrInc;
657 ++numEmitIt;
658 }
659 while (phaseIt != endPhaseIt);
660 }
661 }
662
663 leftToDo -= toProcess;
664 }
665 while (leftToDo);
666 }
667
668
669 ///==========================================================================
670 void CPSEmitter::processRegularEmission(uint firstInstanceIndex, float emitLOD)
671 {
672 NL_PS_FUNC(CPSEmitter_processRegularEmission)
673 nlassert(_Owner);
674 nlassert(_Owner->getOwner());
675 //
676 const bool emitThreshold = _Owner->getOwner()->isEmitThresholdEnabled();
677 //
678 const uint size = _Owner->getSize();
679 nlassert(firstInstanceIndex < size);
680 uint leftToDo = size - firstInstanceIndex, toProcess;
681 float emitPeriod[EMITTER_BUFF_SIZE];
682 const float *currEmitPeriod;
683 uint currEmitPeriodPtrInc = _PeriodScheme ? 1 : 0;
684 sint32 nbToGenerate;
685
686 TPSAttribTime::iterator phaseIt = _Phase.begin() + firstInstanceIndex, endPhaseIt;
687 TPSAttribUInt8::iterator numEmitIt = _NumEmission.begin() + firstInstanceIndex;
688
689 float ellapsedTimeLOD = emitLOD * CParticleSystem::EllapsedTime;
690 uint maxEmissionCountLOD = (uint8) (_MaxEmissionCount * emitLOD);
691 maxEmissionCountLOD = std::max(1u, maxEmissionCountLOD);
692
693 // we don't use an iterator here
694 // because it could be invalidated if size change (a located could generate itself)
695 do
696 {
697 toProcess = leftToDo < EMITTER_BUFF_SIZE ? leftToDo : EMITTER_BUFF_SIZE;
698
699
700 if (_PeriodScheme)
701 {
702 // compute period
703 // NB : we ask to clamp entry because life counter of emitter are incremented, then spawn is called, and only after that dead emitters are removed
704 // so we may have a life counter that is > to 1
705 currEmitPeriod = (float *) (_PeriodScheme->make(_Owner, size - leftToDo, emitPeriod, sizeof(float), toProcess, true, 1 << 16, true));
706 if (emitThreshold)
707 {
708
709 /** Test if 'make' filled our buffer. If this is not the case, we assume that values where precomputed, and that
710 * all null period have already been replaced by the threshold
711 */
712 if (currEmitPeriod == emitPeriod)
713 {
714 // if there possibility to have 0 in the scheme ?
715 if (_PeriodScheme->getMinValue() <= 0.f && _PeriodScheme->getMaxValue() >= 0.f)
716 {
717 replaceNullPeriodsByThreshold(emitPeriod, toProcess);
718 }
719 }
720 }
721 }
722 else
723 {
724 if (_Period != 0.f || !emitThreshold)
725 {
726 currEmitPeriod = &_Period;
727 }
728 else
729 {
730 currEmitPeriod = &EMIT_PERIOD_THRESHOLD;
731 }
732 }
733
734 endPhaseIt = phaseIt + toProcess;
735
736 if (_MaxEmissionCount == 0) // no emission count limit
737 {
738 /// is there an emission delay ?
739 if (_EmitDelay == 0.f) // no emission delay
740 {
741 do
742 {
743 *phaseIt += ellapsedTimeLOD;
744 if ( *phaseIt >= *currEmitPeriod) // phase is greater than period -> must emit
745 {
746 if (*currEmitPeriod != 0)
747 {
748 *phaseIt -= ::floorf(*phaseIt / *currEmitPeriod) * *currEmitPeriod;
749 }
750 const uint32 k = (uint32)(phaseIt - _Phase.begin());
751 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, k) : _GenNb;
752 if (nbToGenerate)
753 {
754 nbToGenerate = (sint32) (emitLOD * nbToGenerate);
755 if (!nbToGenerate) nbToGenerate = 1;
756 processEmit(k, nbToGenerate);
757 }
758 }
759
760 ++phaseIt;
761 currEmitPeriod += currEmitPeriodPtrInc;
762 }
763 while (phaseIt != endPhaseIt);
764 }
765 else // there's an emission delay
766 {
767 do
768 {
769 if (*phaseIt < _EmitDelay)
770 {
771 *phaseIt += CParticleSystem::EllapsedTime;
772 if (*phaseIt < _EmitDelay)
773 {
774 ++phaseIt;
775 currEmitPeriod += currEmitPeriodPtrInc;
776 continue;
777 }
778 else
779 {
780 *phaseIt = (*phaseIt - _EmitDelay) * emitLOD + _EmitDelay;
781 }
782 }
783 else
784 {
785 *phaseIt += ellapsedTimeLOD;
786 }
787
788 if ( *phaseIt >= *currEmitPeriod + _EmitDelay) // phase is greater than period -> must emit
789 {
790 if (*currEmitPeriod != 0)
791 {
792 *phaseIt -= ::floorf((*phaseIt - _EmitDelay) / *currEmitPeriod) * *currEmitPeriod;
793 }
794 const uint32 k = (uint32)(phaseIt - _Phase.begin());
795 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, k) : _GenNb;
796 if (nbToGenerate)
797 {
798 nbToGenerate = (sint32) (emitLOD * nbToGenerate);
799 if (!nbToGenerate) nbToGenerate = 1;
800 processEmit(k, nbToGenerate);
801 }
802 }
803
804 ++phaseIt;
805 currEmitPeriod += currEmitPeriodPtrInc;
806 }
807 while (phaseIt != endPhaseIt);
808 }
809 }
810 else // there's an emission count limit
811 {
812 /// is there an emission delay ?
813 if (_EmitDelay == 0.f) // no emission delay
814 {
815 do
816 {
817 if (*numEmitIt < maxEmissionCountLOD)
818 {
819 *phaseIt += ellapsedTimeLOD;
820 if ( *phaseIt >= *currEmitPeriod) // phase is greater than period -> must emit
821 {
822 if (*currEmitPeriod != 0)
823 {
824 *phaseIt -= ::floorf(*phaseIt / *currEmitPeriod) * *currEmitPeriod;
825 }
826 const uint32 k = (uint32)(phaseIt - _Phase.begin());
827 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, k) : _GenNb;
828 if (nbToGenerate)
829 {
830 nbToGenerate = (sint32) (emitLOD * nbToGenerate);
831 if (!nbToGenerate) nbToGenerate = 1;
832 processEmit(k, nbToGenerate);
833 }
834 ++*numEmitIt;
835 }
836 }
837 else
838 {
839 *numEmitIt = _MaxEmissionCount;
840 }
841 ++phaseIt;
842 currEmitPeriod += currEmitPeriodPtrInc;
843 ++ numEmitIt;
844 }
845 while (phaseIt != endPhaseIt);
846 }
847 else // there's an emission delay
848 {
849 do
850 {
851 if (*numEmitIt < maxEmissionCountLOD)
852 {
853 if (*phaseIt < _EmitDelay)
854 {
855 *phaseIt += CParticleSystem::EllapsedTime;
856 if (*phaseIt < _EmitDelay)
857 {
858 ++phaseIt;
859 currEmitPeriod += currEmitPeriodPtrInc;
860 ++numEmitIt;
861 currEmitPeriod += currEmitPeriodPtrInc;
862 continue;
863 }
864 else
865 {
866 *phaseIt = (*phaseIt - _EmitDelay) * emitLOD + _EmitDelay;
867 }
868 }
869 else
870 {
871 *phaseIt += ellapsedTimeLOD;
872 }
873
874 if ( *phaseIt >= *currEmitPeriod + _EmitDelay) // phase is greater than period -> must emit
875 {
876 if (*currEmitPeriod != 0)
877 {
878 *phaseIt -= ::floorf((*phaseIt - _EmitDelay) / *currEmitPeriod) * *currEmitPeriod;
879 }
880 const uint32 k = (uint32)(phaseIt - _Phase.begin());
881 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, k) : _GenNb;
882 if (nbToGenerate)
883 {
884 nbToGenerate = (sint32) (nbToGenerate * emitLOD);
885 if (!nbToGenerate) nbToGenerate = 1;
886 processEmit(k, nbToGenerate);
887 }
888 ++*numEmitIt;
889 }
890 }
891 else
892 {
893 *numEmitIt = _MaxEmissionCount;
894 }
895 ++phaseIt;
896 currEmitPeriod += currEmitPeriodPtrInc;
897 ++numEmitIt;
898 }
899 while (phaseIt != endPhaseIt);
900 }
901 }
902
903 leftToDo -= toProcess;
904 }
905 while (leftToDo);
906 }
907
908 /// private : generate the various position of an emitter in the given tab for the given slice of time,
909 // depending on whether its motion is parametric or incremental. This is used to create emittees at the right position
910
911 static
912 #ifndef NL_DEBUG
913 inline
914 #endif
915 uint GenEmitterPositions(CPSLocated *emitter,
916 CPSLocated *emittee,
917 uint emitterIndex,
918 uint numStep,
919 TAnimationTime deltaT, /* fraction of time needed to reach the first emission */
920 TAnimationTime step,
921 std::vector<NLMISC::CVector> &dest
922 )
923 {
924 NL_PS_FUNC(GenEmitterPositions)
925 const uint toProcess = std::max(1U, std::min(numStep, (uint) emittee->getMaxSize()));
926 dest.resize(toProcess);
927
928
929 if (!emitter->isParametricMotionEnabled()) // standard case : take current pos and integrate
930 {
931 if (toProcess == 1) // only one emission -> takes current pos
932 {
933 dest[0] = emitter->getPos()[emitterIndex] - deltaT * emitter->getSpeed()[emitterIndex];
934 }
935 else
936 {
937 std::vector<NLMISC::CVector>::iterator outIt = dest.end();
938 std::vector<NLMISC::CVector>::iterator endIt = dest.begin();
939 NLMISC::CVector pos = emitter->getPos()[emitterIndex] - deltaT * emitter->getSpeed()[emitterIndex];
940 NLMISC::CVector speed = step * emitter->getSpeed()[emitterIndex];
941 do
942 {
943 -- outIt;
944 *outIt = pos;
945 pos -= speed;
946 }
947 while (outIt != endIt);
948 }
949 }
950 else // compute parametric trajectory
951 {
952 emitter->integrateSingle(emitter->getOwner()->getSystemDate() + CParticleSystem::RealEllapsedTime - deltaT,
953 -step,
954 toProcess,
955 emitterIndex,
956 &dest[0]
957 );
958 }
959
960 return toProcess;
961 }
962
963
964 /** The same as GenEmitterPositions, but with LOD taken in account.
965 */
966 static inline uint GenEmitterPositionsWithLOD(CPSLocated *emitter,
967 CPSLocated *emittee,
968 uint emitterIndex,
969 uint numStep,
970 TAnimationTime deltaT, /* fraction of time needed to reach the first emission */
971 TAnimationTime step,
972 float invLODRatio,
973 std::vector<NLMISC::CVector> &dest
974 )
975 {
976 NL_PS_FUNC(GenEmitterPositionsWithLOD)
977 const uint toProcess = std::max(1U, std::min(numStep, (uint) emittee->getMaxSize()));
978 dest.resize(toProcess);
979
980
981 if (!emitter->isParametricMotionEnabled()) // standard case : take current pos and integrate
982 {
983 if (toProcess == 1) // only one emission -> takes current pos
984 {
985 dest[0] = emitter->getPos()[emitterIndex] - deltaT * emitter->getSpeed()[emitterIndex];
986 }
987 else
988 {
989 std::vector<NLMISC::CVector>::iterator outIt = dest.end();
990 std::vector<NLMISC::CVector>::iterator endIt = dest.begin();
991 NLMISC::CVector pos = emitter->getPos()[emitterIndex] - deltaT * emitter->getSpeed()[emitterIndex];
992 NLMISC::CVector speed = step * invLODRatio * emitter->getSpeed()[emitterIndex];
993 do
994 {
995 -- outIt;
996 *outIt = pos;
997 pos -= speed;
998 }
999 while (outIt != endIt);
1000 }
1001 }
1002 else // compute parametric trajectory
1003 {
1004 emitter->integrateSingle(emitter->getOwner()->getSystemDate() - deltaT - step * toProcess,
1005 step,
1006 toProcess,
1007 emitterIndex,
1008 &dest[0]
1009 );
1010 }
1011
1012 return toProcess;
1013 }
1014
1015 ///==========================================================================
1016 void CPSEmitter::processRegularEmissionConsistent(uint firstInstanceIndex, float emitLOD, float inverseEmitLOD)
1017 {
1018 NL_PS_FUNC(CPSEmitter_processRegularEmissionConsistent)
1019 /// hmm some code factorisation would do no harm, but we want to keep tests outside the loops as much as possible...
1020
1021 nlassert(_Owner);
1022 nlassert(_Owner->getOwner());
1023 //
1024 const bool emitThreshold = _Owner->getOwner()->isEmitThresholdEnabled();
1025 //
1026
1027
1028 static std::vector<NLMISC::CVector> emitterPositions;
1029 // Positions for the emitter. They are computed by using a parametric trajectory or by using integration
1030
1031 const uint size = _Owner->getSize();
1032 nlassert(firstInstanceIndex < size);
1033 uint leftToDo = size - firstInstanceIndex, toProcess;
1034 float emitPeriod[EMITTER_BUFF_SIZE];
1035 const float *currEmitPeriod;
1036 uint currEmitPeriodPtrInc = _PeriodScheme ? 1 : 0;
1037 sint32 nbToGenerate;
1038
1039
1040 TPSAttribTime::iterator phaseIt = _Phase.begin() + firstInstanceIndex, endPhaseIt;
1041 TPSAttribUInt8::iterator numEmitIt;
1042 if(firstInstanceIndex < _NumEmission.getSize())
1043 {
1044 numEmitIt = _NumEmission.begin() + firstInstanceIndex;
1045 }
1046 else
1047 {
1048 numEmitIt = _NumEmission.end();
1049 }
1050
1051
1052 float ellapsedTimeLOD = CParticleSystem::EllapsedTime * emitLOD;
1053 uint maxEmissionCountLOD = (uint8) (_MaxEmissionCount * emitLOD);
1054 maxEmissionCountLOD = std::max(1u, maxEmissionCountLOD);
1055 // we don't use an iterator here
1056 // because it could be invalidated if size change (a located could generate itself)
1057 do
1058 {
1059 toProcess = leftToDo < EMITTER_BUFF_SIZE ? leftToDo : EMITTER_BUFF_SIZE;
1060
1061
1062 if (_PeriodScheme)
1063 {
1064 // compute period
1065 // NB : we ask to clamp entry because life counter of emitter are incremented, then spawn is called, and only after that dead emitters are removed
1066 // so we may have a life counter that is > to 1
1067 currEmitPeriod = (float *) (_PeriodScheme->make(_Owner, size - leftToDo, emitPeriod, sizeof(float), toProcess, true, 1 << 16, true));
1068 if (emitThreshold)
1069 {
1070
1071 /** Test if 'make' filled our buffer. If this is not the case, we assume that values where precomputed, and that
1072 * all null period have already been replaced by the threshold
1073 */
1074 if (currEmitPeriod == emitPeriod)
1075 {
1076 // if there possibility to have 0 in the scheme ?
1077 if (_PeriodScheme->getMinValue() <= 0.f && _PeriodScheme->getMaxValue() >= 0.f)
1078 {
1079 replaceNullPeriodsByThreshold(emitPeriod, toProcess);
1080 }
1081 }
1082 }
1083 }
1084 else
1085 {
1086 if (_Period != 0.f || !emitThreshold)
1087 {
1088 currEmitPeriod = &_Period;
1089 }
1090 else
1091 {
1092 currEmitPeriod = &EMIT_PERIOD_THRESHOLD;
1093 }
1094 }
1095
1096 endPhaseIt = phaseIt + toProcess;
1097
1098 if (_MaxEmissionCount == 0) // no emission count limit
1099 {
1100 /// is there an emission delay ?
1101 if (_EmitDelay == 0.f) // no emission delay
1102 {
1103 do
1104 {
1105 *phaseIt += ellapsedTimeLOD;
1106 if ( *phaseIt >= *currEmitPeriod) // phase is greater than period -> must emit
1107 {
1108 if (*currEmitPeriod != 0)
1109 {
1110 /** Must ensure phase is valid if period decrease over time
1111 */
1112 *phaseIt = std::min(*phaseIt, *currEmitPeriod + ellapsedTimeLOD);
1113 //
1114 /// compute the number of emissions
1115 uint numEmissions = (uint) ::floorf(*phaseIt / *currEmitPeriod);
1116 *phaseIt -= *currEmitPeriod * numEmissions;
1117
1118 uint emitterIndex = (uint)(phaseIt - _Phase.begin());
1119 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, emitterIndex) : _GenNb;
1120 if (nbToGenerate)
1121 {
1122 float deltaT = std::max(0.f, *phaseIt);
1123
1124 /// compute the position of the emitter for the needed dates
1125 numEmissions = GenEmitterPositionsWithLOD(_Owner,
1126 _EmittedType,
1127 emitterIndex,
1128 numEmissions,
1129 deltaT,
1130 *currEmitPeriod,
1131 inverseEmitLOD,
1132 emitterPositions
1133 );
1134
1135 /// process each emission at the right pos at the right date
1136 nbToGenerate = (sint32) (emitLOD * nbToGenerate);
1137 if (!nbToGenerate) nbToGenerate = 1;
1138 uint k = numEmissions;
1139 float deltaTInc = *currEmitPeriod * inverseEmitLOD;
1140 do
1141 {
1142 --k;
1143 processEmitConsistent(emitterPositions[k],
1144 emitterIndex,
1145 nbToGenerate,
1146 deltaT
1147 );
1148 deltaT += deltaTInc;
1149 }
1150 while (k);
1151 }
1152 }
1153 else
1154 {
1155 const uint32 emitterIndex = (uint32)(phaseIt - _Phase.begin());
1156 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, emitterIndex) : _GenNb;
1157 if (nbToGenerate)
1158 {
1159 nbToGenerate = (sint32) (emitLOD * nbToGenerate);
1160 if (!nbToGenerate) nbToGenerate = 1;
1161 processEmit(emitterIndex, nbToGenerate);
1162 }
1163 }
1164 }
1165
1166 ++phaseIt;
1167 currEmitPeriod += currEmitPeriodPtrInc;
1168 }
1169 while (phaseIt != endPhaseIt);
1170 }
1171 else // thhere's an emission delay
1172 {
1173 do
1174 {
1175 if (*phaseIt < _EmitDelay)
1176 {
1177 *phaseIt += CParticleSystem::EllapsedTime;
1178 if (*phaseIt < _EmitDelay)
1179 {
1180 ++phaseIt;
1181 currEmitPeriod += currEmitPeriodPtrInc;
1182 continue;
1183 }
1184 else
1185 {
1186 *phaseIt = (*phaseIt - _EmitDelay) * emitLOD + _EmitDelay;
1187 }
1188 }
1189 else
1190 {
1191 *phaseIt += ellapsedTimeLOD;
1192 }
1193
1194 if ( *phaseIt >= *currEmitPeriod + _EmitDelay) // phase is greater than period -> must emit
1195 {
1196 if (*currEmitPeriod != 0)
1197 {
1198 /** Must ensure phase is valid if period decrease over time
1199 */
1200 *phaseIt = std::min(*phaseIt, *currEmitPeriod + ellapsedTimeLOD + _EmitDelay);
1201 //
1202 uint numEmissions = (uint) ::floorf((*phaseIt - _EmitDelay) / *currEmitPeriod);
1203 *phaseIt -= *currEmitPeriod * numEmissions;
1204 float deltaT = std::max(*phaseIt - _EmitDelay, 0.f);
1205 //nlassert(deltaT >= 0.f);
1206 /// process each emission at the right pos at the right date
1207 uint emitterIndex = (uint)(phaseIt - _Phase.begin());
1208 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, emitterIndex) : _GenNb;
1209 if (nbToGenerate)
1210 {
1211
1212 /// compute the position of the emitter for the needed date
1213 numEmissions = GenEmitterPositionsWithLOD( _Owner,
1214 _EmittedType,
1215 emitterIndex,
1216 numEmissions,
1217 deltaT,
1218 *currEmitPeriod,
1219 inverseEmitLOD,
1220 emitterPositions
1221 );
1222
1223 nbToGenerate = (sint32) (emitLOD * nbToGenerate);
1224 if (!nbToGenerate) nbToGenerate = 1;
1225 uint k = numEmissions;
1226 float deltaTInc = *currEmitPeriod * inverseEmitLOD;
1227 do
1228 {
1229 --k;
1230 processEmitConsistent(emitterPositions[k],
1231 emitterIndex,
1232 nbToGenerate,
1233 deltaT);
1234 deltaT += deltaTInc;
1235 }
1236 while (k);
1237 }
1238 }
1239 else
1240 {
1241 const uint32 emitterIndex = (uint32)(phaseIt - _Phase.begin());
1242 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, emitterIndex) : _GenNb;
1243 if (nbToGenerate)
1244 {
1245 nbToGenerate = (sint32) (emitLOD * nbToGenerate);
1246 if (!nbToGenerate) nbToGenerate = 1;
1247 processEmit(emitterIndex, nbToGenerate);
1248 }
1249 }
1250 }
1251
1252 ++phaseIt;
1253 currEmitPeriod += currEmitPeriodPtrInc;
1254 }
1255 while (phaseIt != endPhaseIt);
1256 }
1257 }
1258 else // there's an emission count limit
1259 {
1260 /// is there an emission delay ?
1261 if (_EmitDelay == 0.f) // no emission delay
1262 {
1263 do
1264 {
1265 if (*numEmitIt < maxEmissionCountLOD)
1266 {
1267 *phaseIt += ellapsedTimeLOD;
1268 if ( *phaseIt >= *currEmitPeriod) // phase is greater than period -> must emit
1269 {
1270 if (*currEmitPeriod != 0)
1271 {
1272 /** Must ensure phase is valid if period decrease over time
1273 */
1274 *phaseIt = std::min(*phaseIt, *currEmitPeriod + ellapsedTimeLOD);
1275 //
1276 uint numEmissions = (uint) ::floorf(*phaseIt / *currEmitPeriod);
1277 *numEmitIt += numEmissions;
1278 *phaseIt -= *currEmitPeriod * numEmissions;
1279 float deltaT = std::max(*phaseIt, 0.f);
1280 //nlassert(deltaT >= 0.f);
1281 uint emitterIndex = (uint)(phaseIt - _Phase.begin());
1282 if (*numEmitIt > _MaxEmissionCount) // make sure we don't go over the emission limit
1283 {
1284 numEmissions -= *numEmitIt - _MaxEmissionCount;
1285 *numEmitIt = _MaxEmissionCount;
1286 }
1287 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, emitterIndex) : _GenNb;
1288 if (nbToGenerate)
1289 {
1290 /// compute the position of the emitter for the needed date
1291 numEmissions = GenEmitterPositionsWithLOD(_Owner,
1292 _EmittedType,
1293 emitterIndex,
1294 numEmissions,
1295 deltaT,
1296 *currEmitPeriod,
1297 inverseEmitLOD,
1298 emitterPositions
1299 );
1300 uint k = numEmissions;
1301 /// process each emission at the right pos at the right date
1302 nbToGenerate = (sint32) (emitLOD * nbToGenerate);
1303 if (!nbToGenerate) nbToGenerate = 1;
1304 float deltaTInc = *currEmitPeriod * inverseEmitLOD;
1305 do
1306 {
1307 --k;
1308 processEmitConsistent(emitterPositions[k],
1309 emitterIndex,
1310 nbToGenerate,
1311 deltaT
1312 );
1313 deltaT += deltaTInc;
1314 }
1315 while (k);
1316 }
1317 }
1318 else
1319 {
1320 const uint32 emitterIndex = (uint32)(phaseIt - _Phase.begin());
1321 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, emitterIndex) : _GenNb;
1322 if (nbToGenerate)
1323 {
1324 nbToGenerate = (sint32) (emitLOD * nbToGenerate);
1325 if (!nbToGenerate) nbToGenerate = 1;
1326 processEmit(emitterIndex, nbToGenerate);
1327 ++*numEmitIt;
1328 }
1329 }
1330 }
1331 }
1332 else
1333 {
1334 *numEmitIt = _MaxEmissionCount; // if the lod change, must ensure that the
1335 }
1336 ++phaseIt;
1337 currEmitPeriod += currEmitPeriodPtrInc;
1338 ++ numEmitIt;
1339 }
1340 while (phaseIt != endPhaseIt);
1341 }
1342 else // there's an emission delay
1343 {
1344 do
1345 {
1346 if (*numEmitIt < maxEmissionCountLOD)
1347 {
1348 if (*phaseIt < _EmitDelay)
1349 {
1350 *phaseIt += CParticleSystem::EllapsedTime;
1351 if (*phaseIt < _EmitDelay)
1352 {
1353 ++phaseIt;
1354 currEmitPeriod += currEmitPeriodPtrInc;
1355 ++numEmitIt;
1356 continue;
1357 }
1358 else
1359 {
1360 *phaseIt = (*phaseIt - _EmitDelay) * emitLOD + _EmitDelay;
1361 }
1362 }
1363 else
1364 {
1365 *phaseIt += ellapsedTimeLOD;
1366 }
1367 //
1368 if ( *phaseIt >= *currEmitPeriod + _EmitDelay) // phase is greater than period -> must emit
1369 {
1370 if (*currEmitPeriod != 0)
1371 {
1372 /** Must ensure phase is valid if period decrease over time
1373 */
1374 *phaseIt = std::min(*phaseIt, *currEmitPeriod + ellapsedTimeLOD + _EmitDelay);
1375 //
1376 uint numEmissions = (uint) ::floorf((*phaseIt - _EmitDelay) / *currEmitPeriod);
1377 *numEmitIt += numEmissions;
1378 *phaseIt -= *currEmitPeriod * numEmissions;
1379 float deltaT = std::max(*phaseIt - _EmitDelay, 0.f);
1380 //nlassert(deltaT >= 0.f);
1381 uint emitterIndex = (uint)(phaseIt - _Phase.begin());
1382 if (*numEmitIt > _MaxEmissionCount) // make sure we don't go over the emission limit
1383 {
1384 numEmissions -= *numEmitIt - _MaxEmissionCount;
1385 *numEmitIt = _MaxEmissionCount;
1386 }
1387 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, emitterIndex) : _GenNb;
1388 if (nbToGenerate)
1389 {
1390 /// compute the position of the emitter for the needed date
1391 numEmissions = GenEmitterPositionsWithLOD(_Owner,
1392 _EmittedType,
1393 emitterIndex,
1394 numEmissions,
1395 deltaT,
1396 *currEmitPeriod,
1397 inverseEmitLOD,
1398 emitterPositions
1399 );
1400 uint k = numEmissions;
1401 /// process each emission at the right pos at the right date
1402 nbToGenerate = (sint32) (emitLOD * nbToGenerate);
1403 if (!nbToGenerate) nbToGenerate = 1;
1404 float deltaTInc = *currEmitPeriod * inverseEmitLOD;
1405 do
1406 {
1407 --k;
1408 processEmitConsistent(emitterPositions[k],
1409 emitterIndex,
1410 nbToGenerate,
1411 deltaT);
1412 deltaT += deltaTInc;
1413 }
1414 while (k);
1415 }
1416 }
1417 else
1418 {
1419 const uint32 emitterIndex = (uint32)(phaseIt - _Phase.begin());
1420 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, emitterIndex) : _GenNb;
1421 if (nbToGenerate)
1422 {
1423 nbToGenerate = (sint32) (emitLOD * nbToGenerate);
1424 if (!nbToGenerate) nbToGenerate = 1;
1425 processEmit(emitterIndex, nbToGenerate);
1426 ++*numEmitIt;
1427 }
1428 }
1429 }
1430 }
1431 else
1432 {
1433 *numEmitIt = _MaxEmissionCount; // if the lod change, must ensure that the
1434 }
1435 ++phaseIt;
1436 currEmitPeriod += currEmitPeriodPtrInc;
1437 ++numEmitIt;
1438 }
1439 while (phaseIt != endPhaseIt);
1440 }
1441 }
1442
1443 leftToDo -= toProcess;
1444 }
1445 while (leftToDo);
1446 }
1447
1448 ///==========================================================================
1449 void CPSEmitter::processRegularEmissionConsistentWithNoLOD(uint firstInstanceIndex)
1450 {
1451 NL_PS_FUNC(CPSEmitter_processRegularEmissionConsistentWithNoLOD)
1452 /// hum, some code factorization would do no harm, but we want to keep tests outside the loops as much as possible...
1453
1454 nlassert(_Owner);
1455 nlassert(_Owner->getOwner());
1456 //
1457 const bool emitThreshold = _Owner->getOwner()->isEmitThresholdEnabled();
1458 //
1459
1460
1461 static std::vector<NLMISC::CVector> emitterPositions;
1462 // Positions for the emitter. They are computed by using a parametric trajectory or by using integration
1463
1464 const uint size = _Owner->getSize();
1465 nlassert(firstInstanceIndex < size);
1466 uint leftToDo = size - firstInstanceIndex, toProcess;
1467 float emitPeriod[EMITTER_BUFF_SIZE];
1468 const float *currEmitPeriod;
1469 uint currEmitPeriodPtrInc = _PeriodScheme ? 1 : 0;
1470 sint32 nbToGenerate;
1471
1472
1473 TPSAttribTime::iterator phaseIt = _Phase.begin() + firstInstanceIndex, endPhaseIt;
1474 TPSAttribUInt8::iterator numEmitIt;
1475 if (firstInstanceIndex < _NumEmission.getSize())
1476 numEmitIt = _NumEmission.begin() + firstInstanceIndex;
1477 else
1478 numEmitIt = _NumEmission.end();
1479 do
1480 {
1481 toProcess = leftToDo < EMITTER_BUFF_SIZE ? leftToDo : EMITTER_BUFF_SIZE;
1482
1483
1484 if (_PeriodScheme)
1485 {
1486 // compute period
1487 // NB : we ask to clamp entry because life counter of emitter are incremented, then spawn is called, and only after that dead emitters are removed
1488 // so we may have a life counter that is > to 1
1489 currEmitPeriod = (float *) (_PeriodScheme->make(_Owner, size - leftToDo, emitPeriod, sizeof(float), toProcess, true, 1 << 16, true));
1490 if (emitThreshold)
1491 {
1492
1493 /** Test if 'make' filled our buffer. If this is not the case, we assume that values where precomputed, and that
1494 * all null period have already been replaced by the threshold
1495 */
1496 if (currEmitPeriod == emitPeriod)
1497 {
1498 // if there possibility to have 0 in the scheme ?
1499 if (_PeriodScheme->getMinValue() <= 0.f && _PeriodScheme->getMaxValue() >= 0.f)
1500 {
1501 replaceNullPeriodsByThreshold(emitPeriod, toProcess);
1502 }
1503 }
1504 }
1505 }
1506 else
1507 {
1508 if (_Period != 0.f || !emitThreshold)
1509 {
1510 currEmitPeriod = &_Period;
1511 }
1512 else
1513 {
1514 currEmitPeriod = &EMIT_PERIOD_THRESHOLD;
1515 }
1516 }
1517
1518 endPhaseIt = phaseIt + toProcess;
1519
1520 if (_MaxEmissionCount == 0) // no emission count limit
1521 {
1522 /// is there an emission delay ?
1523 if (_EmitDelay == 0.f) // no emission delay
1524 {
1525 do
1526 {
1527 *phaseIt += CParticleSystem::EllapsedTime;
1528 if ( *phaseIt >= *currEmitPeriod) // phase is greater than period -> must emit
1529 {
1530 if (*currEmitPeriod != 0)
1531 {
1532 /** Must ensure phase is valid if period decrease over time
1533 */
1534 *phaseIt = std::min(*phaseIt, *currEmitPeriod + CParticleSystem::EllapsedTime);
1535 //
1536 /// compute the number of emissions
1537 uint numEmissions = (uint) ::floorf(*phaseIt / *currEmitPeriod);
1538 *phaseIt -= *currEmitPeriod * numEmissions;
1539 float deltaT = std::max(0.f, *phaseIt);
1540 //nlassert(deltaT >= 0.f);
1541 uint emitterIndex = (uint)(phaseIt - _Phase.begin());
1542
1543 /// compute the position of the emitter for the needed dates
1544 numEmissions = GenEmitterPositions(_Owner,
1545 _EmittedType,
1546 emitterIndex,
1547 numEmissions,
1548 deltaT,
1549 *currEmitPeriod,
1550 emitterPositions
1551 );
1552
1553 /// process each emission at the right pos at the right date
1554 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, emitterIndex) : _GenNb;
1555 uint k = numEmissions;
1556 do
1557 {
1558 --k;
1559 processEmitConsistent(emitterPositions[k],
1560 emitterIndex,
1561 nbToGenerate,
1562 deltaT);
1563 deltaT += *currEmitPeriod;
1564 }
1565 while (k);
1566 }
1567 else
1568 {
1569 const uint32 emitterIndex = (uint32)(phaseIt - _Phase.begin());
1570 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, emitterIndex) : _GenNb;
1571 processEmit(emitterIndex, nbToGenerate);
1572 }
1573 }
1574
1575 ++phaseIt;
1576 currEmitPeriod += currEmitPeriodPtrInc;
1577 }
1578 while (phaseIt != endPhaseIt);
1579 }
1580 else // thhere's an emission delay
1581 {
1582 do
1583 {
1584 *phaseIt += CParticleSystem::EllapsedTime;
1585 if ( *phaseIt >= *currEmitPeriod + _EmitDelay) // phase is greater than period -> must emit
1586 {
1587 if (*currEmitPeriod != 0)
1588 {
1589 /** Must ensure phase is valid if period decrease over time
1590 */
1591 *phaseIt = std::min(*phaseIt, *currEmitPeriod + CParticleSystem::EllapsedTime + _EmitDelay);
1592 //
1593 uint numEmissions = (uint) ::floorf((*phaseIt - _EmitDelay) / *currEmitPeriod);
1594 *phaseIt -= *currEmitPeriod * numEmissions;
1595 float deltaT = std::max(*phaseIt - _EmitDelay, 0.f);
1596 //nlassert(deltaT >= 0.f);
1597
1598 uint emitterIndex = (uint)(phaseIt - _Phase.begin());
1599 /// compute the position of the emitter for the needed date
1600 numEmissions = GenEmitterPositions(_Owner,
1601 _EmittedType,
1602 emitterIndex,
1603 numEmissions,
1604 deltaT,
1605 *currEmitPeriod,
1606 emitterPositions
1607 );
1608 /// process each emission at the right pos at the right date
1609 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, emitterIndex) : _GenNb;
1610 uint k = numEmissions;
1611 do
1612 {
1613 --k;
1614 processEmitConsistent(emitterPositions[k],
1615 emitterIndex,
1616 nbToGenerate,
1617 deltaT);
1618 deltaT += *currEmitPeriod;
1619 }
1620 while (k);
1621 }
1622 else
1623 {
1624 const uint32 emitterIndex = (uint32)(phaseIt - _Phase.begin());
1625 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, emitterIndex) : _GenNb;
1626 processEmit(emitterIndex, nbToGenerate);
1627 }
1628 }
1629
1630 ++phaseIt;
1631 currEmitPeriod += currEmitPeriodPtrInc;
1632 }
1633 while (phaseIt != endPhaseIt);
1634 }
1635 }
1636 else // there's an emission count limit
1637 {
1638 /// is there an emission delay ?
1639 if (_EmitDelay == 0.f) // no emission delay
1640 {
1641 do
1642 {
1643 if (*numEmitIt < _MaxEmissionCount)
1644 {
1645 *phaseIt += CParticleSystem::EllapsedTime;
1646 if ( *phaseIt >= *currEmitPeriod) // phase is greater than period -> must emit
1647 {
1648 if (*currEmitPeriod != 0)
1649 {
1650 /** Must ensure phase is valid if period decrease over time
1651 */
1652 *phaseIt = std::min(*phaseIt, *currEmitPeriod + CParticleSystem::EllapsedTime);
1653 //
1654 uint numEmissions = (uint) ::floorf(*phaseIt / *currEmitPeriod);
1655 *numEmitIt += numEmissions;
1656 *phaseIt -= *currEmitPeriod * numEmissions;
1657 float deltaT = std::max(*phaseIt, 0.f);
1658 //nlassert(deltaT >= 0.f);
1659 uint emitterIndex = (uint)(phaseIt - _Phase.begin());
1660 if (*numEmitIt > _MaxEmissionCount) // make sure we don't go over the emission limit
1661 {
1662 numEmissions -= *numEmitIt - _MaxEmissionCount;
1663 *numEmitIt = _MaxEmissionCount;
1664 }
1665 /// compute the position of the emitter for the needed date
1666 numEmissions = GenEmitterPositions(_Owner,
1667 _EmittedType,
1668 emitterIndex,
1669 numEmissions,
1670 deltaT,
1671 *currEmitPeriod,
1672 emitterPositions
1673 );
1674 uint k = numEmissions;
1675 /// process each emission at the right pos at the right date
1676 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, emitterIndex) : _GenNb;
1677 do
1678 {
1679 --k;
1680 processEmitConsistent(emitterPositions[k],
1681 emitterIndex,
1682 nbToGenerate,
1683 deltaT);
1684 deltaT += *currEmitPeriod;
1685 }
1686 while (k);
1687 }
1688 else
1689 {
1690 const uint32 emitterIndex = (uint32)(phaseIt - _Phase.begin());
1691 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, emitterIndex) : _GenNb;
1692 processEmit(emitterIndex, nbToGenerate);
1693 ++*numEmitIt;
1694 }
1695 }
1696 }
1697 ++phaseIt;
1698 currEmitPeriod += currEmitPeriodPtrInc;
1699 ++ numEmitIt;
1700 }
1701 while (phaseIt != endPhaseIt);
1702 }
1703 else // there's an emission delay
1704 {
1705 do
1706 {
1707 if (*numEmitIt < _MaxEmissionCount)
1708 {
1709 *phaseIt += CParticleSystem::EllapsedTime;
1710 if ( *phaseIt >= *currEmitPeriod + _EmitDelay) // phase is greater than period -> must emit
1711 {
1712 if (*currEmitPeriod != 0)
1713 {
1714 /** Must ensure phase is valid if period decrease over time
1715 */
1716 *phaseIt = std::min(*phaseIt, *currEmitPeriod + CParticleSystem::EllapsedTime + _EmitDelay);
1717 //
1718 uint numEmissions = (uint) ::floorf((*phaseIt - _EmitDelay) / *currEmitPeriod);
1719 *numEmitIt += numEmissions;
1720 *phaseIt -= *currEmitPeriod * numEmissions;
1721 float deltaT = std::max(*phaseIt - _EmitDelay, 0.f);
1722 //nlassert(deltaT >= 0.f);
1723 uint emitterIndex = (uint)(phaseIt - _Phase.begin());
1724 if (*numEmitIt > _MaxEmissionCount) // make sure we don't go over the emission limit
1725 {
1726 numEmissions -= *numEmitIt - _MaxEmissionCount;
1727 *numEmitIt = _MaxEmissionCount;
1728 }
1729 /// compute the position of the emitter for the needed date
1730 numEmissions = GenEmitterPositions(_Owner,
1731 _EmittedType,
1732 emitterIndex,
1733 numEmissions,
1734 deltaT,
1735 *currEmitPeriod,
1736 emitterPositions
1737 );
1738 uint k = numEmissions;
1739 /// process each emission at the right pos at the right date
1740 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, emitterIndex) : _GenNb;
1741 do
1742 {
1743 --k;
1744 processEmitConsistent(emitterPositions[k],
1745 emitterIndex,
1746 nbToGenerate,
1747 deltaT);
1748 deltaT += *currEmitPeriod;
1749 }
1750 while (k);
1751 }
1752 else
1753 {
1754 const uint32 emitterIndex = (uint32)(phaseIt - _Phase.begin());
1755 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, emitterIndex) : _GenNb;
1756 processEmit(emitterIndex, nbToGenerate);
1757 ++*numEmitIt;
1758 }
1759 }
1760 }
1761 ++phaseIt;
1762 currEmitPeriod += currEmitPeriodPtrInc;
1763 ++numEmitIt;
1764 }
1765 while (phaseIt != endPhaseIt);
1766 }
1767 }
1768
1769 leftToDo -= toProcess;
1770 }
1771 while (leftToDo);
1772 }
1773
1774
1775 ///==========================================================================
1776 void CPSEmitter::step(TPSProcessPass pass)
1777 {
1778 NL_PS_FUNC(CPSEmitter_step)
1779 if (pass == PSToolRender)
1780 {
1781 showTool();
1782 }
1783 }
1784
1785 ///==========================================================================
1786 void CPSEmitter::computeSpawns(uint firstInstanceIndex)
1787 {
1788 NL_PS_FUNC(CPSEmitter_computeSpawns)
1789 if (!_EmittedType) return;
1790 nlassert(CParticleSystem::InsideSimLoop);
1791 const uint32 size = _Owner->getSize();
1792 if (!size) return;
1793 if (CParticleSystem::EllapsedTime == 0.f) return; // do nothing when paused
1794 CParticleSystem *ps = _Owner->getOwner();
1795 nlassert(ps);
1796 float emitLOD;
1797 if (ps->isAutoLODEnabled() && !ps->isSharingEnabled() && !_BypassAutoLOD)
1798 {
1799 // temp test for auto lod
1800 emitLOD = ps->getAutoLODEmitRatio();
1801 }
1802 else
1803 {
1804 emitLOD = 1.f;
1805 }
1806 nlassert(_EmissionType == CPSEmitter::regular);
1807 if (!_ConsistentEmission)
1808 {
1809 if (emitLOD != 1.f)
1810 {
1811 processRegularEmission(firstInstanceIndex, emitLOD);
1812 }
1813 else
1814 {
1815 processRegularEmissionWithNoLOD(firstInstanceIndex);
1816 }
1817 }
1818 else
1819 {
1820 if (emitLOD != 1.f)
1821 {
1822 if (emitLOD != 0.f)
1823 {
1824 processRegularEmissionConsistent(firstInstanceIndex, emitLOD, 1.f / emitLOD);
1825 }
1826 }
1827 else
1828 {
1829 processRegularEmissionConsistentWithNoLOD(firstInstanceIndex);
1830 }
1831 }
1832 }
1833
1834
1835 ///==========================================================================
1836 void CPSEmitter::newElement(const CPSEmitterInfo &info)
1837 {
1838 NL_PS_FUNC(CPSEmitter_newElement)
1839 nlassert(_Phase.getSize() != _Phase.getMaxSize());
1840
1841 _Phase.insert(0.f);
1842 if (_MaxEmissionCount != 0)
1843 {
1844 _NumEmission.insert(0);
1845 }
1846 if (_PeriodScheme && _PeriodScheme->hasMemory()) _PeriodScheme->newElement(info);
1847 if (_GenNbScheme && _GenNbScheme->hasMemory()) _GenNbScheme->newElement(info);
1848
1849 }
1850
1851 ///==========================================================================
1852 inline void CPSEmitter::deleteElementBase(uint32 index)
1853 {
1854 NL_PS_FUNC(CPSEmitter_deleteElementBase)
1855 if (_PeriodScheme && _PeriodScheme->hasMemory()) _PeriodScheme->deleteElement(index);
1856 if (_GenNbScheme && _GenNbScheme->hasMemory()) _GenNbScheme->deleteElement(index);
1857 _Phase.remove(index);
1858 if (_MaxEmissionCount != 0)
1859 {
1860 _NumEmission.remove(index);
1861 }
1862 }
1863
1864 ///==========================================================================
1865 void CPSEmitter::deleteElement(uint32 index)
1866 {
1867 NL_PS_FUNC(CPSEmitter_deleteElement)
1868
1869 if (_EmissionType == CPSEmitter::onDeath && _EmittedType && _Active)
1870 {
1871 if (!_BypassEmitOnDeath)
1872 {
1873 const uint32 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, index) : _GenNb;
1874 processEmitOutsideSimLoop(index, nbToGenerate);
1875 }
1876 }
1877 deleteElementBase(index);
1878 }
1879
1880 ///==========================================================================
1881 void CPSEmitter::deleteElement(uint32 index, TAnimationTime timeUntilNextSimStep)
1882 {
1883 NL_PS_FUNC(CPSEmitter_deleteElement)
1884 if (_EmissionType == CPSEmitter::onDeath && _EmittedType && _Active)
1885 {
1886 const uint32 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, index) : _GenNb;
1887 processEmitConsistent(_Owner->getPos()[index], index, nbToGenerate, timeUntilNextSimStep);
1888 }
1889 deleteElementBase(index);
1890 }
1891
1892
1893 ///==========================================================================
1894 void CPSEmitter::resize(uint32 size)
1895 {
1896 NL_PS_FUNC(CPSEmitter_resize)
1897 nlassert(size < (1 << 16));
1898 if (_PeriodScheme && _PeriodScheme->hasMemory()) _PeriodScheme->resize(size, _Owner->getSize());
1899 if (_GenNbScheme && _GenNbScheme->hasMemory()) _GenNbScheme->resize(size, _Owner->getSize());
1900 _Phase.resize(size);
1901 if (_MaxEmissionCount != 0)
1902 {
1903 _NumEmission.resize(size);
1904 }
1905 }
1906
1907 ///==========================================================================
1908 void CPSEmitter::bounceOccurred(uint32 index, TAnimationTime timeToNextSimStep)
1909 {
1910 NL_PS_FUNC(CPSEmitter_bounceOccurred)
1911 // TODO : avoid duplication with deleteElement
1912 if (_EmittedType && _EmissionType == CPSEmitter::onBounce)
1913 {
1914 const uint32 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, index) : _GenNb;
1915 processEmitConsistent(_Owner->getPos()[index], index, nbToGenerate, timeToNextSimStep);
1916 }
1917 }
1918
1919 ///==========================================================================
1920 void CPSEmitter::serial(NLMISC::IStream &f)
1921 {
1922 NL_PS_FUNC(CPSEmitter_serial)
1923 /// version 6 : the flag _EmitDirBasis no longer exist, it has been replaced by _UserMatrixModeForEmissionDirection
1924 //
1925 /// version 5 : added _BypassAutoLOD
1926 /// version 4 : added consistent emissions
1927 sint ver = f.serialVersion(6);
1928 CPSLocatedBindable::serial(f);
1929
1930 f.serialPolyPtr(_EmittedType);
1931 f.serial(_Phase);
1932 f.serial(_SpeedInheritanceFactor);
1933
1934 bool speedBasisEmission = _SpeedBasisEmission; // tmp copy because of bitfield serialization scheme
1935 f.serial(speedBasisEmission);
1936 _SpeedBasisEmission = speedBasisEmission;
1937
1938 f.serialEnum(_EmissionType);
1939
1940 // this is for use with serial
1941 bool trueB = true, falseB = false;
1942
1943 if (!f.isReading())
1944 {
1945 switch (_EmissionType)
1946 {
1947 case CPSEmitter::regular:
1948 if (_PeriodScheme)
1949 {
1950 f.serial(trueB);
1951 f.serialPolyPtr(_PeriodScheme);
1952 }
1953 else
1954 {
1955 f.serial(falseB);
1956 f.serial(_Period);
1957 }
1958 if (ver >= 3)
1959 {
1960 f.serial(_EmitDelay, _MaxEmissionCount);
1961 }
1962 break;
1963 default:
1964 break;
1965 }
1966 if (_GenNbScheme)
1967 {
1968 f.serial(trueB);
1969 f.serialPolyPtr(_GenNbScheme);
1970 }
1971 else
1972 {
1973 f.serial(falseB);
1974 f.serial(_GenNb);
1975 }
1976 }
1977 else
1978 {
1979 bool useScheme;
1980 switch (_EmissionType)
1981 {
1982 case CPSEmitter::regular:
1983 {
1984 f.serial(useScheme);
1985 if (useScheme)
1986 {
1987 delete _PeriodScheme;
1988 f.serialPolyPtr(_PeriodScheme);
1989 }
1990 else
1991 {
1992 f.serial(_Period);
1993 }
1994 if (ver >= 3)
1995 {
1996 f.serial(_EmitDelay, _MaxEmissionCount);
1997 updateMaxCountVect();
1998 }
1999 }
2000 break;
2001 default:
2002 break;
2003 }
2004
2005 f.serial(useScheme);
2006 if (useScheme)
2007 {
2008 delete _GenNbScheme;
2009 f.serialPolyPtr(_GenNbScheme);
2010 }
2011 else
2012 {
2013 f.serial(_GenNb);
2014 }
2015 }
2016 if (ver > 1 && ver < 6)
2017 {
2018 nlassert(f.isReading());
2019 bool emitDirBasis;
2020 f.serial(emitDirBasis);
2021 if (emitDirBasis)
2022 {
2023 _UserMatrixModeForEmissionDirection = false;
2024 _UserDirectionMatrixMode = PSFXWorldMatrix;
2025 }
2026 else
2027 {
2028 _UserMatrixModeForEmissionDirection = true;
2029 if (_Owner)
2030 {
2031 _UserDirectionMatrixMode = _Owner->getMatrixMode() == PSFXWorldMatrix ? PSIdentityMatrix : PSFXWorldMatrix;
2032 }
2033 else
2034 {
2035 _UserDirectionMatrixMode = PSFXWorldMatrix;
2036 }
2037 }
2038 }
2039 if (ver >= 4)
2040 {
2041 bool consistentEmission = _ConsistentEmission; // tmp copy because of bitfield serialization scheme
2042 f.serial(consistentEmission);
2043 _ConsistentEmission = consistentEmission;
2044 }
2045 if (ver >= 5)
2046 {
2047 bool byassAutoLOD = _BypassAutoLOD; // tmp copy because of bitfield serialization scheme
2048 f.serial(byassAutoLOD);
2049 _BypassAutoLOD = byassAutoLOD;
2050 }
2051 if (ver >= 6)
2052 {
2053 bool userMatrixModeForEmissionDirection = _UserMatrixModeForEmissionDirection; // tmp copy because of bitfield serialization scheme
2054 f.serial(userMatrixModeForEmissionDirection);
2055 _UserMatrixModeForEmissionDirection = userMatrixModeForEmissionDirection;
2056 f.serialEnum(_UserDirectionMatrixMode);
2057 }
2058 }
2059
2060 ///==========================================================================
2061 void CPSEmitter::updateMaxCountVect()
2062 {
2063 NL_PS_FUNC(CPSEmitter_updateMaxCountVect)
2064 if (!_MaxEmissionCount || !_Owner)
2065 {
2066 _NumEmission.resize(0);
2067 }
2068 else
2069 {
2070 _NumEmission.resize(_Owner->getMaxSize());
2071 while (_NumEmission.getSize() != 0)
2072 {
2073 _NumEmission.remove(0);
2074 }
2075 while (_NumEmission.getSize() != _Owner->getSize())
2076 {
2077 _NumEmission.insert(0);
2078 }
2079 }
2080 }
2081
2082 ///==========================================================================
2083 void CPSEmitter::setEmitDelay(float delay)
2084 {
2085 NL_PS_FUNC(CPSEmitter_setEmitDelay)
2086 _EmitDelay = delay;
2087 if (_Owner && _Owner->getOwner())
2088 {
2089 _Owner->getOwner()->systemDurationChanged();
2090 }
2091 }
2092
2093 ///==========================================================================
2094 bool CPSEmitter::setMaxEmissionCount(uint8 count)
2095 {
2096 NL_PS_FUNC(CPSEmitter_setMaxEmissionCount)
2097 if (count == _MaxEmissionCount) return true;
2098 nlassert(_Owner && _Owner->getOwner());
2099 CParticleSystem *ps = _Owner->getOwner();
2100 if (ps->getBypassMaxNumIntegrationSteps())
2101 {
2102 uint8 oldEmissiontCount = _MaxEmissionCount;
2103 // should check that the new value is valid
2104 _MaxEmissionCount = count;
2105 if (testEmitForever())
2106 {
2107 _MaxEmissionCount = oldEmissiontCount;
2108 nlwarning("<CPSEmitter::setMaxEmissionCount> can't set max emission count to %d \
2109 with the current configuration : the system has been flagged with \
2110 'BypassMaxNumIntegrationSteps', and should have a finite duration. \
2111 The new value is not set", (int) count);
2112 return false;
2113 }
2114 }
2115 ps->systemDurationChanged();
2116 _MaxEmissionCount = count;
2117 updateMaxCountVect();
2118 return true;
2119 }
2120
2121 ///==========================================================================
2122 bool CPSEmitter::checkLoop() const
2123 {
2124 NL_PS_FUNC(CPSEmitter_checkLoop)
2125 nlassert(_Owner);
2126 nlassert(_Owner->getOwner());
2127 if (!_EmittedType) return false;
2128 std::set<const CPSLocated *> seenLocated; // the located we've already seen
2129 std::vector<const CPSLocated *> leftLoc(1); // the located that are left to see
2130 leftLoc[0] = _EmittedType;
2131 do
2132 {
2133 const CPSLocated *curr = leftLoc.back();
2134 if (curr == this->_Owner) return true;
2135 leftLoc.pop_back();
2136 seenLocated.insert(curr);
2137 for(uint32 k = 0; k < curr->getNbBoundObjects(); ++k)
2138 {
2139 const CPSEmitter *emitter = dynamic_cast<const CPSEmitter *>(curr->getBoundObject(k));
2140 if (emitter && emitter->_EmittedType)
2141 {
2142 if (seenLocated.find(emitter->_EmittedType) == seenLocated.end()) // not already seen this one ?
2143 {
2144 leftLoc.push_back(emitter->_EmittedType);
2145 }
2146 }
2147 }
2148 }
2149 while (!leftLoc.empty());
2150 return false;
2151 }
2152
2153 ///==========================================================================
2154 bool CPSEmitter::testEmitForever() const
2155 {
2156 NL_PS_FUNC(CPSEmitter_testEmitForever)
2157 if (!_Owner)
2158 {
2159 nlwarning("<CPSEmitter::testEmitForever> The emitter should be inserted in a CPSLocated instance for this call to work.");
2160 nlassert(0);
2161 return true;
2162 }
2163 if (!_Owner->getLastForever()) return false;
2164 switch(getEmissionType())
2165 {
2166 case CPSEmitter::onBounce:
2167 case CPSEmitter::externEmit:
2168 case CPSEmitter::regular:
2169 // it is ok only if a limited number of located is emitted
2170 if (getMaxEmissionCount() == 0) return true;
2171 break;
2172 case CPSEmitter::onDeath: return true; // the emitter never dies, so ..
2173 case CPSEmitter::once: return false;
2174 break;
2175 default:
2176 nlassert(0); // not a known type
2177 break;
2178 }
2179 return false;
2180 }
2181
2182
2183 ////////////////////////////////////////////
2184 // implementation of CPSModulatedEmitter //
2185 ////////////////////////////////////////////
2186
2187 void CPSModulatedEmitter::serialEmitteeSpeedScheme(NLMISC::IStream &f)
2188 {
2189 NL_PS_FUNC(CPSModulatedEmitter_IStream )
2190 bool useScheme;
2191 if (!f.isReading())
2192 {
2193 useScheme = useEmitteeSpeedScheme();
2194 }
2195 f.serial(useScheme);
2196 if (useScheme)
2197 {
2198 f.serialPolyPtr(_EmitteeSpeedScheme);
2199 }
2200 else
2201 {
2202 f.serial(_EmitteeSpeed);
2203 }
2204 }
2205
2206
2207
2208 ////////////////////////////////////////////
2209 // implementation of CPSEmitterOmni //
2210 ////////////////////////////////////////////
2211
2212 ///==========================================================================
2213 void CPSEmitterOmni::emit(const NLMISC::CVector &srcPos, uint32 index, CVector &pos, CVector &speed)
2214 {
2215 NL_PS_FUNC(CPSEmitterOmni_emit)
2216 // TODO : verifier que ca marche si une particule s'emet elle-mem
2217 nlassert(_EmittedType);
2218
2219 CVector v( ((rand() % 1000) - 500) / 500.0f
2220 , ((rand() % 1000) - 500) / 500.0f
2221 , ((rand() % 1000) - 500) / 500.0f);
2222 v.normalize();
2223 v *= _EmitteeSpeedScheme ? _EmitteeSpeedScheme->get(_Owner, index) : _EmitteeSpeed;
2224
2225 pos = srcPos;
2226 speed = v;
2227
2228 }
2229
2230 ///==========================================================================
2231 void CPSEmitterOmni::serial(NLMISC::IStream &f)
2232 {
2233 NL_PS_FUNC(CPSEmitterOmni_serial)
2234 f.serialVersion(1);
2235 CPSEmitter::serial(f);
2236 CPSModulatedEmitter::serialEmitteeSpeedScheme(f);
2237 }
2238
2239 ///==========================================================================
2240 void CPSEmitterOmni::newElement(const CPSEmitterInfo &info)
2241 {
2242 NL_PS_FUNC(CPSEmitterOmni_newElement)
2243 CPSEmitter::newElement(info);
2244 newEmitteeSpeedElement(info);
2245 }
2246
2247 ///==========================================================================
2248 inline void CPSEmitterOmni::deleteElementBase(uint32 index)
2249 {
2250 NL_PS_FUNC(CPSEmitterOmni_deleteElementBase)
2251 deleteEmitteeSpeedElement(index);
2252 }
2253
2254 ///==========================================================================
2255 void CPSEmitterOmni::deleteElement(uint32 index, TAnimationTime timeUntilNextSimStep)
2256 {
2257 NL_PS_FUNC(CPSEmitterOmni_deleteElement)
2258 CPSEmitter::deleteElement(index, timeUntilNextSimStep);
2259 deleteElementBase(index);
2260 }
2261
2262 ///==========================================================================
2263 void CPSEmitterOmni::deleteElement(uint32 index)
2264 {
2265 NL_PS_FUNC(CPSEmitterOmni_deleteElement)
2266 CPSEmitter::deleteElement(index);
2267 deleteElementBase(index);
2268 }
2269
2270 ///==========================================================================
2271 void CPSEmitterOmni::resize(uint32 capacity)
2272 {
2273 NL_PS_FUNC(CPSEmitterOmni_resize)
2274 nlassert(capacity < (1 << 16));
2275 CPSEmitter::resize(capacity);
2276 resizeEmitteeSpeed(capacity);
2277 }
2278
2279 ///==========================================================================
2280 void CPSEmitterDirectionnal::emit(const NLMISC::CVector &srcPos, uint32 index, CVector &pos, CVector &speed)
2281 {
2282 NL_PS_FUNC(CPSEmitterDirectionnal_emit)
2283 // TODO : verifier que ca marche si une particule s'emet elle-mem
2284 nlassert(_EmittedType);
2285
2286
2287 speed = (_EmitteeSpeedScheme ? _EmitteeSpeedScheme->get(_Owner, index) : _EmitteeSpeed) * _Dir;
2288 pos = srcPos;
2289 }
2290
2291 ///==========================================================================
2292 void CPSEmitterDirectionnal::newElement(const CPSEmitterInfo &info)
2293 {
2294 NL_PS_FUNC(CPSEmitterDirectionnal_newElement)
2295 CPSEmitter::newElement(info);
2296 newEmitteeSpeedElement(info);
2297 }
2298
2299
2300 ///==========================================================================
2301 inline void CPSEmitterDirectionnal::deleteElementBase(uint32 index)
2302 {
2303 NL_PS_FUNC(CPSEmitterDirectionnal_deleteElementBase)
2304 deleteEmitteeSpeedElement(index);
2305 }
2306
2307 ///==========================================================================
2308 void CPSEmitterDirectionnal::deleteElement(uint32 index, TAnimationTime timeUntilNextSimStep)
2309 {
2310 NL_PS_FUNC(CPSEmitterDirectionnal_deleteElement)
2311 CPSEmitter::deleteElement(index, timeUntilNextSimStep);
2312 deleteElementBase(index);
2313 }
2314
2315 ///==========================================================================
2316 void CPSEmitterDirectionnal::deleteElement(uint32 index)
2317 {
2318 NL_PS_FUNC(CPSEmitterDirectionnal_deleteElement)
2319 CPSEmitter::deleteElement(index);
2320 deleteElementBase(index);
2321 }
2322
2323
2324
2325 ///==========================================================================
2326 void CPSEmitterDirectionnal::resize(uint32 capacity)
2327 {
2328 NL_PS_FUNC(CPSEmitterDirectionnal_resize)
2329 nlassert(capacity < (1 << 16));
2330 CPSEmitter::resize(capacity);
2331 resizeEmitteeSpeed(capacity);
2332 }
2333
2334 ///==========================================================================
2335 void CPSEmitterDirectionnal::serial(NLMISC::IStream &f)
2336 {
2337 NL_PS_FUNC(CPSEmitterDirectionnal_IStream )
2338 f.serialVersion(1);
2339 CPSEmitter::serial(f);
2340 CPSModulatedEmitter::serialEmitteeSpeedScheme(f);
2341 f.serial(_Dir);
2342 }
2343
2344 ////////////////////////////////////////////
2345 // implementation of CPSEmitterRectangle //
2346 ////////////////////////////////////////////
2347
2348 ///==========================================================================
2349 void CPSEmitterRectangle::serial(NLMISC::IStream &f)
2350 {
2351 NL_PS_FUNC(CPSEmitterRectangle_IStream )
2352 f.serialVersion(1);
2353 CPSEmitter::serial(f);
2354 CPSModulatedEmitter::serialEmitteeSpeedScheme(f);
2355 f.serial(_Basis);
2356 f.serial(_Width);
2357 f.serial(_Height);
2358 f.serial(_Dir);
2359
2360 }
2361
2362 ///==========================================================================
2363 void CPSEmitterRectangle::emit(const NLMISC::CVector &srcPos, uint32 index, CVector &pos, CVector &speed)
2364 {
2365 NL_PS_FUNC(CPSEmitterRectangle_emit)
2366 CVector N = _Basis[index].X ^ _Basis[index].Y;
2367 pos = srcPos + ((rand() % 32000) * (1.f / 16000) - 1.f) * _Width[index] * _Basis[index].X
2368 + ((rand() % 32000) * (1.f / 16000) - 1.f) * _Height[index] * _Basis[index].Y;
2369 speed = (_EmitteeSpeedScheme ? _EmitteeSpeedScheme->get(_Owner, index) : _EmitteeSpeed)
2370 * (_Dir.x * _Basis[index].X+ _Dir.y * _Basis[index].Y + _Dir.z * N);
2371 }
2372
2373 ///==========================================================================
2374 void CPSEmitterRectangle::setMatrix(uint32 index, const CMatrix &m)
2375 {
2376 NL_PS_FUNC(CPSEmitterRectangle_setMatrix)
2377 _Owner->getPos()[index] = m.getPos();
2378
2379
2380 _Basis[index].X = m.getI();
2381 _Basis[index].Y = m.getJ();
2382 }
2383
2384 ///==========================================================================
2385 CMatrix CPSEmitterRectangle::getMatrix(uint32 index) const
2386 {
2387 NL_PS_FUNC(CPSEmitterRectangle_getMatrix)
2388 CMatrix m;
2389 m.setPos(_Owner->getPos()[index]);
2390 m.setRot(_Basis[index].X, _Basis[index].Y, _Basis[index].X ^ _Basis[index].Y, true);
2391 return m;
2392 }
2393
2394 ///==========================================================================
2395 void CPSEmitterRectangle::setScale(uint32 index, float scale)
2396 {
2397 NL_PS_FUNC(CPSEmitterRectangle_setScale)
2398 _Width[index] = scale;
2399 _Height[index] = scale;
2400 }
2401
2402 ///==========================================================================
2403 void CPSEmitterRectangle::setScale(uint32 index, const CVector &s)
2404 {
2405 NL_PS_FUNC(CPSEmitterRectangle_setScale)
2406 _Width[index] = s.x;
2407 _Height[index] = s.y;
2408 }
2409
2410 ///==========================================================================
2411 CVector CPSEmitterRectangle::getScale(uint32 index) const
2412 {
2413 NL_PS_FUNC(CPSEmitterRectangle_getScale)
2414 return CVector(_Width[index], _Height[index], 1.f);
2415 }
2416
2417 ///==========================================================================
2418 void CPSEmitterRectangle::newElement(const CPSEmitterInfo &info)
2419 {
2420 NL_PS_FUNC( CPSEmitterRectangle_newElement)
2421 CPSEmitter::newElement(info);
2422 newEmitteeSpeedElement(info);
2423 _Basis.insert(CPlaneBasis(CVector::K));
2424 _Width.insert(1.f);
2425 _Height.insert(1.f);
2426 }
2427
2428 ///==========================================================================
2429 inline void CPSEmitterRectangle::deleteElementBase(uint32 index)
2430 {
2431 NL_PS_FUNC(CPSEmitterRectangle_deleteElementBase)
2432 deleteEmitteeSpeedElement(index);
2433 _Basis.remove(index);
2434 _Width.remove(index);
2435 _Height.remove(index);
2436 }
2437
2438 ///==========================================================================
2439 void CPSEmitterRectangle::deleteElement(uint32 index)
2440 {
2441 NL_PS_FUNC(CPSEmitterRectangle_deleteElement)
2442 CPSEmitter::deleteElement(index);
2443 deleteElementBase(index);
2444 }
2445
2446 ///==========================================================================
2447 void CPSEmitterRectangle::deleteElement(uint32 index, TAnimationTime timeUntilNextSimStep)
2448 {
2449 NL_PS_FUNC(CPSEmitterRectangle_deleteElement)
2450 CPSEmitter::deleteElement(index, timeUntilNextSimStep);
2451 deleteElementBase(index);
2452 }
2453
2454 ///==========================================================================
2455 void CPSEmitterRectangle::resize(uint32 size)
2456 {
2457 NL_PS_FUNC(CPSEmitterRectangle_resize)
2458 nlassert(size < (1 << 16));
2459 CPSEmitter::resize(size);
2460 resizeEmitteeSpeed(size);
2461 _Basis.resize(size);
2462 _Width.resize(size);
2463 _Height.resize(size);
2464 }
2465
2466 ///==========================================================================
2467 void CPSEmitterRectangle::showTool(void)
2468 {
2469 NL_PS_FUNC(CPSEmitterRectangle_showTool)
2470 nlassert(_Owner);
2471 const uint size = _Owner->getSize();
2472 if (!size) return;
2473 setupDriverModelMatrix();
2474 CMatrix mat;
2475
2476 CPSLocated *loc;
2477 uint32 index;
2478 CPSLocatedBindable *lb;
2479 _Owner->getOwner()->getCurrentEditedElement(loc, index, lb);
2480
2481 for (uint k = 0; k < size; ++k)
2482 {
2483 const CVector &I = _Basis[k].X;
2484 const CVector &J = _Basis[k].Y;
2485 mat.setRot(I, J , I ^J);
2486 mat.setPos(_Owner->getPos()[k]);
2487 CPSUtil::displayBasis(getDriver() ,getLocalToWorldMatrix(), mat, 1.f, *getFontGenerator(), *getFontManager());
2488 setupDriverModelMatrix();
2489
2490 const CRGBA col = ((lb == NULL || this == lb) && loc == _Owner && index == k ? CRGBA::Red : CRGBA(127, 127, 127));
2491
2492
2493
2494 const CVector &pos = _Owner->getPos()[k];
2495 CPSUtil::display3DQuad(*getDriver(), pos + I * _Width[k] + J * _Height[k]
2496 , pos + I * _Width[k] - J * _Height[k]
2497 , pos - I * _Width[k] - J * _Height[k]
2498 , pos - I * _Width[k] + J * _Height[k], col);
2499 }
2500 }
2501
2502
2503
2504 ////////////////////////////////////
2505 // CPSEmitterconic implementation //
2506 ////////////////////////////////////
2507
2508 ///==========================================================================
2509 void CPSEmitterConic::serial(NLMISC::IStream &f)
2510 {
2511 NL_PS_FUNC(CPSEmitterConic_serial)
2512 f.serialVersion(1);
2513 CPSEmitterDirectionnal::serial(f);
2514 f.serial(_Radius);
2515 }
2516
2517 ///==========================================================================
2518 void CPSEmitterConic::setDir(const CVector &v)
2519 {
2520 NL_PS_FUNC(CPSEmitterConic_setDir)
2521 CPSEmitterDirectionnal::setDir(v);
2522
2523 }
2524
2525 ///==========================================================================
2526 void CPSEmitterConic::emit(const NLMISC::CVector &srcPos, uint32 index, CVector &pos, CVector &speed)
2527 {
2528 NL_PS_FUNC(CPSEmitterConic_emit)
2529 // TODO : optimize that
2530 nlassert(_EmittedType);
2531
2532 // we choose a custom direction like with omnidirectionnal emitter
2533 // then we force the direction vect to have the unit size
2534
2535 static const double divRand = (2.0 / RAND_MAX);
2536
2537 CVector dir((float) (rand() * divRand - 1)
2538 , (float) (rand() * divRand - 1)
2539 , (float) (rand() * divRand - 1) );
2540
2541 const float n =dir.norm();
2542
2543 dir *= _Radius / n;
2544
2545 dir -= (_Dir * dir) * _Dir;
2546 dir += _Dir;
2547 dir.normalize();
2548
2549
2550 speed = (_EmitteeSpeedScheme ? _EmitteeSpeedScheme->get(_Owner, index) : _EmitteeSpeed)
2551 * dir;
2552 pos = srcPos;
2553 }
2554
2555 ////////////////////////////////////////
2556 // CPSSphericalEmitter implementation //
2557 ////////////////////////////////////////
2558
2559 ///==========================================================================
2560 void CPSSphericalEmitter::emit(const NLMISC::CVector &srcPos, uint32 index, CVector &pos, CVector &speed)
2561 {
2562 NL_PS_FUNC(CPSSphericalEmitter_emit)
2563 static const double divRand = (2.0 / RAND_MAX);
2564 CVector dir((float) (rand() * divRand - 1), (float) (rand() * divRand - 1) , (float) (rand() * divRand - 1) );
2565 dir.normalize();
2566 pos = srcPos + _Radius[index] * dir;
2567 speed = (_EmitteeSpeedScheme ? _EmitteeSpeedScheme->get(_Owner, index) : _EmitteeSpeed) * dir;
2568 }
2569
2570
2571 ///==========================================================================
2572 void CPSSphericalEmitter::showTool(void)
2573 {
2574 NL_PS_FUNC(CPSSphericalEmitter_showTool)
2575 CPSLocated *loc;
2576 uint32 index;
2577 CPSLocatedBindable *lb;
2578 _Owner->getOwner()->getCurrentEditedElement(loc, index, lb);
2579
2580
2581 TPSAttribFloat::const_iterator radiusIt = _Radius.begin();
2582 TPSAttribVector::const_iterator posIt = _Owner->getPos().begin(), endPosIt = _Owner->getPos().end();
2583 setupDriverModelMatrix();
2584 for (uint k = 0; posIt != endPosIt; ++posIt, ++radiusIt, ++k)
2585 {
2586 const CRGBA col = ((lb == NULL || this == lb) && loc == _Owner && index == k ? CRGBA::Red : CRGBA(127, 127, 127));
2587 CPSUtil::displaySphere(*getDriver(), *radiusIt, *posIt, 5, col);
2588 }
2589 }
2590
2591
2592 ///==========================================================================
2593 void CPSSphericalEmitter::setMatrix(uint32 index, const CMatrix &m)
2594 {
2595 NL_PS_FUNC(CPSSphericalEmitter_setMatrix)
2596 nlassert(index < _Radius.getSize());
2597 // compute new pos
2598 _Owner->getPos()[index] = m.getPos();
2599
2600 }
2601
2602 ///==========================================================================
2603 CMatrix CPSSphericalEmitter::getMatrix(uint32 index) const
2604 {
2605 NL_PS_FUNC(CPSSphericalEmitter_getMatrix)
2606 nlassert(index < _Radius.getSize());
2607 CMatrix m;
2608 m.identity();
2609 m.translate(_Owner->getPos()[index]);
2610 return m;
2611 }
2612
2613 ///==========================================================================
2614 void CPSSphericalEmitter::serial(NLMISC::IStream &f)
2615 {
2616 NL_PS_FUNC(CPSSphericalEmitter_serial)
2617 f.serialVersion(1);
2618 CPSEmitter::serial(f);
2619 CPSModulatedEmitter::serialEmitteeSpeedScheme(f);
2620 f.serial(_Radius);
2621 }
2622
2623 ///==========================================================================
2624 void CPSSphericalEmitter::newElement(const CPSEmitterInfo &info)
2625 {
2626 NL_PS_FUNC(CPSSphericalEmitter_newElement)
2627 CPSEmitter::newElement(info);
2628 newEmitteeSpeedElement(info);
2629 _Radius.insert(1.f);
2630 }
2631
2632 ///==========================================================================
2633 inline void CPSSphericalEmitter::deleteElementBase(uint32 index)
2634 {
2635 NL_PS_FUNC(CPSSphericalEmitter_deleteElementBase)
2636 deleteEmitteeSpeedElement(index);
2637 _Radius.remove(index);
2638 }
2639
2640 ///==========================================================================
2641 void CPSSphericalEmitter::deleteElement(uint32 index)
2642 {
2643 NL_PS_FUNC(CPSSphericalEmitter_deleteElement)
2644 CPSEmitter::deleteElement(index);
2645 deleteElementBase(index);
2646 }
2647
2648 ///==========================================================================
2649 void CPSSphericalEmitter::deleteElement(uint32 index, TAnimationTime timeUntilNextSimStep)
2650 {
2651 NL_PS_FUNC(CPSSphericalEmitter_deleteElement)
2652 CPSEmitter::deleteElement(index, timeUntilNextSimStep);
2653 deleteElementBase(index);
2654 }
2655
2656 ///==========================================================================
2657 void CPSSphericalEmitter::resize(uint32 size)
2658 {
2659 NL_PS_FUNC(CPSSphericalEmitter_resize)
2660 nlassert(size < (1 << 16));
2661 CPSEmitter::resize(size);
2662 resizeEmitteeSpeed(size);
2663 _Radius.resize(size);
2664 }
2665
2666 /////////////////////////////////////
2667 // CPSRadialEmitter implementation //
2668 /////////////////////////////////////
2669
2670 ///==========================================================================
2671 void CPSRadialEmitter::serial(NLMISC::IStream &f)
2672 {
2673 NL_PS_FUNC(CPSRadialEmitter_serial)
2674 f.serialVersion(1);
2675 CPSEmitterDirectionnal::serial(f);
2676 }
2677
2678 ///==========================================================================
2679 void CPSRadialEmitter::emit(const NLMISC::CVector &srcPos, uint32 index, NLMISC::CVector &pos, NLMISC::CVector &speed)
2680 {
2681 NL_PS_FUNC(CPSRadialEmitter_emit)
2682 // TODO : verify if it works when a particle emits itself
2683 nlassert(_EmittedType);
2684
2685 static const double divRand = (2.0 / RAND_MAX);
2686 CVector dir((float) (rand() * divRand - 1),
2687 (float) (rand() * divRand - 1),
2688 (float) (rand() * divRand - 1) );
2689 dir -= (dir * _Dir) * _Dir; //keep tangential direction
2690 dir.normalize();
2691 speed = (_EmitteeSpeedScheme ? _EmitteeSpeedScheme->get(_Owner, index) : _EmitteeSpeed) * dir;
2692 pos = srcPos;
2693 }
2694
2695
2696 ///===============================================================================
2697 void CPSEmitter::enableSpeedBasisEmission(bool enabled /*=true*/)
2698 {
2699 NL_PS_FUNC(CPSEmitter_enableSpeedBasisEmission)
2700 bool wasUserMatNeeded = isUserMatrixUsed();
2701 _SpeedBasisEmission = enabled;
2702 updatePSRefCountForUserMatrixUsage(isUserMatrixUsed(), wasUserMatNeeded);
2703 }
2704
2705 ///===============================================================================
2706 void CPSEmitter::enableUserMatrixModeForEmissionDirection(bool enable /*=true*/)
2707 {
2708 NL_PS_FUNC(CPSEmitter_enableUserMatrixModeForEmissionDirection)
2709 bool wasUserMatNeeded = isUserMatrixUsed();
2710 _UserMatrixModeForEmissionDirection = enable;
2711 updatePSRefCountForUserMatrixUsage(isUserMatrixUsed(), wasUserMatNeeded);
2712 }
2713
2714 ///===============================================================================
2715 void CPSEmitter::setUserMatrixModeForEmissionDirection(TPSMatrixMode matrixMode)
2716 {
2717 NL_PS_FUNC(CPSEmitter_setUserMatrixModeForEmissionDirection)
2718 bool wasUserMatNeeded = isUserMatrixUsed();
2719 _UserDirectionMatrixMode = matrixMode;
2720 updatePSRefCountForUserMatrixUsage(isUserMatrixUsed(), wasUserMatNeeded);
2721 }
2722
2723
2724 ///==========================================================================
2725 void CPSEmitter::updatePSRefCountForUserMatrixUsage(bool matrixIsNeededNow, bool matrixWasNeededBefore)
2726 {
2727 NL_PS_FUNC(CPSEmitter_updatePSRefCountForUserMatrixUsage)
2728 if (_Owner && _Owner->getOwner())
2729 {
2730 if (matrixIsNeededNow && !matrixWasNeededBefore)
2731 {
2732 _Owner->getOwner()->addRefForUserSysCoordInfo();
2733 }
2734 else if (!matrixIsNeededNow && matrixWasNeededBefore)
2735 {
2736 _Owner->getOwner()->releaseRefForUserSysCoordInfo();
2737 }
2738 }
2739 }
2740
2741 ///==========================================================================
2742 bool CPSEmitter::isUserMatrixUsed() const
2743 {
2744 NL_PS_FUNC(CPSEmitter_isUserMatrixUsed)
2745 return !_SpeedBasisEmission && _UserMatrixModeForEmissionDirection && _UserDirectionMatrixMode == PSUserMatrix;
2746 }
2747
2748 ///==========================================================================
2749 bool CPSEmitter::getUserMatrixUsageCount() const
2750 {
2751 NL_PS_FUNC(CPSEmitter_getUserMatrixUsageCount)
2752 return isUserMatrixUsed() ? 1 : 0;
2753 }
2754
2755
2756
2757 ///==========================================================================
2758 void CPSEmitter::doEmitOnce(uint firstInstanceIndex)
2759 {
2760 NL_PS_FUNC(CPSEmitter_doEmitOnce)
2761 if (!_EmittedType) return;
2762 if (!_GenNbScheme && _GenNb == 0) return;
2763 nlassert(_Owner);
2764 nlassert(CParticleSystem::InsideSimLoop); // should only be called by the sim loop
2765 float emitLOD;
2766 nlassert(_Owner);
2767 nlassert(_Owner->getOwner());
2768 const CParticleSystem *ps = _Owner->getOwner();
2769 if (ps->isAutoLODEnabled() && !ps->isSharingEnabled() && !_BypassAutoLOD)
2770 {
2771 // temp test for auto lod
2772 emitLOD = ps->getAutoLODEmitRatio();
2773 }
2774 else
2775 {
2776 emitLOD = 1.f;
2777 }
2778 nlassert(emitLOD >= 0.f);
2779 if (_GenNbScheme)
2780 {
2781 const uint BATCH_SIZE = 1024;
2782 uint32 numToEmit[BATCH_SIZE];
2783 uint k = firstInstanceIndex;
2784 nlassert(firstInstanceIndex < _Owner->getSize());
2785 uint leftToDo = _Owner->getSize() - firstInstanceIndex;
2786
2787 while (leftToDo)
2788 {
2789 uint toProcess = std::min((uint) BATCH_SIZE, leftToDo);
2790 uint32 *numToEmitPtr = (uint32 *) _GenNbScheme->make(_Owner, k, numToEmit, sizeof(uint32), true);
2791 leftToDo -= toProcess;
2792 while (toProcess)
2793 {
2794 CVector startPos;
2795 if (!_Owner->isParametricMotionEnabled())
2796 {
2797 startPos = _Owner->getPos()[k] - _Owner->getSpeed()[k] * CParticleSystem::EllapsedTime;
2798 }
2799 else
2800 {
2801 startPos = _Owner->getParametricInfos()[k].Pos;
2802 }
2803 float currTime = _Owner->getTime()[k];
2804 _Owner->getTime()[k] = 0.f; // when emit occurred, time was 0
2805 sint32 nbToGenerate = (sint32) (emitLOD * *numToEmitPtr);
2806 if (nbToGenerate > 0)
2807 {
2808 nbToGenerate = std::min(nbToGenerate, (sint32) _EmittedType->getMaxSize());
2809 processEmitConsistent(startPos, k, nbToGenerate, _Owner->getAgeInSeconds(k) / CParticleSystem::RealEllapsedTimeRatio);
2810 }
2811 // restore time & pos
2812 _Owner->getTime()[k] = currTime;
2813 ++ k;
2814 ++ numToEmitPtr;
2815 -- toProcess;
2816 }
2817 }
2818 }
2819 else
2820 {
2821 sint nbToGenerate = (sint) (emitLOD * _GenNb);
2822 if (nbToGenerate <= 0) nbToGenerate = 1;
2823 nbToGenerate = std::min(nbToGenerate, (sint) _EmittedType->getMaxSize());
2824 for(uint k = firstInstanceIndex; k < _Owner->getSize(); ++k)
2825 {
2826 // retrieve previous position (because motion step is done before spawn step)
2827 CVector startPos;
2828 if (!_Owner->isParametricMotionEnabled())
2829 {
2830 startPos = _Owner->getPos()[k] - _Owner->getSpeed()[k] * CParticleSystem::EllapsedTime;
2831 }
2832 else
2833 {
2834 startPos = _Owner->getParametricInfos()[k].Pos;
2835 }
2836 float currTime = _Owner->getTime()[k];
2837 _Owner->getTime()[k] = 0.f; // when emit occurred, time was 0
2838 processEmitConsistent(startPos, k, nbToGenerate, _Owner->getAgeInSeconds(k) / CParticleSystem::RealEllapsedTimeRatio);
2839 // restore time & pos
2840 _Owner->getTime()[k] = currTime;
2841 }
2842 }
2843 }
2844
2845 ///==========================================================================
2846 void CPSEmitter::updateEmitTrigger()
2847 {
2848 NL_PS_FUNC(CPSEmitter_updateEmitTrigger)
2849 if (!_EmitTrigger) return;
2850 nlassert(_Owner);
2851 nlassert(_Owner->getOwner());
2852 const CParticleSystem *ps = _Owner->getOwner();
2853 float emitLOD;
2854 if (ps->isAutoLODEnabled() && !ps->isSharingEnabled() && !_BypassAutoLOD)
2855 {
2856 // temp test for auto lod
2857 emitLOD = ps->getAutoLODEmitRatio();
2858 }
2859 else
2860 {
2861 emitLOD = 1.f;
2862 }
2863 if (_GenNbScheme)
2864 {
2865 const uint BATCH_SIZE = 1024;
2866 uint32 numToEmit[BATCH_SIZE];
2867 uint k = 0;
2868 uint leftToDo = _Owner->getSize();
2869 while (leftToDo)
2870 {
2871 uint toProcess = std::min(BATCH_SIZE, leftToDo);
2872 uint32 *numToEmitPtr = (uint32 *) _GenNbScheme->make(_Owner, k, numToEmit, sizeof(uint32), true);
2873 while (toProcess)
2874 {
2875 uint32 nbToGenerate = (sint32) (emitLOD * *numToEmitPtr);
2876 if (!nbToGenerate) nbToGenerate = 1;
2877 processEmit(k, nbToGenerate);
2878 ++ k;
2879 ++ numToEmitPtr;
2880 }
2881
2882 leftToDo -= toProcess;
2883 }
2884 }
2885 else
2886 {
2887 uint nbToGenerate = (sint32) (emitLOD * _GenNb);
2888 if (!nbToGenerate) nbToGenerate = 1;
2889 for(uint k = 0; k < _Owner->getSize(); ++k)
2890 {
2891 processEmit(k, nbToGenerate);
2892 }
2893 }
2894 _EmitTrigger = false;
2895 }
2896
2897
2898
2899 } // NL3D
2900
2901 namespace NLMISC
2902 {
2903
2904 std::string toString(NL3D::CPSEmitter::TEmissionType type)
2905 {
2906 NL_PS_FUNC(toString_CPSEmitter_TEmissionType)
2907 nlctassert(NL3D::CPSEmitter::numEmissionType == 5); // If this ct assertion is raised, the content of TEmissionType has changed, so should change this function !
2908 switch (type)
2909 {
2910 case NL3D::CPSEmitter::regular: return "regular";
2911 case NL3D::CPSEmitter::onDeath: return "onDeath";
2912 case NL3D::CPSEmitter::once: return "once";
2913 case NL3D::CPSEmitter::onBounce: return "onBounce";
2914 case NL3D::CPSEmitter::externEmit: return "externEmit";
2915 default:
2916 nlassert(0);
2917 return "";
2918 break;
2919 }
2920 }
2921
2922
2923 } // NLMISC