BF2.5: First commit of smoke code.
[blender.git] / intern / smoke / intern / FLUID_3D.h
1 //////////////////////////////////////////////////////////////////////
2 // This file is part of Wavelet Turbulence.
3 // 
4 // Wavelet Turbulence is free software: you can redistribute it and/or modify
5 // it under the terms of the GNU General Public License as published by
6 // the Free Software Foundation, either version 3 of the License, or
7 // (at your option) any later version.
8 // 
9 // Wavelet Turbulence is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 // GNU General Public License for more details.
13 // 
14 // You should have received a copy of the GNU General Public License
15 // along with Wavelet Turbulence.  If not, see <http://www.gnu.org/licenses/>.
16 // 
17 // Copyright 2008 Theodore Kim and Nils Thuerey
18 // 
19 // FLUID_3D.h: interface for the FLUID_3D class.
20 //
21 //////////////////////////////////////////////////////////////////////
22
23 #ifndef FLUID_3D_H
24 #define FLUID_3D_H
25
26 #include <cstdlib>
27 #include <cmath>
28 #include <iostream>
29 #include "OBSTACLE.h"
30 #include "WTURBULENCE.h"
31 #include "VEC3.h"
32
33 using namespace std;
34 using namespace BasicVector;
35 class WTURBULENCE;
36
37 class FLUID_3D  
38 {
39         public:
40                 FLUID_3D(int *res, int amplify, float *p0, float *p1, float dt);
41                 FLUID_3D() {};
42                 virtual ~FLUID_3D();
43
44                 void initBlenderRNA(float *alpha, float *beta);
45                 
46                 // create & allocate vector noise advection 
47                 void initVectorNoise(int amplify);
48
49                 void addSmokeColumn();
50                 static void addSmokeTestCase(float* field, Vec3Int res, float value);
51
52                 void step();
53                 void addObstacle(OBSTACLE* obstacle);
54
55                 const float* xVelocity() { return _xVelocity; }; 
56                 const float* yVelocity() { return _yVelocity; }; 
57                 const float* zVelocity() { return _zVelocity; }; 
58
59                 int xRes() const { return _xRes; };
60                 int yRes() const { return _yRes; };
61                 int zRes() const { return _zRes; };
62
63         public:  
64                 // dimensions
65                 int _xRes, _yRes, _zRes, _maxRes;
66                 Vec3Int _res;
67                 int _totalCells;
68                 int _slabSize;
69                 float _dx;
70                 float _p0[3];
71                 float _p1[3];
72                 float _totalTime;
73                 int _totalSteps;
74                 int _totalImgDumps;
75                 int _totalVelDumps;
76
77     void artificialDamping(float* field);
78
79                 // fields
80                 float* _density;
81                 float* _densityOld;
82                 float* _heat;
83                 float* _heatOld;
84                 float* _pressure;
85                 float* _xVelocity;
86                 float* _yVelocity;
87                 float* _zVelocity;
88                 float* _xVelocityOld;
89                 float* _yVelocityOld;
90                 float* _zVelocityOld;
91                 float* _xForce;
92                 float* _yForce;
93                 float* _zForce;
94                 float* _divergence;
95                 float* _xVorticity;
96                 float* _yVorticity;
97                 float* _zVorticity;
98                 float* _vorticity;
99                 unsigned char*  _obstacles;
100
101                 // CG fields
102                 float* _residual;
103                 float* _direction;
104                 float* _q;
105                 int _iterations;
106
107                 // simulation constants
108                 float _dt;
109                 float _vorticityEps;
110                 float _heatDiffusion;
111                 float *_alpha; // for the buoyancy density term <-- as pointer to get blender RNA in here
112                 float *_beta; // was _buoyancy <-- as pointer to get blender RNA in here
113                 float _tempAmb; /* ambient temperature */
114
115                 // WTURBULENCE object, if active
116                 WTURBULENCE* _wTurbulence;
117
118                 // boundary setting functions
119                 void copyBorderAll(float* field);
120
121                 // timestepping functions
122                 void wipeBoundaries();
123                 void addForce();
124                 void addVorticity();
125                 void addBuoyancy(float *heat, float *density);
126
127                 // solver stuff
128                 void project();
129                 void diffuseHeat();
130                 void solvePressure(float* field, float* b, unsigned char* skip);
131                 void solveHeat(float* field, float* b, unsigned char* skip);
132
133                 // handle obstacle boundaries
134                 void setObstacleBoundaries();
135
136         public:
137                 // advection, accessed e.g. by WTURBULENCE class
138                 void advectMacCormack();
139
140                 // boundary setting functions
141                 static void copyBorderX(float* field, Vec3Int res);
142                 static void copyBorderY(float* field, Vec3Int res);
143                 static void copyBorderZ(float* field, Vec3Int res);
144                 static void setNeumannX(float* field, Vec3Int res);
145                 static void setNeumannY(float* field, Vec3Int res);
146                 static void setNeumannZ(float* field, Vec3Int res);
147                 static void setZeroX(float* field, Vec3Int res);
148                 static void setZeroY(float* field, Vec3Int res);
149                 static void setZeroZ(float* field, Vec3Int res);
150                 static void setZeroBorder(float* field, Vec3Int res) {
151                         setZeroX(field, res);
152                         setZeroY(field, res);
153                         setZeroZ(field, res);
154                 };
155
156                 // static advection functions, also used by WTURBULENCE
157                 static void advectFieldSemiLagrange(const float dt, const float* velx, const float* vely,  const float* velz,
158                                 float* oldField, float* newField, Vec3Int res);
159                 static void advectFieldMacCormack(const float dt, const float* xVelocity, const float* yVelocity, const float* zVelocity, 
160                                 float* oldField, float* newField, float* temp1, float* temp2, Vec3Int res, const float* obstacles);
161
162                 // maccormack helper functions
163                 static void clampExtrema(const float dt, const float* xVelocity, const float* yVelocity,  const float* zVelocity,
164                                 float* oldField, float* newField, Vec3Int res);
165                 static void clampOutsideRays(const float dt, const float* xVelocity, const float* yVelocity,  const float* zVelocity,
166                                 float* oldField, float* newField, Vec3Int res, const float* obstacles, const float *oldAdvection);
167
168                 // output helper functions
169                 static void writeImageSliceXY(const float *field, Vec3Int res, int slice, string prefix, int picCnt, float scale=1.);
170                 static void writeImageSliceYZ(const float *field, Vec3Int res, int slice, string prefix, int picCnt, float scale=1.);
171                 static void writeImageSliceXZ(const float *field, Vec3Int res, int slice, string prefix, int picCnt, float scale=1.);
172                 static void writeProjectedIntern(const float *field, Vec3Int res, int dir1, int dir2, string prefix, int picCnt, float scale=1.); 
173 };
174
175 #endif
176