initial commit of the fluid simulator.
[blender.git] / intern / elbeem / intern / particletracer.h
1 /******************************************************************************
2  *
3  * El'Beem - Free Surface Fluid Simulation with the Lattice Boltzmann Method
4  * Copyright 2003,2004 Nils Thuerey
5  *
6  * Particle Viewer/Tracer
7  *
8  *****************************************************************************/
9 #ifndef NTL_PARTICLETRACER_H
10
11 #include "ntl_geometryobject.h"
12
13
14 //! A single particle
15 class ParticleObject
16 {
17         public:
18         //! Standard constructor
19         inline ParticleObject(ntlVec3Gfx mp) :
20                         mPos(mp), mActive( true ) { };
21         //! Copy constructor
22         inline ParticleObject(const ParticleObject &a) :
23                         mPos(a.mPos), mActive(a.mActive) { };
24         //! Destructor
25         inline ~ParticleObject() { /* empty */ };
26
27                 //! add vector to position
28                 inline void advance(double vx, double vy, double vz) {
29                         mPos[0] += vx; mPos[1] += vy; mPos[2] += vz; }
30
31                 //! add vector to position
32                 inline ntlVec3Gfx getPos() { return mPos; }
33
34                 //! get active flag
35                 inline bool getActive() { return mActive; }
36                 //! set active flag
37                 inline void setActive(bool set) { mActive = set; }
38                 
39         protected:
40
41                 /*! the particle position */
42                 ntlVec3Gfx mPos;
43
44                 /*! particle active? */
45                 bool mActive;
46 };
47
48
49 //! A whole particle array
50 class ParticleTracer :
51         public ntlGeometryObject
52 {
53         public:
54         //! Standard constructor
55         ParticleTracer();
56         //! Destructor
57         ~ParticleTracer() { /* empty */ };
58
59                 //! add a particle at this position
60                 void addParticle(double x, double y, double z);
61
62                 //! save particle positions before adding a new timestep
63                 void savePreviousPositions();
64
65                 //! draw the particle array
66                 void draw();
67                 
68                 //! parse settings from attributes (dont use own list!)
69                 void parseAttrList( AttributeList *att );
70
71
72                 // access funcs
73                 
74                 //! set the number of timesteps to trace
75                 void setTimesteps(int steps);
76
77                 //! set the number of particles
78                 inline void setNumParticles(int set) { mNumParticles = set; }
79                 //! get the number of particles
80                 inline int  getNumParticles()                           { return mNumParticles; }
81
82                 //! set the number of timesteps to trace
83                 inline void setTrailLength(int set) { mTrailLength = set; mParts.resize(mTrailLength*mTrailInterval); }
84                 //! get the number of timesteps to trace
85                 inline int  getTrailLength()                            { return mTrailLength; }
86                 //! set the number of timesteps between each anim step saving
87                 inline void setTrailInterval(int set) { mTrailInterval = set; mParts.resize(mTrailLength*mTrailInterval); }
88
89                 //! get the no. of particles in the current array
90                 inline int getPartArraySize() { return mParts[0].size(); }
91
92                 //! iterate over all newest particles (for advancing positions)
93                 inline vector<ParticleObject>::iterator getParticlesBegin() { return mParts[0].begin(); }
94                 //! end iterator for newest particles
95                 inline vector<ParticleObject>::iterator getParticlesEnd() { return mParts[0].end(); }
96                 
97                 /*! set geometry start (for renderer) */
98                 inline void setStart(ntlVec3Gfx set) { mStart = set; }
99                 /*! set geometry end (for renderer) */
100                 inline void setEnd(ntlVec3Gfx set) { mEnd = set; }
101                 
102                 /*! set simulation domain start */
103                 inline void setSimStart(ntlVec3Gfx set) { mSimStart = set; }
104                 /*! set simulation domain end */
105                 inline void setSimEnd(ntlVec3Gfx set) { mSimEnd = set; }
106                 
107                 //! set the particle scaling factor
108                 inline void setPartScale(double set) { mPartScale = set; }
109                 //! set the trail scaling factor
110                 inline void setTrailScale(double set) { mTrailScale = set; }
111
112
113                 // NTL geometry implementation
114
115                 /*! Get the triangles from this object */
116                 virtual void getTriangles( vector<ntlTriangle> *triangles, 
117                                 vector<ntlVec3Gfx> *vertices, 
118                                 vector<ntlVec3Gfx> *normals, int objectId );
119
120
121         protected:
122
123                 /*! the particle array (for multiple timesteps) */
124                 vector< vector<ParticleObject> > mParts;
125
126                 /*! desired number of particles */
127                 int mNumParticles;
128
129                 /*! number of particle positions to trace */
130                 int mTrailLength;
131
132                 /*! number of timesteps to between saving particle positions */
133                 int mTrailInterval;
134                 int mTrailIntervalCounter;
135
136                 /*! size of the particles to display */
137                 double mPartSize;
138
139                 /*! size of the particle trail */
140                 double mTrailScale;
141
142                 /*! start and end vectors for the triangulation region to create particles in */
143                 ntlVec3Gfx mStart, mEnd;
144
145                 /*! start and end vectors of the simulation domain */
146                 ntlVec3Gfx mSimStart, mSimEnd;
147
148                 /*! scaling param for particles */
149                 double mPartScale;
150                 /*! head and tail distance for particle shapes */
151                 double mPartHeadDist, mPartTailDist;
152                 /*! no of segments for particle cone */
153                 int mPartSegments;
154                 /*! use length/absval of values to scale particles? */
155                 int mValueScale;
156                 /*! value length maximal cutoff value, for mValueScale==2 */
157                 double mValueCutoffTop;
158                 /*! value length minimal cutoff value, for mValueScale==2 */
159                 double mValueCutoffBottom;
160
161 };
162
163 #define NTL_PARTICLETRACER_H
164 #endif
165