Fluid: Refactored the Mantaflow <-> Blender pointer exchange function and switched to from NULL to nullptr in cpp files

3 files changed, 271 insertions, 274 deletions

diff --git a/intern/mantaflow/intern/MANTA_main.cpp b/intern/mantaflow/intern/MANTA_main.cpp
index 0e0a0ddf021..79363126aff 100644
--- a/intern/mantaflow/intern/MANTA_main.cpp
+++ b/intern/mantaflow/intern/MANTA_main.cpp
@@ -84,81 +84,81 @@ MANTA::MANTA(int *res, FluidModifierData *mmd) : mCurrentID(++solverID)
   mResGuiding = mmd->domain->res;
 
   // Smoke low res grids
-  mDensity = NULL;
-  mShadow = NULL;
-  mHeat = NULL;
-  mVelocityX = NULL;
-  mVelocityY = NULL;
-  mVelocityZ = NULL;
-  mForceX = NULL;
-  mForceY = NULL;
-  mForceZ = NULL;
-  mFlame = NULL;
-  mFuel = NULL;
-  mReact = NULL;
-  mColorR = NULL;
-  mColorG = NULL;
-  mColorB = NULL;
-  mObstacle = NULL;
-  mDensityIn = NULL;
-  mHeatIn = NULL;
-  mColorRIn = NULL;
-  mColorGIn = NULL;
-  mColorBIn = NULL;
-  mFuelIn = NULL;
-  mReactIn = NULL;
-  mEmissionIn = NULL;
+  mDensity = nullptr;
+  mShadow = nullptr;
+  mHeat = nullptr;
+  mVelocityX = nullptr;
+  mVelocityY = nullptr;
+  mVelocityZ = nullptr;
+  mForceX = nullptr;
+  mForceY = nullptr;
+  mForceZ = nullptr;
+  mFlame = nullptr;
+  mFuel = nullptr;
+  mReact = nullptr;
+  mColorR = nullptr;
+  mColorG = nullptr;
+  mColorB = nullptr;
+  mObstacle = nullptr;
+  mDensityIn = nullptr;
+  mHeatIn = nullptr;
+  mColorRIn = nullptr;
+  mColorGIn = nullptr;
+  mColorBIn = nullptr;
+  mFuelIn = nullptr;
+  mReactIn = nullptr;
+  mEmissionIn = nullptr;
 
   // Smoke high res grids
-  mDensityHigh = NULL;
-  mFlameHigh = NULL;
-  mFuelHigh = NULL;
-  mReactHigh = NULL;
-  mColorRHigh = NULL;
-  mColorGHigh = NULL;
-  mColorBHigh = NULL;
-  mTextureU = NULL;
-  mTextureV = NULL;
-  mTextureW = NULL;
-  mTextureU2 = NULL;
-  mTextureV2 = NULL;
-  mTextureW2 = NULL;
+  mDensityHigh = nullptr;
+  mFlameHigh = nullptr;
+  mFuelHigh = nullptr;
+  mReactHigh = nullptr;
+  mColorRHigh = nullptr;
+  mColorGHigh = nullptr;
+  mColorBHigh = nullptr;
+  mTextureU = nullptr;
+  mTextureV = nullptr;
+  mTextureW = nullptr;
+  mTextureU2 = nullptr;
+  mTextureV2 = nullptr;
+  mTextureW2 = nullptr;
 
   // Fluid low res grids
-  mPhiIn = NULL;
-  mPhiOutIn = NULL;
-  mPhi = NULL;
+  mPhiIn = nullptr;
+  mPhiOutIn = nullptr;
+  mPhi = nullptr;
 
   // Mesh
-  mMeshNodes = NULL;
-  mMeshTriangles = NULL;
-  mMeshVelocities = NULL;
+  mMeshNodes = nullptr;
+  mMeshTriangles = nullptr;
+  mMeshVelocities = nullptr;
 
   // Fluid obstacle
-  mPhiObsIn = NULL;
-  mNumObstacle = NULL;
-  mObVelocityX = NULL;
-  mObVelocityY = NULL;
-  mObVelocityZ = NULL;
+  mPhiObsIn = nullptr;
+  mNumObstacle = nullptr;
+  mObVelocityX = nullptr;
+  mObVelocityY = nullptr;
+  mObVelocityZ = nullptr;
 
   // Fluid guiding
-  mPhiGuideIn = NULL;
-  mNumGuide = NULL;
-  mGuideVelocityX = NULL;
-  mGuideVelocityY = NULL;
-  mGuideVelocityZ = NULL;
+  mPhiGuideIn = nullptr;
+  mNumGuide = nullptr;
+  mGuideVelocityX = nullptr;
+  mGuideVelocityY = nullptr;
+  mGuideVelocityZ = nullptr;
 
   // Fluid initial velocity
-  mInVelocityX = NULL;
-  mInVelocityY = NULL;
-  mInVelocityZ = NULL;
+  mInVelocityX = nullptr;
+  mInVelocityY = nullptr;
+  mInVelocityZ = nullptr;
 
   // Secondary particles
-  mFlipParticleData = NULL;
-  mFlipParticleVelocity = NULL;
-  mSndParticleData = NULL;
-  mSndParticleVelocity = NULL;
-  mSndParticleLife = NULL;
+  mFlipParticleData = nullptr;
+  mFlipParticleVelocity = nullptr;
+  mSndParticleData = nullptr;
+  mSndParticleVelocity = nullptr;
+  mSndParticleLife = nullptr;
 
   // Cache read success indicators
   mFlipFromFile = false;
@@ -1029,7 +1029,7 @@ int MANTA::updateFlipStructures(FluidModifierData *mmd, int framenr)
 
   std::string pformat = getCacheFileEnding(mmd->domain->cache_particle_format);
   BLI_path_join(
-      cacheDir, sizeof(cacheDir), mmd->domain->cache_directory, FLUID_DOMAIN_DIR_DATA, NULL);
+      cacheDir, sizeof(cacheDir), mmd->domain->cache_directory, FLUID_DOMAIN_DIR_DATA, nullptr);
 
   // TODO (sebbas): Use pp_xl and pVel_xl when using upres simulation?
 
@@ -1081,7 +1081,7 @@ int MANTA::updateMeshStructures(FluidModifierData *mmd, int framenr)
   std::string mformat = getCacheFileEnding(mmd->domain->cache_mesh_format);
   std::string dformat = getCacheFileEnding(mmd->domain->cache_data_format);
   BLI_path_join(
-      cacheDir, sizeof(cacheDir), mmd->domain->cache_directory, FLUID_DOMAIN_DIR_MESH, NULL);
+      cacheDir, sizeof(cacheDir), mmd->domain->cache_directory, FLUID_DOMAIN_DIR_MESH, nullptr);
 
   ss << "lMesh_####" << mformat;
   BLI_join_dirfile(targetFile, sizeof(targetFile), cacheDir, ss.str().c_str());
@@ -1131,8 +1131,11 @@ int MANTA::updateParticleStructures(FluidModifierData *mmd, int framenr)
   targetFile[0] = '\0';
 
   std::string pformat = getCacheFileEnding(mmd->domain->cache_particle_format);
-  BLI_path_join(
-      cacheDir, sizeof(cacheDir), mmd->domain->cache_directory, FLUID_DOMAIN_DIR_PARTICLES, NULL);
+  BLI_path_join(cacheDir,
+                sizeof(cacheDir),
+                mmd->domain->cache_directory,
+                FLUID_DOMAIN_DIR_PARTICLES,
+                nullptr);
 
   ss << "ppSnd_####" << pformat;
   BLI_join_dirfile(targetFile, sizeof(targetFile), cacheDir, ss.str().c_str());
@@ -1192,7 +1195,7 @@ int MANTA::writeConfiguration(FluidModifierData *mmd, int framenr)
   std::string dformat = getCacheFileEnding(mmd->domain->cache_data_format);
 
   BLI_path_join(
-      cacheDir, sizeof(cacheDir), mmd->domain->cache_directory, FLUID_DOMAIN_DIR_CONFIG, NULL);
+      cacheDir, sizeof(cacheDir), mmd->domain->cache_directory, FLUID_DOMAIN_DIR_CONFIG, nullptr);
   BLI_path_make_safe(cacheDir);
   BLI_dir_create_recursive(cacheDir); /* Create 'config' subdir if it does not exist already */
 
@@ -1246,7 +1249,7 @@ int MANTA::writeData(FluidModifierData *mmd, int framenr)
                 sizeof(cacheDirData),
                 mmd->domain->cache_directory,
                 FLUID_DOMAIN_DIR_DATA,
-                NULL);
+                nullptr);
   BLI_path_make_safe(cacheDirData);
 
   ss.str("");
@@ -1285,7 +1288,7 @@ int MANTA::readConfiguration(FluidModifierData *mmd, int framenr)
   std::string dformat = getCacheFileEnding(mmd->domain->cache_data_format);
 
   BLI_path_join(
-      cacheDir, sizeof(cacheDir), mmd->domain->cache_directory, FLUID_DOMAIN_DIR_CONFIG, NULL);
+      cacheDir, sizeof(cacheDir), mmd->domain->cache_directory, FLUID_DOMAIN_DIR_CONFIG, nullptr);
   BLI_path_make_safe(cacheDir);
 
   ss.str("");
@@ -1345,16 +1348,25 @@ int MANTA::readData(FluidModifierData *mmd, int framenr)
                 sizeof(cacheDirData),
                 mmd->domain->cache_directory,
                 FLUID_DOMAIN_DIR_DATA,
-                NULL);
+                nullptr);
   BLI_path_make_safe(cacheDirData);
 
   /* Exit early if there is nothing present in the cache for this frame */
   ss.str("");
-  ss << "vel_####" << dformat;
-  BLI_join_dirfile(targetFile, sizeof(targetFile), cacheDirData, ss.str().c_str());
-  BLI_path_frame(targetFile, framenr, 0);
-  if (!BLI_exists(targetFile))
-    return 0;
+  if (mUsingSmoke) {
+    ss << "density_####" << dformat;
+    BLI_join_dirfile(targetFile, sizeof(targetFile), cacheDirData, ss.str().c_str());
+    BLI_path_frame(targetFile, framenr, 0);
+    if (!BLI_exists(targetFile))
+      return 0;
+  }
+  if (mUsingLiquid) {
+    ss << "phi_####" << dformat;
+    BLI_join_dirfile(targetFile, sizeof(targetFile), cacheDirData, ss.str().c_str());
+    BLI_path_frame(targetFile, framenr, 0);
+    if (!BLI_exists(targetFile))
+      return 0;
+  }
 
   ss.str("");
   ss << "fluid_load_data_" << mCurrentID << "('" << escapeSlashes(cacheDirData) << "', " << framenr
@@ -1402,7 +1414,7 @@ int MANTA::readNoise(FluidModifierData *mmd, int framenr)
                 sizeof(cacheDirNoise),
                 mmd->domain->cache_directory,
                 FLUID_DOMAIN_DIR_NOISE,
-                NULL);
+                nullptr);
   BLI_path_make_safe(cacheDirNoise);
 
   /* Exit early if there is nothing present in the cache for this frame */
@@ -1447,7 +1459,7 @@ int MANTA::readMesh(FluidModifierData *mmd, int framenr)
                 sizeof(cacheDirMesh),
                 mmd->domain->cache_directory,
                 FLUID_DOMAIN_DIR_MESH,
-                NULL);
+                nullptr);
   BLI_path_make_safe(cacheDirMesh);
 
   /* Exit early if there is nothing present in the cache for this frame */
@@ -1503,7 +1515,7 @@ int MANTA::readParticles(FluidModifierData *mmd, int framenr)
                 sizeof(cacheDirParticles),
                 mmd->domain->cache_directory,
                 FLUID_DOMAIN_DIR_PARTICLES,
-                NULL);
+                nullptr);
   BLI_path_make_safe(cacheDirParticles);
 
   /* Exit early if there is nothing present in the cache for this frame */
@@ -1544,7 +1556,7 @@ int MANTA::readGuiding(FluidModifierData *mmd, int framenr, bool sourceDomain)
   const char *subdir = (sourceDomain) ? FLUID_DOMAIN_DIR_DATA : FLUID_DOMAIN_DIR_GUIDE;
 
   BLI_path_join(
-      cacheDirGuiding, sizeof(cacheDirGuiding), mmd->domain->cache_directory, subdir, NULL);
+      cacheDirGuiding, sizeof(cacheDirGuiding), mmd->domain->cache_directory, subdir, nullptr);
   BLI_path_make_safe(cacheDirGuiding);
 
   /* Exit early if there is nothing present in the cache for this frame */
@@ -1592,12 +1604,12 @@ int MANTA::bakeData(FluidModifierData *mmd, int framenr)
                 sizeof(cacheDirData),
                 mmd->domain->cache_directory,
                 FLUID_DOMAIN_DIR_DATA,
-                NULL);
+                nullptr);
   BLI_path_join(cacheDirGuiding,
                 sizeof(cacheDirGuiding),
                 mmd->domain->cache_directory,
                 FLUID_DOMAIN_DIR_GUIDE,
-                NULL);
+                nullptr);
   BLI_path_make_safe(cacheDirData);
   BLI_path_make_safe(cacheDirGuiding);
 
@@ -1633,12 +1645,12 @@ int MANTA::bakeNoise(FluidModifierData *mmd, int framenr)
                 sizeof(cacheDirData),
                 mmd->domain->cache_directory,
                 FLUID_DOMAIN_DIR_DATA,
-                NULL);
+                nullptr);
   BLI_path_join(cacheDirNoise,
                 sizeof(cacheDirNoise),
                 mmd->domain->cache_directory,
                 FLUID_DOMAIN_DIR_NOISE,
-                NULL);
+                nullptr);
   BLI_path_make_safe(cacheDirData);
   BLI_path_make_safe(cacheDirNoise);
 
@@ -1672,12 +1684,12 @@ int MANTA::bakeMesh(FluidModifierData *mmd, int framenr)
                 sizeof(cacheDirData),
                 mmd->domain->cache_directory,
                 FLUID_DOMAIN_DIR_DATA,
-                NULL);
+                nullptr);
   BLI_path_join(cacheDirMesh,
                 sizeof(cacheDirMesh),
                 mmd->domain->cache_directory,
                 FLUID_DOMAIN_DIR_MESH,
-                NULL);
+                nullptr);
   BLI_path_make_safe(cacheDirData);
   BLI_path_make_safe(cacheDirMesh);
 
@@ -1713,12 +1725,12 @@ int MANTA::bakeParticles(FluidModifierData *mmd, int framenr)
                 sizeof(cacheDirData),
                 mmd->domain->cache_directory,
                 FLUID_DOMAIN_DIR_DATA,
-                NULL);
+                nullptr);
   BLI_path_join(cacheDirParticles,
                 sizeof(cacheDirParticles),
                 mmd->domain->cache_directory,
                 FLUID_DOMAIN_DIR_PARTICLES,
-                NULL);
+                nullptr);
   BLI_path_make_safe(cacheDirData);
   BLI_path_make_safe(cacheDirParticles);
 
@@ -1749,7 +1761,7 @@ int MANTA::bakeGuiding(FluidModifierData *mmd, int framenr)
                 sizeof(cacheDirGuiding),
                 mmd->domain->cache_directory,
                 FLUID_DOMAIN_DIR_GUIDE,
-                NULL);
+                nullptr);
   BLI_path_make_safe(cacheDirGuiding);
 
   ss.str("");
@@ -1800,11 +1812,12 @@ void MANTA::exportSmokeScript(FluidModifierData *mmd)
   char cacheDirScript[FILE_MAX] = "\0";
 
   BLI_path_join(
-      cacheDir, sizeof(cacheDir), mmd->domain->cache_directory, FLUID_DOMAIN_DIR_SCRIPT, NULL);
+      cacheDir, sizeof(cacheDir), mmd->domain->cache_directory, FLUID_DOMAIN_DIR_SCRIPT, nullptr);
   BLI_path_make_safe(cacheDir);
   /* Create 'script' subdir if it does not exist already */
   BLI_dir_create_recursive(cacheDir);
-  BLI_path_join(cacheDirScript, sizeof(cacheDirScript), cacheDir, FLUID_DOMAIN_SMOKE_SCRIPT, NULL);
+  BLI_path_join(
+      cacheDirScript, sizeof(cacheDirScript), cacheDir, FLUID_DOMAIN_SMOKE_SCRIPT, nullptr);
   BLI_path_make_safe(cacheDir);
 
   bool noise = mmd->domain->flags & FLUID_DOMAIN_USE_NOISE;
@@ -1903,12 +1916,12 @@ void MANTA::exportLiquidScript(FluidModifierData *mmd)
   char cacheDirScript[FILE_MAX] = "\0";
 
   BLI_path_join(
-      cacheDir, sizeof(cacheDir), mmd->domain->cache_directory, FLUID_DOMAIN_DIR_SCRIPT, NULL);
+      cacheDir, sizeof(cacheDir), mmd->domain->cache_directory, FLUID_DOMAIN_DIR_SCRIPT, nullptr);
   BLI_path_make_safe(cacheDir);
   /* Create 'script' subdir if it does not exist already */
   BLI_dir_create_recursive(cacheDir);
   BLI_path_join(
-      cacheDirScript, sizeof(cacheDirScript), cacheDir, FLUID_DOMAIN_LIQUID_SCRIPT, NULL);
+      cacheDirScript, sizeof(cacheDirScript), cacheDir, FLUID_DOMAIN_LIQUID_SCRIPT, nullptr);
   BLI_path_make_safe(cacheDirScript);
 
   bool mesh = mmd->domain->flags & FLUID_DOMAIN_USE_MESH;
@@ -2005,11 +2018,11 @@ static PyObject *callPythonFunction(std::string varName,
     if (MANTA::with_debug)
       std::cout << "Missing Python variable name and/or function name -- name is: " << varName
                 << ", function name is: " << functionName << std::endl;
-    return NULL;
+    return nullptr;
   }
 
   PyGILState_STATE gilstate = PyGILState_Ensure();
-  PyObject *main = NULL, *var = NULL, *func = NULL, *returnedValue = NULL;
+  PyObject *main = nullptr, *var = nullptr, *func = nullptr, *returnedValue = nullptr;
 
   /* Be sure to initialise Python before importing main. */
   Py_Initialize();
@@ -2017,20 +2030,20 @@ static PyObject *callPythonFunction(std::string varName,
   // Get pyobject that holds result value
   main = PyImport_ImportModule("__main__");
   if (!main)
-    return NULL;
+    return nullptr;
 
   var = PyObject_GetAttrString(main, varName.c_str());
   if (!var)
-    return NULL;
+    return nullptr;
 
   func = PyObject_GetAttrString(var, functionName.c_str());
 
   Py_DECREF(var);
   if (!func)
-    return NULL;
+    return nullptr;
 
   if (!isAttribute) {
-    returnedValue = PyObject_CallObject(func, NULL);
+    returnedValue = PyObject_CallObject(func, nullptr);
     Py_DECREF(func);
   }
 
@@ -2067,7 +2080,7 @@ static void *stringToPointer(char *inputString)
 {
   std::string str(inputString);
   std::istringstream in(str);
-  void *dataPointer = NULL;
+  void *dataPointer = nullptr;
   in >> dataPointer;
   return dataPointer;
 }
@@ -2405,9 +2418,9 @@ void MANTA::updateParticlesFromUni(const char *filename, bool isSecondarySys, bo
   }
 
   // Pointer to FLIP system or to secondary particle system
-  std::vector<pData> *dataPointer = NULL;
-  std::vector<pVel> *velocityPointer = NULL;
-  std::vector<float> *lifePointer = NULL;
+  std::vector<pData> *dataPointer = nullptr;
+  std::vector<pVel> *velocityPointer = nullptr;
+  std::vector<float> *lifePointer = nullptr;
 
   if (isSecondarySys) {
     dataPointer = mSndParticleData;
@@ -2488,27 +2501,6 @@ void MANTA::updateParticlesFromUni(const char *filename, bool isSecondarySys, bo
   gzclose(gzf);
 }
 
-template<typename T>
-void MANTA::setPointers(std::vector<std::tuple<T **, std::string, std::string, bool>> objects)
-{
-  PyObject *mantaObject = NULL;
-
-  for (typename std::vector<std::tuple<T **, std::string, std::string, bool>>::iterator it =
-           objects.begin();
-       it != objects.end();
-       ++it) {
-    if (!std::get<3>(*it))
-      continue;
-    mantaObject = callPythonFunction(std::get<1>(*it), std::get<2>(*it));
-    if (mantaObject) {
-      (*std::get<0>(*it)) = (T *)stringToPointer(pyObjectToString(mantaObject));
-    }
-    else {
-      (*std::get<0>(*it)) = NULL;
-    }
-  }
-}
-
 void MANTA::updatePointers()
 {
   if (with_debug)
@@ -2532,153 +2524,159 @@ void MANTA::updatePointers()
   std::string mesh_ext2 = "_" + mesh2;
   std::string noise_ext = "_" + noise;
 
-  std::vector<std::tuple<int **, std::string, std::string, bool>> mantaIntObjects;
-  mantaIntObjects.push_back(std::make_tuple(&mObstacle, "flags" + solver_ext, func, true));
-
-  std::vector<std::tuple<float **, std::string, std::string, bool>> mantaFloatObjects;
-  mantaFloatObjects.push_back(std::make_tuple(&mPhiIn, "phiIn" + solver_ext, func, true));
-  mantaFloatObjects.push_back(std::make_tuple(&mVelocityX, "x_vel" + solver_ext, func, true));
-  mantaFloatObjects.push_back(std::make_tuple(&mVelocityY, "y_vel" + solver_ext, func, true));
-  mantaFloatObjects.push_back(std::make_tuple(&mVelocityZ, "z_vel" + solver_ext, func, true));
-  mantaFloatObjects.push_back(std::make_tuple(&mForceX, "x_force" + solver_ext, func, true));
-  mantaFloatObjects.push_back(std::make_tuple(&mForceY, "y_force" + solver_ext, func, true));
-  mantaFloatObjects.push_back(std::make_tuple(&mForceZ, "z_force" + solver_ext, func, true));
-  mantaFloatObjects.push_back(
-      std::make_tuple(&mPhiOutIn, "phiOutIn" + solver_ext, func, mUsingOutflow));
-  mantaFloatObjects.push_back(
-      std::make_tuple(&mPhiObsIn, "phiObsIn" + solver_ext, func, mUsingObstacle));
-  mantaFloatObjects.push_back(
-      std::make_tuple(&mObVelocityX, "x_obvel" + solver_ext, func, mUsingObstacle));
-  mantaFloatObjects.push_back(
-      std::make_tuple(&mObVelocityY, "y_obvel" + solver_ext, func, mUsingObstacle));
-  mantaFloatObjects.push_back(
-      std::make_tuple(&mObVelocityZ, "z_obvel" + solver_ext, func, mUsingObstacle));
-  mantaFloatObjects.push_back(
-      std::make_tuple(&mPhiGuideIn, "phiGuideIn" + solver_ext, func, mUsingGuiding));
-  mantaFloatObjects.push_back(
-      std::make_tuple(&mGuideVelocityX, "x_guidevel" + solver_ext, func, mUsingGuiding));
-  mantaFloatObjects.push_back(
-      std::make_tuple(&mGuideVelocityY, "y_guidevel" + solver_ext, func, mUsingGuiding));
-  mantaFloatObjects.push_back(
-      std::make_tuple(&mGuideVelocityZ, "z_guidevel" + solver_ext, func, mUsingGuiding));
-  mantaFloatObjects.push_back(
-      std::make_tuple(&mInVelocityX, "x_invel" + solver_ext, func, mUsingInvel));
-  mantaFloatObjects.push_back(
-      std::make_tuple(&mInVelocityY, "y_invel" + solver_ext, func, mUsingInvel));
-  mantaFloatObjects.push_back(
-      std::make_tuple(&mInVelocityZ, "z_invel" + solver_ext, func, mUsingInvel));
-  mantaFloatObjects.push_back(
-      std::make_tuple(&mNumObstacle, "numObs" + solver_ext, func, mUsingObstacle));
-  mantaFloatObjects.push_back(
-      std::make_tuple(&mNumGuide, "numGuides" + solver_ext, func, mUsingGuiding));
-
-  mantaFloatObjects.push_back(std::make_tuple(&mPhi, "phi" + solver_ext, func, mUsingLiquid));
-
-  mantaFloatObjects.push_back(
-      std::make_tuple(&mDensity, "density" + solver_ext, func, mUsingSmoke));
-  mantaFloatObjects.push_back(
-      std::make_tuple(&mDensityIn, "densityIn" + solver_ext, func, mUsingSmoke));
-  mantaFloatObjects.push_back(std::make_tuple(&mShadow, "shadow" + solver_ext, func, mUsingSmoke));
-  mantaFloatObjects.push_back(
-      std::make_tuple(&mEmissionIn, "emissionIn" + solver_ext, func, mUsingSmoke));
-  mantaFloatObjects.push_back(
-      std::make_tuple(&mHeat, "heat" + solver_ext, func, mUsingSmoke & mUsingHeat));
-  mantaFloatObjects.push_back(
-      std::make_tuple(&mHeatIn, "heatIn" + solver_ext, func, mUsingSmoke & mUsingHeat));
-  mantaFloatObjects.push_back(
-      std::make_tuple(&mFlame, "flame" + solver_ext, func, mUsingSmoke & mUsingFire));
-  mantaFloatObjects.push_back(
-      std::make_tuple(&mFuel, "fuel" + solver_ext, func, mUsingSmoke & mUsingFire));
-  mantaFloatObjects.push_back(
-      std::make_tuple(&mReact, "react" + solver_ext, func, mUsingSmoke & mUsingFire));
-  mantaFloatObjects.push_back(
-      std::make_tuple(&mFuelIn, "fuelIn" + solver_ext, func, mUsingSmoke & mUsingFire));
-  mantaFloatObjects.push_back(
-      std::make_tuple(&mReactIn, "reactIn" + solver_ext, func, mUsingSmoke & mUsingFire));
-  mantaFloatObjects.push_back(
-      std::make_tuple(&mColorR, "color_r" + solver_ext, func, mUsingSmoke & mUsingColors));
-  mantaFloatObjects.push_back(
-      std::make_tuple(&mColorG, "color_g" + solver_ext, func, mUsingSmoke & mUsingColors));
-  mantaFloatObjects.push_back(
-      std::make_tuple(&mColorB, "color_b" + solver_ext, func, mUsingSmoke & mUsingColors));
-  mantaFloatObjects.push_back(
-      std::make_tuple(&mColorRIn, "color_r_in" + solver_ext, func, mUsingSmoke & mUsingColors));
-  mantaFloatObjects.push_back(
-      std::make_tuple(&mColorGIn, "color_g_in" + solver_ext, func, mUsingSmoke & mUsingColors));
-  mantaFloatObjects.push_back(
-      std::make_tuple(&mColorBIn, "color_b_in" + solver_ext, func, mUsingSmoke & mUsingColors));
-
-  mantaFloatObjects.push_back(
-      std::make_tuple(&mDensityHigh, "density" + noise_ext, func, mUsingSmoke & mUsingNoise));
-  mantaFloatObjects.push_back(
-      std::make_tuple(&mTextureU, "texture_u" + solver_ext, func, mUsingSmoke & mUsingNoise));
-  mantaFloatObjects.push_back(
-      std::make_tuple(&mTextureV, "texture_v" + solver_ext, func, mUsingSmoke & mUsingNoise));
-  mantaFloatObjects.push_back(
-      std::make_tuple(&mTextureW, "texture_w" + solver_ext, func, mUsingSmoke & mUsingNoise));
-  mantaFloatObjects.push_back(
-      std::make_tuple(&mTextureU2, "texture_u2" + solver_ext, func, mUsingSmoke & mUsingNoise));
-  mantaFloatObjects.push_back(
-      std::make_tuple(&mTextureV2, "texture_v2" + solver_ext, func, mUsingSmoke & mUsingNoise));
-  mantaFloatObjects.push_back(
-      std::make_tuple(&mTextureW2, "texture_w2" + solver_ext, func, mUsingSmoke & mUsingNoise));
-  mantaFloatObjects.push_back(std::make_tuple(
-      &mFlameHigh, "flame" + noise_ext, func, mUsingSmoke & mUsingNoise & mUsingFire));
-  mantaFloatObjects.push_back(std::make_tuple(
-      &mFuelHigh, "fuel" + noise_ext, func, mUsingSmoke & mUsingNoise & mUsingFire));
-  mantaFloatObjects.push_back(std::make_tuple(
-      &mReactHigh, "react" + noise_ext, func, mUsingSmoke & mUsingNoise & mUsingFire));
-  mantaFloatObjects.push_back(std::make_tuple(
-      &mColorRHigh, "color_r" + noise_ext, func, mUsingSmoke & mUsingNoise & mUsingColors));
-  mantaFloatObjects.push_back(std::make_tuple(
-      &mColorGHigh, "color_g" + noise_ext, func, mUsingSmoke & mUsingNoise & mUsingColors));
-  mantaFloatObjects.push_back(std::make_tuple(
-      &mColorBHigh, "color_b" + noise_ext, func, mUsingSmoke & mUsingNoise & mUsingColors));
-
-  std::vector<std::tuple<std::vector<pData> **, std::string, std::string, bool>> mantaPDataObjects;
-  mantaPDataObjects.push_back(
-      std::make_tuple(&mFlipParticleData, "pp" + solver_ext, func, mUsingLiquid));
-  mantaPDataObjects.push_back(std::make_tuple(
-      &mSndParticleData,
-      "ppSnd" + snd_ext,
-      func,
-      mUsingLiquid & (mUsingDrops | mUsingBubbles | mUsingFloats | mUsingTracers)));
-
-  std::vector<std::tuple<std::vector<pVel> **, std::string, std::string, bool>> mantaPVelObjects;
-  mantaPVelObjects.push_back(
-      std::make_tuple(&mFlipParticleVelocity, "pVel" + parts_ext, func, mUsingLiquid));
-  mantaPVelObjects.push_back(std::make_tuple(
-      &mMeshVelocities, "mVel" + mesh_ext2, func, mUsingLiquid & mUsingMesh & mUsingMVel));
-  mantaPVelObjects.push_back(std::make_tuple(
-      &mSndParticleVelocity,
-      "pVelSnd" + parts_ext,
-      func,
-      mUsingLiquid & (mUsingDrops | mUsingBubbles | mUsingFloats | mUsingTracers)));
-
-  std::vector<std::tuple<std::vector<Node> **, std::string, std::string, bool>> mantaNodeObjects;
-  mantaNodeObjects.push_back(
-      std::make_tuple(&mMeshNodes, "mesh" + mesh_ext, funcNodes, mUsingLiquid & mUsingMesh));
-
-  std::vector<std::tuple<std::vector<Triangle> **, std::string, std::string, bool>>
-      mantaTriangleObjects;
-  mantaTriangleObjects.push_back(
-      std::make_tuple(&mMeshTriangles, "mesh" + mesh_ext, funcTris, mUsingLiquid & mUsingMesh));
-
-  std::vector<std::tuple<std::vector<float> **, std::string, std::string, bool>>
-      mantaFloatVecObjects;
-  mantaFloatVecObjects.push_back(std::make_tuple(
-      &mSndParticleLife,
-      "pLifeSnd" + parts_ext,
-      func,
-      mUsingLiquid & (mUsingDrops | mUsingBubbles | mUsingFloats | mUsingTracers)));
-
-  setPointers(mantaIntObjects);
-  setPointers(mantaFloatObjects);
-  setPointers(mantaPDataObjects);
-  setPointers(mantaPVelObjects);
-  setPointers(mantaNodeObjects);
-  setPointers(mantaTriangleObjects);
-  setPointers(mantaFloatVecObjects);
+  mObstacle = (int *)stringToPointer(
+      pyObjectToString(callPythonFunction("flags" + solver_ext, func)));
+  mPhiIn = (float *)stringToPointer(
+      pyObjectToString(callPythonFunction("phiIn" + solver_ext, func)));
+  mVelocityX = (float *)stringToPointer(
+      pyObjectToString(callPythonFunction("x_vel" + solver_ext, func)));
+  mVelocityY = (float *)stringToPointer(
+      pyObjectToString(callPythonFunction("y_vel" + solver_ext, func)));
+  mVelocityZ = (float *)stringToPointer(
+      pyObjectToString(callPythonFunction("z_vel" + solver_ext, func)));
+  mForceX = (float *)stringToPointer(
+      pyObjectToString(callPythonFunction("x_force" + solver_ext, func)));
+  mForceY = (float *)stringToPointer(
+      pyObjectToString(callPythonFunction("y_force" + solver_ext, func)));
+  mForceZ = (float *)stringToPointer(
+      pyObjectToString(callPythonFunction("z_force" + solver_ext, func)));
+
+  if (mUsingOutflow) {
+    mPhiOutIn = (float *)stringToPointer(
+        pyObjectToString(callPythonFunction("phiOutIn" + solver_ext, func)));
+  }
+  if (mUsingObstacle) {
+    mPhiObsIn = (float *)stringToPointer(
+        pyObjectToString(callPythonFunction("phiObsIn" + solver_ext, func)));
+    mObVelocityX = (float *)stringToPointer(
+        pyObjectToString(callPythonFunction("x_obvel" + solver_ext, func)));
+    mObVelocityY = (float *)stringToPointer(
+        pyObjectToString(callPythonFunction("y_obvel" + solver_ext, func)));
+    mObVelocityZ = (float *)stringToPointer(
+        pyObjectToString(callPythonFunction("z_obvel" + solver_ext, func)));
+    mNumObstacle = (float *)stringToPointer(
+        pyObjectToString(callPythonFunction("numObs" + solver_ext, func)));
+  }
+  if (mUsingGuiding) {
+    mPhiGuideIn = (float *)stringToPointer(
+        pyObjectToString(callPythonFunction("phiGuideIn" + solver_ext, func)));
+    mGuideVelocityX = (float *)stringToPointer(
+        pyObjectToString(callPythonFunction("x_guidevel" + solver_ext, func)));
+    mGuideVelocityY = (float *)stringToPointer(
+        pyObjectToString(callPythonFunction("y_guidevel" + solver_ext, func)));
+    mGuideVelocityZ = (float *)stringToPointer(
+        pyObjectToString(callPythonFunction("z_guidevel" + solver_ext, func)));
+  }
+  if (mUsingInvel) {
+    mInVelocityX = (float *)stringToPointer(
+        pyObjectToString(callPythonFunction("x_invel" + solver_ext, func)));
+    mInVelocityY = (float *)stringToPointer(
+        pyObjectToString(callPythonFunction("y_invel" + solver_ext, func)));
+    mInVelocityZ = (float *)stringToPointer(
+        pyObjectToString(callPythonFunction("z_invel" + solver_ext, func)));
+    mNumGuide = (float *)stringToPointer(
+        pyObjectToString(callPythonFunction("numGuides" + solver_ext, func)));
+  }
+  if (mUsingSmoke) {
+    mDensity = (float *)stringToPointer(
+        pyObjectToString(callPythonFunction("density" + solver_ext, func)));
+    mDensityIn = (float *)stringToPointer(
+        pyObjectToString(callPythonFunction("densityIn" + solver_ext, func)));
+    mShadow = (float *)stringToPointer(
+        pyObjectToString(callPythonFunction("shadow" + solver_ext, func)));
+    mEmissionIn = (float *)stringToPointer(
+        pyObjectToString(callPythonFunction("emissionIn" + solver_ext, func)));
+  }
+  if (mUsingSmoke && mUsingHeat) {
+    mHeat = (float *)stringToPointer(
+        pyObjectToString(callPythonFunction("heat" + solver_ext, func)));
+    mHeatIn = (float *)stringToPointer(
+        pyObjectToString(callPythonFunction("heatIn" + solver_ext, func)));
+  }
+  if (mUsingSmoke && mUsingFire) {
+    mFlame = (float *)stringToPointer(
+        pyObjectToString(callPythonFunction("flame" + solver_ext, func)));
+    mFuel = (float *)stringToPointer(
+        pyObjectToString(callPythonFunction("fuel" + solver_ext, func)));
+    mReact = (float *)stringToPointer(
+        pyObjectToString(callPythonFunction("react" + solver_ext, func)));
+    mFuelIn = (float *)stringToPointer(
+        pyObjectToString(callPythonFunction("fuelIn" + solver_ext, func)));
+    mReactIn = (float *)stringToPointer(
+        pyObjectToString(callPythonFunction("reactIn" + solver_ext, func)));
+  }
+  if (mUsingSmoke && mUsingColors) {
+    mColorR = (float *)stringToPointer(
+        pyObjectToString(callPythonFunction("color_r" + solver_ext, func)));
+    mColorG = (float *)stringToPointer(
+        pyObjectToString(callPythonFunction("color_g" + solver_ext, func)));
+    mColorB = (float *)stringToPointer(
+        pyObjectToString(callPythonFunction("color_b" + solver_ext, func)));
+    mColorRIn = (float *)stringToPointer(
+        pyObjectToString(callPythonFunction("color_r_in" + solver_ext, func)));
+    mColorGIn = (float *)stringToPointer(
+        pyObjectToString(callPythonFunction("color_g_in" + solver_ext, func)));
+    mColorBIn = (float *)stringToPointer(
+        pyObjectToString(callPythonFunction("color_b_in" + solver_ext, func)));
+  }
+  if (mUsingSmoke && mUsingNoise) {
+    mDensityHigh = (float *)stringToPointer(
+        pyObjectToString(callPythonFunction("density" + noise_ext, func)));
+    mTextureU = (float *)stringToPointer(
+        pyObjectToString(callPythonFunction("texture_u" + solver_ext, func)));
+    mTextureV = (float *)stringToPointer(
+        pyObjectToString(callPythonFunction("texture_v" + solver_ext, func)));
+    mTextureW = (float *)stringToPointer(
+        pyObjectToString(callPythonFunction("texture_w" + solver_ext, func)));
+    mTextureU2 = (float *)stringToPointer(
+        pyObjectToString(callPythonFunction("texture_u2" + solver_ext, func)));
+    mTextureV2 = (float *)stringToPointer(
+        pyObjectToString(callPythonFunction("texture_v2" + solver_ext, func)));
+    mTextureW2 = (float *)stringToPointer(
+        pyObjectToString(callPythonFunction("texture_w2" + solver_ext, func)));
+  }
+  if (mUsingSmoke && mUsingNoise && mUsingFire) {
+    mFlameHigh = (float *)stringToPointer(
+        pyObjectToString(callPythonFunction("flame" + noise_ext, func)));
+    mFuelHigh = (float *)stringToPointer(
+        pyObjectToString(callPythonFunction("fuel" + noise_ext, func)));
+    mReactHigh = (float *)stringToPointer(
+        pyObjectToString(callPythonFunction("react" + noise_ext, func)));
+  }
+  if (mUsingSmoke && mUsingNoise && mUsingColors) {
+    mColorRHigh = (float *)stringToPointer(
+        pyObjectToString(callPythonFunction("color_r" + noise_ext, func)));
+    mColorGHigh = (float *)stringToPointer(
+        pyObjectToString(callPythonFunction("color_g" + noise_ext, func)));
+    mColorBHigh = (float *)stringToPointer(
+        pyObjectToString(callPythonFunction("color_b" + noise_ext, func)));
+  }
+  if (mUsingLiquid) {
+    mPhi = (float *)stringToPointer(
+        pyObjectToString(callPythonFunction("phi" + solver_ext, func)));
+    mFlipParticleData = (std::vector<pData> *)stringToPointer(
+        pyObjectToString(callPythonFunction("pp" + solver_ext, func)));
+    mFlipParticleVelocity = (std::vector<pVel> *)stringToPointer(
+        pyObjectToString(callPythonFunction("pVel" + parts_ext, func)));
+  }
+  if (mUsingLiquid && mUsingMesh) {
+    mMeshNodes = (std::vector<Node> *)stringToPointer(
+        pyObjectToString(callPythonFunction("mesh" + mesh_ext, funcNodes)));
+    mMeshTriangles = (std::vector<Triangle> *)stringToPointer(
+        pyObjectToString(callPythonFunction("mesh" + mesh_ext, funcTris)));
+  }
+  if (mUsingLiquid && mUsingMVel) {
+    mMeshVelocities = (std::vector<pVel> *)stringToPointer(
+        pyObjectToString(callPythonFunction("mVel" + mesh_ext2, func)));
+  }
+  if (mUsingLiquid && (mUsingDrops | mUsingBubbles | mUsingFloats | mUsingTracers)) {
+    mSndParticleData = (std::vector<pData> *)stringToPointer(
+        pyObjectToString(callPythonFunction("ppSnd" + snd_ext, func)));
+    mSndParticleVelocity = (std::vector<pVel> *)stringToPointer(
+        pyObjectToString(callPythonFunction("pVelSnd" + parts_ext, func)));
+    mSndParticleLife = (std::vector<float> *)stringToPointer(
+        pyObjectToString(callPythonFunction("pLifeSnd" + parts_ext, func)));
+  }
 
   mFlipFromFile = true;
   mMeshFromFile = false;
diff --git a/intern/mantaflow/intern/MANTA_main.h b/intern/mantaflow/intern/MANTA_main.h
index d9b4f6789fd..f8d94e2631c 100644
--- a/intern/mantaflow/intern/MANTA_main.h
+++ b/intern/mantaflow/intern/MANTA_main.h
@@ -854,8 +854,6 @@ struct MANTA {
   void updateParticlesFromUni(const char *filename, bool isSecondarySys, bool isVelData);
   void updateMeshFromFile(const char *filename);
   void updateParticlesFromFile(const char *filename, bool isSecondarySys, bool isVelData);
-  template<class T>
-  void setPointers(std::vector<std::tuple<T **, std::string, std::string, bool>>);
 };
 
 #endif
diff --git a/intern/mantaflow/intern/manta_fluid_API.cpp b/intern/mantaflow/intern/manta_fluid_API.cpp
index 61dff91cd35..35f2ebbaf44 100644
--- a/intern/mantaflow/intern/manta_fluid_API.cpp
+++ b/intern/mantaflow/intern/manta_fluid_API.cpp
@@ -372,7 +372,8 @@ void manta_smoke_export(MANTA *smoke,
   if (b)
     *b = smoke->getColorB();
   *obstacle = smoke->getObstacle();
-  *shadow = smoke->getShadow();
+  if (shadow)
+    *shadow = smoke->getShadow();
   *dt = 1;  // dummy value, not needed for smoke
   *dx = 1;  // dummy value, not needed for smoke
 }
@@ -557,9 +558,9 @@ float *manta_smoke_get_flame(MANTA *smoke)
 {
   return smoke->getFlame();
 }
-float *manta_smoke_get_shadow(MANTA *fluid)
+float *manta_smoke_get_shadow(MANTA *smoke)
 {
-  return fluid->getShadow();
+  return smoke->getShadow();
 }
 
 float *manta_smoke_get_color_r(MANTA *smoke)