1 /*
2 * This program is free software; you can redistribute it and/or
3 * modify it under the terms of the GNU General Public License
4 * as published by the Free Software Foundation; either version 2
5 * of the License, or (at your option) any later version.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software Foundation,
14 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15 *
16 * The Original Code is Copyright (C) 2016 Blender Foundation.
17 * All rights reserved.
18 */
19
20 /** \file
21 * \ingroup mantaflow
22 */
23
24 #include <cmath>
25
26 #include "MANTA_main.h"
27 #include "manta_fluid_API.h"
28
29 /* Fluid functions */
manta_init(int * res,struct FluidModifierData * fmd)30 MANTA *manta_init(int *res, struct FluidModifierData *fmd)
31 {
32 return new MANTA(res, fmd);
33 }
manta_free(MANTA * fluid)34 void manta_free(MANTA *fluid)
35 {
36 delete fluid;
37 fluid = nullptr;
38 }
39
manta_ensure_obstacle(MANTA * fluid,struct FluidModifierData * fmd)40 int manta_ensure_obstacle(MANTA *fluid, struct FluidModifierData *fmd)
41 {
42 if (!fluid || !fmd)
43 return 0;
44 return fluid->initObstacle(fmd);
45 }
manta_ensure_guiding(MANTA * fluid,struct FluidModifierData * fmd)46 int manta_ensure_guiding(MANTA *fluid, struct FluidModifierData *fmd)
47 {
48 if (!fluid || !fmd)
49 return 0;
50 return fluid->initGuiding(fmd);
51 }
manta_ensure_invelocity(MANTA * fluid,struct FluidModifierData * fmd)52 int manta_ensure_invelocity(MANTA *fluid, struct FluidModifierData *fmd)
53 {
54 if (!fluid || !fmd)
55 return 0;
56 return fluid->initInVelocity(fmd);
57 }
manta_ensure_outflow(MANTA * fluid,struct FluidModifierData * fmd)58 int manta_ensure_outflow(MANTA *fluid, struct FluidModifierData *fmd)
59 {
60 if (!fluid || !fmd)
61 return 0;
62 return fluid->initOutflow(fmd);
63 }
64
manta_write_config(MANTA * fluid,FluidModifierData * fmd,int framenr)65 int manta_write_config(MANTA *fluid, FluidModifierData *fmd, int framenr)
66 {
67 if (!fluid || !fmd)
68 return 0;
69 return fluid->writeConfiguration(fmd, framenr);
70 }
71
manta_write_data(MANTA * fluid,FluidModifierData * fmd,int framenr)72 int manta_write_data(MANTA *fluid, FluidModifierData *fmd, int framenr)
73 {
74 if (!fluid || !fmd)
75 return 0;
76 return fluid->writeData(fmd, framenr);
77 }
78
manta_write_noise(MANTA * fluid,FluidModifierData * fmd,int framenr)79 int manta_write_noise(MANTA *fluid, FluidModifierData *fmd, int framenr)
80 {
81 if (!fluid || !fmd)
82 return 0;
83 return fluid->writeNoise(fmd, framenr);
84 }
85
manta_read_config(MANTA * fluid,FluidModifierData * fmd,int framenr)86 int manta_read_config(MANTA *fluid, FluidModifierData *fmd, int framenr)
87 {
88 if (!fluid || !fmd)
89 return 0;
90 return fluid->readConfiguration(fmd, framenr);
91 }
92
manta_read_data(MANTA * fluid,FluidModifierData * fmd,int framenr,bool resumable)93 int manta_read_data(MANTA *fluid, FluidModifierData *fmd, int framenr, bool resumable)
94 {
95 if (!fluid || !fmd)
96 return 0;
97 return fluid->readData(fmd, framenr, resumable);
98 }
99
manta_read_noise(MANTA * fluid,FluidModifierData * fmd,int framenr,bool resumable)100 int manta_read_noise(MANTA *fluid, FluidModifierData *fmd, int framenr, bool resumable)
101 {
102 if (!fluid || !fmd)
103 return 0;
104 return fluid->readNoise(fmd, framenr, resumable);
105 }
106
manta_read_mesh(MANTA * fluid,FluidModifierData * fmd,int framenr)107 int manta_read_mesh(MANTA *fluid, FluidModifierData *fmd, int framenr)
108 {
109 if (!fluid || !fmd)
110 return 0;
111 return fluid->readMesh(fmd, framenr);
112 }
113
manta_read_particles(MANTA * fluid,FluidModifierData * fmd,int framenr,bool resumable)114 int manta_read_particles(MANTA *fluid, FluidModifierData *fmd, int framenr, bool resumable)
115 {
116 if (!fluid || !fmd)
117 return 0;
118 return fluid->readParticles(fmd, framenr, resumable);
119 }
120
manta_read_guiding(MANTA * fluid,FluidModifierData * fmd,int framenr,bool sourceDomain)121 int manta_read_guiding(MANTA *fluid, FluidModifierData *fmd, int framenr, bool sourceDomain)
122 {
123 if (!fluid || !fmd)
124 return 0;
125 return fluid->readGuiding(fmd, framenr, sourceDomain);
126 }
127
manta_bake_data(MANTA * fluid,FluidModifierData * fmd,int framenr)128 int manta_bake_data(MANTA *fluid, FluidModifierData *fmd, int framenr)
129 {
130 if (!fluid || !fmd)
131 return 0;
132 return fluid->bakeData(fmd, framenr);
133 }
134
manta_bake_noise(MANTA * fluid,FluidModifierData * fmd,int framenr)135 int manta_bake_noise(MANTA *fluid, FluidModifierData *fmd, int framenr)
136 {
137 if (!fluid || !fmd)
138 return 0;
139 return fluid->bakeNoise(fmd, framenr);
140 }
141
manta_bake_mesh(MANTA * fluid,FluidModifierData * fmd,int framenr)142 int manta_bake_mesh(MANTA *fluid, FluidModifierData *fmd, int framenr)
143 {
144 if (!fluid || !fmd)
145 return 0;
146 return fluid->bakeMesh(fmd, framenr);
147 }
148
manta_bake_particles(MANTA * fluid,FluidModifierData * fmd,int framenr)149 int manta_bake_particles(MANTA *fluid, FluidModifierData *fmd, int framenr)
150 {
151 if (!fluid || !fmd)
152 return 0;
153 return fluid->bakeParticles(fmd, framenr);
154 }
155
manta_bake_guiding(MANTA * fluid,FluidModifierData * fmd,int framenr)156 int manta_bake_guiding(MANTA *fluid, FluidModifierData *fmd, int framenr)
157 {
158 if (!fluid || !fmd)
159 return 0;
160 return fluid->bakeGuiding(fmd, framenr);
161 }
162
manta_has_data(MANTA * fluid,FluidModifierData * fmd,int framenr)163 int manta_has_data(MANTA *fluid, FluidModifierData *fmd, int framenr)
164 {
165 if (!fluid || !fmd)
166 return 0;
167 return fluid->hasData(fmd, framenr);
168 }
169
manta_has_noise(MANTA * fluid,FluidModifierData * fmd,int framenr)170 int manta_has_noise(MANTA *fluid, FluidModifierData *fmd, int framenr)
171 {
172 if (!fluid || !fmd)
173 return 0;
174 return fluid->hasNoise(fmd, framenr);
175 }
176
manta_has_mesh(MANTA * fluid,FluidModifierData * fmd,int framenr)177 int manta_has_mesh(MANTA *fluid, FluidModifierData *fmd, int framenr)
178 {
179 if (!fluid || !fmd)
180 return 0;
181 return fluid->hasMesh(fmd, framenr);
182 }
183
manta_has_particles(MANTA * fluid,FluidModifierData * fmd,int framenr)184 int manta_has_particles(MANTA *fluid, FluidModifierData *fmd, int framenr)
185 {
186 if (!fluid || !fmd)
187 return 0;
188 return fluid->hasParticles(fmd, framenr);
189 }
190
manta_has_guiding(MANTA * fluid,FluidModifierData * fmd,int framenr,bool domain)191 int manta_has_guiding(MANTA *fluid, FluidModifierData *fmd, int framenr, bool domain)
192 {
193 if (!fluid || !fmd)
194 return 0;
195 return fluid->hasGuiding(fmd, framenr, domain);
196 }
197
manta_update_variables(MANTA * fluid,FluidModifierData * fmd)198 void manta_update_variables(MANTA *fluid, FluidModifierData *fmd)
199 {
200 if (!fluid)
201 return;
202 fluid->updateVariables(fmd);
203 }
204
manta_get_frame(MANTA * fluid)205 int manta_get_frame(MANTA *fluid)
206 {
207 if (!fluid)
208 return 0;
209 return fluid->getFrame();
210 }
211
manta_get_timestep(MANTA * fluid)212 float manta_get_timestep(MANTA *fluid)
213 {
214 if (!fluid)
215 return 0;
216 return fluid->getTimestep();
217 }
218
manta_adapt_timestep(MANTA * fluid)219 void manta_adapt_timestep(MANTA *fluid)
220 {
221 if (!fluid)
222 return;
223 fluid->adaptTimestep();
224 }
225
manta_needs_realloc(MANTA * fluid,FluidModifierData * fmd)226 bool manta_needs_realloc(MANTA *fluid, FluidModifierData *fmd)
227 {
228 if (!fluid || !fmd)
229 return false;
230 return fluid->needsRealloc(fmd);
231 }
232
manta_update_pointers(struct MANTA * fluid,struct FluidModifierData * fmd,bool flush)233 void manta_update_pointers(struct MANTA *fluid, struct FluidModifierData *fmd, bool flush)
234 {
235 if (!fluid || !fmd)
236 return;
237 fluid->updatePointers(fmd, flush);
238 }
239
240 /* Fluid accessors */
manta_get_index(int x,int max_x,int y,int max_y,int z)241 size_t manta_get_index(int x, int max_x, int y, int max_y, int z /*, int max_z */)
242 {
243 return x + y * max_x + z * max_x * max_y;
244 }
manta_get_index2d(int x,int max_x,int y)245 size_t manta_get_index2d(int x, int max_x, int y /*, int max_y, int z, int max_z */)
246 {
247 return x + y * max_x;
248 }
manta_get_velocity_x(MANTA * fluid)249 float *manta_get_velocity_x(MANTA *fluid)
250 {
251 return fluid->getVelocityX();
252 }
manta_get_velocity_y(MANTA * fluid)253 float *manta_get_velocity_y(MANTA *fluid)
254 {
255 return fluid->getVelocityY();
256 }
manta_get_velocity_z(MANTA * fluid)257 float *manta_get_velocity_z(MANTA *fluid)
258 {
259 return fluid->getVelocityZ();
260 }
261
manta_get_ob_velocity_x(MANTA * fluid)262 float *manta_get_ob_velocity_x(MANTA *fluid)
263 {
264 return fluid->getObVelocityX();
265 }
manta_get_ob_velocity_y(MANTA * fluid)266 float *manta_get_ob_velocity_y(MANTA *fluid)
267 {
268 return fluid->getObVelocityY();
269 }
manta_get_ob_velocity_z(MANTA * fluid)270 float *manta_get_ob_velocity_z(MANTA *fluid)
271 {
272 return fluid->getObVelocityZ();
273 }
274
manta_get_guide_velocity_x(MANTA * fluid)275 float *manta_get_guide_velocity_x(MANTA *fluid)
276 {
277 return fluid->getGuideVelocityX();
278 }
manta_get_guide_velocity_y(MANTA * fluid)279 float *manta_get_guide_velocity_y(MANTA *fluid)
280 {
281 return fluid->getGuideVelocityY();
282 }
manta_get_guide_velocity_z(MANTA * fluid)283 float *manta_get_guide_velocity_z(MANTA *fluid)
284 {
285 return fluid->getGuideVelocityZ();
286 }
287
manta_get_in_velocity_x(MANTA * fluid)288 float *manta_get_in_velocity_x(MANTA *fluid)
289 {
290 return fluid->getInVelocityX();
291 }
manta_get_in_velocity_y(MANTA * fluid)292 float *manta_get_in_velocity_y(MANTA *fluid)
293 {
294 return fluid->getInVelocityY();
295 }
manta_get_in_velocity_z(MANTA * fluid)296 float *manta_get_in_velocity_z(MANTA *fluid)
297 {
298 return fluid->getInVelocityZ();
299 }
300
manta_get_force_x(MANTA * fluid)301 float *manta_get_force_x(MANTA *fluid)
302 {
303 return fluid->getForceX();
304 }
manta_get_force_y(MANTA * fluid)305 float *manta_get_force_y(MANTA *fluid)
306 {
307 return fluid->getForceY();
308 }
manta_get_force_z(MANTA * fluid)309 float *manta_get_force_z(MANTA *fluid)
310 {
311 return fluid->getForceZ();
312 }
313
manta_get_phiguide_in(MANTA * fluid)314 float *manta_get_phiguide_in(MANTA *fluid)
315 {
316 return fluid->getPhiGuideIn();
317 }
318
manta_get_num_obstacle(MANTA * fluid)319 float *manta_get_num_obstacle(MANTA *fluid)
320 {
321 return fluid->getNumObstacle();
322 }
manta_get_num_guide(MANTA * fluid)323 float *manta_get_num_guide(MANTA *fluid)
324 {
325 return fluid->getNumGuide();
326 }
327
manta_get_res_x(MANTA * fluid)328 int manta_get_res_x(MANTA *fluid)
329 {
330 return fluid->getResX();
331 }
manta_get_res_y(MANTA * fluid)332 int manta_get_res_y(MANTA *fluid)
333 {
334 return fluid->getResY();
335 }
manta_get_res_z(MANTA * fluid)336 int manta_get_res_z(MANTA *fluid)
337 {
338 return fluid->getResZ();
339 }
340
manta_get_phi_in(MANTA * fluid)341 float *manta_get_phi_in(MANTA *fluid)
342 {
343 return fluid->getPhiIn();
344 }
manta_get_phistatic_in(MANTA * fluid)345 float *manta_get_phistatic_in(MANTA *fluid)
346 {
347 return fluid->getPhiStaticIn();
348 }
manta_get_phiobs_in(MANTA * fluid)349 float *manta_get_phiobs_in(MANTA *fluid)
350 {
351 return fluid->getPhiObsIn();
352 }
manta_get_phiobsstatic_in(MANTA * fluid)353 float *manta_get_phiobsstatic_in(MANTA *fluid)
354 {
355 return fluid->getPhiObsStaticIn();
356 }
manta_get_phiout_in(MANTA * fluid)357 float *manta_get_phiout_in(MANTA *fluid)
358 {
359 return fluid->getPhiOutIn();
360 }
manta_get_phioutstatic_in(MANTA * fluid)361 float *manta_get_phioutstatic_in(MANTA *fluid)
362 {
363 return fluid->getPhiOutStaticIn();
364 }
manta_get_phi(MANTA * fluid)365 float *manta_get_phi(MANTA *fluid)
366 {
367 return fluid->getPhi();
368 }
manta_get_pressure(MANTA * fluid)369 float *manta_get_pressure(MANTA *fluid)
370 {
371 return fluid->getPressure();
372 }
373
374 /* Smoke functions */
manta_smoke_export_script(MANTA * smoke,FluidModifierData * fmd)375 void manta_smoke_export_script(MANTA *smoke, FluidModifierData *fmd)
376 {
377 if (!smoke || !fmd)
378 return;
379 smoke->exportSmokeScript(fmd);
380 }
381
get_rgba(float * r,float * g,float * b,float * a,int total_cells,float * data,int sequential)382 static void get_rgba(
383 float *r, float *g, float *b, float *a, int total_cells, float *data, int sequential)
384 {
385 int i;
386 /* Use offsets to map RGB grids to to correct location in data grid. */
387 int m = 4, i_g = 1, i_b = 2, i_a = 3;
388 if (sequential) {
389 m = 1;
390 i_g *= total_cells;
391 i_b *= total_cells;
392 i_a *= total_cells;
393 }
394
395 for (i = 0; i < total_cells; i++) {
396 float alpha = a[i];
397 data[i * m] = r[i] * alpha;
398 data[i * m + i_g] = g[i] * alpha;
399 data[i * m + i_b] = b[i] * alpha;
400 data[i * m + i_a] = alpha;
401 }
402 }
403
manta_smoke_get_rgba(MANTA * smoke,float * data,int sequential)404 void manta_smoke_get_rgba(MANTA *smoke, float *data, int sequential)
405 {
406 get_rgba(smoke->getColorR(),
407 smoke->getColorG(),
408 smoke->getColorB(),
409 smoke->getDensity(),
410 smoke->getTotalCells(),
411 data,
412 sequential);
413 }
414
manta_noise_get_rgba(MANTA * smoke,float * data,int sequential)415 void manta_noise_get_rgba(MANTA *smoke, float *data, int sequential)
416 {
417 get_rgba(smoke->getColorRHigh(),
418 smoke->getColorGHigh(),
419 smoke->getColorBHigh(),
420 smoke->getDensityHigh(),
421 smoke->getTotalCellsHigh(),
422 data,
423 sequential);
424 }
425
get_rgba_fixed_color(float color[3],int total_cells,float * data,int sequential)426 static void get_rgba_fixed_color(float color[3], int total_cells, float *data, int sequential)
427 {
428 int i;
429 int m = 4, i_g = 1, i_b = 2, i_a = 3;
430 if (sequential) {
431 m = 1;
432 i_g *= total_cells;
433 i_b *= total_cells;
434 i_a *= total_cells;
435 }
436
437 for (i = 0; i < total_cells; i++) {
438 data[i * m] = color[0];
439 data[i * m + i_g] = color[1];
440 data[i * m + i_b] = color[2];
441 data[i * m + i_a] = 1.0f;
442 }
443 }
444
manta_smoke_get_rgba_fixed_color(MANTA * smoke,float color[3],float * data,int sequential)445 void manta_smoke_get_rgba_fixed_color(MANTA *smoke, float color[3], float *data, int sequential)
446 {
447 get_rgba_fixed_color(color, smoke->getTotalCells(), data, sequential);
448 }
449
manta_noise_get_rgba_fixed_color(MANTA * smoke,float color[3],float * data,int sequential)450 void manta_noise_get_rgba_fixed_color(MANTA *smoke, float color[3], float *data, int sequential)
451 {
452 get_rgba_fixed_color(color, smoke->getTotalCellsHigh(), data, sequential);
453 }
454
manta_smoke_ensure_heat(MANTA * smoke,struct FluidModifierData * fmd)455 int manta_smoke_ensure_heat(MANTA *smoke, struct FluidModifierData *fmd)
456 {
457 if (!smoke || !fmd)
458 return 0;
459 return smoke->initHeat(fmd);
460 }
461
manta_smoke_ensure_fire(MANTA * smoke,struct FluidModifierData * fmd)462 int manta_smoke_ensure_fire(MANTA *smoke, struct FluidModifierData *fmd)
463 {
464 if (!smoke || !fmd)
465 return 0;
466
467 bool result = smoke->initFire(fmd);
468 if (smoke->usingNoise()) {
469 result &= smoke->initFireHigh(fmd);
470 }
471 return result;
472 }
473
manta_smoke_ensure_colors(MANTA * smoke,struct FluidModifierData * fmd)474 int manta_smoke_ensure_colors(MANTA *smoke, struct FluidModifierData *fmd)
475 {
476 if (!smoke || !fmd)
477 return 0;
478
479 bool result = smoke->initColors(fmd);
480 if (smoke->usingNoise()) {
481 result &= smoke->initColorsHigh(fmd);
482 }
483 return result;
484 }
485
486 /* Smoke accessors */
manta_smoke_get_density(MANTA * smoke)487 float *manta_smoke_get_density(MANTA *smoke)
488 {
489 return smoke->getDensity();
490 }
manta_smoke_get_fuel(MANTA * smoke)491 float *manta_smoke_get_fuel(MANTA *smoke)
492 {
493 return smoke->getFuel();
494 }
manta_smoke_get_react(MANTA * smoke)495 float *manta_smoke_get_react(MANTA *smoke)
496 {
497 return smoke->getReact();
498 }
manta_smoke_get_heat(MANTA * smoke)499 float *manta_smoke_get_heat(MANTA *smoke)
500 {
501 return smoke->getHeat();
502 }
manta_smoke_get_flame(MANTA * smoke)503 float *manta_smoke_get_flame(MANTA *smoke)
504 {
505 return smoke->getFlame();
506 }
manta_smoke_get_shadow(MANTA * smoke)507 float *manta_smoke_get_shadow(MANTA *smoke)
508 {
509 return smoke->getShadow();
510 }
511
manta_smoke_get_color_r(MANTA * smoke)512 float *manta_smoke_get_color_r(MANTA *smoke)
513 {
514 return smoke->getColorR();
515 }
manta_smoke_get_color_g(MANTA * smoke)516 float *manta_smoke_get_color_g(MANTA *smoke)
517 {
518 return smoke->getColorG();
519 }
manta_smoke_get_color_b(MANTA * smoke)520 float *manta_smoke_get_color_b(MANTA *smoke)
521 {
522 return smoke->getColorB();
523 }
524
manta_smoke_get_flags(MANTA * smoke)525 int *manta_smoke_get_flags(MANTA *smoke)
526 {
527 return smoke->getFlags();
528 }
529
manta_smoke_get_density_in(MANTA * smoke)530 float *manta_smoke_get_density_in(MANTA *smoke)
531 {
532 return smoke->getDensityIn();
533 }
manta_smoke_get_heat_in(MANTA * smoke)534 float *manta_smoke_get_heat_in(MANTA *smoke)
535 {
536 return smoke->getHeatIn();
537 }
manta_smoke_get_color_r_in(MANTA * smoke)538 float *manta_smoke_get_color_r_in(MANTA *smoke)
539 {
540 return smoke->getColorRIn();
541 }
manta_smoke_get_color_g_in(MANTA * smoke)542 float *manta_smoke_get_color_g_in(MANTA *smoke)
543 {
544 return smoke->getColorGIn();
545 }
manta_smoke_get_color_b_in(MANTA * smoke)546 float *manta_smoke_get_color_b_in(MANTA *smoke)
547 {
548 return smoke->getColorBIn();
549 }
manta_smoke_get_fuel_in(MANTA * smoke)550 float *manta_smoke_get_fuel_in(MANTA *smoke)
551 {
552 return smoke->getFuelIn();
553 }
manta_smoke_get_react_in(MANTA * smoke)554 float *manta_smoke_get_react_in(MANTA *smoke)
555 {
556 return smoke->getReactIn();
557 }
manta_smoke_get_emission_in(MANTA * smoke)558 float *manta_smoke_get_emission_in(MANTA *smoke)
559 {
560 return smoke->getEmissionIn();
561 }
562
manta_smoke_has_heat(MANTA * smoke)563 int manta_smoke_has_heat(MANTA *smoke)
564 {
565 return (smoke->getHeat()) ? 1 : 0;
566 }
manta_smoke_has_fuel(MANTA * smoke)567 int manta_smoke_has_fuel(MANTA *smoke)
568 {
569 return (smoke->getFuel()) ? 1 : 0;
570 }
manta_smoke_has_colors(MANTA * smoke)571 int manta_smoke_has_colors(MANTA *smoke)
572 {
573 return (smoke->getColorR() && smoke->getColorG() && smoke->getColorB()) ? 1 : 0;
574 }
575
manta_noise_get_density(MANTA * smoke)576 float *manta_noise_get_density(MANTA *smoke)
577 {
578 return (smoke && smoke->usingNoise()) ? smoke->getDensityHigh() : nullptr;
579 }
manta_noise_get_fuel(MANTA * smoke)580 float *manta_noise_get_fuel(MANTA *smoke)
581 {
582 return (smoke && smoke->usingNoise()) ? smoke->getFuelHigh() : nullptr;
583 }
manta_noise_get_react(MANTA * smoke)584 float *manta_noise_get_react(MANTA *smoke)
585 {
586 return (smoke && smoke->usingNoise()) ? smoke->getReactHigh() : nullptr;
587 }
manta_noise_get_color_r(MANTA * smoke)588 float *manta_noise_get_color_r(MANTA *smoke)
589 {
590 return (smoke && smoke->usingNoise()) ? smoke->getColorRHigh() : nullptr;
591 }
manta_noise_get_color_g(MANTA * smoke)592 float *manta_noise_get_color_g(MANTA *smoke)
593 {
594 return (smoke && smoke->usingNoise()) ? smoke->getColorGHigh() : nullptr;
595 }
manta_noise_get_color_b(MANTA * smoke)596 float *manta_noise_get_color_b(MANTA *smoke)
597 {
598 return (smoke && smoke->usingNoise()) ? smoke->getColorBHigh() : nullptr;
599 }
manta_noise_get_flame(MANTA * smoke)600 float *manta_noise_get_flame(MANTA *smoke)
601 {
602 return (smoke && smoke->usingNoise()) ? smoke->getFlameHigh() : nullptr;
603 }
manta_noise_get_texture_u(MANTA * smoke)604 float *manta_noise_get_texture_u(MANTA *smoke)
605 {
606 return (smoke && smoke->usingNoise()) ? smoke->getTextureU() : nullptr;
607 }
manta_noise_get_texture_v(MANTA * smoke)608 float *manta_noise_get_texture_v(MANTA *smoke)
609 {
610 return (smoke && smoke->usingNoise()) ? smoke->getTextureV() : nullptr;
611 }
manta_noise_get_texture_w(MANTA * smoke)612 float *manta_noise_get_texture_w(MANTA *smoke)
613 {
614 return (smoke && smoke->usingNoise()) ? smoke->getTextureW() : nullptr;
615 }
manta_noise_get_texture_u2(MANTA * smoke)616 float *manta_noise_get_texture_u2(MANTA *smoke)
617 {
618 return (smoke && smoke->usingNoise()) ? smoke->getTextureU2() : nullptr;
619 }
manta_noise_get_texture_v2(MANTA * smoke)620 float *manta_noise_get_texture_v2(MANTA *smoke)
621 {
622 return (smoke && smoke->usingNoise()) ? smoke->getTextureV2() : nullptr;
623 }
manta_noise_get_texture_w2(MANTA * smoke)624 float *manta_noise_get_texture_w2(MANTA *smoke)
625 {
626 return (smoke && smoke->usingNoise()) ? smoke->getTextureW2() : nullptr;
627 }
628
manta_noise_has_fuel(MANTA * smoke)629 int manta_noise_has_fuel(MANTA *smoke)
630 {
631 return (smoke->getFuelHigh()) ? 1 : 0;
632 }
manta_noise_has_colors(MANTA * smoke)633 int manta_noise_has_colors(MANTA *smoke)
634 {
635 return (smoke->getColorRHigh() && smoke->getColorGHigh() && smoke->getColorBHigh()) ? 1 : 0;
636 }
637
manta_noise_get_res(MANTA * smoke,int * res)638 void manta_noise_get_res(MANTA *smoke, int *res)
639 {
640 if (smoke && smoke->usingNoise()) {
641 res[0] = smoke->getResXHigh();
642 res[1] = smoke->getResYHigh();
643 res[2] = smoke->getResZHigh();
644 }
645 }
manta_noise_get_cells(MANTA * smoke)646 int manta_noise_get_cells(MANTA *smoke)
647 {
648 int total_cells_high = smoke->getResXHigh() * smoke->getResYHigh() * smoke->getResZHigh();
649 return (smoke && smoke->usingNoise()) ? total_cells_high : 0;
650 }
651
652 /* Liquid functions */
manta_liquid_export_script(MANTA * liquid,FluidModifierData * fmd)653 void manta_liquid_export_script(MANTA *liquid, FluidModifierData *fmd)
654 {
655 if (!liquid || !fmd)
656 return;
657 liquid->exportLiquidScript(fmd);
658 }
659
manta_liquid_ensure_sndparts(MANTA * liquid,struct FluidModifierData * fmd)660 int manta_liquid_ensure_sndparts(MANTA *liquid, struct FluidModifierData *fmd)
661 {
662 if (!liquid || !fmd)
663 return 0;
664 return liquid->initLiquidSndParts(fmd);
665 }
666
667 /* Liquid accessors */
manta_liquid_get_particle_res_x(MANTA * liquid)668 int manta_liquid_get_particle_res_x(MANTA *liquid)
669 {
670 return liquid->getParticleResX();
671 }
manta_liquid_get_particle_res_y(MANTA * liquid)672 int manta_liquid_get_particle_res_y(MANTA *liquid)
673 {
674 return liquid->getParticleResY();
675 }
manta_liquid_get_particle_res_z(MANTA * liquid)676 int manta_liquid_get_particle_res_z(MANTA *liquid)
677 {
678 return liquid->getParticleResZ();
679 }
680
manta_liquid_get_mesh_res_x(MANTA * liquid)681 int manta_liquid_get_mesh_res_x(MANTA *liquid)
682 {
683 return liquid->getMeshResX();
684 }
manta_liquid_get_mesh_res_y(MANTA * liquid)685 int manta_liquid_get_mesh_res_y(MANTA *liquid)
686 {
687 return liquid->getMeshResY();
688 }
manta_liquid_get_mesh_res_z(MANTA * liquid)689 int manta_liquid_get_mesh_res_z(MANTA *liquid)
690 {
691 return liquid->getMeshResZ();
692 }
693
manta_liquid_get_particle_upres(MANTA * liquid)694 int manta_liquid_get_particle_upres(MANTA *liquid)
695 {
696 return liquid->getParticleUpres();
697 }
manta_liquid_get_mesh_upres(MANTA * liquid)698 int manta_liquid_get_mesh_upres(MANTA *liquid)
699 {
700 return liquid->getMeshUpres();
701 }
702
manta_liquid_get_num_verts(MANTA * liquid)703 int manta_liquid_get_num_verts(MANTA *liquid)
704 {
705 return liquid->getNumVertices();
706 }
manta_liquid_get_num_normals(MANTA * liquid)707 int manta_liquid_get_num_normals(MANTA *liquid)
708 {
709 return liquid->getNumNormals();
710 }
manta_liquid_get_num_triangles(MANTA * liquid)711 int manta_liquid_get_num_triangles(MANTA *liquid)
712 {
713 return liquid->getNumTriangles();
714 }
715
manta_liquid_get_vertex_x_at(MANTA * liquid,int i)716 float manta_liquid_get_vertex_x_at(MANTA *liquid, int i)
717 {
718 return liquid->getVertexXAt(i);
719 }
manta_liquid_get_vertex_y_at(MANTA * liquid,int i)720 float manta_liquid_get_vertex_y_at(MANTA *liquid, int i)
721 {
722 return liquid->getVertexYAt(i);
723 }
manta_liquid_get_vertex_z_at(MANTA * liquid,int i)724 float manta_liquid_get_vertex_z_at(MANTA *liquid, int i)
725 {
726 return liquid->getVertexZAt(i);
727 }
728
manta_liquid_get_normal_x_at(MANTA * liquid,int i)729 float manta_liquid_get_normal_x_at(MANTA *liquid, int i)
730 {
731 return liquid->getNormalXAt(i);
732 }
manta_liquid_get_normal_y_at(MANTA * liquid,int i)733 float manta_liquid_get_normal_y_at(MANTA *liquid, int i)
734 {
735 return liquid->getNormalYAt(i);
736 }
manta_liquid_get_normal_z_at(MANTA * liquid,int i)737 float manta_liquid_get_normal_z_at(MANTA *liquid, int i)
738 {
739 return liquid->getNormalZAt(i);
740 }
741
manta_liquid_get_triangle_x_at(MANTA * liquid,int i)742 int manta_liquid_get_triangle_x_at(MANTA *liquid, int i)
743 {
744 return liquid->getTriangleXAt(i);
745 }
manta_liquid_get_triangle_y_at(MANTA * liquid,int i)746 int manta_liquid_get_triangle_y_at(MANTA *liquid, int i)
747 {
748 return liquid->getTriangleYAt(i);
749 }
manta_liquid_get_triangle_z_at(MANTA * liquid,int i)750 int manta_liquid_get_triangle_z_at(MANTA *liquid, int i)
751 {
752 return liquid->getTriangleZAt(i);
753 }
754
manta_liquid_get_vertvel_x_at(MANTA * liquid,int i)755 float manta_liquid_get_vertvel_x_at(MANTA *liquid, int i)
756 {
757 return liquid->getVertVelXAt(i);
758 }
manta_liquid_get_vertvel_y_at(MANTA * liquid,int i)759 float manta_liquid_get_vertvel_y_at(MANTA *liquid, int i)
760 {
761 return liquid->getVertVelYAt(i);
762 }
manta_liquid_get_vertvel_z_at(MANTA * liquid,int i)763 float manta_liquid_get_vertvel_z_at(MANTA *liquid, int i)
764 {
765 return liquid->getVertVelZAt(i);
766 }
767
manta_liquid_get_num_flip_particles(MANTA * liquid)768 int manta_liquid_get_num_flip_particles(MANTA *liquid)
769 {
770 return liquid->getNumFlipParticles();
771 }
manta_liquid_get_num_snd_particles(MANTA * liquid)772 int manta_liquid_get_num_snd_particles(MANTA *liquid)
773 {
774 return liquid->getNumSndParticles();
775 }
776
manta_liquid_get_flip_particle_flag_at(MANTA * liquid,int i)777 int manta_liquid_get_flip_particle_flag_at(MANTA *liquid, int i)
778 {
779 return liquid->getFlipParticleFlagAt(i);
780 }
manta_liquid_get_snd_particle_flag_at(MANTA * liquid,int i)781 int manta_liquid_get_snd_particle_flag_at(MANTA *liquid, int i)
782 {
783 return liquid->getSndParticleFlagAt(i);
784 }
785
manta_liquid_get_flip_particle_position_x_at(MANTA * liquid,int i)786 float manta_liquid_get_flip_particle_position_x_at(MANTA *liquid, int i)
787 {
788 return liquid->getFlipParticlePositionXAt(i);
789 }
manta_liquid_get_flip_particle_position_y_at(MANTA * liquid,int i)790 float manta_liquid_get_flip_particle_position_y_at(MANTA *liquid, int i)
791 {
792 return liquid->getFlipParticlePositionYAt(i);
793 }
manta_liquid_get_flip_particle_position_z_at(MANTA * liquid,int i)794 float manta_liquid_get_flip_particle_position_z_at(MANTA *liquid, int i)
795 {
796 return liquid->getFlipParticlePositionZAt(i);
797 }
798
manta_liquid_get_flip_particle_velocity_x_at(MANTA * liquid,int i)799 float manta_liquid_get_flip_particle_velocity_x_at(MANTA *liquid, int i)
800 {
801 return liquid->getFlipParticleVelocityXAt(i);
802 }
manta_liquid_get_flip_particle_velocity_y_at(MANTA * liquid,int i)803 float manta_liquid_get_flip_particle_velocity_y_at(MANTA *liquid, int i)
804 {
805 return liquid->getFlipParticleVelocityYAt(i);
806 }
manta_liquid_get_flip_particle_velocity_z_at(MANTA * liquid,int i)807 float manta_liquid_get_flip_particle_velocity_z_at(MANTA *liquid, int i)
808 {
809 return liquid->getFlipParticleVelocityZAt(i);
810 }
811
manta_liquid_get_snd_particle_position_x_at(MANTA * liquid,int i)812 float manta_liquid_get_snd_particle_position_x_at(MANTA *liquid, int i)
813 {
814 return liquid->getSndParticlePositionXAt(i);
815 }
manta_liquid_get_snd_particle_position_y_at(MANTA * liquid,int i)816 float manta_liquid_get_snd_particle_position_y_at(MANTA *liquid, int i)
817 {
818 return liquid->getSndParticlePositionYAt(i);
819 }
manta_liquid_get_snd_particle_position_z_at(MANTA * liquid,int i)820 float manta_liquid_get_snd_particle_position_z_at(MANTA *liquid, int i)
821 {
822 return liquid->getSndParticlePositionZAt(i);
823 }
824
manta_liquid_get_snd_particle_velocity_x_at(MANTA * liquid,int i)825 float manta_liquid_get_snd_particle_velocity_x_at(MANTA *liquid, int i)
826 {
827 return liquid->getSndParticleVelocityXAt(i);
828 }
manta_liquid_get_snd_particle_velocity_y_at(MANTA * liquid,int i)829 float manta_liquid_get_snd_particle_velocity_y_at(MANTA *liquid, int i)
830 {
831 return liquid->getSndParticleVelocityYAt(i);
832 }
manta_liquid_get_snd_particle_velocity_z_at(MANTA * liquid,int i)833 float manta_liquid_get_snd_particle_velocity_z_at(MANTA *liquid, int i)
834 {
835 return liquid->getSndParticleVelocityZAt(i);
836 }
837
manta_liquid_flip_from_file(MANTA * liquid)838 bool manta_liquid_flip_from_file(MANTA *liquid)
839 {
840 return liquid->usingFlipFromFile();
841 }
manta_liquid_mesh_from_file(MANTA * liquid)842 bool manta_liquid_mesh_from_file(MANTA *liquid)
843 {
844 return liquid->usingMeshFromFile();
845 }
manta_liquid_particle_from_file(MANTA * liquid)846 bool manta_liquid_particle_from_file(MANTA *liquid)
847 {
848 return liquid->usingParticleFromFile();
849 }
850