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