nevrax.org : docs

00001 
+00007 /* Copyright, 2001 Nevrax Ltd.
+00008  *
+00009  * This file is part of NEVRAX NEL.
+00010  * NEVRAX NEL is free software; you can redistribute it and/or modify
+00011  * it under the terms of the GNU General Public License as published by
+00012  * the Free Software Foundation; either version 2, or (at your option)
+00013  * any later version.
+00014 
+00015  * NEVRAX NEL is distributed in the hope that it will be useful, but
+00016  * WITHOUT ANY WARRANTY; without even the implied warranty of
+00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+00018  * General Public License for more details.
+00019 
+00020  * You should have received a copy of the GNU General Public License
+00021  * along with NEVRAX NEL; see the file COPYING. If not, write to the
+00022  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+00023  * MA 02111-1307, USA.
+00024  */
+00025 
+00026 #include "std3d.h"
+00027 
+00028 #include "3d/ps_macro.h"
+00029 #include "3d/ps_shockwave.h"
+00030 #include "3d/driver.h"
+00031 #include "3d/texture_grouped.h"
+00032 #include "3d/ps_iterator.h"
+00033 #include "3d/particle_system.h"
+00034 
+00035 
+00036 namespace NL3D 
+00037 {                                                          
+00038 
+00040 // constant definition   //
+00042 
+00043 // max number of shockwave to be processed at once
+00044 static const uint ShockWaveBufSize = 128; 
+00045 
+00046 // the number of vertices we want in a vertex buffer
+00047 static const uint NumVertsInBuffer = 8 * ShockWaveBufSize;
+00048 
+00049 
+00050 CPSShockWave::TPBMap CPSShockWave::_PBMap; // the primitive blocks
+00051 CPSShockWave::TVBMap CPSShockWave::_VBMap; // vb ith unanimated texture
+00052 CPSShockWave::TVBMap CPSShockWave::_AnimTexVBMap; // vb ith unanimated texture
+00053 CPSShockWave::TVBMap CPSShockWave::_ColoredVBMap; // vb ith unanimated texture
+00054 CPSShockWave::TVBMap CPSShockWave::_ColoredAnimTexVBMap; // vb ith unanimated texture
+00056 // CPSShockWave implementation //
+00058 
+00059 
+00065 class CPSShockWaveHelper
+00066 {
+00067 public:
+00068         template <class T>      
+00069         static void drawShockWave(T posIt, CPSShockWave &s, uint size, uint32 srcStep)
+00070         {
+00071                 PARTICLES_CHECK_MEM;
+00072                 nlassert(s._Owner);
+00073 
+00074                 // get / build the vertex buffer and the primitive block
+00075                 CVertexBuffer *vb;
+00076                 CPrimitiveBlock *pb;
+00077                 s.getVBnPB(vb, pb);
+00078 
+00079                 const uint32 vSize = vb->getVertexSize();
+00080                 IDriver *driver = s.getDriver();
+00081                 s._Owner->incrementNbDrawnParticles(size); // for benchmark purpose     
+00082                 s.setupDriverModelMatrix();
+00083                 const uint numShockWaveToDealWith = std::min(ShockWaveBufSize, s.getNumShockWavesInVB());
+00084                 driver->activeVertexBuffer(*vb);        
+00085 
+00086                 static CPlaneBasis planeBasis[ShockWaveBufSize];
+00087                 float       sizes[ShockWaveBufSize];
+00088                 float       angles[ShockWaveBufSize];
+00089                 
+00090                 uint leftToDo  = size, toProcess;
+00091                 T endIt;
+00092                 uint8 *currVertex;
+00093                 uint k ;
+00094 
+00095                 const float angleStep = 256.f / s._NbSeg;
+00096                 float currAngle;
+00097 
+00098                 CPlaneBasis *ptCurrBasis;
+00099                 uint32  ptCurrBasisIncrement = s._PlaneBasisScheme ? 1 : 0;
+00100 
+00101                 float *ptCurrSize;
+00102                 uint32 ptCurrSizeIncrement = s._SizeScheme ? 1 : 0;
+00103 
+00104                 float *ptCurrAngle;
+00105                 uint32 ptCurrAngleIncrement = s._Angle2DScheme ? 1 : 0;
+00106 
+00107                 CVector radVect, innerVect;
+00108                 float radiusRatio;
+00109 
+00110                 do
+00111                 {
+00112                         currVertex = (uint8 *) vb->getVertexCoordPointer();
+00113                         toProcess = leftToDo > numShockWaveToDealWith ? numShockWaveToDealWith : leftToDo;
+00114                         endIt = posIt + toProcess;
+00115                         if (s._SizeScheme)
+00116                         {
+00117                                 ptCurrSize  = (float *) (s._SizeScheme->make(s._Owner, size - leftToDo, (void *) sizes, sizeof(float), toProcess, true, srcStep));                      
+00118                         }
+00119                         else
+00120                         {
+00121                                 ptCurrSize = &s._ParticleSize;
+00122                         }
+00123 
+00124                         if (s._PlaneBasisScheme)
+00125                         {
+00126                                 ptCurrBasis  = (CPlaneBasis *) (s._PlaneBasisScheme->make(s._Owner, size - leftToDo, (void *) planeBasis, sizeof(CPlaneBasis), toProcess, true, srcStep));                      
+00127                         }
+00128                         else
+00129                         {
+00130                                 ptCurrBasis = &s._PlaneBasis;
+00131                         }
+00132 
+00133                         if (s._Angle2DScheme)
+00134                         {
+00135                                 ptCurrAngle  = (float *) (s._Angle2DScheme->make(s._Owner, size - leftToDo, (void *) angles, sizeof(float), toProcess, true, srcStep));                 
+00136                         }
+00137                         else
+00138                         {
+00139                                 ptCurrAngle = &s._Angle2D;
+00140                         }
+00141                         
+00142 
+00143                         s.updateVbColNUVForRender(size - leftToDo, toProcess, srcStep, *vb);
+00144                         do
+00145                         {                       
+00146                                 currAngle = *ptCurrAngle;
+00147                                 if (fabsf(*ptCurrSize) > 10E-6)
+00148                                 {
+00149                                         radiusRatio = (*ptCurrSize - s._RadiusCut) / *ptCurrSize;
+00150                                 }
+00151                                 else
+00152                                 {
+00153                                         radiusRatio = 0.f;
+00154                                 }
+00155 
+00156                                 for (k = 0; k <= s._NbSeg; ++k)
+00157                                 {
+00158                                         radVect = *ptCurrSize * (CPSUtil::getCos((sint32) currAngle) * ptCurrBasis->X + CPSUtil::getSin((sint32) currAngle) * ptCurrBasis->Y);
+00159                                         innerVect = radiusRatio * radVect;
+00160                                         CHECK_VERTEX_BUFFER(*vb, currVertex);
+00161                                         * (CVector *) currVertex = *posIt + radVect;
+00162                                         currVertex += vSize;
+00163                                         CHECK_VERTEX_BUFFER(*vb, currVertex);
+00164                                         * (CVector *) currVertex = *posIt + innerVect;
+00165                                         currVertex += vSize;
+00166                                         currAngle += angleStep;                         
+00167                                 }
+00168                                 
+00169                                 ++posIt;
+00170                                 ptCurrBasis +=  ptCurrBasisIncrement;
+00171                                 ptCurrSize  +=  ptCurrSizeIncrement;
+00172                                 ptCurrAngle  +=  ptCurrAngleIncrement;
+00173                         }
+00174                         while (posIt != endIt);                 
+00175 
+00176                         pb->setNumQuad(toProcess * s._NbSeg);
+00177                         driver->render(*pb, s._Mat);
+00178                         leftToDo -= toProcess;          
+00179                 }
+00180                 while (leftToDo);
+00181                 PARTICLES_CHECK_MEM;
+00182         }
+00183 };
+00184 
+00186 CPSShockWave::CPSShockWave(uint nbSeg, float radiusCut, CSmartPtr<ITexture> tex) 
+00187                 :  _NbSeg(nbSeg)
+00188                    , _RadiusCut(radiusCut)
+00189                    , _UFactor(1.f)
+00190 
+00191 {
+00192         nlassert(nbSeg > 2 && nbSeg <= 64);
+00193         setTexture(tex);
+00194         init();
+00195         _Name = std::string("ShockWave");
+00196 }
+00197 
+00199 uint32 CPSShockWave::getMaxNumFaces(void) const
+00200 {
+00201         nlassert(_Owner);
+00202         return (_Owner->getMaxSize() * _NbSeg) << 1 ;
+00203 }
+00204 
+00206 bool CPSShockWave::hasTransparentFaces(void)
+00207 {
+00208         return getBlendingMode() != CPSMaterial::alphaTest ;
+00209 }
+00210 
+00212 bool CPSShockWave::hasOpaqueFaces(void)
+00213 {
+00214         return !hasTransparentFaces();
+00215 }
+00216 
+00218 void CPSShockWave::setNbSegs(uint nbSeg)
+00219 {
+00220         nlassert(nbSeg > 2 && nbSeg <= 64);
+00221         _NbSeg = nbSeg;
+00222         if (_Owner)
+00223         {
+00224                 resize(_Owner->getMaxSize());
+00225                 notifyOwnerMaxNumFacesChanged();
+00226         }
+00227 }
+00228 
+00230 void CPSShockWave::setRadiusCut(float radiusCut)
+00231 {
+00232         _RadiusCut = radiusCut; 
+00233         if (_Owner)
+00234         {
+00235                 resize(_Owner->getMaxSize());
+00236         }
+00237 }
+00238 
+00240 void    CPSShockWave::setUFactor(float value)
+00241 {
+00242         nlassert(_Owner); // must be attached to an owner before to call this method
+00243         _UFactor = value;
+00244         resize(_Owner->getSize()); // resize also recomputes the UVs..
+00245 }
+00246 
+00248 void CPSShockWave::serial(NLMISC::IStream &f) throw(NLMISC::EStream)
+00249 {       
+00250         sint ver  = f.serialVersion(2);
+00251         CPSParticle::serial(f);
+00252         CPSColoredParticle::serialColorScheme(f);
+00253         CPSSizedParticle::serialSizeScheme(f);
+00254         CPSTexturedParticle::serialTextureScheme(f);
+00255         CPSRotated3DPlaneParticle::serialPlaneBasisScheme(f);
+00256         CPSRotated2DParticle::serialAngle2DScheme(f);
+00257         serialMaterial(f);
+00258         f.serial(_NbSeg, _RadiusCut);
+00259         if (ver > 1)
+00260         {
+00261                 f.serial(_UFactor);
+00262         }
+00263         init(); 
+00264 }
+00265 
+00267 inline void CPSShockWave::setupUFactor()
+00268 {       
+00269         if (_UFactor != 1.f)
+00270         {
+00271                 _Mat.enableUserTexMat(0);
+00272                 CMatrix texMat;
+00273                 texMat.setRot(_UFactor  * NLMISC::CVector::I,
+00274                                           NLMISC::CVector::J,
+00275                                           NLMISC::CVector::K
+00276                                          );
+00277                 _Mat.setUserTexMat(0, texMat);
+00278         }
+00279         else
+00280         {
+00281                 _Mat.enableUserTexMat(0, false);
+00282         }       
+00283 }
+00284 
+00286 void CPSShockWave::draw(bool opaque)
+00287 {
+00288         PARTICLES_CHECK_MEM;    
+00289         if (!_Owner->getSize()) return; 
+00290 
+00291         uint32 step;
+00292         uint   numToProcess;
+00293         computeSrcStep(step, numToProcess);     
+00294         if (!numToProcess) return;
+00295 
+00296 
+00297         
+00299         CParticleSystem &ps = *(_Owner->getOwner());
+00301         if (_ColorScheme != NULL && ps.getColorAttenuationScheme() != NULL)
+00302         {               
+00303                 CPSMaterial::forceModulateConstantColor(true, ps.getGlobalColor());             
+00304         }
+00305         else
+00306         {
+00307                 forceModulateConstantColor(false);
+00308                 if (!ps.getColorAttenuationScheme())
+00309                 {
+00310                         _Mat.setColor(_Color);
+00311                 }
+00312                 else
+00313                 {
+00314                         NLMISC::CRGBA col;
+00315                         col.modulateFromColor(ps.getGlobalColor(), _Color);
+00316                         _Mat.setColor(col);
+00317                 }
+00318         }
+00320 
+00321         setupUFactor();
+00322         
+00323         if (step == (1 << 16))
+00324         {
+00325                 CPSShockWaveHelper::drawShockWave(_Owner->getPos().begin(),                                
+00326                                                                                   *this,
+00327                                                                                   numToProcess,
+00328                                                                                   step
+00329                                                                                  );
+00330         }
+00331         else
+00332         {               
+00333                 CPSShockWaveHelper::drawShockWave(TIteratorVectStep1616(_Owner->getPos().begin(), 0, step),                                
+00334                                                                                   *this,
+00335                                                                                   numToProcess,
+00336                                                                                   step
+00337                                                                                  );
+00338         }
+00339         
+00340         PARTICLES_CHECK_MEM;
+00341 }
+00342 
+00344 bool CPSShockWave::completeBBox(NLMISC::CAABBox &box) const
+00345 {
+00346         // TODO : implement this
+00347         return false;
+00348 }
+00349 
+00351 void CPSShockWave::init(void)
+00352 {
+00353         _Mat.setLighting(false);        
+00354         _Mat.setZFunc(CMaterial::less);
+00355         _Mat.setDoubleSided(true);
+00356         updateMatAndVbForColor();
+00357         updateMatAndVbForTexture();
+00358 }
+00359 
+00361 void CPSShockWave::updateVbColNUVForRender(uint32 startIndex, uint32 size, uint32 srcStep, CVertexBuffer &vb)
+00362 {
+00363         nlassert(_Owner);
+00364         if (!size) return;
+00365         if (_ColorScheme)
+00366         {
+00367                 // compute the colors, each color is replicated n times...
+00368                 _ColorScheme->makeN(_Owner, startIndex, vb.getColorPointer(), vb.getVertexSize(), size, (_NbSeg + 1) << 1, srcStep);
+00369         }
+00370 
+00371         if (_TexGroup) // if it has a constant texture we are sure it has been setupped before...
+00372         {       
+00373                 sint32 textureIndex[ShockWaveBufSize];
+00374                 const uint32 stride = vb.getVertexSize(), stride2 = stride << 1;
+00375                 uint8 *currUV = (uint8 *) vb.getTexCoordPointer();                              
+00376                 uint k;         
+00377 
+00378                 uint32 currIndexIncr;
+00379                 const sint32 *currIndex;                
+00380 
+00381                 if (_TextureIndexScheme)
+00382                 {
+00383                         currIndex  = (sint32 *) (_TextureIndexScheme->make(_Owner, startIndex, textureIndex, sizeof(sint32), size, true, srcStep));                     
+00384                         currIndexIncr = 1;
+00385                 }
+00386                 else
+00387                 {       
+00388                         currIndex = &_TextureIndex;
+00389                         currIndexIncr = 0;
+00390                 }
+00391                 
+00392                 while (size--)
+00393                 {
+00394                         // for now, we don't make texture index wrapping
+00395                         const CTextureGrouped::TFourUV &uvGroup = _TexGroup->getUVQuad((uint32) *currIndex);
+00396 
+00397                         k = _NbSeg + 1;
+00398 
+00399                         for (k = 0; k <= _NbSeg; ++k)
+00400                         {
+00401                                 
+00402                                 *(CUV *) currUV = uvGroup.uv0 + CUV(k * _UFactor, 0);
+00403                                 *(CUV *) (currUV + stride) = uvGroup.uv3 + CUV(k * _UFactor, 0);                                
+00404                                 // point the next quad
+00405                                 currUV += stride2;
+00406                         }
+00407                         while (--k);
+00408 
+00409                         currIndex += currIndexIncr;
+00410                 }               
+00411         }       
+00412 }
+00413 
+00415 void CPSShockWave::updateMatAndVbForColor(void)
+00416 {       
+00417 
+00418         if (_Owner)
+00419         {
+00420                 resize(_Owner->getMaxSize());
+00421         }       
+00422 }
+00423 
+00425 void CPSShockWave::updateMatAndVbForTexture(void)
+00426 {
+00427         _Mat.setTexture(0, _TexGroup ? (ITexture *) _TexGroup : (ITexture *) _Tex);     
+00428 }
+00429 
+00431 void CPSShockWave::newElement(CPSLocated *emitterLocated, uint32 emitterIndex)
+00432 {
+00433         newColorElement(emitterLocated, emitterIndex);
+00434         newTextureIndexElement(emitterLocated, emitterIndex);
+00435         newSizeElement(emitterLocated, emitterIndex);
+00436         newAngle2DElement(emitterLocated, emitterIndex);
+00437 }
+00438 
+00440 void CPSShockWave::deleteElement(uint32 index)
+00441 {
+00442         deleteColorElement(index);
+00443         deleteTextureIndexElement(index);
+00444         deleteSizeElement(index);
+00445         deleteAngle2DElement(index);
+00446 }
+00447 
+00449 void CPSShockWave::resize(uint32 aSize)
+00450 {
+00451         nlassert(aSize < (1 << 16));
+00452         resizeColor(aSize);
+00453         resizeTextureIndex(aSize);
+00454         resizeSize(aSize);
+00455         resizeAngle2D(aSize);   
+00456 }
+00457 
+00459 void CPSShockWave::getVBnPB(CVertexBuffer *&retVb, CPrimitiveBlock *&retPb)
+00460 {
+00461         TVBMap &vbMap = _ColorScheme == NULL  ? (_TexGroup == NULL ?  _VBMap : _AnimTexVBMap)
+00462                                                                                   : (_TexGroup == NULL ?  _ColoredVBMap : _ColoredAnimTexVBMap);
+00463 
+00464 
+00465         TVBMap::iterator vbIt = vbMap.find(_NbSeg);
+00466         if (vbIt != vbMap.end())
+00467         {
+00468                 retVb = &(vbIt->second);
+00469                 TPBMap::iterator pbIt = _PBMap.find(_NbSeg);
+00470                 nlassert(pbIt != _PBMap.end());
+00471                 retPb = &(pbIt->second);
+00472         }
+00473         else // we need to create the vb
+00474         {               
+00475                 // create an entry (we setup the primitive block at the same time, this could be avoided, but doesn't make much difference)             
+00476                 CVertexBuffer &vb = vbMap[_NbSeg]; // create a vb
+00477                 CPrimitiveBlock &pb = _PBMap[_NbSeg]; // eventually create a pb
+00478                 const uint32 size = getNumShockWavesInVB();
+00479                 vb.setVertexFormat(CVertexBuffer::PositionFlag |
+00480                                                    CVertexBuffer::TexCoord0Flag |
+00481                                                    (_ColorScheme != NULL ?  CVertexBuffer::PrimaryColorFlag : 0) 
+00482                                                   );    
+00483                 vb.setNumVertices((size * (_NbSeg + 1)) << 1 );         
+00484                 pb.reserveQuad(size * _NbSeg);
+00485                 for (uint32 k = 0; k < size; ++k)
+00486                 {
+00487                         for (uint32 l = 0; l < _NbSeg; ++l)
+00488                         {       
+00489                                 const uint32 index = ((k * (_NbSeg + 1)) + l) << 1;                                             
+00490                                 pb.setQuad(l + (k * _NbSeg) , index , index + 2, index + 3, index + 1);                 
+00491                                 vb.setTexCoord(index, 0, CUV((float) l, 0));
+00492                                 vb.setTexCoord(index + 1, 0, CUV((float) l, 1));                        
+00493                         }
+00494                         const uint32 index = ((k * (_NbSeg + 1)) + _NbSeg) << 1;
+00495                         vb.setTexCoord(index, 0, CUV((float) _NbSeg, 0));
+00496                         vb.setTexCoord(index + 1, 0, CUV((float) _NbSeg, 1));                   
+00497                 }
+00498                 retVb = &vb;
+00499                 retPb = &pb;
+00500         }
+00501 }
+00502 
+00504 uint CPSShockWave::getNumShockWavesInVB() const
+00505 {
+00506         const uint numRib = NumVertsInBuffer / ((_NbSeg + 1) << 1);
+00507         return std::max(1u, numRib);
+00508 }
+00509 
+00510 } // NL3D
+
ps_shockwave.cpp
