nel/src/3d/ps_tail_dot.cpp

   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