Smoke: decoupling of wavelet #2, new noise strength option on gui, fftw3 option in...
[blender.git] / intern / smoke / intern / smoke_API.cpp
1 /**
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program 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 this program; if not, write to the Free Software Foundation,
18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19  *
20  * The Original Code is Copyright (C) 2009 by Daniel Genrich
21  * All rights reserved.
22  *
23  * Contributor(s): None
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 #include "FLUID_3D.h"
29 #include "WTURBULENCE.h"
30
31 #include <stdio.h>
32 #include <stdlib.h>
33
34 // y in smoke is z in blender
35 extern "C" FLUID_3D *smoke_init(int *res, int amplify, float *p0, float *p1, float dt)
36 {
37         // smoke lib uses y as top-bottom/vertical axis where blender uses z
38         FLUID_3D *fluid = new FLUID_3D(res, amplify, p0, dt);
39
40         // printf("xres: %d, yres: %d, zres: %d\n", res[0], res[1], res[2]);
41
42         return fluid;
43 }
44
45 extern "C" WTURBULENCE *smoke_turbulence_init(int *res, int amplify, int noisetype)
46 {
47         // initialize wavelet turbulence
48         if(amplify)
49                 return new WTURBULENCE(res[0],res[1],res[2], amplify, noisetype);
50         else 
51                 return NULL;
52 }
53
54 extern "C" void smoke_free(FLUID_3D *fluid)
55 {
56         delete fluid;
57         fluid = NULL;
58 }
59
60 extern "C" void smoke_turbulence_free(WTURBULENCE *wt)
61 {
62          delete wt;
63          wt = NULL;
64 }
65
66 extern "C" void smoke_step(FLUID_3D *fluid)
67 {
68         fluid->step();
69 }
70
71 extern "C" void smoke_turbulence_step(WTURBULENCE *wt, FLUID_3D *fluid)
72 {
73         if(wt) 
74                 wt->stepTurbulenceFull(fluid->_dt/fluid->_dx, fluid->_xVelocity, fluid->_yVelocity, fluid->_zVelocity, fluid->_obstacles); 
75 }
76
77 extern "C" void smoke_initBlenderRNA(FLUID_3D *fluid, float *alpha, float *beta)
78 {
79         fluid->initBlenderRNA(alpha, beta);
80 }
81
82 extern "C" void smoke_initWaveletBlenderRNA(WTURBULENCE *wt, float *strength)
83 {
84         wt->initBlenderRNA(strength);
85 }
86
87 template < class T > inline T ABS( T a ) {
88         return (0 < a) ? a : -a ;
89 }
90
91 extern "C" float *smoke_get_density(FLUID_3D *fluid)
92 {
93         return fluid->_density;
94 }
95
96 extern "C" float *smoke_get_heat(FLUID_3D *fluid)
97 {
98         return fluid->_heat;
99 }
100
101 extern "C" float *smoke_get_velocity_x(FLUID_3D *fluid)
102 {
103         return fluid->_xVorticity;
104 }
105
106 extern "C" float *smoke_get_velocity_y(FLUID_3D *fluid)
107 {
108         return fluid->_yVorticity;
109 }
110
111 extern "C" float *smoke_get_velocity_z(FLUID_3D *fluid)
112 {
113         return fluid->_zVorticity;
114 }
115
116 extern "C" float *smoke_turbulence_get_density(WTURBULENCE *wt)
117 {
118         return wt ? wt->getDensityBig() : NULL;
119 }
120
121 extern "C" void smoke_turbulence_get_res(WTURBULENCE *wt, int *res)
122 {
123         if(wt)
124         {
125                 Vec3Int r = wt->getResBig();
126                 res[0] = r[0];
127                 res[1] = r[1];
128                 res[2] = r[2];
129         }
130 }
131
132 extern "C" unsigned char *smoke_get_obstacle(FLUID_3D *fluid)
133 {
134         return fluid->_obstacles;
135 }
136
137 extern "C" size_t smoke_get_index(int x, int max_x, int y, int max_y, int z /*, int max_z */)
138 {
139         // // const int index = x + y * smd->res[0] + z * smd->res[0]*smd->res[1];
140         return x + y * max_x + z * max_x*max_y;
141 }
142
143 extern "C" size_t smoke_get_index2d(int x, int max_x, int y /*, int max_y, int z, int max_z */)
144 {
145         return x + y * max_x;
146 }
147
148 extern "C" void smoke_turbulence_set_noise(WTURBULENCE *wt, int type)
149 {
150         wt->setNoise(type);
151 }