Mantaflow [Part 1]: Added preprocessed Mantaflow source files

Includes preprocessed Mantaflow source files for both OpenMP and TBB (if OpenMP is not present, TBB files will be used instead).

These files come directly from the Mantaflow repository. Future updates to the core fluid solver will take place by updating the files.

Reviewed By: sergey, mont29

Maniphest Tasks: T59995

Differential Revision: https://developer.blender.org/D3850

1 files changed, 138 insertions, 0 deletions

diff --git a/extern/mantaflow/preprocessed/vortexpart.h b/extern/mantaflow/preprocessed/vortexpart.h
new file mode 100644
index 00000000000..20335c20058
--- /dev/null
+++ b/extern/mantaflow/preprocessed/vortexpart.h
@@ -0,0 +1,138 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Vortex particles
+ * (warning, the vortex methods are currently experimental, and not fully supported!)
+ *
+ ******************************************************************************/
+
+#ifndef _VORTEXPART_H
+#define _VORTEXPART_H
+
+#include "particle.h"
+
+namespace Manta {
+class Mesh;
+
+struct VortexParticleData {
+  VortexParticleData() : pos(0.0), vorticity(0.0), sigma(0), flag(0)
+  {
+  }
+  VortexParticleData(const Vec3 &p, const Vec3 &v, Real sig)
+      : pos(p), vorticity(v), sigma(sig), flag(0)
+  {
+  }
+  Vec3 pos, vorticity;
+  Real sigma;
+  int flag;
+  static ParticleBase::SystemType getType()
+  {
+    return ParticleBase::VORTEX;
+  }
+};
+
+//! Vortex particles
+class VortexParticleSystem : public ParticleSystem<VortexParticleData> {
+ public:
+  VortexParticleSystem(FluidSolver *parent);
+  static int _W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    PbClass *obj = Pb::objFromPy(_self);
+    if (obj)
+      delete obj;
+    try {
+      PbArgs _args(_linargs, _kwds);
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(0, "VortexParticleSystem::VortexParticleSystem", !noTiming);
+      {
+        ArgLocker _lock;
+        FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock);
+        obj = new VortexParticleSystem(parent);
+        obj->registerObject(_self, &_args);
+        _args.check();
+      }
+      pbFinalizePlugin(obj->getParent(), "VortexParticleSystem::VortexParticleSystem", !noTiming);
+      return 0;
+    }
+    catch (std::exception &e) {
+      pbSetError("VortexParticleSystem::VortexParticleSystem", e.what());
+      return -1;
+    }
+  }
+
+  void advectSelf(Real scale = 1.0, int integrationMode = IntRK4);
+  static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      VortexParticleSystem *pbo = dynamic_cast<VortexParticleSystem *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "VortexParticleSystem::advectSelf", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        Real scale = _args.getOpt<Real>("scale", 0, 1.0, &_lock);
+        int integrationMode = _args.getOpt<int>("integrationMode", 1, IntRK4, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->advectSelf(scale, integrationMode);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "VortexParticleSystem::advectSelf", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("VortexParticleSystem::advectSelf", e.what());
+      return 0;
+    }
+  }
+
+  void applyToMesh(Mesh &mesh, Real scale = 1.0, int integrationMode = IntRK4);
+  static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      VortexParticleSystem *pbo = dynamic_cast<VortexParticleSystem *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "VortexParticleSystem::applyToMesh", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        Mesh &mesh = *_args.getPtr<Mesh>("mesh", 0, &_lock);
+        Real scale = _args.getOpt<Real>("scale", 1, 1.0, &_lock);
+        int integrationMode = _args.getOpt<int>("integrationMode", 2, IntRK4, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->applyToMesh(mesh, scale, integrationMode);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "VortexParticleSystem::applyToMesh", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("VortexParticleSystem::applyToMesh", e.what());
+      return 0;
+    }
+  }
+
+  virtual ParticleBase *clone();
+ public:
+  PbArgs _args;
+}
+#define _C_VortexParticleSystem
+;
+
+}  // namespace Manta
+
+#endif