doxygen: add newline after \file
[blender.git] / intern / smoke / intern / FLUID_3D.h
1 /** \file
2  * \ingroup smoke
3  */
4 //////////////////////////////////////////////////////////////////////
5 // This file is part of Wavelet Turbulence.
6 // 
7 // Wavelet Turbulence is free software: you can redistribute it and/or modify
8 // it under the terms of the GNU General Public License as published by
9 // the Free Software Foundation, either version 3 of the License, or
10 // (at your option) any later version.
11 // 
12 // Wavelet Turbulence 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 General Public License for more details.
16 // 
17 // You should have received a copy of the GNU General Public License
18 // along with Wavelet Turbulence.  If not, see <http://www.gnu.org/licenses/>.
19 // 
20 // Copyright 2008 Theodore Kim and Nils Thuerey
21 // 
22 // FLUID_3D.h: interface for the FLUID_3D class.
23 //
24 //////////////////////////////////////////////////////////////////////
25 // Heavy parallel optimization done. Many of the old functions now
26 // take begin and end parameters and process only specified part of the data.
27 // Some functions were divided into multiple ones.
28 //              - MiikaH
29 //////////////////////////////////////////////////////////////////////
30
31 #ifndef FLUID_3D_H
32 #define FLUID_3D_H
33
34 #include <cstdlib>
35 #include <cmath>
36 #include <cstring>
37 #include <iostream>
38 #include "OBSTACLE.h"
39 // #include "WTURBULENCE.h"
40 #include "VEC3.h"
41
42 using namespace std;
43 using namespace BasicVector;
44 struct WTURBULENCE;
45
46 struct FLUID_3D  
47 {
48         public:
49                 FLUID_3D(int *res, float dx, float dtdef, int init_heat, int init_fire, int init_colors);
50                 FLUID_3D() {};
51                 virtual ~FLUID_3D();
52
53                 void initHeat();
54                 void initFire();
55                 void initColors(float init_r, float init_g, float init_b);
56
57                 void initBlenderRNA(float *alpha, float *beta, float *dt_factor, float *vorticity, int *border_colli, float *burning_rate,
58                                                         float *flame_smoke, float *flame_smoke_color, float *flame_vorticity, float *ignition_temp, float *max_temp);
59                 
60                 // create & allocate vector noise advection 
61                 void initVectorNoise(int amplify);
62
63                 void addSmokeColumn();
64                 static void addSmokeTestCase(float* field, Vec3Int res);
65
66                 void step(float dt, float gravity[3]);
67                 void addObstacle(OBSTACLE* obstacle);
68
69                 const float* xVelocity() { return _xVelocity; }; 
70                 const float* yVelocity() { return _yVelocity; }; 
71                 const float* zVelocity() { return _zVelocity; }; 
72
73                 int xRes() const { return _xRes; };
74                 int yRes() const { return _yRes; };
75                 int zRes() const { return _zRes; };
76
77         public:
78                 // dimensions
79                 int _xRes, _yRes, _zRes, _maxRes;
80                 Vec3Int _res;
81                 size_t _totalCells;
82                 int _slabSize;
83                 float _dx;
84                 float _p0[3];
85                 float _p1[3];
86                 float _totalTime;
87                 int _totalSteps;
88                 int _totalImgDumps;
89                 int _totalVelDumps;
90
91                 void artificialDampingSL(int zBegin, int zEnd);
92                 void artificialDampingExactSL(int pos);
93
94                 void setBorderObstacles();
95
96                 // fields
97                 float* _density;
98                 float* _densityOld;
99                 float* _heat;
100                 float* _heatOld;
101                 float* _xVelocity;
102                 float* _yVelocity;
103                 float* _zVelocity;
104                 float* _xVelocityOb;
105                 float* _yVelocityOb;
106                 float* _zVelocityOb;
107                 float* _xVelocityOld;
108                 float* _yVelocityOld;
109                 float* _zVelocityOld;
110                 float* _xForce;
111                 float* _yForce;
112                 float* _zForce;
113                 unsigned char*  _obstacles; /* only used (useful) for static obstacles like domain boundaries */
114                 unsigned char*  _obstaclesAnim;
115
116                 // Required for proper threading:
117                 float* _xVelocityTemp;
118                 float* _yVelocityTemp;
119                 float* _zVelocityTemp;
120                 float* _heatTemp;
121                 float* _densityTemp;
122
123                 // fire simulation
124                 float *_flame;
125                 float *_fuel;
126                 float *_fuelTemp;
127                 float *_fuelOld;
128                 float *_react;
129                 float *_reactTemp;
130                 float *_reactOld;
131
132                 // smoke color
133                 float *_color_r;
134                 float *_color_rOld;
135                 float *_color_rTemp;
136                 float *_color_g;
137                 float *_color_gOld;
138                 float *_color_gTemp;
139                 float *_color_b;
140                 float *_color_bOld;
141                 float *_color_bTemp;
142
143
144                 // CG fields
145                 int _iterations;
146
147                 // simulation constants
148                 float _dt;
149                 float *_dtFactor;
150                 float _vorticityEps;
151                 float _heatDiffusion;
152                 float *_vorticityRNA;   // RNA-pointer.
153                 float *_alpha; // for the buoyancy density term <-- as pointer to get blender RNA in here
154                 float *_beta; // was _buoyancy <-- as pointer to get blender RNA in here
155                 float _tempAmb; /* ambient temperature */
156                 float _constantScaling;
157
158                 bool _domainBcFront;  // z
159                 bool _domainBcTop;    // y
160                 bool _domainBcLeft;   // x
161                 bool _domainBcBack;   // DOMAIN_BC_FRONT
162                 bool _domainBcBottom; // DOMAIN_BC_TOP
163                 bool _domainBcRight;  // DOMAIN_BC_LEFT
164                 int *_borderColli; // border collision rules <-- as pointer to get blender RNA in here
165                 int _colloPrev;         // To track whether value has been changed (to not
166                                                         // have to recalibrate borders if nothing has changed
167                 void setBorderCollisions();
168
169                 void setObstacleVelocity(int zBegin, int zEnd);
170
171                 // WTURBULENCE object, if active
172                 // WTURBULENCE* _wTurbulence;
173
174                 // boundary setting functions
175                 void copyBorderAll(float* field, int zBegin, int zEnd);
176
177                 // timestepping functions
178                 void wipeBoundaries(int zBegin, int zEnd);
179                 void wipeBoundariesSL(int zBegin, int zEnd);
180                 void addForce(int zBegin, int zEnd);
181                 void addVorticity(int zBegin, int zEnd);
182                 void addBuoyancy(float *heat, float *density, float gravity[3], int zBegin, int zEnd);
183
184                 // solver stuff
185                 void project();
186                 void diffuseHeat();
187                 void diffuseColor();
188                 void solvePressure(float* field, float* b, unsigned char* skip);
189                 void solvePressurePre(float* field, float* b, unsigned char* skip);
190                 void solveHeat(float* field, float* b, unsigned char* skip);
191                 void solveDiffusion(float* field, float* b, float* factor);
192
193
194                 // handle obstacle boundaries
195                 void setObstacleBoundaries(float *_pressure, int zBegin, int zEnd);
196                 void setObstaclePressure(float *_pressure, int zBegin, int zEnd);
197
198                 void fixObstacleCompression(float *divergence);
199
200         public:
201                 // advection, accessed e.g. by WTURBULENCE class
202                 //void advectMacCormack();
203                 void advectMacCormackBegin(int zBegin, int zEnd);
204                 void advectMacCormackEnd1(int zBegin, int zEnd);
205                 void advectMacCormackEnd2(int zBegin, int zEnd);
206
207                 void floodFillComponent(int *components, size_t *queue, size_t limit, size_t start, int from, int to);
208                 void mergeComponents(int *components, size_t *queue, size_t cur, size_t other);
209
210                 /* burning */
211                 float *_burning_rate; // RNA pointer
212                 float *_flame_smoke; // RNA pointer
213                 float *_flame_smoke_color; // RNA pointer
214                 float *_flame_vorticity; // RNA pointer
215                 float *_ignition_temp; // RNA pointer
216                 float *_max_temp; // RNA pointer
217                 void processBurn(float *fuel, float *smoke, float *react, float *heat,
218                                                  float *r, float *g, float *b, int total_cells, float dt);
219                 void updateFlame(float *react, float *flame, int total_cells);
220
221                 // boundary setting functions
222                 static void copyBorderX(float* field, Vec3Int res, int zBegin, int zEnd);
223                 static void copyBorderY(float* field, Vec3Int res, int zBegin, int zEnd);
224                 static void copyBorderZ(float* field, Vec3Int res, int zBegin, int zEnd);
225                 static void setNeumannX(float* field, Vec3Int res, int zBegin, int zEnd);
226                 static void setNeumannY(float* field, Vec3Int res, int zBegin, int zEnd);
227                 static void setNeumannZ(float* field, Vec3Int res, int zBegin, int zEnd);
228                 static void setZeroX(float* field, Vec3Int res, int zBegin, int zEnd);
229                 static void setZeroY(float* field, Vec3Int res, int zBegin, int zEnd);
230                 static void setZeroZ(float* field, Vec3Int res, int zBegin, int zEnd);
231                 static void setZeroBorder(float* field, Vec3Int res, int zBegin, int zEnd) {
232                         setZeroX(field, res, zBegin, zEnd);
233                         setZeroY(field, res, zBegin, zEnd);
234                         setZeroZ(field, res, zBegin, zEnd);
235                 };
236
237                 
238
239                 // static advection functions, also used by WTURBULENCE
240                 static void advectFieldSemiLagrange(const float dt, const float* velx, const float* vely,  const float* velz,
241                                 float* oldField, float* newField, Vec3Int res, int zBegin, int zEnd);
242                 static void advectFieldMacCormack1(const float dt, const float* xVelocity, const float* yVelocity, const float* zVelocity, 
243                                 float* oldField, float* tempResult, Vec3Int res, int zBegin, int zEnd);
244                 static void advectFieldMacCormack2(const float dt, const float* xVelocity, const float* yVelocity, const float* zVelocity, 
245                                 float* oldField, float* newField, float* tempResult, float* temp1,Vec3Int res, const unsigned char* obstacles, int zBegin, int zEnd);
246
247
248                 // temp ones for testing
249                 /*static void advectFieldMacCormack(const float dt, const float* xVelocity, const float* yVelocity, const float* zVelocity, 
250                                 float* oldField, float* newField, float* temp1, float* temp2, Vec3Int res, const unsigned char* obstacles);*/
251                 /*static void advectFieldSemiLagrange2(const float dt, const float* velx, const float* vely,  const float* velz,
252                                 float* oldField, float* newField, Vec3Int res);*/
253
254                 // maccormack helper functions
255                 static void clampExtrema(const float dt, const float* xVelocity, const float* yVelocity,  const float* zVelocity,
256                                 float* oldField, float* newField, Vec3Int res, int zBegin, int zEnd);
257                 static void clampOutsideRays(const float dt, const float* xVelocity, const float* yVelocity,  const float* zVelocity,
258                                 float* oldField, float* newField, Vec3Int res, const unsigned char* obstacles, const float *oldAdvection, int zBegin, int zEnd);
259
260
261
262                 // output helper functions
263                 // static void writeImageSliceXY(const float *field, Vec3Int res, int slice, string prefix, int picCnt, float scale=1.);
264                 // static void writeImageSliceYZ(const float *field, Vec3Int res, int slice, string prefix, int picCnt, float scale=1.);
265                 // static void writeImageSliceXZ(const float *field, Vec3Int res, int slice, string prefix, int picCnt, float scale=1.);
266                 // static void writeProjectedIntern(const float *field, Vec3Int res, int dir1, int dir2, string prefix, int picCnt, float scale=1.); 
267 };
268
269 #endif