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 
+00027 #ifndef WATER_HEIGHT_MAP_H
+00028 #define WATER_HEIGHT_MAP_H
+00029 
+00030 
+00031 #include "nel/misc/types_nl.h"
+00032 #include "nel/misc/vector_2f.h"
+00033 #include "nel/3d/u_water.h"
+00034 #include "nel/3d/animation_time.h"
+00035 
+00036 
+00037 #include <vector>
+00038 #include <string>
+00039 
+00040 
+00041 
+00042 
+00043 namespace NL3D
+00044 {
+00045 
+00046 
+00047 class CWaterPoolManager;
+00048 
+00049 
+00065 const uint NumWaterMap = 3; // number of water maps
+00066 
+00067 class CWaterHeightMap : public UWaterHeightMap
+00068 {
+00069 public:
+00070         
+00074         void animate(float deltaT);
+00075 
+00079         void                                    setSize(uint32 size);
+00080 
+00082         uint32                                  getSize(void) const { return _Size; }
+00083 
+00085 
+00091         void                                    setUserPos(sint x, sint y);
+00092 
+00093 
+00097         void                                    getUserPos(sint &x, sint &y) const;
+00098 
+00099         
+00100 
+00102         void                                    perturbate(sint x, sint y, sint radius, float intensity);
+00103 
+00106         virtual void    perturbate(const NLMISC::CVector2f &pos, float strenght, float radius) ;
+00107 
+00108 
+00110         void                                    perturbatePoint(sint x, sint y, float intensity);
+00111 
+00114         virtual void    perturbatePoint(const NLMISC::CVector2f &pos, float strenght);
+00115 
+00118         virtual float   getHeight(const NLMISC::CVector2f &pos);
+00119         
+00120 
+00122         float                                   *getPointer(void) { return &(_Map[_CurrMap][0]); }
+00123 
+00125         float                                   *getPrevPointer(void) { return &(_Map[(_CurrMap + (NumWaterMap - 1)) % NumWaterMap][0]); }
+00126 
+00128         float                                   getBufferRatio() const { return _PropagationTime != 0 ? _PropagateEllapsedTime / _PropagationTime : 0.f; }
+00129 
+00131         //NLMISC::CVector2f             *getGradPointer(void) { return &_Grad[0]; }
+00132         
+00133 
+00135         void                                    enableWaves(bool enabled = true) { _WavesEnabled = enabled; }
+00136 
+00138         bool                                    areWavesEnabled() const { return _WavesEnabled; }
+00139 
+00147         void                                    setWaves(float intensity, float period, uint radius, bool border);
+00148 
+00150         float                                   getWaveIntensity() const { return _WaveIntensity; }
+00151 
+00153         float                                   getWavePeriod() const { return _WavePeriod; }
+00154 
+00156         uint32                                  getWaveImpulsionRadius() const { return _WaveImpulsionRadius; }
+00157 
+00159         bool                                    getBorderWaves() const { return _BorderWaves; }
+00160 
+00162         void                                    setDamping(float damping) { nlassert(damping >= 0 && damping < 1); _Damping = damping; }
+00163         float                                   getDamping() const { return _Damping; }
+00164 
+00166         void                                    setFilterWeight(float filterWeight) { _FilterWeight = filterWeight; }
+00167         float                                   getFilterWeight() const { return _FilterWeight; }
+00168 
+00170         void                                    setUnitSize(float unitSize) { _UnitSize = unitSize; }
+00171         float                                   getUnitSize() const { return _UnitSize; }
+00172 
+00174         sint64                                  Date;
+00175 
+00177         void                                    serial(NLMISC::IStream &f)  throw(NLMISC::EStream);
+00178 
+00180         void                                    setName(const std::string &name) { _Name = name; }
+00181 
+00183         const std::string               &getName() const { return _Name; }
+00184 
+00185         // ctor (use the water pool manager instead)
+00186         CWaterHeightMap();
+00187         // dtor
+00188         virtual ~CWaterHeightMap() {}
+00189 
+00191         void                                    setPropagationTime(float time);
+00192 
+00194         TAnimationTime                  getPropagationTime() const { return _PropagationTime; }
+00195 
+00196 
+00197 private:
+00198         void animateWaves(float deltaT);
+00199 
+00200         void updateUserPos();
+00201 
+00202         void animatePart(float startTime, float endTime);
+00203 
+00208         void                                    propagate(uint startLine, uint endLine);
+00209         
+00210 
+00212         void                                    filter(uint startLine, uint endLine);
+00213 
+00215         void                                    swapBuffers(float deltaT);
+00216 
+00217 
+00218         friend class CWaterPoolManager;
+00219 
+00220         std::string                _Name;       
+00221         bool                                       _WavesEnabled;
+00222         float                                      _Damping;
+00223         float                                      _FilterWeight;
+00224         float                                      _UnitSize;
+00225         float                                      _WaveIntensity;
+00226         float                                      _WavePeriod;
+00227         uint32                                     _WaveImpulsionRadius;
+00228         bool                                       _BorderWaves;
+00229         float                                      _EmitEllapsedTime;
+00230         float                                      _PropagateEllapsedTime;
+00231         TAnimationTime             _PropagationTime; // the time needed to perform a propagation, this allow split the propagation computation over time.
+00232 
+00233 
+00234         uint                                       _X, _Y;      
+00235         uint                                       _NewX, _NewY;        
+00236         typedef std::vector<float>                              TFloatVect;
+00237         typedef std::vector<NLMISC::CVector2f > TFloat2Vect;
+00238 
+00239         TFloatVect                                 _Map[NumWaterMap]; // the 2 maps used for propagation
+00240         //TFloat2Vect                              _Grad;   // used to store the gradient 
+00241         uint8                                      _CurrMap;    
+00242         uint32                                     _Size;       
+00243 
+00245         void                                            clearArea(uint8 currMap, sint x, sint y, sint width, sint height);
+00246         // same than clearArea, but perform on both maps
+00247         void                                            clearZone(sint x, sint y, sint width, sint height);
+00249         void                                            makeCpy(uint buffer, uint dX, uint dY, uint sX, uint sY, uint width, uint height);
+00250 
+00252         void                                            clearBorder(uint currMap);
+00253 
+00254 
+00255 };
+00256 
+00257 } // NL3D
+00258 
+00259 #endif
+
water_height_map.h
