8cadf3bc9895135456946b15c81e73cc7f9104b4
[blender-staging.git] / intern / smoke / intern / FLUID_3D.h
1 /** \file smoke/intern/FLUID_3D.h
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 class WTURBULENCE;
45
46 class 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         public:
199                 // advection, accessed e.g. by WTURBULENCE class
200                 //void advectMacCormack();
201                 void advectMacCormackBegin(int zBegin, int zEnd);
202                 void advectMacCormackEnd1(int zBegin, int zEnd);
203                 void advectMacCormackEnd2(int zBegin, int zEnd);
204
205                 /* burning */
206                 float *_burning_rate; // RNA pointer
207                 float *_flame_smoke; // RNA pointer
208                 float *_flame_smoke_color; // RNA pointer
209                 float *_flame_vorticity; // RNA pointer
210                 float *_ignition_temp; // RNA pointer
211                 float *_max_temp; // RNA pointer
212                 void processBurn(float *fuel, float *smoke, float *react, float *flame, float *heat,
213                                                  float *r, float *g, float *b, int total_cells, float dt);
214
215                 // boundary setting functions
216                 static void copyBorderX(float* field, Vec3Int res, int zBegin, int zEnd);
217                 static void copyBorderY(float* field, Vec3Int res, int zBegin, int zEnd);
218                 static void copyBorderZ(float* field, Vec3Int res, int zBegin, int zEnd);
219                 static void setNeumannX(float* field, Vec3Int res, int zBegin, int zEnd);
220                 static void setNeumannY(float* field, Vec3Int res, int zBegin, int zEnd);
221                 static void setNeumannZ(float* field, Vec3Int res, int zBegin, int zEnd);
222                 static void setZeroX(float* field, Vec3Int res, int zBegin, int zEnd);
223                 static void setZeroY(float* field, Vec3Int res, int zBegin, int zEnd);
224                 static void setZeroZ(float* field, Vec3Int res, int zBegin, int zEnd);
225                 static void setZeroBorder(float* field, Vec3Int res, int zBegin, int zEnd) {
226                         setZeroX(field, res, zBegin, zEnd);
227                         setZeroY(field, res, zBegin, zEnd);
228                         setZeroZ(field, res, zBegin, zEnd);
229                 };
230
231                 
232
233                 // static advection functions, also used by WTURBULENCE
234                 static void advectFieldSemiLagrange(const float dt, const float* velx, const float* vely,  const float* velz,
235                                 float* oldField, float* newField, Vec3Int res, int zBegin, int zEnd);
236                 static void advectFieldMacCormack1(const float dt, const float* xVelocity, const float* yVelocity, const float* zVelocity, 
237                                 float* oldField, float* tempResult, Vec3Int res, int zBegin, int zEnd);
238                 static void advectFieldMacCormack2(const float dt, const float* xVelocity, const float* yVelocity, const float* zVelocity, 
239                                 float* oldField, float* newField, float* tempResult, float* temp1,Vec3Int res, const unsigned char* obstacles, int zBegin, int zEnd);
240
241
242                 // temp ones for testing
243                 /*static void advectFieldMacCormack(const float dt, const float* xVelocity, const float* yVelocity, const float* zVelocity, 
244                                 float* oldField, float* newField, float* temp1, float* temp2, Vec3Int res, const unsigned char* obstacles);*/
245                 /*static void advectFieldSemiLagrange2(const float dt, const float* velx, const float* vely,  const float* velz,
246                                 float* oldField, float* newField, Vec3Int res);*/
247
248                 // maccormack helper functions
249                 static void clampExtrema(const float dt, const float* xVelocity, const float* yVelocity,  const float* zVelocity,
250                                 float* oldField, float* newField, Vec3Int res, int zBegin, int zEnd);
251                 static void clampOutsideRays(const float dt, const float* xVelocity, const float* yVelocity,  const float* zVelocity,
252                                 float* oldField, float* newField, Vec3Int res, const unsigned char* obstacles, const float *oldAdvection, int zBegin, int zEnd);
253
254
255
256                 // output helper functions
257                 // static void writeImageSliceXY(const float *field, Vec3Int res, int slice, string prefix, int picCnt, float scale=1.);
258                 // static void writeImageSliceYZ(const float *field, Vec3Int res, int slice, string prefix, int picCnt, float scale=1.);
259                 // static void writeImageSliceXZ(const float *field, Vec3Int res, int slice, string prefix, int picCnt, float scale=1.);
260                 // static void writeProjectedIntern(const float *field, Vec3Int res, int dir1, int dir2, string prefix, int picCnt, float scale=1.); 
261 };
262
263 #endif