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