nel/src/3d/ps_particle_basic.cpp

   1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This source file has been modified by the following contributors:
   5 // Copyright (C) 2013  Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
   6 //
   7 // This program is free software: you can redistribute it and/or modify
   8 // it under the terms of the GNU Affero General Public License as
   9 // published by the Free Software Foundation, either version 3 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU Affero General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU Affero General Public License
  18 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19
  20 #include "std3d.h"
  21
  22 #include "nel/3d/ps_particle_basic.h"
  23 #include "nel/3d/ps_macro.h"
  24 #include "nel/3d/driver.h"
  25 #include "nel/3d/texture_grouped.h"
  26 #include "nel/3d/texture_bump.h"
  27 #include "nel/3d/texture_mem.h"
  28 #include "nel/3d/particle_system.h"
  29
  30
  31 #ifdef DEBUG_NEW
  32 #define new DEBUG_NEW
  33 #endif
  34
  35 namespace NL3D
  36 {
  37
  38
  39
  40 /////////////////////////////////
  41 // CPSParticle implementation  //
  42 /////////////////////////////////
  43
  44 //=======================================
  45 CPSParticle::CPSParticle() : _DisableAutoLOD(false),
  46                                                          _UsesGlobalColorLighting(false)
  47 {
  48         NL_PS_FUNC(CPSParticle_CPSParticle)
  49 }
  50
  51 //=======================================
  52 void CPSParticle::showTool()
  53 {
  54         NL_PS_FUNC(CPSParticle_showTool)
  55         PARTICLES_CHECK_MEM;
  56
  57         CVector I = CVector::I;
  58         CVector J = CVector::J;
  59
  60         const CVector tab[] = { 2 * J, I + J
  61                                                         , I + J, 2 * I + J
  62                                                         , 2 * I + J, I
  63                                                         , I,  2 * I - J
  64                                                         , 2 * I - J, - .5f * J
  65                                                         , - .5f * J, -2 * I - J
  66                                                         , -2 * I - J, - I
  67                                                         , - I, -2 * I + J
  68                                                         , -2 * I + J, - I + J
  69                                                         , - I + J, 2 * J
  70                                                 };
  71         const uint tabSize = sizeof(tab) / (2 * sizeof(CVector));
  72
  73         const float sSize = 0.1f;
  74         displayIcon2d(tab, tabSize, sSize);
  75
  76         PARTICLES_CHECK_MEM;
  77 }
  78
  79 //=======================================
  80 void CPSParticle::computeSrcStep(uint32 &step, uint &numToProcess)
  81 {
  82         NL_PS_FUNC(CPSParticle_computeSrcStep)
  83         nlassert(_Owner && _Owner->getOwner());
  84         const CParticleSystem &ps = *(_Owner->getOwner());
  85         if (_DisableAutoLOD || !ps.isAutoLODEnabled() || !ps.isSharingEnabled() || _Owner->getSize() == 0) // Should Auto-LOD be used ?
  86         {
  87                 step = (1 << 16);
  88                 numToProcess = _Owner->getSize();
  89         }
  90         else
  91         {
  92                 float oneMinusLODRatio = ps.getOneMinusCurrentLODRatio();
  93                 float LODRatio = 1.f - oneMinusLODRatio;
  94                 if (LODRatio > ps.getAutoLODStartDistPercent())
  95                 {
  96                         float factor = (LODRatio - 1.f) / (ps.getAutoLODStartDistPercent() - 1.f);
  97                         NLMISC::clamp(factor, 0.f, 1.f);
  98                         float r = factor;
  99                         for (uint k = 1; k < ps.getAutoLODDegradationExponent(); ++k)
 100                         {
 101                                 r *= factor;
 102                         }
 103                         numToProcess = (uint) (_Owner->getSize() * r);
 104                         if (numToProcess < 1) { numToProcess = 1; }
 105
 106                         step =   ps.getAutoLODMode() ?                             // skip or limit number, depending on the mode
 107                                 (_Owner->getSize() << 16) / numToProcess : // skip particles
 108                                 (1 << 16);                                                         // just display less particles
 109                 }
 110                 else
 111                 {
 112                         step = (1 << 16);
 113                         numToProcess = _Owner->getSize();
 114                 }
 115         }
 116
 117 }
 118
 119 //////////////////////////////////////
 120 // coloured particle implementation //
 121 //////////////////////////////////////
 122
 123 //=======================================
 124 void CPSColoredParticle::setColorScheme(CPSAttribMaker<CRGBA> *col)
 125 {
 126         NL_PS_FUNC(CPSColoredParticle_setColorScheme)
 127         nlassert(col);
 128         delete _ColorScheme;
 129         _ColorScheme = col;
 130         if (getColorOwner() && col->hasMemory()) col->resize(getColorOwner()->getMaxSize(), getColorOwner()->getSize());
 131         updateMatAndVbForColor();
 132 }
 133
 134 //=======================================
 135 void CPSColoredParticle::setColor(NLMISC::CRGBA col)
 136 {
 137         NL_PS_FUNC(CPSColoredParticle_setColor)
 138         delete _ColorScheme;
 139         _ColorScheme = NULL;
 140         _Color = col;
 141         updateMatAndVbForColor();
 142 }
 143
 144 //=======================================
 145 CPSColoredParticle::CPSColoredParticle() : _Color(CRGBA(255, 255, 255)), _ColorScheme(NULL)
 146 {
 147         NL_PS_FUNC(CPSColoredParticle_CPSColoredParticle)
 148 }
 149
 150 //=======================================
 151 CPSColoredParticle::~CPSColoredParticle()
 152 {
 153         NL_PS_FUNC(CPSColoredParticle_CPSColoredParticleDtor)
 154         delete _ColorScheme;
 155 }
 156
 157 //=======================================
 158 void CPSColoredParticle::serialColorScheme(NLMISC::IStream &f)
 159 {
 160         NL_PS_FUNC(CPSColoredParticle_IStream )
 161         f.serialVersion(1);
 162         if (f.isReading())
 163         {
 164                 if (_ColorScheme)
 165                 {
 166                         delete _ColorScheme;
 167                         _ColorScheme = NULL;
 168                 }
 169         }
 170         bool useColorScheme = _ColorScheme != NULL;
 171         f.serial(useColorScheme);
 172         if (useColorScheme)
 173         {
 174                 f.serialPolyPtr(_ColorScheme);
 175         }
 176         else
 177         {
 178                 f.serial(_Color);
 179         }
 180 }
 181
 182 ///////////////////////////////////
 183 // sized particle implementation //
 184 ///////////////////////////////////
 185
 186 //=======================================
 187 void CPSSizedParticle::setSizeScheme(CPSAttribMaker<float> *size)
 188 {
 189         NL_PS_FUNC(CPSSizedParticle_setSizeScheme)
 190         nlassert(size != NULL);
 191         delete _SizeScheme;
 192         _SizeScheme = size;
 193         if (getSizeOwner() && size->hasMemory()) size->resize(getSizeOwner()->getMaxSize(), getSizeOwner()->getSize());
 194 }
 195
 196 //=======================================
 197 void CPSSizedParticle::setSize(float size)
 198 {
 199         NL_PS_FUNC(CPSSizedParticle_setSize)
 200         delete _SizeScheme;
 201         _SizeScheme = NULL;
 202         _ParticleSize = size;
 203 }
 204
 205 //=======================================
 206 CPSSizedParticle::CPSSizedParticle() : _ParticleSize(0.3f), _SizeScheme(NULL)
 207 {
 208         NL_PS_FUNC(CPSSizedParticle_CPSSizedParticle)
 209 }
 210
 211 //=======================================
 212 CPSSizedParticle::~CPSSizedParticle()
 213 {
 214         NL_PS_FUNC(CPSSizedParticle_CPSSizedParticleDtor)
 215         delete _SizeScheme;
 216 }
 217
 218 //=======================================
 219 void CPSSizedParticle::serialSizeScheme(NLMISC::IStream &f)
 220 {
 221         NL_PS_FUNC(CPSSizedParticle_serialSizeScheme)
 222         f.serialVersion(1);
 223         if (f.isReading())
 224         {
 225                 if (_SizeScheme)
 226                 {
 227                         delete _SizeScheme;
 228                         _SizeScheme = NULL;
 229                 }
 230         }
 231         bool useSizeScheme = _SizeScheme != NULL;
 232         f.serial(useSizeScheme);
 233         if (useSizeScheme)
 234         {
 235                 f.serialPolyPtr(_SizeScheme);
 236         }
 237         else
 238         {
 239                 f.serial(_ParticleSize);
 240         }
 241 };
 242
 243 /////////////////////////////////////
 244 // rotated particle implementation //
 245 /////////////////////////////////////
 246
 247 float CPSRotated2DParticle::_RotTable[256 * 4];
 248 bool CPSRotated2DParticle::_InitializedRotTab = false;
 249
 250 ///===================================================================================
 251 void CPSRotated2DParticle::setAngle2DScheme(CPSAttribMaker<float> *angle2DScheme)
 252 {
 253         NL_PS_FUNC(CPSRotated2DParticle_setAngle2DScheme)
 254         nlassert(angle2DScheme);
 255         delete _Angle2DScheme;
 256         _Angle2DScheme = angle2DScheme;
 257         if (getAngle2DOwner() && angle2DScheme->hasMemory()) angle2DScheme->resize(getAngle2DOwner()->getMaxSize(), getAngle2DOwner()->getSize());
 258 }
 259
 260 ///===================================================================================
 261 void CPSRotated2DParticle::setAngle2D(float angle2DScheme)
 262 {
 263         NL_PS_FUNC(CPSRotated2DParticle_setAngle2D)
 264         delete _Angle2DScheme;
 265         _Angle2DScheme = NULL;
 266         _Angle2D = angle2DScheme;
 267 }
 268
 269 ///===================================================================================
 270 CPSRotated2DParticle::CPSRotated2DParticle() : _Angle2D(0), _Angle2DScheme(NULL)
 271 {
 272         NL_PS_FUNC(CPSRotated2DParticle_CPSRotated2DParticle)
 273 }
 274
 275 ///===================================================================================
 276 CPSRotated2DParticle::~CPSRotated2DParticle()
 277 {
 278         NL_PS_FUNC(CPSRotated2DParticle_CPSRotated2DParticleDtor)
 279         delete _Angle2DScheme;
 280 }
 281
 282 ///===================================================================================
 283 void CPSRotated2DParticle::serialAngle2DScheme(NLMISC::IStream &f)
 284 {
 285         NL_PS_FUNC(CPSRotated2DParticle_serialAngle2DScheme)
 286         f.serialVersion(1);
 287         if (f.isReading())
 288         {
 289                 if (_Angle2DScheme)
 290                 {
 291                         delete _Angle2DScheme;
 292                         _Angle2DScheme = NULL;
 293                 }
 294         }
 295         bool useAngle2DScheme = _Angle2DScheme != NULL;
 296         f.serial(useAngle2DScheme);
 297         if (useAngle2DScheme)
 298         {
 299                 f.serialPolyPtr(_Angle2DScheme);
 300         }
 301         else
 302         {
 303                 f.serial(_Angle2D);
 304         }
 305 }
 306
 307 ///===================================================================================
 308 void CPSRotated2DParticle::initRotTable(void)
 309 {
 310         NL_PS_FUNC(CPSRotated2DParticle_initRotTable)
 311         float *ptFloat = _RotTable;
 312         for (uint32 k = 0; k < 256; ++k)
 313         {
 314                 const float ca = (float) cos(k * (1.0f / 256.0f) * 2.0f * NLMISC::Pi);
 315                 const float sa = (float) sin(k * (1.0f / 256.0f) * 2.0f * NLMISC::Pi);
 316
 317                 *ptFloat++ = -ca - sa;
 318                 *ptFloat++ = -sa + ca;
 319
 320                 *ptFloat++ = ca - sa;
 321                 *ptFloat++ = sa + ca;
 322         }
 323         _InitializedRotTab = true;
 324 }
 325
 326 //////////////////////////////////////
 327 // textured particle implementation //
 328 //////////////////////////////////////
 329
 330 ///===================================================================================
 331 void CPSTexturedParticle::setTextureIndexScheme(CPSAttribMaker<sint32> *animOrder)
 332 {
 333         NL_PS_FUNC(CPSTexturedParticle_setTextureIndexScheme)
 334         nlassert(animOrder);
 335         nlassert(_TexGroup); // setTextureGroup must have been called before this
 336         delete _TextureIndexScheme;
 337         _TextureIndexScheme = animOrder;
 338         if (getTextureIndexOwner() && animOrder->hasMemory()) animOrder->resize(getTextureIndexOwner()->getMaxSize(), getTextureIndexOwner()->getSize());
 339
 340
 341         updateMatAndVbForTexture();
 342 }
 343
 344 ///===================================================================================
 345 void CPSTexturedParticle::setTextureIndex(sint32 index)
 346 {
 347         NL_PS_FUNC(CPSTexturedParticle_setTextureIndex)
 348         delete _TextureIndexScheme;
 349         _TextureIndexScheme = NULL;
 350         _TextureIndex = index;
 351 }
 352
 353 ///===================================================================================
 354 void CPSTexturedParticle::setTextureGroup(NLMISC::CSmartPtr<CTextureGrouped> texGroup)
 355 {
 356         NL_PS_FUNC(CPSTexturedParticle_setTextureGroup)
 357         nlassert(texGroup);
 358         if (_Tex)
 359         {
 360                 _Tex = NULL;
 361         }
 362         _TexGroup = texGroup;
 363         updateMatAndVbForTexture();
 364 }
 365
 366 ///===================================================================================
 367 void CPSTexturedParticle::setTexture(CSmartPtr<ITexture> tex)
 368 {
 369         NL_PS_FUNC(CPSTexturedParticle_setTexture)
 370         delete _TextureIndexScheme;
 371         _TextureIndexScheme = NULL;
 372         _Tex = tex;
 373         _TexGroup = NULL; // release any grouped texture if one was set before
 374         updateMatAndVbForTexture();
 375 }
 376
 377 ///===================================================================================
 378 CPSTexturedParticle::CPSTexturedParticle() : _TexGroup(NULL),
 379                                                                                          _TextureIndexScheme(NULL),
 380                                                                                          _TextureIndex(0)
 381 {
 382         NL_PS_FUNC(CPSTexturedParticle_CPSTexturedParticle)
 383 }
 384
 385 ///===================================================================================
 386 CPSTexturedParticle::~CPSTexturedParticle()
 387 {
 388         NL_PS_FUNC(CPSTexturedParticle_CPSTexturedParticleDtor)
 389         delete _TextureIndexScheme;
 390 }
 391
 392 ///===================================================================================
 393 void CPSTexturedParticle::serialTextureScheme(NLMISC::IStream &f)
 394 {
 395         NL_PS_FUNC(CPSTexturedParticle_serialTextureScheme)
 396         f.serialVersion(1);
 397         if (f.isReading())
 398         {
 399                 if (_TextureIndexScheme)
 400                 {
 401                         delete _TextureIndexScheme;
 402                         _TextureIndexScheme = NULL;
 403                         _Tex = NULL;
 404                         _TexGroup = NULL;
 405                 }
 406         }
 407
 408         bool useAnimatedTexture;
 409         if (!f.isReading())
 410         {
 411                 useAnimatedTexture = (_TexGroup != NULL);
 412         }
 413         f.serial(useAnimatedTexture);
 414         if (useAnimatedTexture)
 415         {
 416                 if (f.isReading())
 417                 {
 418                         CTextureGrouped *ptTex = NULL;
 419                         f.serialPolyPtr(ptTex);
 420                         _TexGroup = ptTex;
 421                 }
 422                 else
 423                 {
 424                         CTextureGrouped *ptTex = _TexGroup;
 425                         f.serialPolyPtr(ptTex);
 426                 }
 427
 428                 bool useTextureIndexScheme = _TextureIndexScheme != NULL;
 429                 f.serial(useTextureIndexScheme);
 430                 if (useTextureIndexScheme)
 431                 {
 432                         f.serialPolyPtr(_TextureIndexScheme);
 433                         _TextureIndex = 0;
 434                 }
 435                 else
 436                 {
 437                         f.serial(_TextureIndex);
 438                 }
 439         }
 440         else
 441         {
 442                 if (f.isReading())
 443                 {
 444                         ITexture *ptTex = NULL;
 445                         f.serialPolyPtr(ptTex);
 446                         _Tex = ptTex;
 447                 }
 448                 else
 449                 {
 450                         ITexture *ptTex = _Tex;
 451                         f.serialPolyPtr(ptTex);
 452                 }
 453         }
 454 }
 455
 456 ////////////////////////////////////////////////////////
 457 //       CPSRotated3DPlaneParticle  implementation    //
 458 ////////////////////////////////////////////////////////
 459
 460 ///===================================================================================
 461 void CPSRotated3DPlaneParticle::setPlaneBasisScheme(CPSAttribMaker<CPlaneBasis> *basisMaker)
 462 {
 463         NL_PS_FUNC(CPSRotated3DPlaneParticle_setPlaneBasisScheme)
 464         nlassert(basisMaker);
 465         delete _PlaneBasisScheme;
 466         _PlaneBasisScheme = basisMaker;
 467         if (getPlaneBasisOwner() && basisMaker->hasMemory()) basisMaker->resize(getPlaneBasisOwner()->getMaxSize(), getPlaneBasisOwner()->getSize());
 468 }
 469
 470 ///===================================================================================
 471 void CPSRotated3DPlaneParticle::setPlaneBasis(const CPlaneBasis &basis)
 472 {
 473         NL_PS_FUNC(CPSRotated3DPlaneParticle_setPlaneBasis)
 474         delete _PlaneBasisScheme;
 475         _PlaneBasisScheme = NULL;
 476         _PlaneBasis = basis;
 477 }
 478
 479 ///===================================================================================
 480 CPSRotated3DPlaneParticle::CPSRotated3DPlaneParticle() : _PlaneBasisScheme(NULL)
 481 {
 482         NL_PS_FUNC(CPSRotated3DPlaneParticle_CPSRotated3DPlaneParticle)
 483         _PlaneBasis.X = CVector::I;
 484         _PlaneBasis.Y = CVector::J;
 485 }
 486
 487 ///===================================================================================
 488 CPSRotated3DPlaneParticle::~CPSRotated3DPlaneParticle()
 489 {
 490         NL_PS_FUNC(CPSRotated3DPlaneParticle_CPSRotated3DPlaneParticleDtor)
 491         delete _PlaneBasisScheme;
 492 }
 493
 494 ///===================================================================================
 495 void CPSRotated3DPlaneParticle::serialPlaneBasisScheme(NLMISC::IStream &f)
 496 {
 497         NL_PS_FUNC(CPSRotated3DPlaneParticle_serialPlaneBasisScheme)
 498         f.serialVersion(1);
 499         f.serialPolyPtr(_PlaneBasisScheme);
 500         bool usePlaneBasisScheme = _PlaneBasisScheme != NULL;
 501         if (!usePlaneBasisScheme)
 502         {
 503                 f.serial(_PlaneBasis);
 504         }
 505 }
 506
 507 ////////////////////////////////
 508 // CPSMaterial implementation //
 509 ////////////////////////////////
 510
 511 ///===================================================================================
 512 CPSMaterial::CPSMaterial()
 513 {
 514         NL_PS_FUNC(CPSMaterial_CPSMaterial)
 515         _Mat.setBlend(true);
 516         _Mat.setBlendFunc(CMaterial::one, CMaterial::one);
 517         _Mat.setZWrite(false);
 518 }
 519
 520 ///===================================================================================
 521 void CPSMaterial::serialMaterial(NLMISC::IStream &f)
 522 {
 523         NL_PS_FUNC(CPSMaterial_IStream )
 524         // version 3 : added zbias
 525         sint ver = f.serialVersion(3);
 526         TBlendingMode m = getBlendingMode();
 527         f.serialEnum(m);
 528         setBlendingMode(m);
 529         if (ver == 2)
 530         {
 531                 bool zTest = isZTestEnabled();
 532                 f.serial(zTest);
 533                 enableZTest(zTest);
 534         }
 535         else
 536         if (ver >= 3)
 537         {
 538                 // bit 0 : ztest enabled
 539                 // bit 1 : 1 if zbias is not 0, in this case zbias follows
 540                 uint8 flags = (isZTestEnabled() ? 1 : 0) | (getZBias() != 0.f ? 2 : 0);
 541                 f.serial(flags);
 542                 enableZTest((flags & 1) != 0);
 543                 if (flags & 2)
 544                 {
 545                         float zBias = getZBias();
 546                         f.serial(zBias);
 547                         setZBias(zBias);
 548                 }
 549         }
 550 }
 551
 552
 553 ///===================================================================================
 554 void CPSMaterial::enableZTest(bool enabled)
 555 {
 556         NL_PS_FUNC(CPSMaterial_enableZTest)
 557         _Mat.setZFunc(enabled ? CMaterial::less : CMaterial::always);
 558 }
 559
 560 ///===================================================================================
 561 bool CPSMaterial::isZTestEnabled() const
 562 {
 563         NL_PS_FUNC(CPSMaterial_isZTestEnabled)
 564         return _Mat.getZFunc() != CMaterial::always;
 565 }
 566
 567 ///===================================================================================
 568 void CPSMaterial::setBlendingMode(CPSMaterial::TBlendingMode mode)
 569 {
 570         NL_PS_FUNC(CPSMaterial_setBlendingMode)
 571         switch (mode)
 572         {
 573                 case add:
 574                         _Mat.setBlend(true);
 575                         _Mat.setBlendFunc(CMaterial::one, CMaterial::one);
 576                         _Mat.setZWrite(false);
 577                         _Mat.setAlphaTest(false);
 578                 break;
 579                 case modulate:
 580                         _Mat.setBlend(true);
 581                         _Mat.setBlendFunc(CMaterial::zero, CMaterial::srccolor);
 582                         _Mat.setZWrite(false);
 583                         _Mat.setAlphaTest(false);
 584                 break;
 585                 case alphaBlend:
 586                         _Mat.setBlend(true);
 587                         _Mat.setBlendFunc(CMaterial::srcalpha, CMaterial::invsrcalpha);
 588                         _Mat.setZWrite(false);
 589                         _Mat.setAlphaTest(false);
 590                 break;
 591                 case alphaTest:
 592                         _Mat.setBlend(false);
 593                         _Mat.setZWrite(true);
 594                         _Mat.setAlphaTest(true);
 595                 break;
 596         }
 597 }
 598
 599 ///===================================================================================
 600 CPSMaterial::TBlendingMode CPSMaterial::getBlendingMode(void) const
 601 {
 602         NL_PS_FUNC(CPSMaterial_getBlendingMode)
 603         if (_Mat.getBlend())
 604         {
 605                 CMaterial::TBlend srcBlend = _Mat.getSrcBlend();
 606                 CMaterial::TBlend destBlend = _Mat.getDstBlend();
 607
 608                 if (srcBlend == CMaterial::one && destBlend == CMaterial::one) return add;
 609                 if (srcBlend == CMaterial::zero && destBlend == CMaterial::srccolor) return modulate;
 610                 if (srcBlend == CMaterial::srcalpha && destBlend == CMaterial::invsrcalpha) return alphaBlend;
 611
 612                 // unrecognized mode
 613                 nlassert(0);
 614                 return alphaTest; // to avoid a warning only ...
 615         }
 616         else
 617         {
 618                 return alphaTest;
 619         }
 620 }
 621
 622 ///===================================================================================
 623 void CPSMaterial::forceModulateConstantColor(bool force, const NLMISC::CRGBA &col)
 624 {
 625         NL_PS_FUNC(CPSMaterial_forceModulateConstantColor)
 626         if (force)
 627         {
 628                 /// TODO : caching..
 629                 _Mat.texConstantColor(1, col);
 630                 _Mat.texEnvOpRGB(1, CMaterial::Modulate);
 631                 _Mat.texEnvOpAlpha(1, CMaterial::Modulate);
 632                 _Mat.texEnvArg0RGB(1, CMaterial::Previous, CMaterial::SrcColor);
 633                 _Mat.texEnvArg1RGB(1, CMaterial::Constant, CMaterial::SrcColor);
 634                 _Mat.texEnvArg0Alpha(1, CMaterial::Previous, CMaterial::SrcAlpha);
 635                 _Mat.texEnvArg1Alpha(1, CMaterial::Constant, CMaterial::SrcAlpha);
 636                 forceTexturedMaterialStages(2);
 637         }
 638         else
 639         {
 640                 if (_Mat.getTexture(1) != NULL)
 641                 {
 642                         _Mat.setTexture(1, NULL);
 643                 }
 644         }
 645 }
 646
 647
 648 ///===================================================================================
 649 void CPSMaterial::forceTexturedMaterialStages(uint numStages)
 650 {
 651         NL_PS_FUNC(CPSMaterial_forceTexturedMaterialStages)
 652         ITexture *blankTex = NULL;
 653         uint k;
 654         for (k = 0; k < numStages; ++k)
 655         {
 656                 if (_Mat.getTexture(k) == NULL)
 657                 {
 658                         if (!blankTex)
 659                         {
 660                                 blankTex = CTextureMem::Create1x1WhiteTex();
 661                         }
 662                         _Mat.setTexture(k, blankTex);
 663                 }
 664         }
 665         for (; k < IDRV_MAT_MAXTEXTURES; ++k)
 666         {
 667                 if (_Mat.getTexture(k) != NULL)
 668                 {
 669                         _Mat.setTexture(k, NULL);
 670                 }
 671         }
 672 }
 673
 674
 675 /////////////////////////////////////////////
 676 // CPSMultiTexturedParticle implementation //
 677 /////////////////////////////////////////////
 678
 679 //=======================================
 680 bool CPSMultiTexturedParticle::_ForceBasicCaps  = false;
 681
 682 //=======================================
 683 CPSMultiTexturedParticle::CPSMultiTexturedParticle() : _MainOp(Add), _AlternateOp(Add), _MultiTexState(TouchFlag), _BumpFactor(1.f)
 684 {
 685         NL_PS_FUNC(CPSMultiTexturedParticle_CPSMultiTexturedParticle)
 686 }
 687
 688 //=======================================
 689 void    CPSMultiTexturedParticle::enableMultiTexture(bool enabled /*= true*/)
 690 {
 691         NL_PS_FUNC(CPSMultiTexturedParticle_enableMultiTexture)
 692         if (isMultiTextureEnabled() == enabled) return;
 693         if (!enabled)
 694         {
 695                 _Texture2                  = NULL;
 696                 _AlternateTexture2 = NULL;
 697                 _MultiTexState = 0;
 698         }
 699         else
 700         {
 701                 _MainOp = Modulate;
 702                 _TexScroll[0].set(0, 0);
 703                 _TexScroll[1].set(0, 0);
 704                 _MultiTexState = (uint8) MultiTextureEnabled;
 705         }
 706         touch();
 707 }
 708
 709 //=======================================
 710 void    CPSMultiTexturedParticle::enableAlternateTex(bool enabled /*= true*/)
 711 {
 712         NL_PS_FUNC(CPSMultiTexturedParticle_enableAlternateTex)
 713         nlassert(isMultiTextureEnabled()); // multitexturing must have been enabled first
 714         if (enabled == isAlternateTexEnabled()) return;
 715
 716         if (enabled)
 717         {
 718                 _TexScrollAlternate[0].set(0, 0);
 719                 _TexScrollAlternate[1].set(0, 0);
 720                 _AlternateOp = Modulate;
 721                 _MultiTexState |= (uint8) AlternateTextureEnabled;
 722         }
 723         else
 724         {
 725                 _Texture2 = NULL;
 726                 _MultiTexState &= ~(uint8) AlternateTextureEnabled;
 727         }
 728         touch();
 729 }
 730
 731 //=======================================
 732 void    CPSMultiTexturedParticle::serialMultiTex(NLMISC::IStream &f)
 733 {
 734         NL_PS_FUNC(CPSMultiTexturedParticle_serialMultiTex)
 735         /// version 1 : bump factor
 736         sint ver = f.serialVersion(1);
 737         f.serial(_MultiTexState);
 738         if (isMultiTextureEnabled())
 739         {
 740                 f.serialEnum(_MainOp);
 741                 if (_MainOp == EnvBumpMap && ver >= 1)
 742                 {
 743                         f.serial(_BumpFactor);
 744                 }
 745                 ITexture *tex = NULL;
 746                 if (f.isReading())
 747                 {
 748                         f.serialPolyPtr(tex);
 749                         _Texture2 = tex;
 750                 }
 751                 else
 752                 {
 753                         tex = _Texture2;
 754                         f.serialPolyPtr(tex);
 755                 }
 756                 f.serial(_TexScroll[0], _TexScroll[1]);
 757
 758                 if (isAlternateTexEnabled())
 759                 {
 760                         f.serialEnum(_AlternateOp);
 761                         if (f.isReading())
 762                         {
 763                                 f.serialPolyPtr(tex);
 764                                 _AlternateTexture2 = tex;
 765                         }
 766                         else
 767                         {
 768                                 tex = _AlternateTexture2;
 769                                 f.serialPolyPtr(tex);
 770                         }
 771                         f.serial(_TexScrollAlternate[0], _TexScrollAlternate[1]);
 772                 }
 773                 else
 774                 {
 775                         _AlternateTexture2 = NULL;
 776                 }
 777         }
 778         else
 779         {
 780                 if (f.isReading())
 781                 {
 782                         _Texture2                  = NULL;
 783                         _AlternateTexture2 = NULL;
 784                 }
 785         }
 786 }
 787
 788 //=======================================
 789 void CPSMultiTexturedParticle::setupMaterial(ITexture *primary, IDriver *driver, CMaterial &mat, CVertexBuffer &vb)
 790 {
 791         NL_PS_FUNC(CPSMultiTexturedParticle_setupMaterial)
 792         /// if bump is used, the matrix must be setupped each time (not a material field)
 793         if (!_ForceBasicCaps && isMultiTextureEnabled() && _MainOp  == EnvBumpMap)
 794         {
 795                 if (driver->supportTextureAddrMode(CMaterial::OffsetTexture))
 796                 {
 797                         CTextureBump *tb = dynamic_cast<CTextureBump *>((ITexture *) _Texture2);
 798                         if (tb != NULL)
 799                         {
 800                                 float normFactor = tb->getNormalizationFactor();
 801                                 if (normFactor == 0.f) // have we computed the normalization factor ?
 802                                 {
 803                                         /// todo : caching of this value
 804                                         tb->generate();
 805                                         normFactor = tb->getNormalizationFactor();
 806                                         tb->release();
 807                                 }
 808                                 const float bMat[] = { _BumpFactor * normFactor, 0.f, 0.f, _BumpFactor * normFactor};
 809                                 driver->setMatrix2DForTextureOffsetAddrMode(1, bMat);
 810                         }
 811                         vb.setUVRouting(0, 1);
 812                         vb.setUVRouting(1, 0);
 813                 }
 814                 else if (driver->supportEMBM())
 815                 {
 816                         uint embmTex = 0;
 817                         const uint numTexStages = driver->getNbTextureStages();
 818                         for(uint k = 0; k < numTexStages; ++k)
 819                         {
 820                                 vb.setUVRouting(k, 0);
 821                                 if (driver->isEMBMSupportedAtStage(k))
 822                                 {
 823                                         vb.setUVRouting(k, 1);
 824                                         if (k != (numTexStages - 1))
 825                                         {
 826                                                 vb.setUVRouting(k + 1, 0);
 827                                         }
 828                                         embmTex = k;
 829                                         break;
 830                                 }
 831                         }
 832                         CTextureBump *tb = dynamic_cast<CTextureBump *>((ITexture *) _Texture2);
 833                         if (tb != NULL)
 834                         {
 835                                 float normFactor = tb->getNormalizationFactor();
 836                                 if (normFactor == 0.f) // have we computed the normalization factor ?
 837                                 {
 838                                         /// todo : caching of this value
 839                                         tb->generate();
 840                                         normFactor = tb->getNormalizationFactor();
 841                                         tb->release();
 842                                 }
 843                                 const float bMat[] = { _BumpFactor * normFactor, 0.f, 0.f, _BumpFactor * normFactor};
 844                                 driver->setEMBMMatrix(embmTex, bMat);
 845                         }
 846                 }
 847         }
 848
 849         if (!isTouched() && areBasicCapsForcedLocal() == areBasicCapsForced()) return;
 850         forceBasicCapsLocal(areBasicCapsForced());
 851         if (!isMultiTextureEnabled())
 852         {
 853                 mat.setTexture(0, primary);
 854                 mat.texEnvOpRGB(0, CMaterial::Modulate);
 855                 mat.setTexture(1, NULL);
 856         }
 857         else
 858         {
 859                 if (_MainOp  != EnvBumpMap)
 860                 {
 861                         setupMultiTexEnv(_MainOp, primary, _Texture2, mat, *driver);
 862                         _MultiTexState &= ~(uint8) EnvBumpMapUsed;
 863                         _MultiTexState &= ~(uint8) AlternateTextureUsed;
 864                 }
 865                 else
 866                 {
 867                         if (!_ForceBasicCaps && (driver->supportTextureAddrMode(CMaterial::OffsetTexture) || driver->supportEMBM())) // envbumpmap supported ?
 868                         {
 869                                 CTextureBump *tb = dynamic_cast<CTextureBump *>((ITexture *) _Texture2);
 870                                 if (tb != NULL)
 871                                 {
 872                                         float normFactor = tb->getNormalizationFactor();
 873                                         if (normFactor == 0.f) // have we computed the normalization factor ?
 874                                         {
 875                                                 /// todo : caching of this value
 876                                                 tb->generate();
 877                                                 normFactor = tb->getNormalizationFactor();
 878                                                 tb->release();
 879                                         }
 880                                         setupMultiTexEnv(_MainOp, primary, _Texture2, mat, *driver);
 881                                 }
 882                                 _MultiTexState &= ~(uint8) AlternateTextureUsed;
 883                                 _MultiTexState |= (uint8) EnvBumpMapUsed;
 884                         }
 885                         else // switch to alternate
 886                         {
 887                                 _MultiTexState |= (uint8) AlternateTextureUsed;
 888                                 if (isAlternateTexEnabled() && _AlternateTexture2)
 889                                 {
 890                                         setupMultiTexEnv(_AlternateOp, primary, _AlternateTexture2, mat, *driver);
 891                                 }
 892                                 else
 893                                 {
 894                                         mat.setTexture(0, primary);
 895                                         mat.texEnvOpRGB(0, CMaterial::Modulate);
 896                                 }
 897                                 _MultiTexState &= ~(uint8) EnvBumpMapUsed;
 898                         }
 899                 }
 900         }
 901         updateTexWrapMode(*driver);
 902         unTouch();
 903 }
 904
 905 //=======================================
 906 void    CPSMultiTexturedParticle::setupMultiTexEnv(TOperator op, ITexture *tex1, ITexture *tex2, CMaterial &mat, IDriver &drv)
 907 {
 908         NL_PS_FUNC(CPSMultiTexturedParticle_setupMultiTexEnv)
 909         switch (op)
 910         {
 911                 case Add:
 912                         mat.setTexture(0, tex1);
 913                         mat.setTexture(1, tex2);
 914                         mat.texEnvOpRGB(0, CMaterial::Modulate);
 915                         mat.texEnvOpRGB(1, CMaterial::Add);
 916                         mat.enableTexAddrMode(false);
 917                         break;
 918                 case Modulate:
 919                         mat.setTexture(0, tex1);
 920                         mat.setTexture(1, tex2);
 921                         mat.texEnvOpRGB(0, CMaterial::Modulate);
 922                         mat.texEnvOpRGB(1, CMaterial::Modulate);
 923                         mat.enableTexAddrMode(false);
 924                         break;
 925                 case EnvBumpMap:
 926                         if (drv.supportTextureAddrMode(CMaterial::OffsetTexture))
 927                         {
 928                                 mat.setTexture(0, tex2);
 929                                 mat.setTexture(1, tex1);
 930                                 mat.texEnvOpRGB(0, CMaterial::Replace);
 931                                 mat.texEnvOpRGB(1, CMaterial::Modulate);
 932                                 mat.enableTexAddrMode(true);
 933                                 mat.setTexAddressingMode(0, CMaterial::FetchTexture);
 934                                 mat.setTexAddressingMode(1, CMaterial::OffsetTexture);
 935                         }
 936                         else if (drv.supportEMBM())
 937                         {
 938                                 const uint numTexStages = drv.getNbTextureStages();
 939                                 // if embm unit is at last stage, it operates on texture at previous stage
 940                                 // otherwise it operates on texture at next stage
 941                                 for(uint k = 0; k < numTexStages; ++k)
 942                                 {
 943                                         if (drv.isEMBMSupportedAtStage(k))
 944                                         {
 945                                                 if (k == (numTexStages - 1))
 946                                                 {
 947                                                         mat.setTexture(k, tex2);
 948                                                         mat.texEnvOpRGB(k, CMaterial::EMBM);
 949                                                         mat.texEnvOpAlpha(k, CMaterial::EMBM);
 950                                                         mat.setTexture(0, tex1);
 951                                                         mat.texEnvOpRGB(0, CMaterial::Modulate);
 952                                                         mat.texEnvArg0RGB(0, CMaterial::Texture, CMaterial::SrcColor);
 953                                                         mat.texEnvArg1RGB(0, CMaterial::Diffuse, CMaterial::SrcColor);
 954                                                         mat.texEnvArg0Alpha(0, CMaterial::Texture, CMaterial::SrcAlpha);
 955                                                         mat.texEnvArg1Alpha(0, CMaterial::Diffuse, CMaterial::SrcAlpha);
 956                                                 }
 957                                                 else
 958                                                 {
 959                                                         // stage before the bump map must not be empty so fill them
 960                                                         for(uint l = 0; l < k; ++l)
 961                                                         {
 962                                                                 mat.setTexture(l, tex1);
 963                                                                 mat.texEnvOpRGB(l, CMaterial::Modulate);
 964                                                         }
 965                                                         mat.setTexture(k, tex2);
 966                                                         mat.texEnvOpRGB(k, CMaterial::EMBM);
 967                                                         mat.setTexture(k + 1, tex1);
 968                                                         mat.texEnvOpRGB(k + 1, CMaterial::Modulate);
 969                                                         mat.texEnvArg0RGB(k + 1, CMaterial::Texture, CMaterial::SrcColor);
 970                                                         mat.texEnvArg1RGB(k + 1, CMaterial::Diffuse, CMaterial::SrcColor);
 971                                                         mat.texEnvArg0Alpha(k + 1, CMaterial::Texture, CMaterial::SrcAlpha);
 972                                                         mat.texEnvArg1Alpha(k + 1, CMaterial::Diffuse, CMaterial::SrcAlpha);
 973                                                 }
 974                                                 break;
 975                                         }
 976                                 }
 977                         }
 978                 break;
 979                 case Decal:
 980                         mat.setTexture(0, tex1);
 981                         mat.texEnvOpRGB(0, CMaterial::Replace);
 982                         mat.setTexture(1, NULL);
 983                         mat.enableTexAddrMode(false);
 984                         break;
 985                 default: break;
 986         }
 987 }
 988
 989 //=====static func to convert a texture to a bumpmap
 990 static void ConvertToBumpMap(NLMISC::CSmartPtr<ITexture> &ptr)
 991 {
 992         NL_PS_FUNC(ConvertToBumpMap)
 993         if (!dynamic_cast<CTextureBump *>( (ITexture *) ptr))
 994         {
 995                 // convert to a bumpmap
 996                 CTextureBump *tb = new CTextureBump;
 997                 tb->setHeightMap((ITexture *) ptr);
 998                 tb->enableSharing(true);
 999                 ptr = tb;
1000         }
1001 }
1002
1003 //=====static func to convert a bumpmap to a texture (its heightmap)
1004 static void ConvertFromBumpMap(NLMISC::CSmartPtr<ITexture> &ptr)
1005 {
1006         NL_PS_FUNC(ConvertFromBumpMap)
1007         CTextureBump *bm = dynamic_cast<CTextureBump *>( (ITexture *) ptr);
1008         if (bm)
1009         {
1010                 // retrieve the heightmap from the bumpmap
1011                 NLMISC::CSmartPtr<ITexture> hm = bm->getHeightMap();
1012                 ptr = hm;
1013         }
1014 }
1015
1016 //=========================================
1017 void    CPSMultiTexturedParticle::setTexture2Alternate(ITexture *tex)
1018 {
1019         NL_PS_FUNC(CPSMultiTexturedParticle_setTexture2Alternate)
1020         _AlternateTexture2 = tex;
1021         if (_AlternateOp != EnvBumpMap)
1022         {
1023                 ConvertFromBumpMap(_AlternateTexture2);
1024         }
1025         else
1026         {
1027                 ConvertToBumpMap(_AlternateTexture2);
1028         }
1029         touch();
1030 }
1031
1032 //==========================================
1033 void    CPSMultiTexturedParticle::setTexture2(ITexture *tex)
1034 {
1035         NL_PS_FUNC(CPSMultiTexturedParticle_setTexture2)
1036         _Texture2 = tex;
1037         if (_MainOp != EnvBumpMap)
1038         {
1039                 ConvertFromBumpMap(_Texture2);
1040         }
1041         else
1042         {
1043                 if (!dynamic_cast<NL3D::CTextureBump *>((ITexture *) _Texture2))
1044                 {
1045                         ConvertToBumpMap(_Texture2);
1046                 }
1047         }
1048         touch();
1049 }
1050
1051 //==========================================
1052 void    CPSMultiTexturedParticle::setMainTexOp(TOperator op)
1053 {
1054         NL_PS_FUNC(CPSMultiTexturedParticle_setMainTexOp)
1055         _MainOp = op;
1056         if (_MainOp == EnvBumpMap)
1057         {
1058                 ConvertToBumpMap(_Texture2);
1059         }
1060         else
1061         {
1062                 ConvertFromBumpMap(_Texture2);
1063         }
1064         touch();
1065 }
1066
1067 //==========================================
1068 void    CPSMultiTexturedParticle::setAlternateTexOp(TOperator op)
1069 {
1070         NL_PS_FUNC(CPSMultiTexturedParticle_setAlternateTexOp)
1071         _AlternateOp = op;
1072         if (_AlternateOp == EnvBumpMap)
1073         {
1074                 ConvertToBumpMap(_AlternateTexture2);
1075         }
1076         else
1077         {
1078                 ConvertFromBumpMap(_AlternateTexture2);
1079         }
1080         touch();
1081 }
1082
1083
1084
1085 //==========================================
1086 void    CPSMultiTexturedParticle::setUseLocalDate(bool use)
1087 {
1088         NL_PS_FUNC(CPSMultiTexturedParticle_setUseLocalDate)
1089         if (use) _MultiTexState |= ScrollUseLocalDate;
1090         else _MultiTexState &= ~ ScrollUseLocalDate;
1091 }
1092
1093
1094 //==========================================
1095 void    CPSMultiTexturedParticle::setUseLocalDateAlt(bool use)
1096 {
1097         NL_PS_FUNC(CPSMultiTexturedParticle_setUseLocalDateAlt)
1098         if (use) _MultiTexState |= ScrollUseLocalDateAlternate;
1099         else _MultiTexState &= ~ ScrollUseLocalDateAlternate;
1100 }
1101
1102 //==========================================
1103 void CPSTexturedParticle::enumTexs(std::vector<NLMISC::CSmartPtr<ITexture> > &dest)
1104 {
1105         NL_PS_FUNC(CPSTexturedParticle_enumTexs)
1106         if (_Tex)
1107         {
1108                 dest.push_back(_Tex);
1109         }
1110         if (getTextureGroup())
1111         {
1112                 dest.push_back(getTextureGroup());
1113         }
1114 }
1115
1116 //==========================================
1117 void CPSMultiTexturedParticle::enumTexs(std::vector<NLMISC::CSmartPtr<ITexture> > &dest, IDriver &drv)
1118 {
1119         NL_PS_FUNC(CPSMultiTexturedParticle_enumTexs)
1120         if (_MainOp  == EnvBumpMap && !_ForceBasicCaps)
1121         {
1122                 if (drv.supportTextureAddrMode(CMaterial::OffsetTexture) || drv.supportEMBM())
1123                 {
1124                         if (_Texture2) dest.push_back(_Texture2);
1125                 }
1126                 else
1127                 {
1128                         if (_AlternateTexture2) dest.push_back(_AlternateTexture2);
1129                 }
1130                 return;
1131         }
1132         if (_Texture2) dest.push_back(_Texture2);
1133 }
1134
1135 // *****************************************************************************************************
1136 bool CPSMultiTexturedParticle::isAlternateTextureUsed(IDriver &driver) const
1137 {
1138         NL_PS_FUNC(CPSMultiTexturedParticle_isAlternateTextureUsed)
1139         if (!isTouched() && areBasicCapsForcedLocal() == areBasicCapsForced()) return (_MultiTexState & AlternateTextureUsed) != 0;
1140         if (_MainOp  != EnvBumpMap) return false;
1141         return _ForceBasicCaps || (!driver.supportTextureAddrMode(CMaterial::OffsetTexture) && !driver.supportEMBM());
1142 }
1143
1144 } // NL3D