code cleanup: quiet warnings for gcc's -Wundef, -Wmissing-declarations
[blender.git] / intern / smoke / intern / smoke_API.cpp
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program 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 this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2009 by Daniel Genrich
19  * All rights reserved.
20  *
21  * Contributor(s): Daniel Genrich
22  *                 Blender Foundation
23  *
24  * ***** END GPL LICENSE BLOCK *****
25  */
26
27 /** \file smoke/intern/smoke_API.cpp
28  *  \ingroup smoke
29  */
30
31 #include "FLUID_3D.h"
32 #include "WTURBULENCE.h"
33
34 #include <stdio.h>
35 #include <stdlib.h>
36 #include <math.h>
37
38 #include "../extern/smoke_API.h"  /* to ensure valid prototypes */
39
40 // y in smoke is z in blender
41 extern "C" FLUID_3D *smoke_init(int *res, float *p0, float dtdef)
42 {
43         // smoke lib uses y as top-bottom/vertical axis where blender uses z
44         FLUID_3D *fluid = new FLUID_3D(res, p0, dtdef);
45
46         // printf("xres: %d, yres: %d, zres: %d\n", res[0], res[1], res[2]);
47
48         return fluid;
49 }
50
51 extern "C" WTURBULENCE *smoke_turbulence_init(int *res, int amplify, int noisetype)
52 {
53         // initialize wavelet turbulence
54         if(amplify)
55                 return new WTURBULENCE(res[0],res[1],res[2], amplify, noisetype);
56         else 
57                 return NULL;
58 }
59
60 extern "C" void smoke_free(FLUID_3D *fluid)
61 {
62         delete fluid;
63         fluid = NULL;
64 }
65
66 extern "C" void smoke_turbulence_free(WTURBULENCE *wt)
67 {
68          delete wt;
69          wt = NULL;
70 }
71
72 extern "C" size_t smoke_get_index(int x, int max_x, int y, int max_y, int z /*, int max_z */)
73 {
74         // // const int index = x + y * smd->res[0] + z * smd->res[0]*smd->res[1];
75         return x + y * max_x + z * max_x*max_y;
76 }
77
78 extern "C" size_t smoke_get_index2d(int x, int max_x, int y /*, int max_y, int z, int max_z */)
79 {
80         return x + y * max_x;
81 }
82
83 extern "C" void smoke_step(FLUID_3D *fluid, float dtSubdiv)
84 {
85         fluid->step(dtSubdiv);
86 }
87
88 extern "C" void smoke_turbulence_step(WTURBULENCE *wt, FLUID_3D *fluid)
89 {
90         wt->stepTurbulenceFull(fluid->_dt/fluid->_dx, fluid->_xVelocity, fluid->_yVelocity, fluid->_zVelocity, fluid->_obstacles); 
91 }
92
93 extern "C" void smoke_initBlenderRNA(FLUID_3D *fluid, float *alpha, float *beta, float *dt_factor, float *vorticity, int *border_colli)
94 {
95         fluid->initBlenderRNA(alpha, beta, dt_factor, vorticity, border_colli);
96 }
97
98 extern "C" void smoke_dissolve(FLUID_3D *fluid, int speed, int log)
99 {
100         float *density = fluid->_density;
101         //float *densityOld = fluid->_densityOld;
102         float *heat = fluid->_heat;
103
104         if(log)
105         {
106                 /* max density/speed = dydx */
107                 float dydx = 1.0 / (float)speed;
108                 size_t size= fluid->_xRes * fluid->_yRes * fluid->_zRes;
109
110                 for(size_t i = 0; i < size; i++)
111                 {
112                         density[i] *= (1.0 - dydx);
113
114                         if(density[i] < 0.0f)
115                                 density[i] = 0.0f;
116
117                         heat[i] *= (1.0 - dydx);
118
119                         /*if(heat[i] < 0.0f)
120                                 heat[i] = 0.0f;*/
121                 }
122         }
123         else // linear falloff
124         {
125                 /* max density/speed = dydx */
126                 float dydx = 1.0 / (float)speed;
127                 size_t size= fluid->_xRes * fluid->_yRes * fluid->_zRes;
128
129                 for(size_t i = 0; i < size; i++)
130                 {
131                         density[i] -= dydx;
132
133                         if(density[i] < 0.0f)
134                                 density[i] = 0.0f;
135
136                         if(abs(heat[i]) < dydx) heat[i] = 0.0f;
137                         else if (heat[i]>0.0f) heat[i] -= dydx;
138                         else if (heat[i]<0.0f) heat[i] += dydx;
139                                 
140                 }
141         }
142 }
143
144 extern "C" void smoke_dissolve_wavelet(WTURBULENCE *wt, int speed, int log)
145 {
146         float *density = wt->getDensityBig();
147         Vec3Int r = wt->getResBig();
148
149         if(log)
150         {
151                 /* max density/speed = dydx */
152                 float dydx = 1.0 / (float)speed;
153                 size_t size= r[0] * r[1] * r[2];
154
155                 for(size_t i = 0; i < size; i++)
156                 {
157                         density[i] *= (1.0 - dydx);
158
159                         if(density[i] < 0.0f)
160                                 density[i] = 0.0f;
161                 }
162         }
163         else // linear falloff
164         {
165                 /* max density/speed = dydx */
166                 float dydx = 1.0 / (float)speed;
167                 size_t size= r[0] * r[1] * r[2];
168
169                 for(size_t i = 0; i < size; i++)
170                 {
171                         density[i] -= dydx;
172
173                         if(density[i] < 0.0f)
174                                 density[i] = 0.0f;                              
175                 }
176         }
177 }
178
179 extern "C" void smoke_initWaveletBlenderRNA(WTURBULENCE *wt, float *strength)
180 {
181         wt->initBlenderRNA(strength);
182 }
183
184 template < class T > inline T ABS( T a )
185 {
186         return (0 < a) ? a : -a ;
187 }
188
189 extern "C" void smoke_export(FLUID_3D *fluid, float *dt, float *dx, float **dens, float **densold, float **heat, float **heatold, float **vx, float **vy, float **vz, float **vxold, float **vyold, float **vzold, unsigned char **obstacles)
190 {
191         *dens = fluid->_density;
192         *densold = fluid->_densityOld;
193         *heat = fluid->_heat;
194         *heatold = fluid->_heatOld;
195         *vx = fluid->_xVelocity;
196         *vy = fluid->_yVelocity;
197         *vz = fluid->_zVelocity;
198         *vxold = fluid->_xVelocityOld;
199         *vyold = fluid->_yVelocityOld;
200         *vzold = fluid->_zVelocityOld;
201         *obstacles = fluid->_obstacles;
202         *dt = fluid->_dt;
203         *dx = fluid->_dx;
204
205 }
206
207 extern "C" void smoke_turbulence_export(WTURBULENCE *wt, float **dens, float **densold, float **tcu, float **tcv, float **tcw)
208 {
209         if(!wt)
210                 return;
211
212         *dens = wt->_densityBig;
213         *densold = wt->_densityBigOld;
214         *tcu = wt->_tcU;
215         *tcv = wt->_tcV;
216         *tcw = wt->_tcW;
217 }
218
219 extern "C" float *smoke_get_density(FLUID_3D *fluid)
220 {
221         return fluid->_density;
222 }
223
224 extern "C" float *smoke_get_heat(FLUID_3D *fluid)
225 {
226         return fluid->_heat;
227 }
228
229 extern "C" float *smoke_get_velocity_x(FLUID_3D *fluid)
230 {
231         return fluid->_xVelocity;
232 }
233
234 extern "C" float *smoke_get_velocity_y(FLUID_3D *fluid)
235 {
236         return fluid->_yVelocity;
237 }
238
239 extern "C" float *smoke_get_velocity_z(FLUID_3D *fluid)
240 {
241         return fluid->_zVelocity;
242 }
243
244 extern "C" float *smoke_get_force_x(FLUID_3D *fluid)
245 {
246         return fluid->_xForce;
247 }
248
249 extern "C" float *smoke_get_force_y(FLUID_3D *fluid)
250 {
251         return fluid->_yForce;
252 }
253
254 extern "C" float *smoke_get_force_z(FLUID_3D *fluid)
255 {
256         return fluid->_zForce;
257 }
258
259 extern "C" float *smoke_turbulence_get_density(WTURBULENCE *wt)
260 {
261         return wt ? wt->getDensityBig() : NULL;
262 }
263
264 extern "C" void smoke_turbulence_get_res(WTURBULENCE *wt, int *res)
265 {
266         if(wt)
267         {
268                 Vec3Int r = wt->getResBig();
269                 res[0] = r[0];
270                 res[1] = r[1];
271                 res[2] = r[2];
272         }
273 }
274
275 extern "C" unsigned char *smoke_get_obstacle(FLUID_3D *fluid)
276 {
277         return fluid->_obstacles;
278 }
279
280 extern "C" void smoke_get_ob_velocity(FLUID_3D *fluid, float **x, float **y, float **z)
281 {
282         *x = fluid->_xVelocityOb;
283         *y = fluid->_yVelocityOb;
284         *z = fluid->_zVelocityOb;
285 }
286
287 #if 0
288 extern "C" unsigned char *smoke_get_obstacle_anim(FLUID_3D *fluid)
289 {
290         return fluid->_obstaclesAnim;
291 }
292 #endif
293
294 extern "C" void smoke_turbulence_set_noise(WTURBULENCE *wt, int type)
295 {
296         wt->setNoise(type);
297 }