?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'main/rendor-staging' into fixes
[ryzomcore.git] / nel / src / 3d / ps_tail_dot.cpp
blobe8146e5829f52a5abb7bd8dcd8714bee306ddacc
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_tail_dot.h"
20 #include "nel/3d/ps_macro.h"
21 #include "nel/3d/driver.h"
22 #include "nel/3d/particle_system.h"
23 #include "nel/3d/texture_mem.h"
24 #include "nel/misc/smart_ptr.h"
25
26 #include <memory>
27
28 #ifdef DEBUG_NEW
29 #define new DEBUG_NEW
30 #endif
31
32 namespace NL3D
33 {
34 static NLMISC::CRGBA GradientB2W[] = {NLMISC::CRGBA(0, 0, 0, 0), NLMISC::CRGBA(255, 255, 255, 255) };
35
36 /// private use : this create a gradient texture that goew from black to white
37 static ITexture *CreateGradientTexture()
38 {
39 NL_PS_FUNC(CreateGradientTexture)
40 CUniquePtr<CTextureMem> tex(new CTextureMem((uint8 *) &GradientB2W,
41 sizeof(GradientB2W),
42 false, /* dont delete */
43 false, /* not a file */
44 2, 1)
45 );
46 tex->setWrapS(ITexture::Clamp);
47 tex->setShareName("#GradBW");
48 return tex.release();
49 }
50
51
52 ///////////////////////////////
53 // CPSTailDot implementation //
54 ///////////////////////////////
55
56 CPSTailDot::TVBMap CPSTailDot::_VBMap; // index / vertex buffers with no color
57 CPSTailDot::TVBMap CPSTailDot::_FadedVBMap; // index / vertex buffers for constant color with fading
58 CPSTailDot::TVBMap CPSTailDot::_ColoredVBMap; // index / vertex buffer + colors
59 CPSTailDot::TVBMap CPSTailDot::_FadedColoredVBMap; // index / vertex buffer + faded colors
60
61 //=======================================================
62 CPSTailDot::CPSTailDot() : _ColorFading(false),
63 _GlobalColor(false),
64 _Lighted(false),
65 _ForceLighted(false),
66 _Touch(true)
67 {
68 NL_PS_FUNC(CPSTailDot_CPSTailDot)
69 setInterpolationMode(Linear);
70 setSegDuration(0.06f);
71 if (CParticleSystem::getSerializeIdentifierFlag()) _Name = std::string("TailDot");
72 }
73
74 //=======================================================
75 CPSTailDot::~CPSTailDot()
76 {
77 NL_PS_FUNC(CPSTailDot_CPSTailDotDtor)
78 // delete _DyingRibbons;
79 }
80
81 //=======================================================
82 void CPSTailDot::serial(NLMISC::IStream &f)
83 {
84 NL_PS_FUNC(CPSTailDot_serial)
85
86 sint ver = f.serialVersion(3);
87 if (ver == 1)
88 {
89 nlassert(f.isReading());
90
91 /// we had CPSParticle::serial(f), but this is not the base class anymore, so we emulate this...
92 /// version 2 : auto-lod saved
93 sint ver2 = f.serialVersion(2);
94
95 // here is CPSLocatedBindable::serial(f)
96 sint ver3 = f.serialVersion(4);
97 f.serialPtr(_Owner);
98 if (ver3 > 1) f.serialEnum(_LOD);
99 if (ver3 > 2) f.serial(_Name);
100 if (ver3 > 3)
101 {
102 if (f.isReading())
103 {
104 uint32 id;
105 f.serial(id);
106 setExternID(id);
107 }
108 else
109 {
110 f.serial(_ExternID);
111 }
112 }
113
114 if (ver2 >= 2)
115 {
116 bool bDisableAutoLOD;
117 f.serial(bDisableAutoLOD);
118 disableAutoLOD(bDisableAutoLOD);
119 }
120
121 uint32 tailNbSegs;
122 bool colorFading;
123 bool systemBasisEnabled;
124
125 CPSColoredParticle::serialColorScheme(f);
126 f.serial(tailNbSegs, colorFading, systemBasisEnabled);
127
128 _ColorFading = colorFading;
129 _NbSegs = tailNbSegs >> 1;
130 if (_NbSegs < 2) _NbSegs = 2;
131 setInterpolationMode(Linear);
132 serialMaterial(f);
133
134
135 nlassert(_Owner);
136 resize(_Owner->getMaxSize());
137 initDateVect();
138 resetFromOwner();
139 }
140
141 if (ver >= 2)
142 {
143 CPSRibbonBase::serial(f);
144 CPSColoredParticle::serialColorScheme(f);
145 CPSMaterial::serialMaterial(f);
146 bool colorFading = _ColorFading;
147 f.serial(colorFading);
148 _ColorFading = colorFading;
149 if (ver >= 3)
150 {
151 uint32 tailNbSegs = _NbSegs;
152 f.serial(tailNbSegs);
153 }
154 if (f.isReading())
155 {
156 setTailNbSeg(_NbSegs);
157 touch();
158 }
159 }
160 }
161
162
163 //=======================================================
164 void CPSTailDot::step(TPSProcessPass pass)
165 {
166 NL_PS_FUNC(CPSTailDot_step)
167 if (pass == PSMotion)
168 {
169 if (!_Parametric)
170 {
171 updateGlobals();
172 }
173 }
174 else
175 if (
176 (pass == PSBlendRender && hasTransparentFaces())
177 || (pass == PSSolidRender && hasOpaqueFaces())
178 )
179 {
180 uint32 step;
181 uint numToProcess;
182 computeSrcStep(step, numToProcess);
183 if (!numToProcess) return;
184
185 /// update the material color
186 CParticleSystem &ps = *(_Owner->getOwner());
187 if (ps.getForceGlobalColorLightingFlag() || usesGlobalColorLighting())
188 {
189 _Mat.setColor(ps.getGlobalColorLighted());
190 }
191 else
192 {
193 _Mat.setColor(ps.getGlobalColor());
194 }
195
196 /** We support Auto-LOD for ribbons, although there is a built-in LOD (that change the geometry rather than the number of ribbons)
197 * that gives better result (both can be used simultaneously)
198 */
199
200 displayRibbons(numToProcess, step);
201
202 }
203 else
204 if (pass == PSToolRender) // edition mode only
205 {
206 //showTool();
207 }
208 }
209
210
211 //=======================================================
212 void CPSTailDot::newElement(const CPSEmitterInfo &info)
213 {
214 NL_PS_FUNC(CPSTailDot_newElement)
215 CPSRibbonBase::newElement(info);
216 newColorElement(info);
217 }
218
219
220 //=======================================================
221 void CPSTailDot::deleteElement(uint32 index)
222 {
223 NL_PS_FUNC(CPSTailDot_deleteElement)
224 CPSRibbonBase::deleteElement(index);
225 deleteColorElement(index);
226 }
227
228
229 //=======================================================
230 void CPSTailDot::resize(uint32 size)
231 {
232 NL_PS_FUNC(CPSTailDot_resize)
233 nlassert(size < (1 << 16));
234 CPSRibbonBase::resize(size);
235 resizeColor(size);
236 }
237
238 //=======================================================
239 void CPSTailDot::updateMatAndVbForColor(void)
240 {
241 NL_PS_FUNC(CPSTailDot_updateMatAndVbForColor)
242 touch();
243 }
244
245 //==========================================================================
246 void CPSTailDot::displayRibbons(uint32 nbRibbons, uint32 srcStep)
247 {
248 // if (!FilterPS[8]) return;
249 NL_PS_FUNC(CPSTailDot_displayRibbons)
250 if (!nbRibbons) return;
251 nlassert(_Owner);
252 CPSRibbonBase::updateLOD();
253 if (_UsedNbSegs < 2) return;
254 const float date = _Owner->getOwner()->getSystemDate();
255 uint8 *currVert;
256 CVBnPB &VBnPB = getVBnPB(); // get the appropriate vb (built it if needed)
257 CVertexBuffer &VB = VBnPB.VB;
258 CIndexBuffer &PB = VBnPB.PB;
259 const uint32 vertexSize = VB.getVertexSize();
260 uint colorOffset=0;
261
262 IDriver *drv = this->getDriver();
263 #ifdef NL_DEBUG
264 nlassert(drv);
265 #endif
266 drv->setupModelMatrix(getLocalToWorldTrailMatrix());
267 _Owner->incrementNbDrawnParticles(nbRibbons); // for benchmark purpose
268 const uint numRibbonBatch = getNumRibbonsInVB(); // number of ribons to process at once
269 if (_UsedNbSegs == 0) return;
270
271 ////////////////////
272 // Material setup //
273 ////////////////////
274 CParticleSystem &ps = *(_Owner->getOwner());
275 bool useGlobalColor = ps.getColorAttenuationScheme() != NULL || ps.isUserColorUsed();
276 if (useGlobalColor != _GlobalColor)
277 {
278 _GlobalColor = useGlobalColor;
279 touch();
280 }
281 if (usesGlobalColorLighting() != _Lighted)
282 {
283 _Lighted = usesGlobalColorLighting();
284 touch();
285 }
286 if (ps.getForceGlobalColorLightingFlag() != _ForceLighted)
287 {
288 _ForceLighted = ps.getForceGlobalColorLightingFlag();
289 touch();
290 }
291 updateMaterial();
292 setupGlobalColor();
293 //
294 if (_ColorScheme)
295 {
296 colorOffset = VB.getColorOff();
297 }
298
299 /////////////////////
300 // Compute ribbons //
301 /////////////////////
302
303 uint toProcess;
304 uint ribbonIndex = 0; // index of the first ribbon in the batch being processed
305 uint32 fpRibbonIndex = 0; // fixed point index in source
306 if (_ColorScheme)
307 {
308 _ColorScheme->setColorType(drv->getVertexColorFormat());
309 }
310 do
311 {
312 toProcess = std::min((uint) (nbRibbons - ribbonIndex) /* = left to do */, numRibbonBatch);
313 VB.setNumVertices((_UsedNbSegs + 1) * toProcess);
314 {
315 CVertexBufferReadWrite vba;
316 VB.lock (vba);
317 currVert = (uint8 *) vba.getVertexCoordPointer();
318
319 /// compute colors
320 if (_ColorScheme)
321 {
322 _ColorScheme->makeN(this->_Owner, ribbonIndex, currVert + colorOffset, vertexSize, toProcess, _UsedNbSegs + 1, srcStep);
323 }
324 uint k = toProcess;
325 //////////////////////////////////////////////////////////////////////////////////////
326 // interpolate and project points the result is directly setup in the vertex buffer //
327 //////////////////////////////////////////////////////////////////////////////////////
328 if (!_Parametric)
329 {
330
331 //////////////////////
332 // INCREMENTAL CASE //
333 //////////////////////
334 do
335 {
336 // the parent class has a method to get the ribbons positions
337 computeRibbon((uint) (fpRibbonIndex >> 16), (CVector *) currVert, vertexSize);
338 currVert += vertexSize * (_UsedNbSegs + 1);
339 fpRibbonIndex += srcStep;
340 }
341 while (--k);
342 }
343 else
344 {
345 //////////////////////
346 // PARAMETRIC CASE //
347 //////////////////////
348 do
349 {
350 // we compute each pos thanks to the parametric curve
351 _Owner->integrateSingle(date - _UsedSegDuration * (_UsedNbSegs + 1), _UsedSegDuration, _UsedNbSegs + 1, (uint) (fpRibbonIndex >> 16),
352 (NLMISC::CVector *) currVert, vertexSize);
353 currVert += vertexSize * (_UsedNbSegs + 1);
354 fpRibbonIndex += srcStep;
355 }
356 while (--k);
357
358 }
359 }
360 const uint numLine = _UsedNbSegs * toProcess;
361 PB.setNumIndexes(2 * numLine);
362 // display the result
363 drv->activeIndexBuffer(PB);
364 drv->activeVertexBuffer(VB);
365 drv->renderLines (_Mat, 0, numLine);
366 ribbonIndex += toProcess;
367 }
368 while (ribbonIndex != nbRibbons);
369 }
370
371 //==========================================================================
372 bool CPSTailDot::hasTransparentFaces(void)
373 {
374 NL_PS_FUNC(CPSTailDot_hasTransparentFaces)
375 return getBlendingMode() != CPSMaterial::alphaTest ;
376 }
377
378
379 //==========================================================================
380 bool CPSTailDot::hasOpaqueFaces(void)
381 {
382 NL_PS_FUNC(CPSTailDot_hasOpaqueFaces)
383 return !hasTransparentFaces();
384 }
385
386 //==========================================================================
387 uint32 CPSTailDot::getNumWantedTris() const
388 {
389 NL_PS_FUNC(CPSTailDot_getNumWantedTris)
390 nlassert(_Owner);
391 //return _Owner->getMaxSize() * _NbSegs;
392 return _Owner->getSize() * _NbSegs;
393 }
394
395
396
397 //==========================================================================
398 CPSTailDot::CVBnPB &CPSTailDot::getVBnPB()
399 {
400 NL_PS_FUNC(CPSTailDot_getVBnPB)
401 /// choose the right vb
402 TVBMap &map = _ColorScheme ? (_ColorFading ? _FadedColoredVBMap : _ColoredVBMap) // per ribbon color
403 : (_ColorFading ? _FadedVBMap : _VBMap); // global color
404 TVBMap::iterator it = map.find(_UsedNbSegs + 1);
405 if (it != map.end())
406 {
407 return it->second;
408 }
409 else // must create this vb, with few different size, it is still interseting, though they are only destroyed at exit
410 {
411 const uint numRibbonInVB = getNumRibbonsInVB();
412 CVBnPB &VBnPB = map[_UsedNbSegs + 1]; // make an entry
413
414 /// set the vb format & size
415 /// In the case of a ribbon with color and fading, we encode the fading in a texture
416 /// If the ribbon has fading, but only a global color, we encode it in the primary color
417 CVertexBuffer &vb = VBnPB.VB;
418 vb.setPreferredMemory(CVertexBuffer::AGPVolatile, true);
419 vb.setVertexFormat(CVertexBuffer::PositionFlag
420 |(_ColorScheme || _ColorFading ? CVertexBuffer::PrimaryColorFlag : 0)
421 | (_ColorScheme && _ColorFading ? CVertexBuffer::TexCoord0Flag : 0));
422
423 vb.setNumVertices((_UsedNbSegs + 1) * numRibbonInVB ); // 1 seg = 1 line + terminal vertices
424
425 // set the primitive block size
426 CIndexBuffer &pb = VBnPB.PB;
427 pb.setFormat(NL_DEFAULT_INDEX_BUFFER_FORMAT);
428 pb.setNumIndexes(2 * _UsedNbSegs * numRibbonInVB);
429 /// Setup the pb and vb parts. Not very fast but executed only once
430 uint vbIndex = 0;
431 uint pbIndex = 0;
432 CIndexBufferReadWrite ibaWrite;
433 pb.lock (ibaWrite);
434 CVertexBufferReadWrite vba;
435 vb.lock (vba);
436 for (uint i = 0; i < numRibbonInVB; ++i)
437 {
438 for (uint k = 0; k < (_UsedNbSegs + 1); ++k)
439 {
440
441 if (_ColorScheme && _ColorFading)
442 {
443 vba.setTexCoord(vbIndex, 0, 0.5f - 0.5f * ((float) k / _UsedNbSegs), 0);
444 }
445 else if (_ColorFading)
446 {
447 uint8 intensity = (uint8) (255 * (1.f - ((float) k / _UsedNbSegs)));
448 NLMISC::CRGBA col(intensity, intensity, intensity, intensity);
449 vba.setColor(vbIndex, col);
450 }
451
452 /// add 1 line in the primitive block
453 if (k != _UsedNbSegs)
454 {
455 ibaWrite.setLine(pbIndex, vbIndex, vbIndex + 1);
456 pbIndex+=2;
457 }
458 ++vbIndex;
459 }
460 }
461 vb.setName("CPSTailDot");
462 NL_SET_IB_NAME(pb, "CPSTailDot");
463 return VBnPB;
464 }
465 }
466
467 //==========================================================================
468 uint CPSTailDot::getNumRibbonsInVB() const
469 {
470 NL_PS_FUNC(CPSTailDot_getNumRibbonsInVB)
471 /// approximation of the max number of vertices we want in a vb
472 const uint vertexInVB = 256;
473 return std::max(1u, (uint) (vertexInVB / (_UsedNbSegs + 1)));
474 }
475
476
477 //==========================================================================
478 void CPSTailDot::updateMaterial()
479 {
480 NL_PS_FUNC(CPSTailDot_updateMaterial)
481 if (!_Touch) return;
482
483 static NLMISC::CRefPtr<ITexture> ptGradTexture;
484
485 CParticleSystem &ps = *(_Owner->getOwner());
486 if (_ColorScheme)
487 { // PER RIBBON COLOR
488 if (ps.getForceGlobalColorLightingFlag() || usesGlobalColorLighting() || ps.getColorAttenuationScheme() || ps.isUserColorUsed())
489 {
490 if (_ColorFading) // global color + fading + per ribbon color
491 {
492 // the first stage is used to get fading * global color
493 // the second stage multiply the result by the diffuse colot
494 if (ptGradTexture == NULL) // have we got a gradient texture ?
495 {
496 ptGradTexture = CreateGradientTexture();
497 }
498 _Mat.setTexture(0, ptGradTexture);
499 CPSMaterial::forceTexturedMaterialStages(2); // use constant color 0 * diffuse, 1 stage needed
500 SetupModulatedStage(_Mat, 0, CMaterial::Texture, CMaterial::Constant);
501 SetupModulatedStage(_Mat, 1, CMaterial::Previous, CMaterial::Diffuse);
502 }
503 else // per ribbon color with global color
504 {
505 CPSMaterial::forceTexturedMaterialStages(1); // use constant color 0 * diffuse, 1 stage needed
506 SetupModulatedStage(_Mat, 0, CMaterial::Diffuse, CMaterial::Constant);
507 }
508 }
509 else
510 {
511 if (_ColorFading) // per ribbon color, fading
512 {
513 if (ptGradTexture == NULL) // have we got a gradient texture ?
514 {
515 ptGradTexture = CreateGradientTexture();
516 }
517 _Mat.setTexture(0, ptGradTexture);
518 CPSMaterial::forceTexturedMaterialStages(1);
519 SetupModulatedStage(_Mat, 0, CMaterial::Texture, CMaterial::Diffuse);
520 }
521 else // per color ribbon with no fading, and no global color
522 {
523 CPSMaterial::forceTexturedMaterialStages(0); // no texture use constant diffuse only
524 }
525 }
526 }
527 else // GLOBAL COLOR
528 {
529 if (_ColorFading)
530 {
531 CPSMaterial::forceTexturedMaterialStages(1); // use constant color 0 * diffuse, 1 stage needed
532 SetupModulatedStage(_Mat, 0, CMaterial::Diffuse, CMaterial::Constant);
533 }
534 else // constant color
535 {
536 CPSMaterial::forceTexturedMaterialStages(0); // no texture use constant diffuse only
537 }
538 }
539
540 _Touch = false;
541 }
542
543 //==========================================================================
544 void CPSTailDot::setupGlobalColor()
545 {
546 NL_PS_FUNC(CPSTailDot_setupGlobalColor)
547 /// setup the global color if it is used
548 CParticleSystem &ps = *(_Owner->getOwner());
549 if (_ColorScheme)
550 {
551 if (ps.getForceGlobalColorLightingFlag() || usesGlobalColorLighting())
552 {
553 _Mat.texConstantColor(0, ps.getGlobalColorLighted());
554 }
555 else
556 {
557 _Mat.texConstantColor(0, ps.getGlobalColor());
558 }
559 }
560 else // GLOBAL COLOR with / without fading
561 {
562 if (ps.getForceGlobalColorLightingFlag() || usesGlobalColorLighting())
563 {
564 NLMISC::CRGBA col;
565 col.modulateFromColor(ps.getGlobalColorLighted(), _Color);
566 if (_ColorFading)
567 {
568 _Mat.texConstantColor(0, col);
569 }
570 else // color attenuation, no fading :
571 {
572 _Mat.setColor(col);
573 }
574 }
575 else
576 if (ps.getColorAttenuationScheme() || ps.isUserColorUsed())
577 {
578 NLMISC::CRGBA col;
579 col.modulateFromColor(ps.getGlobalColor(), _Color);
580 if (_ColorFading)
581 {
582 _Mat.texConstantColor(0, col);
583 }
584 else // color attenuation, no fading :
585 {
586 _Mat.setColor(col);
587 }
588 }
589 else
590 {
591 if (_ColorFading)
592 {
593 _Mat.texConstantColor(0, _Color);
594 }
595 else // constant color
596 {
597 _Mat.setColor(_Color);
598 }
599 }
600 }
601 }
602
603 } // NL3D