nevrax.org : docs

00001 
00007 /* Copyright, 2000, 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/flare_shape.h"
00029 #include "3d/flare_model.h"
00030 #include "3d/scene.h"
00031 #include "3d/driver.h"
00032 
00033 namespace NL3D {
00034 
00035 
00036 /*
00037  * Constructor
00038  */
00039 CFlareShape::CFlareShape()  : _Color(NLMISC::CRGBA::White),
00040                                                           _DazzleColor(NLMISC::CRGBA::Black),
00041                                                           _Persistence(1),
00042                                                           _Spacing(1),
00043                                                           _Attenuable(false),
00044                                                           _AttenuationRange (1.0f),                                                       
00045                                                           _FirstFlareKeepSize(false),
00046                                                           _DazzleEnabled(false),
00047                                                           _DazzleAttenuationRange(0.f),                                                   
00048                                                           _MaxViewDistRatio (0.9f),
00049                                                           _InfiniteDist(false)
00050 {
00051         // init default pos
00052         for (uint k = 0; k < MaxFlareNum; ++k)
00053         {
00054                 _Tex [k]  = NULL;
00055                 _Size[k]  = 1.f;
00056                 _Pos[k]   = k * (1.f / MaxFlareNum);
00057         }
00058         _DefaultPos.setValue(CVector::Null);
00059         setDistMax(1000);
00060 }
00061 
00062 
00063 void CFlareShape::serial(NLMISC::IStream &f) throw(NLMISC::EStream)
00064 {
00065         int ver = f.serialVersion(3);
00066         f.serial(_Color, _Persistence, _Spacing);       
00067         f.serial(_Attenuable);
00068         if (_Attenuable)
00069         {
00070                 f.serial(_AttenuationRange);
00071         }
00072         f.serial(_FirstFlareKeepSize);
00073         for (uint k = 0; k < MaxFlareNum; ++k)
00074         {
00075                 ITexture *tex = _Tex[k];
00076                 f.serialPolyPtr(tex);
00077                 if (f.isReading())
00078                 {
00079                         _Tex[k] = tex;
00080                 }
00081                 f.serial(_Size[k], _Pos[k]);
00082         }
00083         f.serial(_InfiniteDist);
00084         if (!_InfiniteDist)
00085         {
00086                 f.serial(_MaxViewDist, _MaxViewDistRatio);
00087         }
00088         f.serial(_DazzleEnabled);
00089         if (_DazzleEnabled)
00090         {
00091                 f.serial(_DazzleColor, _DazzleAttenuationRange);
00092         }
00093         f.serial(_InfiniteDist);
00094 
00095         if (ver >= 2)
00096                 f.serial( _DistMax );   
00097 }
00098 
00099         
00100 CTransformShape         *CFlareShape::createInstance(CScene &scene)
00101 {
00102         CFlareModel *fm = NLMISC::safe_cast<CFlareModel *>(scene.createModel(FlareModelClassId) );
00103         fm->Shape = this;       
00104         fm->_Scene = &scene;
00105         // set default pos
00106         fm->ITransformable::setPos( ((CAnimatedValueVector&)_DefaultPos.getValue()).Value  );
00107         return fm;
00108 }
00109 
00110 float                           CFlareShape::getNumTriangles (float distance)
00111 {
00112         float count = 0;
00113         for (uint k = 0; k < MaxFlareNum; ++k)
00114         {
00115         if (_Tex[k]) count += 2;
00116         }
00117         return count;
00118 }
00119 
00120 bool                            CFlareShape::clip(const std::vector<CPlane>     &pyramid, const CMatrix &worldMatrix)
00121 {               
00122         // compute flare pos in world basis : 
00123         const NLMISC::CVector pos = worldMatrix.getPos();
00124         for (std::vector<NLMISC::CPlane>::const_iterator it = pyramid.begin(); it != pyramid.end(); ++it)
00125         {
00126                 if ((*it) * pos > 0) return false;
00127         }
00128         return true;
00129 }
00130 
00131 
00132 void                            CFlareShape::getAABBox(NLMISC::CAABBox &bbox) const
00133 {
00134         // the flare himself is a point
00135         bbox.setCenter(CVector::Null);
00136         bbox.setHalfSize(CVector::Null);
00137 }
00138 
00139 
00140 void                            CFlareShape::flushTextures (IDriver &driver)
00141 {
00142         // Flush each texture
00143         for (uint tex=0; tex<MaxFlareNum; tex++)
00144         {
00145                 if (_Tex[tex] != NULL)
00146                 {
00148                         driver.setupTexture (*_Tex[tex]);
00149                 }
00150         }
00151 }
00152 
00153 
00154 } // NL3D
flare_shape.cpp
