Blender V5.3
MANTA_main.h
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2016 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#pragma once
10
11#include <atomic>
12#include <cassert>
13#include <string>
14#include <unordered_map>
15#include <vector>
16
17using std::atomic;
18using std::string;
19using std::unordered_map;
20using std::vector;
21
22namespace blender {
23
24struct MANTA {
25 public:
26 MANTA(int *res, struct FluidModifierData *fmd);
27 virtual ~MANTA();
28
29 /* Mirroring Mantaflow structures for particle data (pVel also used for mesh vert vels). */
30 struct pData {
31 float pos[3];
32 int flag;
33 };
34 struct pVel {
35 float pos[3];
36 };
37
38 /* Mirroring Mantaflow structures for meshes. */
39 struct Node {
40 int flags;
41 float pos[3], normal[3];
42 };
43 struct Triangle {
44 int c[3];
45 int flags;
46 };
47
48 /* Grid initialization functions. */
49 bool initHeat(struct FluidModifierData *fmd = nullptr);
50 bool initFire(struct FluidModifierData *fmd = nullptr);
51 bool initColors(struct FluidModifierData *fmd = nullptr);
52 bool initFireHigh(struct FluidModifierData *fmd = nullptr);
53 bool initColorsHigh(struct FluidModifierData *fmd = nullptr);
54 bool initLiquid(FluidModifierData *fmd = nullptr);
55 bool initLiquidMesh(FluidModifierData *fmd = nullptr);
56 bool initLiquidViscosity(FluidModifierData *fmd = nullptr);
57 bool initObstacle(FluidModifierData *fmd = nullptr);
58 bool initCurvature(FluidModifierData *fmd = nullptr);
59 bool initGuiding(FluidModifierData *fmd = nullptr);
60 bool initFractions(FluidModifierData *fmd = nullptr);
61 bool initInVelocity(FluidModifierData *fmd = nullptr);
62 bool initOutflow(FluidModifierData *fmd = nullptr);
63 bool initSndParts(FluidModifierData *fmd = nullptr);
64 bool initLiquidSndParts(FluidModifierData *fmd = nullptr);
65
66 /* Pointer transfer: Mantaflow -> Blender. Use flush to reset all pointers to nullptr. */
67 void updatePointers(FluidModifierData *fmd, bool flush = false);
68
69 /* Write cache. */
70 bool writeConfiguration(FluidModifierData *fmd, int framenr);
71 bool writeData(FluidModifierData *fmd, int framenr);
72 bool writeNoise(FluidModifierData *fmd, int framenr);
73 /* Write calls for mesh and particles were left in bake calls for now. */
74
75 /* Read cache (via Python). */
76 bool readConfiguration(FluidModifierData *fmd, int framenr);
77 bool readData(FluidModifierData *fmd, int framenr, bool resumable);
78 bool readNoise(FluidModifierData *fmd, int framenr, bool resumable);
79 bool readMesh(FluidModifierData *fmd, int framenr);
80 bool readParticles(FluidModifierData *fmd, int framenr, bool resumable);
81 bool readGuiding(FluidModifierData *fmd, int framenr, bool sourceDomain);
82
83 /* Propagate variable changes from RNA to Python. */
85
86 /* Bake cache. */
87 bool bakeData(FluidModifierData *fmd, int framenr);
88 bool bakeNoise(FluidModifierData *fmd, int framenr);
89 bool bakeMesh(FluidModifierData *fmd, int framenr);
90 bool bakeParticles(FluidModifierData *fmd, int framenr);
91 bool bakeGuiding(FluidModifierData *fmd, int framenr);
92
93 /* IO for Mantaflow scene script. */
94 bool exportSmokeScript(struct FluidModifierData *fmd);
95 bool exportLiquidScript(struct FluidModifierData *fmd);
96
97 /* Check cache status by frame. */
98 bool hasConfig(FluidModifierData *fmd, int framenr);
99 bool hasData(FluidModifierData *fmd, int framenr);
100 bool hasNoise(FluidModifierData *fmd, int framenr);
101 bool hasMesh(FluidModifierData *fmd, int framenr);
102 bool hasParticles(FluidModifierData *fmd, int framenr);
103 bool hasGuiding(FluidModifierData *fmd, int framenr, bool sourceDomain);
104
106 {
107 return mTotalCells;
108 }
110 {
111 return mTotalCellsHigh;
112 }
114 {
115 return mUsingNoise;
116 }
118 {
119 return mResX;
120 }
122 {
123 return mResY;
124 }
126 {
127 return mResZ;
128 }
130 {
131 return mResXParticle;
132 }
134 {
135 return mResYParticle;
136 }
138 {
139 return mResZParticle;
140 }
142 {
143 return mResXMesh;
144 }
146 {
147 return mResYMesh;
148 }
150 {
151 return mResZMesh;
152 }
154 {
155 return mResXNoise;
156 }
158 {
159 return mResYNoise;
160 }
162 {
163 return mResZNoise;
164 }
166 {
167 return mUpresMesh;
168 }
170 {
171 return mUpresParticle;
172 }
173
174 /* Smoke getters. */
175 float *getDensity()
176 {
177 return mDensity;
178 }
179 float *getHeat()
180 {
181 return mHeat;
182 }
184 {
185 return mVelocityX;
186 }
188 {
189 return mVelocityY;
190 }
192 {
193 return mVelocityZ;
194 }
196 {
197 return mObVelocityX;
198 }
200 {
201 return mObVelocityY;
202 }
204 {
205 return mObVelocityZ;
206 }
208 {
209 return mGuideVelocityX;
210 }
212 {
213 return mGuideVelocityY;
214 }
216 {
217 return mGuideVelocityZ;
218 }
220 {
221 return mInVelocityX;
222 }
224 {
225 return mInVelocityY;
226 }
228 {
229 return mInVelocityZ;
230 }
231 float *getForceX()
232 {
233 return mForceX;
234 }
235 float *getForceY()
236 {
237 return mForceY;
238 }
239 float *getForceZ()
240 {
241 return mForceZ;
242 }
243 int *getFlags()
244 {
245 return mFlags;
246 }
248 {
249 return mNumObstacle;
250 }
251 float *getNumGuide()
252 {
253 return mNumGuide;
254 }
255 float *getFlame()
256 {
257 return mFlame;
258 }
259 float *getFuel()
260 {
261 return mFuel;
262 }
263 float *getReact()
264 {
265 return mReact;
266 }
267 float *getColorR()
268 {
269 return mColorR;
270 }
271 float *getColorG()
272 {
273 return mColorG;
274 }
275 float *getColorB()
276 {
277 return mColorB;
278 }
279 float *getShadow()
280 {
281 return mShadow;
282 }
284 {
285 return mDensityIn;
286 }
287 float *getHeatIn()
288 {
289 return mHeatIn;
290 }
291 float *getColorRIn()
292 {
293 return mColorRIn;
294 }
295 float *getColorGIn()
296 {
297 return mColorGIn;
298 }
299 float *getColorBIn()
300 {
301 return mColorBIn;
302 }
303 float *getFuelIn()
304 {
305 return mFuelIn;
306 }
307 float *getReactIn()
308 {
309 return mReactIn;
310 }
312 {
313 return mEmissionIn;
314 }
315
317 {
318 return mDensityHigh;
319 }
321 {
322 return mFlameHigh;
323 }
324 float *getFuelHigh()
325 {
326 return mFuelHigh;
327 }
329 {
330 return mReactHigh;
331 }
333 {
334 return mColorRHigh;
335 }
337 {
338 return mColorGHigh;
339 }
341 {
342 return mColorBHigh;
343 }
344 float *getTextureU()
345 {
346 return mTextureU;
347 }
348 float *getTextureV()
349 {
350 return mTextureV;
351 }
352 float *getTextureW()
353 {
354 return mTextureW;
355 }
357 {
358 return mTextureU2;
359 }
361 {
362 return mTextureV2;
363 }
365 {
366 return mTextureW2;
367 }
368
369 float *getPhiIn()
370 {
371 return mPhiIn;
372 }
374 {
375 return mPhiStaticIn;
376 }
377 float *getPhiObsIn()
378 {
379 return mPhiObsIn;
380 }
382 {
383 return mPhiObsStaticIn;
384 }
386 {
387 return mPhiGuideIn;
388 }
389 float *getPhiOutIn()
390 {
391 return mPhiOutIn;
392 }
394 {
395 return mPhiOutStaticIn;
396 }
397 float *getPhi()
398 {
399 return mPhi;
400 }
401 float *getPressure()
402 {
403 return mPressure;
404 }
405
406 static atomic<int> solverID;
407 static int with_debug; /* On or off (1 or 0), also sets manta debug level. */
408
409 /* Mesh getters. */
411 {
412 return (mMeshNodes && !mMeshNodes->empty()) ? mMeshNodes->size() : 0;
413 }
415 {
416 return (mMeshNodes && !mMeshNodes->empty()) ? mMeshNodes->size() : 0;
417 }
419 {
420 return (mMeshTriangles && !mMeshTriangles->empty()) ? mMeshTriangles->size() : 0;
421 }
422
423 float getVertexXAt(int i)
424 {
425 assert(i >= 0);
426 if (mMeshNodes && !mMeshNodes->empty()) {
427 assert(i < mMeshNodes->size());
428 return (*mMeshNodes)[i].pos[0];
429 }
430 return 0.0f;
431 }
432 float getVertexYAt(int i)
433 {
434 assert(i >= 0);
435 if (mMeshNodes && !mMeshNodes->empty()) {
436 assert(i < mMeshNodes->size());
437 return (*mMeshNodes)[i].pos[1];
438 }
439 return 0.0f;
440 }
441 float getVertexZAt(int i)
442 {
443 assert(i >= 0);
444 if (mMeshNodes && !mMeshNodes->empty()) {
445 assert(i < mMeshNodes->size());
446 return (*mMeshNodes)[i].pos[2];
447 }
448 return 0.0f;
449 }
450
451 float getNormalXAt(int i)
452 {
453 assert(i >= 0);
454 if (mMeshNodes && !mMeshNodes->empty()) {
455 assert(i < mMeshNodes->size());
456 return (*mMeshNodes)[i].normal[0];
457 }
458 return 0.0f;
459 }
460 float getNormalYAt(int i)
461 {
462 assert(i >= 0);
463 if (mMeshNodes && !mMeshNodes->empty()) {
464 assert(i < mMeshNodes->size());
465 return (*mMeshNodes)[i].normal[1];
466 }
467 return 0.0f;
468 }
469 float getNormalZAt(int i)
470 {
471 assert(i >= 0);
472 if (mMeshNodes && !mMeshNodes->empty()) {
473 assert(i < mMeshNodes->size());
474 return (*mMeshNodes)[i].normal[2];
475 }
476 return 0.0f;
477 }
478
479 int getTriangleXAt(int i)
480 {
481 assert(i >= 0);
482 if (mMeshTriangles && !mMeshTriangles->empty()) {
483 assert(i < mMeshTriangles->size());
484 return (*mMeshTriangles)[i].c[0];
485 }
486 return 0;
487 }
488 int getTriangleYAt(int i)
489 {
490 assert(i >= 0);
491 if (mMeshTriangles && !mMeshTriangles->empty()) {
492 assert(i < mMeshTriangles->size());
493 return (*mMeshTriangles)[i].c[1];
494 }
495 return 0;
496 }
497 int getTriangleZAt(int i)
498 {
499 assert(i >= 0);
500 if (mMeshTriangles && !mMeshTriangles->empty()) {
501 assert(i < mMeshTriangles->size());
502 return (*mMeshTriangles)[i].c[2];
503 }
504 return 0;
505 }
506
507 float getVertVelXAt(int i)
508 {
509 assert(i >= 0);
510 if (mMeshVelocities && !mMeshVelocities->empty()) {
511 assert(i < mMeshVelocities->size());
512 return (*mMeshVelocities)[i].pos[0];
513 }
514 return 0.0f;
515 }
516 float getVertVelYAt(int i)
517 {
518 assert(i >= 0);
519 if (mMeshVelocities && !mMeshVelocities->empty()) {
520 assert(i < mMeshVelocities->size());
521 return (*mMeshVelocities)[i].pos[1];
522 }
523 return 0.0f;
524 }
525 float getVertVelZAt(int i)
526 {
527 assert(i >= 0);
528 if (mMeshVelocities && !mMeshVelocities->empty()) {
529 assert(i < mMeshVelocities->size());
530 return (*mMeshVelocities)[i].pos[2];
531 }
532 return 0.0f;
533 }
534
535 // Particle getters
537 {
538 assert(i >= 0);
539 if (mFlipParticleData && !mFlipParticleData->empty()) {
540 assert(i < mFlipParticleData->size());
541 return (*mFlipParticleData)[i].flag;
542 }
543 return 0;
544 }
546 {
547 assert(i >= 0);
548 if (mParticleData && !mParticleData->empty()) {
549 assert(i < mParticleData->size());
550 return (*mParticleData)[i].flag;
551 }
552 return 0;
553 }
554
556 {
557 assert(i >= 0);
558 if (mFlipParticleData && !mFlipParticleData->empty()) {
559 assert(i < mFlipParticleData->size());
560 return (*mFlipParticleData)[i].pos[0];
561 }
562 return 0.0f;
563 }
565 {
566 assert(i >= 0);
567 if (mFlipParticleData && !mFlipParticleData->empty()) {
568 assert(i < mFlipParticleData->size());
569 return (*mFlipParticleData)[i].pos[1];
570 }
571 return 0.0f;
572 }
574 {
575 assert(i >= 0);
576 if (mFlipParticleData && !mFlipParticleData->empty()) {
577 assert(i < mFlipParticleData->size());
578 return (*mFlipParticleData)[i].pos[2];
579 }
580 return 0.0f;
581 }
582
584 {
585 assert(i >= 0);
586 if (mParticleData && !mParticleData->empty()) {
587 assert(i < mParticleData->size());
588 return (*mParticleData)[i].pos[0];
589 }
590 return 0.0f;
591 }
593 {
594 assert(i >= 0);
595 if (mParticleData && !mParticleData->empty()) {
596 assert(i < mParticleData->size());
597 return (*mParticleData)[i].pos[1];
598 }
599 return 0.0f;
600 }
602 {
603 assert(i >= 0);
604 if (mParticleData && !mParticleData->empty()) {
605 assert(i < mParticleData->size());
606 return (*mParticleData)[i].pos[2];
607 }
608 return 0.0f;
609 }
610
612 {
613 assert(i >= 0);
614 if (mFlipParticleVelocity && !mFlipParticleVelocity->empty()) {
615 assert(i < mFlipParticleVelocity->size());
616 return (*mFlipParticleVelocity)[i].pos[0];
617 }
618 return 0.0f;
619 }
621 {
622 assert(i >= 0);
623 if (mFlipParticleVelocity && !mFlipParticleVelocity->empty()) {
624 assert(i < mFlipParticleVelocity->size());
625 return (*mFlipParticleVelocity)[i].pos[1];
626 }
627 return 0.0f;
628 }
630 {
631 assert(i >= 0);
632 if (mFlipParticleVelocity && !mFlipParticleVelocity->empty()) {
633 assert(i < mFlipParticleVelocity->size());
634 return (*mFlipParticleVelocity)[i].pos[2];
635 }
636 return 0.0f;
637 }
638
640 {
641 assert(i >= 0);
642 if (mParticleVelocity && !mParticleVelocity->empty()) {
643 assert(i < mParticleVelocity->size());
644 return (*mParticleVelocity)[i].pos[0];
645 }
646 return 0.0f;
647 }
649 {
650 assert(i >= 0);
651 if (mParticleVelocity && !mParticleVelocity->empty()) {
652 assert(i < mParticleVelocity->size());
653 return (*mParticleVelocity)[i].pos[1];
654 }
655 return 0.0f;
656 }
658 {
659 assert(i >= 0);
660 if (mParticleVelocity && !mParticleVelocity->empty()) {
661 assert(i < mParticleVelocity->size());
662 return (*mParticleVelocity)[i].pos[2];
663 }
664 return 0.0f;
665 }
666
668 {
669 return (mFlipParticleData && !mFlipParticleData->empty()) ?
670 (float *)&mFlipParticleData->front() :
671 nullptr;
672 }
674 {
675 return (mParticleData && !mParticleData->empty()) ? (float *)&mParticleData->front() : nullptr;
676 }
677
679 {
680 return (mFlipParticleVelocity && !mFlipParticleVelocity->empty()) ?
681 (float *)&mFlipParticleVelocity->front() :
682 nullptr;
683 }
685 {
686 return (mParticleVelocity && !mParticleVelocity->empty()) ?
687 (float *)&mParticleVelocity->front() :
688 nullptr;
689 }
691 {
692 return (mParticleLife && !mParticleLife->empty()) ? (float *)&mParticleLife->front() : nullptr;
693 }
694
696 {
697 return (mFlipParticleData && !mFlipParticleData->empty()) ? mFlipParticleData->size() : 0;
698 }
700 {
701 return (mParticleData && !mParticleData->empty()) ? mParticleData->size() : 0;
702 }
703
705 {
706 return mFlipFromFile;
707 }
709 {
710 return mMeshFromFile;
711 }
713 {
714 return mParticlesFromFile;
715 }
716
717 /* Direct access to solver time attributes. */
718 int getFrame();
719 float getTimestep();
720 void adaptTimestep();
721
723
724 private:
725 /* Simulation constants. */
726 size_t mTotalCells = -1;
727 size_t mTotalCellsHigh = -1;
728 size_t mTotalCellsMesh = -1;
729 size_t mTotalCellsParticles = -1;
730
731 unordered_map<string, string> mRNAMap;
732
733 /* The ID of the solver objects will be incremented for every new object. */
734 const int mCurrentID;
735
736 bool mUsingHeat = false;
737 bool mUsingColors = false;
738 bool mUsingFire = false;
739 bool mUsingObstacle = false;
740 bool mUsingGuiding = false;
741 bool mUsingFractions = false;
742 bool mUsingInvel = false;
743 bool mUsingOutflow = false;
744 bool mUsingNoise = false;
745 bool mUsingMesh = false;
746 bool mUsingDiffusion = false;
747 bool mUsingViscosity = false;
748 bool mUsingMVel = false;
749 bool mUsingLiquid = false;
750 bool mUsingSmoke = false;
751 bool mUsingDrops = false;
752 bool mUsingBubbles = false;
753 bool mUsingFloats = false;
754 bool mUsingTracers = false;
755
756 bool mFlipFromFile = false;
757 bool mMeshFromFile = false;
758 bool mParticlesFromFile = false;
759 bool mSmokeFromFile = false;
760 bool mNoiseFromFile = false;
761
762 int mResX = -1;
763 int mResY = -1;
764 int mResZ = -1;
765 const int mMaxRes;
766
767 int mResXNoise = -1;
768 int mResYNoise = -1;
769 int mResZNoise = -1;
770 int mResXMesh = -1;
771 int mResYMesh = -1;
772 int mResZMesh = -1;
773 int mResXParticle = -1;
774 int mResYParticle = -1;
775 int mResZParticle = -1;
776 int *mResGuiding = nullptr;
777
778 int mUpresMesh = -1;
779 int mUpresParticle = -1;
780
781 /* Fluid grids. */
782 float *mVelocityX = nullptr;
783 float *mVelocityY = nullptr;
784 float *mVelocityZ = nullptr;
785 float *mObVelocityX = nullptr;
786 float *mObVelocityY = nullptr;
787 float *mObVelocityZ = nullptr;
788 float *mGuideVelocityX = nullptr;
789 float *mGuideVelocityY = nullptr;
790 float *mGuideVelocityZ = nullptr;
791 float *mInVelocityX = nullptr;
792 float *mInVelocityY = nullptr;
793 float *mInVelocityZ = nullptr;
794 float *mForceX = nullptr;
795 float *mForceY = nullptr;
796 float *mForceZ = nullptr;
797 int *mFlags = nullptr;
798 float *mNumObstacle = nullptr;
799 float *mNumGuide = nullptr;
800 float *mPressure = nullptr;
801
802 /* Smoke grids. */
803 float *mDensity = nullptr;
804 float *mHeat = nullptr;
805 float *mFlame = nullptr;
806 float *mFuel = nullptr;
807 float *mReact = nullptr;
808 float *mColorR = nullptr;
809 float *mColorG = nullptr;
810 float *mColorB = nullptr;
811 float *mShadow = nullptr;
812 float *mDensityIn = nullptr;
813 float *mHeatIn = nullptr;
814 float *mFuelIn = nullptr;
815 float *mReactIn = nullptr;
816 float *mEmissionIn = nullptr;
817 float *mColorRIn = nullptr;
818 float *mColorGIn = nullptr;
819 float *mColorBIn = nullptr;
820 float *mDensityHigh = nullptr;
821 float *mFlameHigh = nullptr;
822 float *mFuelHigh = nullptr;
823 float *mReactHigh = nullptr;
824 float *mColorRHigh = nullptr;
825 float *mColorGHigh = nullptr;
826 float *mColorBHigh = nullptr;
827 float *mTextureU = nullptr;
828 float *mTextureV = nullptr;
829 float *mTextureW = nullptr;
830 float *mTextureU2 = nullptr;
831 float *mTextureV2 = nullptr;
832 float *mTextureW2 = nullptr;
833
834 /* Liquid grids. */
835 float *mPhiIn = nullptr;
836 float *mPhiStaticIn = nullptr;
837 float *mPhiObsIn = nullptr;
838 float *mPhiObsStaticIn = nullptr;
839 float *mPhiGuideIn = nullptr;
840 float *mPhiOutIn = nullptr;
841 float *mPhiOutStaticIn = nullptr;
842 float *mPhi = nullptr;
843
844 /* Mesh fields. */
845 vector<Node> *mMeshNodes;
846 vector<Triangle> *mMeshTriangles;
847 vector<pVel> *mMeshVelocities;
848
849 /* Particle fields. */
850 vector<pData> *mFlipParticleData;
851 vector<pVel> *mFlipParticleVelocity;
852
853 vector<pData> *mParticleData;
854 vector<pVel> *mParticleVelocity;
855 vector<float> *mParticleLife;
856
857 void initializeRNAMap(struct FluidModifierData *fmd = nullptr);
858 bool initDomain(struct FluidModifierData *fmd = nullptr);
859 bool initNoise(struct FluidModifierData *fmd = nullptr);
860 bool initMesh(struct FluidModifierData *fmd = nullptr);
861 bool initSmoke(struct FluidModifierData *fmd = nullptr);
862 bool initSmokeNoise(struct FluidModifierData *fmd = nullptr);
863 void initializeMantaflow();
864 void terminateMantaflow();
865 bool runPythonString(vector<string> commands);
866 string getRealValue(const string &varName);
867 string parseLine(const string &line);
868 string parseScript(const string &setup_string, FluidModifierData *fmd = nullptr);
869 string getDirectory(struct FluidModifierData *fmd, string subdirectory);
870 string getFile(struct FluidModifierData *fmd,
871 string subdirectory,
872 string fname,
873 string extension,
874 int framenr);
875};
876
877} // namespace blender
BMesh Iterators.
float * getFlipParticleData()
Definition MANTA_main.h:667
bool exportLiquidScript(struct FluidModifierData *fmd)
bool initColors(struct FluidModifierData *fmd=nullptr)
bool initCurvature(FluidModifierData *fmd=nullptr)
int getTriangleXAt(int i)
Definition MANTA_main.h:479
float * getFuel()
Definition MANTA_main.h:259
bool hasGuiding(FluidModifierData *fmd, int framenr, bool sourceDomain)
bool initLiquidMesh(FluidModifierData *fmd=nullptr)
float * getTextureW()
Definition MANTA_main.h:352
bool hasConfig(FluidModifierData *fmd, int framenr)
float * getColorBHigh()
Definition MANTA_main.h:340
float * getReact()
Definition MANTA_main.h:263
bool initInVelocity(FluidModifierData *fmd=nullptr)
float * getFlameHigh()
Definition MANTA_main.h:320
bool initFireHigh(struct FluidModifierData *fmd=nullptr)
float * getPressure()
Definition MANTA_main.h:401
bool initHeat(struct FluidModifierData *fmd=nullptr)
float * getNumGuide()
Definition MANTA_main.h:251
float * getSndParticleData()
Definition MANTA_main.h:673
bool initLiquidSndParts(FluidModifierData *fmd=nullptr)
float * getInVelocityZ()
Definition MANTA_main.h:227
float * getVelocityX()
Definition MANTA_main.h:183
float getSndParticleVelocityXAt(int i)
Definition MANTA_main.h:639
bool initFire(struct FluidModifierData *fmd=nullptr)
size_t getTotalCellsHigh()
Definition MANTA_main.h:109
float * getHeatIn()
Definition MANTA_main.h:287
float * getColorGIn()
Definition MANTA_main.h:295
bool readMesh(FluidModifierData *fmd, int framenr)
bool usingMeshFromFile()
Definition MANTA_main.h:708
float * getColorRIn()
Definition MANTA_main.h:291
bool initLiquidViscosity(FluidModifierData *fmd=nullptr)
float * getTextureW2()
Definition MANTA_main.h:364
float * getFuelIn()
Definition MANTA_main.h:303
float getSndParticlePositionXAt(int i)
Definition MANTA_main.h:583
float * getPhi()
Definition MANTA_main.h:397
float * getNumObstacle()
Definition MANTA_main.h:247
bool initSndParts(FluidModifierData *fmd=nullptr)
bool usingParticleFromFile()
Definition MANTA_main.h:712
bool bakeGuiding(FluidModifierData *fmd, int framenr)
float getSndParticleVelocityZAt(int i)
Definition MANTA_main.h:657
float * getColorR()
Definition MANTA_main.h:267
float * getHeat()
Definition MANTA_main.h:179
float getFlipParticleVelocityXAt(int i)
Definition MANTA_main.h:611
float * getFuelHigh()
Definition MANTA_main.h:324
float * getTextureU()
Definition MANTA_main.h:344
float * getPhiStaticIn()
Definition MANTA_main.h:373
bool exportSmokeScript(struct FluidModifierData *fmd)
bool readParticles(FluidModifierData *fmd, int framenr, bool resumable)
float * getForceY()
Definition MANTA_main.h:235
float * getReactHigh()
Definition MANTA_main.h:328
bool usingNoise()
Definition MANTA_main.h:113
float * getPhiObsStaticIn()
Definition MANTA_main.h:381
float getVertexYAt(int i)
Definition MANTA_main.h:432
bool hasParticles(FluidModifierData *fmd, int framenr)
int getParticleResX()
Definition MANTA_main.h:129
bool bakeNoise(FluidModifierData *fmd, int framenr)
bool usingFlipFromFile()
Definition MANTA_main.h:704
int getTriangleZAt(int i)
Definition MANTA_main.h:497
float getVertVelZAt(int i)
Definition MANTA_main.h:525
bool writeConfiguration(FluidModifierData *fmd, int framenr)
float * getDensityHigh()
Definition MANTA_main.h:316
int getParticleResY()
Definition MANTA_main.h:133
float * getPhiOutStaticIn()
Definition MANTA_main.h:393
bool readGuiding(FluidModifierData *fmd, int framenr, bool sourceDomain)
float * getPhiObsIn()
Definition MANTA_main.h:377
bool bakeParticles(FluidModifierData *fmd, int framenr)
float getSndParticleVelocityYAt(int i)
Definition MANTA_main.h:648
float * getInVelocityY()
Definition MANTA_main.h:223
float * getPhiGuideIn()
Definition MANTA_main.h:385
float getFlipParticleVelocityZAt(int i)
Definition MANTA_main.h:629
float * getGuideVelocityY()
Definition MANTA_main.h:211
float * getFlame()
Definition MANTA_main.h:255
float * getShadow()
Definition MANTA_main.h:279
float * getColorBIn()
Definition MANTA_main.h:299
float * getSndParticleLife()
Definition MANTA_main.h:690
bool readData(FluidModifierData *fmd, int framenr, bool resumable)
float getSndParticlePositionZAt(int i)
Definition MANTA_main.h:601
float * getColorGHigh()
Definition MANTA_main.h:336
static int with_debug
Definition MANTA_main.h:407
bool initGuiding(FluidModifierData *fmd=nullptr)
float getNormalYAt(int i)
Definition MANTA_main.h:460
int getTriangleYAt(int i)
Definition MANTA_main.h:488
float * getGuideVelocityZ()
Definition MANTA_main.h:215
float * getDensityIn()
Definition MANTA_main.h:283
MANTA(int *res, struct FluidModifierData *fmd)
float getNormalXAt(int i)
Definition MANTA_main.h:451
float * getGuideVelocityX()
Definition MANTA_main.h:207
int getNumVertices()
Definition MANTA_main.h:410
float * getSndParticleVelocity()
Definition MANTA_main.h:684
bool initLiquid(FluidModifierData *fmd=nullptr)
bool bakeData(FluidModifierData *fmd, int framenr)
bool needsRealloc(FluidModifierData *fmd)
float getVertVelYAt(int i)
Definition MANTA_main.h:516
float getFlipParticlePositionZAt(int i)
Definition MANTA_main.h:573
bool readNoise(FluidModifierData *fmd, int framenr, bool resumable)
bool bakeMesh(FluidModifierData *fmd, int framenr)
static atomic< int > solverID
Definition MANTA_main.h:406
int getSndParticleFlagAt(int i)
Definition MANTA_main.h:545
float * getColorG()
Definition MANTA_main.h:271
bool initFractions(FluidModifierData *fmd=nullptr)
float * getTextureV()
Definition MANTA_main.h:348
bool initObstacle(FluidModifierData *fmd=nullptr)
float * getInVelocityX()
Definition MANTA_main.h:219
float * getColorRHigh()
Definition MANTA_main.h:332
float * getForceZ()
Definition MANTA_main.h:239
int getNumFlipParticles()
Definition MANTA_main.h:695
float getVertVelXAt(int i)
Definition MANTA_main.h:507
int getNumSndParticles()
Definition MANTA_main.h:699
float * getReactIn()
Definition MANTA_main.h:307
int getParticleResZ()
Definition MANTA_main.h:137
float getNormalZAt(int i)
Definition MANTA_main.h:469
float * getObVelocityY()
Definition MANTA_main.h:199
float getFlipParticlePositionYAt(int i)
Definition MANTA_main.h:564
float * getTextureV2()
Definition MANTA_main.h:360
bool hasData(FluidModifierData *fmd, int framenr)
float * getFlipParticleVelocity()
Definition MANTA_main.h:678
float getVertexXAt(int i)
Definition MANTA_main.h:423
bool writeNoise(FluidModifierData *fmd, int framenr)
bool hasNoise(FluidModifierData *fmd, int framenr)
float * getEmissionIn()
Definition MANTA_main.h:311
bool updateVariables(FluidModifierData *fmd)
float * getObVelocityX()
Definition MANTA_main.h:195
float * getPhiIn()
Definition MANTA_main.h:369
int getNumTriangles()
Definition MANTA_main.h:418
float * getForceX()
Definition MANTA_main.h:231
int * getFlags()
Definition MANTA_main.h:243
float getVertexZAt(int i)
Definition MANTA_main.h:441
float * getVelocityY()
Definition MANTA_main.h:187
float * getVelocityZ()
Definition MANTA_main.h:191
float getSndParticlePositionYAt(int i)
Definition MANTA_main.h:592
float * getDensity()
Definition MANTA_main.h:175
bool readConfiguration(FluidModifierData *fmd, int framenr)
float * getPhiOutIn()
Definition MANTA_main.h:389
int getParticleUpres()
Definition MANTA_main.h:169
int getFlipParticleFlagAt(int i)
Definition MANTA_main.h:536
int getNumNormals()
Definition MANTA_main.h:414
size_t getTotalCells()
Definition MANTA_main.h:105
float getFlipParticlePositionXAt(int i)
Definition MANTA_main.h:555
float getFlipParticleVelocityYAt(int i)
Definition MANTA_main.h:620
float * getTextureU2()
Definition MANTA_main.h:356
float * getObVelocityZ()
Definition MANTA_main.h:203
bool hasMesh(FluidModifierData *fmd, int framenr)
bool initColorsHigh(struct FluidModifierData *fmd=nullptr)
float * getColorB()
Definition MANTA_main.h:275
void updatePointers(FluidModifierData *fmd, bool flush=false)
bool writeData(FluidModifierData *fmd, int framenr)
bool initOutflow(FluidModifierData *fmd=nullptr)