Fluid: Refactored Python fluid initialization functions

Initialization functions now have a return type which will be asserted during fluid object creation.

intern/mantaflow/extern/manta_fluid_API.h

@@ -33,10 +33,10 @@ struct MANTA;
 /* Fluid functions */
 struct MANTA *manta_init(int *res, struct FluidModifierData *fmd);
 void manta_free(struct MANTA *fluid);
-void manta_ensure_obstacle(struct MANTA *fluid, struct FluidModifierData *fmd);
+int manta_ensure_obstacle(struct MANTA *fluid, struct FluidModifierData *fmd);
-void manta_ensure_guiding(struct MANTA *fluid, struct FluidModifierData *fmd);
+int manta_ensure_guiding(struct MANTA *fluid, struct FluidModifierData *fmd);
-void manta_ensure_invelocity(struct MANTA *fluid, struct FluidModifierData *fmd);
+int manta_ensure_invelocity(struct MANTA *fluid, struct FluidModifierData *fmd);
-void manta_ensure_outflow(struct MANTA *fluid, struct FluidModifierData *fmd);
+int manta_ensure_outflow(struct MANTA *fluid, struct FluidModifierData *fmd);
 int manta_write_config(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
 int manta_write_data(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
 int manta_write_noise(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
@@ -122,9 +122,9 @@ void manta_noise_get_rgba_fixed_color(struct MANTA *smoke,
                                       float color[3],
                                       float *data,
                                       int sequential);
-void manta_smoke_ensure_heat(struct MANTA *smoke, struct FluidModifierData *fmd);
+int manta_smoke_ensure_heat(struct MANTA *smoke, struct FluidModifierData *fmd);
-void manta_smoke_ensure_fire(struct MANTA *smoke, struct FluidModifierData *fmd);
+int manta_smoke_ensure_fire(struct MANTA *smoke, struct FluidModifierData *fmd);
-void manta_smoke_ensure_colors(struct MANTA *smoke, struct FluidModifierData *fmd);
+int manta_smoke_ensure_colors(struct MANTA *smoke, struct FluidModifierData *fmd);
 
 /* Smoke accessors */
 float *manta_smoke_get_density(struct MANTA *smoke);
@@ -168,7 +168,7 @@ int manta_noise_get_cells(struct MANTA *smoke);
 
 /* Liquid functions */
 void manta_liquid_export_script(struct MANTA *smoke, struct FluidModifierData *fmd);
-void manta_liquid_ensure_sndparts(struct MANTA *fluid, struct FluidModifierData *fmd);
+int manta_liquid_ensure_sndparts(struct MANTA *fluid, struct FluidModifierData *fmd);
 
 /* Liquid accessors */
 int manta_liquid_get_particle_res_x(struct MANTA *liquid);

intern/mantaflow/intern/MANTA_main.cpp

@@ -196,17 +196,18 @@ MANTA::MANTA(int *res, FluidModifierData *fmd) : mCurrentID(++solverID)
   // Initializa RNA map with values that Python will need
   initializeRNAMap(fmd);
 
+  bool initSuccess = true;
   // Initialize Mantaflow variables in Python
   // Liquid
   if (mUsingLiquid) {
-    initDomain();
+    initSuccess &= initDomain();
-    initLiquid();
+    initSuccess &= initLiquid();
     if (mUsingObstacle)
-      initObstacle();
+      initSuccess &= initObstacle();
     if (mUsingInvel)
-      initInVelocity();
+      initSuccess &= initInVelocity();
     if (mUsingOutflow)
-      initOutflow();
+      initSuccess &= initOutflow();
 
     if (mUsingDrops || mUsingBubbles || mUsingFloats || mUsingTracers) {
       mUpresParticle = fds->particle_scale;
@@ -215,8 +216,8 @@ MANTA::MANTA(int *res, FluidModifierData *fmd) : mCurrentID(++solverID)
       mResZParticle = mUpresParticle * mResZ;
       mTotalCellsParticles = mResXParticle * mResYParticle * mResZParticle;
 
-      initSndParts();
+      initSuccess &= initSndParts();
-      initLiquidSndParts();
+      initSuccess &= initLiquidSndParts();
     }
 
     if (mUsingMesh) {
@@ -227,43 +228,43 @@ MANTA::MANTA(int *res, FluidModifierData *fmd) : mCurrentID(++solverID)
       mTotalCellsMesh = mResXMesh * mResYMesh * mResZMesh;
 
       // Initialize Mantaflow variables in Python
-      initMesh();
+      initSuccess &= initMesh();
-      initLiquidMesh();
+      initSuccess &= initLiquidMesh();
     }
 
     if (mUsingDiffusion) {
-      initCurvature();
+      initSuccess &= initCurvature();
     }
 
     if (mUsingGuiding) {
       mResGuiding = (fds->guide_parent) ? fds->guide_res : fds->res;
-      initGuiding();
+      initSuccess &= initGuiding();
     }
     if (mUsingFractions) {
-      initFractions();
+      initSuccess &= initFractions();
     }
   }
 
   // Smoke
   if (mUsingSmoke) {
-    initDomain();
+    initSuccess &= initDomain();
-    initSmoke();
+    initSuccess &= initSmoke();
     if (mUsingHeat)
-      initHeat();
+      initSuccess &= initHeat();
     if (mUsingFire)
-      initFire();
+      initSuccess &= initFire();
     if (mUsingColors)
-      initColors();
+      initSuccess &= initColors();
     if (mUsingObstacle)
-      initObstacle();
+      initSuccess &= initObstacle();
     if (mUsingInvel)
-      initInVelocity();
+      initSuccess &= initInVelocity();
     if (mUsingOutflow)
-      initOutflow();
+      initSuccess &= initOutflow();
 
     if (mUsingGuiding) {
       mResGuiding = (fds->guide_parent) ? fds->guide_res : fds->res;
-      initGuiding();
+      initSuccess &= initGuiding();
     }
 
     if (mUsingNoise) {
@@ -274,19 +275,20 @@ MANTA::MANTA(int *res, FluidModifierData *fmd) : mCurrentID(++solverID)
       mTotalCellsHigh = mResXNoise * mResYNoise * mResZNoise;
 
       // Initialize Mantaflow variables in Python
-      initNoise();
+      initSuccess &= initNoise();
-      initSmokeNoise();
+      initSuccess &= initSmokeNoise();
       if (mUsingFire)
-        initFireHigh();
+        initSuccess &= initFireHigh();
       if (mUsingColors)
-        initColorsHigh();
+        initSuccess &= initColorsHigh();
     }
   }
-
+  /* All requested initializations must not fail in constructor. */
+  BLI_assert(initSuccess);
   updatePointers(fmd);
 }
 
-void MANTA::initDomain(FluidModifierData *fmd)
+bool MANTA::initDomain(FluidModifierData *fmd)
 {
   // Vector will hold all python commands that are to be executed
   vector<string> pythonCommands;
@@ -306,20 +308,20 @@ void MANTA::initDomain(FluidModifierData *fmd)
                      fluid_adapt_time_step + fluid_time_stepping;
   string finalString = parseScript(tmpString, fmd);
   pythonCommands.push_back(finalString);
-  runPythonString(pythonCommands);
+  return runPythonString(pythonCommands);
 }
 
-void MANTA::initNoise(FluidModifierData *fmd)
+bool MANTA::initNoise(FluidModifierData *fmd)
 {
   vector<string> pythonCommands;
   string tmpString = fluid_variables_noise + fluid_solver_noise;
   string finalString = parseScript(tmpString, fmd);
   pythonCommands.push_back(finalString);
 
-  runPythonString(pythonCommands);
+  return runPythonString(pythonCommands);
 }
 
-void MANTA::initSmoke(FluidModifierData *fmd)
+bool MANTA::initSmoke(FluidModifierData *fmd)
 {
   vector<string> pythonCommands;
   string tmpString = smoke_variables + smoke_alloc + smoke_adaptive_step + smoke_save_data +
@@ -327,10 +329,10 @@ void MANTA::initSmoke(FluidModifierData *fmd)
   string finalString = parseScript(tmpString, fmd);
   pythonCommands.push_back(finalString);
 
-  runPythonString(pythonCommands);
+  return runPythonString(pythonCommands);
 }
 
-void MANTA::initSmokeNoise(FluidModifierData *fmd)
+bool MANTA::initSmokeNoise(FluidModifierData *fmd)
 {
   vector<string> pythonCommands;
   string tmpString = smoke_variables_noise + smoke_alloc_noise + smoke_wavelet_noise +
@@ -338,11 +340,11 @@ void MANTA::initSmokeNoise(FluidModifierData *fmd)
   string finalString = parseScript(tmpString, fmd);
   pythonCommands.push_back(finalString);
 
-  runPythonString(pythonCommands);
   mUsingNoise = true;
+  return runPythonString(pythonCommands);
 }
 
-void MANTA::initHeat(FluidModifierData *fmd)
+bool MANTA::initHeat(FluidModifierData *fmd)
 {
   if (!mHeat) {
     vector<string> pythonCommands;
@@ -350,12 +352,13 @@ void MANTA::initHeat(FluidModifierData *fmd)
     string finalString = parseScript(tmpString, fmd);
     pythonCommands.push_back(finalString);
 
-    runPythonString(pythonCommands);
     mUsingHeat = true;
+    return runPythonString(pythonCommands);
   }
+  return false;
 }
 
-void MANTA::initFire(FluidModifierData *fmd)
+bool MANTA::initFire(FluidModifierData *fmd)
 {
   if (!mFuel) {
     vector<string> pythonCommands;
@@ -363,12 +366,13 @@ void MANTA::initFire(FluidModifierData *fmd)
     string finalString = parseScript(tmpString, fmd);
     pythonCommands.push_back(finalString);
 
-    runPythonString(pythonCommands);
     mUsingFire = true;
+    return runPythonString(pythonCommands);
   }
+  return false;
 }
 
-void MANTA::initFireHigh(FluidModifierData *fmd)
+bool MANTA::initFireHigh(FluidModifierData *fmd)
 {
   if (!mFuelHigh) {
     vector<string> pythonCommands;
@@ -376,12 +380,13 @@ void MANTA::initFireHigh(FluidModifierData *fmd)
     string finalString = parseScript(tmpString, fmd);
     pythonCommands.push_back(finalString);
 
-    runPythonString(pythonCommands);
     mUsingFire = true;
+    return runPythonString(pythonCommands);
   }
+  return false;
 }
 
-void MANTA::initColors(FluidModifierData *fmd)
+bool MANTA::initColors(FluidModifierData *fmd)
 {
   if (!mColorR) {
     vector<string> pythonCommands;
@@ -389,12 +394,13 @@ void MANTA::initColors(FluidModifierData *fmd)
     string finalString = parseScript(tmpString, fmd);
     pythonCommands.push_back(finalString);
 
-    runPythonString(pythonCommands);
     mUsingColors = true;
+    return runPythonString(pythonCommands);
   }
+  return false;
 }
 
-void MANTA::initColorsHigh(FluidModifierData *fmd)
+bool MANTA::initColorsHigh(FluidModifierData *fmd)
 {
   if (!mColorRHigh) {
     vector<string> pythonCommands;
@@ -402,12 +408,13 @@ void MANTA::initColorsHigh(FluidModifierData *fmd)
     string finalString = parseScript(tmpString, fmd);
     pythonCommands.push_back(finalString);
 
-    runPythonString(pythonCommands);
     mUsingColors = true;
+    return runPythonString(pythonCommands);
   }
+  return false;
 }
 
-void MANTA::initLiquid(FluidModifierData *fmd)
+bool MANTA::initLiquid(FluidModifierData *fmd)
 {
   if (!mPhiIn) {
     vector<string> pythonCommands;
@@ -416,44 +423,45 @@ void MANTA::initLiquid(FluidModifierData *fmd)
     string finalString = parseScript(tmpString, fmd);
     pythonCommands.push_back(finalString);
 
-    runPythonString(pythonCommands);
     mUsingLiquid = true;
+    return runPythonString(pythonCommands);
   }
+  return false;
 }
 
-void MANTA::initMesh(FluidModifierData *fmd)
+bool MANTA::initMesh(FluidModifierData *fmd)
 {
   vector<string> pythonCommands;
   string tmpString = fluid_variables_mesh + fluid_solver_mesh + liquid_load_mesh;
   string finalString = parseScript(tmpString, fmd);
   pythonCommands.push_back(finalString);
 
-  runPythonString(pythonCommands);
   mUsingMesh = true;
+  return runPythonString(pythonCommands);
 }
 
-void MANTA::initLiquidMesh(FluidModifierData *fmd)
+bool MANTA::initLiquidMesh(FluidModifierData *fmd)
 {
   vector<string> pythonCommands;
   string tmpString = liquid_alloc_mesh + liquid_step_mesh + liquid_save_mesh;
   string finalString = parseScript(tmpString, fmd);
   pythonCommands.push_back(finalString);
 
-  runPythonString(pythonCommands);
   mUsingMesh = true;
+  return runPythonString(pythonCommands);
 }
 
-void MANTA::initCurvature(FluidModifierData *fmd)
+bool MANTA::initCurvature(FluidModifierData *fmd)
 {
   std::vector<std::string> pythonCommands;
   std::string finalString = parseScript(liquid_alloc_curvature, fmd);
   pythonCommands.push_back(finalString);
 
-  runPythonString(pythonCommands);
   mUsingDiffusion = true;
+  return runPythonString(pythonCommands);
 }
 
-void MANTA::initObstacle(FluidModifierData *fmd)
+bool MANTA::initObstacle(FluidModifierData *fmd)
 {
   if (!mPhiObsIn) {
     vector<string> pythonCommands;
@@ -461,12 +469,13 @@ void MANTA::initObstacle(FluidModifierData *fmd)
     string finalString = parseScript(tmpString, fmd);
     pythonCommands.push_back(finalString);
 
-    runPythonString(pythonCommands);
     mUsingObstacle = true;
+    return runPythonString(pythonCommands);
   }
+  return false;
 }
 
-void MANTA::initGuiding(FluidModifierData *fmd)
+bool MANTA::initGuiding(FluidModifierData *fmd)
 {
   if (!mPhiGuideIn) {
     vector<string> pythonCommands;
@@ -475,23 +484,24 @@ void MANTA::initGuiding(FluidModifierData *fmd)
     string finalString = parseScript(tmpString, fmd);
     pythonCommands.push_back(finalString);
 
-    runPythonString(pythonCommands);
     mUsingGuiding = true;
+    return runPythonString(pythonCommands);
   }
+  return false;
 }
 
-void MANTA::initFractions(FluidModifierData *fmd)
+bool MANTA::initFractions(FluidModifierData *fmd)
 {
   vector<string> pythonCommands;
   string tmpString = fluid_alloc_fractions + fluid_with_fractions;
   string finalString = parseScript(tmpString, fmd);
   pythonCommands.push_back(finalString);
 
-  runPythonString(pythonCommands);
   mUsingFractions = true;
+  return runPythonString(pythonCommands);
 }
 
-void MANTA::initInVelocity(FluidModifierData *fmd)
+bool MANTA::initInVelocity(FluidModifierData *fmd)
 {
   if (!mInVelocityX) {
     vector<string> pythonCommands;
@@ -499,12 +509,13 @@ void MANTA::initInVelocity(FluidModifierData *fmd)
     string finalString = parseScript(tmpString, fmd);
     pythonCommands.push_back(finalString);
 
-    runPythonString(pythonCommands);
     mUsingInvel = true;
+    return runPythonString(pythonCommands);
   }
+  return false;
 }
 
-void MANTA::initOutflow(FluidModifierData *fmd)
+bool MANTA::initOutflow(FluidModifierData *fmd)
 {
   if (!mPhiOutIn) {
     vector<string> pythonCommands;
@@ -512,22 +523,23 @@ void MANTA::initOutflow(FluidModifierData *fmd)
     string finalString = parseScript(tmpString, fmd);
     pythonCommands.push_back(finalString);
 
-    runPythonString(pythonCommands);
     mUsingOutflow = true;
+    return runPythonString(pythonCommands);
   }
+  return false;
 }
 
-void MANTA::initSndParts(FluidModifierData *fmd)
+bool MANTA::initSndParts(FluidModifierData *fmd)
 {
   vector<string> pythonCommands;
   string tmpString = fluid_variables_particles + fluid_solver_particles;
   string finalString = parseScript(tmpString, fmd);
   pythonCommands.push_back(finalString);
 
-  runPythonString(pythonCommands);
+  return runPythonString(pythonCommands);
 }
 
-void MANTA::initLiquidSndParts(FluidModifierData *fmd)
+bool MANTA::initLiquidSndParts(FluidModifierData *fmd)
 {
   if (!mSndParticleData) {
     vector<string> pythonCommands;
@@ -537,8 +549,9 @@ void MANTA::initLiquidSndParts(FluidModifierData *fmd)
     string finalString = parseScript(tmpString, fmd);
     pythonCommands.push_back(finalString);
 
-    runPythonString(pythonCommands);
+    return runPythonString(pythonCommands);
   }
+  return false;
 }
 
 MANTA::~MANTA()

intern/mantaflow/intern/MANTA_main.h

@@ -64,21 +64,21 @@ struct MANTA {
   void step(struct FluidModifierData *fmd, int startFrame);
 
   // Grid initialization functions
-  void initHeat(struct FluidModifierData *fmd = NULL);
+  bool initHeat(struct FluidModifierData *fmd = NULL);
-  void initFire(struct FluidModifierData *fmd = NULL);
+  bool initFire(struct FluidModifierData *fmd = NULL);
-  void initColors(struct FluidModifierData *fmd = NULL);
+  bool initColors(struct FluidModifierData *fmd = NULL);
-  void initFireHigh(struct FluidModifierData *fmd = NULL);
+  bool initFireHigh(struct FluidModifierData *fmd = NULL);
-  void initColorsHigh(struct FluidModifierData *fmd = NULL);
+  bool initColorsHigh(struct FluidModifierData *fmd = NULL);
-  void initLiquid(FluidModifierData *fmd = NULL);
+  bool initLiquid(FluidModifierData *fmd = NULL);
-  void initLiquidMesh(FluidModifierData *fmd = NULL);
+  bool initLiquidMesh(FluidModifierData *fmd = NULL);
-  void initObstacle(FluidModifierData *fmd = NULL);
+  bool initObstacle(FluidModifierData *fmd = NULL);
-  void initCurvature(FluidModifierData *fmd = NULL);
+  bool initCurvature(FluidModifierData *fmd = NULL);
-  void initGuiding(FluidModifierData *fmd = NULL);
+  bool initGuiding(FluidModifierData *fmd = NULL);
-  void initFractions(FluidModifierData *fmd = NULL);
+  bool initFractions(FluidModifierData *fmd = NULL);
-  void initInVelocity(FluidModifierData *fmd = NULL);
+  bool initInVelocity(FluidModifierData *fmd = NULL);
-  void initOutflow(FluidModifierData *fmd = NULL);
+  bool initOutflow(FluidModifierData *fmd = NULL);
-  void initSndParts(FluidModifierData *fmd = NULL);
+  bool initSndParts(FluidModifierData *fmd = NULL);
-  void initLiquidSndParts(FluidModifierData *fmd = NULL);
+  bool initLiquidSndParts(FluidModifierData *fmd = NULL);
 
   // Pointer transfer: Mantaflow -> Blender
   void updatePointers(FluidModifierData *fmd);
@@ -874,12 +874,12 @@ struct MANTA {
   vector<pVel> *mSndParticleVelocity;
   vector<float> *mSndParticleLife;
 
-  void initializeRNAMap(struct FluidModifierData *fmd = NULL);
+  void initializeRNAMap(struct FluidModifierData *doRnaRefresh = NULL);
-  void initDomain(struct FluidModifierData *fmd = NULL);
+  bool initDomain(struct FluidModifierData *doRnaRefresh = NULL);
-  void initNoise(struct FluidModifierData *fmd = NULL);
+  bool initNoise(struct FluidModifierData *doRnaRefresh = NULL);
-  void initMesh(struct FluidModifierData *fmd = NULL);
+  bool initMesh(struct FluidModifierData *doRnaRefresh = NULL);
-  void initSmoke(struct FluidModifierData *fmd = NULL);
+  bool initSmoke(struct FluidModifierData *doRnaRefresh = NULL);
-  void initSmokeNoise(struct FluidModifierData *fmd = NULL);
+  bool initSmokeNoise(struct FluidModifierData *doRnaRefresh = NULL);
   void initializeMantaflow();
   void terminateMantaflow();
   bool runPythonString(vector<string> commands);

intern/mantaflow/intern/manta_fluid_API.cpp

@@ -37,33 +37,29 @@ void manta_free(MANTA *fluid)
   fluid = nullptr;
 }
 
-void manta_ensure_obstacle(MANTA *fluid, struct FluidModifierData *fmd)
+int manta_ensure_obstacle(MANTA *fluid, struct FluidModifierData *fmd)
 {
-  if (!fluid)
+  if (!fluid || !fmd)
-    return;
+    return 0;
-  fluid->initObstacle(fmd);
+  return fluid->initObstacle(fmd);
-  fluid->updatePointers(fmd);
 }
-void manta_ensure_guiding(MANTA *fluid, struct FluidModifierData *fmd)
+int manta_ensure_guiding(MANTA *fluid, struct FluidModifierData *fmd)
 {
-  if (!fluid)
+  if (!fluid || !fmd)
-    return;
+    return 0;
-  fluid->initGuiding(fmd);
+  return fluid->initGuiding(fmd);
-  fluid->updatePointers(fmd);
 }
-void manta_ensure_invelocity(MANTA *fluid, struct FluidModifierData *fmd)
+int manta_ensure_invelocity(MANTA *fluid, struct FluidModifierData *fmd)
 {
-  if (!fluid)
+  if (!fluid || !fmd)
-    return;
+    return 0;
-  fluid->initInVelocity(fmd);
+  return fluid->initInVelocity(fmd);
-  fluid->updatePointers(fmd);
 }
-void manta_ensure_outflow(MANTA *fluid, struct FluidModifierData *fmd)
+int manta_ensure_outflow(MANTA *fluid, struct FluidModifierData *fmd)
 {
-  if (!fluid)
+  if (!fluid || !fmd)
-    return;
+    return 0;
-  fluid->initOutflow(fmd);
+  return fluid->initOutflow(fmd);
-  fluid->updatePointers(fmd);
 }
 
 int manta_write_config(MANTA *fluid, FluidModifierData *fmd, int framenr)
@@ -448,34 +444,35 @@ void manta_noise_get_rgba_fixed_color(MANTA *smoke, float color[3], float *data,
   get_rgba_fixed_color(color, smoke->getTotalCellsHigh(), data, sequential);
 }
 
-void manta_smoke_ensure_heat(MANTA *smoke, struct FluidModifierData *fmd)
+int manta_smoke_ensure_heat(MANTA *smoke, struct FluidModifierData *fmd)
 {
-  if (smoke) {
+  if (!smoke || !fmd)
-    smoke->initHeat(fmd);
+    return 0;
-    smoke->updatePointers(fmd);
+  return smoke->initHeat(fmd);
-  }
 }
 
-void manta_smoke_ensure_fire(MANTA *smoke, struct FluidModifierData *fmd)
+int manta_smoke_ensure_fire(MANTA *smoke, struct FluidModifierData *fmd)
 {
-  if (smoke) {
+  if (!smoke || !fmd)
-    smoke->initFire(fmd);
+    return 0;
-    if (smoke->usingNoise()) {
+
-      smoke->initFireHigh(fmd);
+  int result = smoke->initFire(fmd);
-    }
+  if (smoke->usingNoise()) {
-    smoke->updatePointers(fmd);
+    result &= smoke->initFireHigh(fmd);
   }
+  return result;
 }
 
-void manta_smoke_ensure_colors(MANTA *smoke, struct FluidModifierData *fmd)
+int manta_smoke_ensure_colors(MANTA *smoke, struct FluidModifierData *fmd)
 {
-  if (smoke) {
+  if (!smoke || !fmd)
-    smoke->initColors(fmd);
+    return 0;
-    if (smoke->usingNoise()) {
+
-      smoke->initColorsHigh(fmd);
+  int result = smoke->initColors(fmd);
-    }
+  if (smoke->usingNoise()) {
-    smoke->updatePointers(fmd);
+    result &= smoke->initColorsHigh(fmd);
   }
+  return result;
 }
 
 /* Smoke accessors */
@@ -652,12 +649,11 @@ void manta_liquid_export_script(MANTA *liquid, FluidModifierData *fmd)
   liquid->exportLiquidScript(fmd);
 }
 
-void manta_liquid_ensure_sndparts(MANTA *liquid, struct FluidModifierData *fmd)
+int manta_liquid_ensure_sndparts(MANTA *liquid, struct FluidModifierData *fmd)
 {
-  if (liquid) {
+  if (!liquid || !fmd)
-    liquid->initLiquidSndParts(fmd);
+    return 0;
-    liquid->updatePointers(fmd);
+  return liquid->initLiquidSndParts(fmd);
-  }
 }
 
 /* Liquid accessors */