[Bf-blender-cvs] [b75c38ee836] fluid-mantaflow: Mantaflow: Fixed more issues raised in part 11 of the review (D3861)

Sebastián Barschkis noreply at git.blender.org
Wed Dec 11 17:41:45 CET 2019


Commit: b75c38ee8369fc7686cc88575b513c231f8bde2b
Author: Sebastián Barschkis
Date:   Wed Dec 11 17:41:38 2019 +0100
Branches: fluid-mantaflow
https://developer.blender.org/rBb75c38ee8369fc7686cc88575b513c231f8bde2b

Mantaflow: Fixed more issues raised in part 11 of the review (D3861)

===================================================================

M	source/blender/blenkernel/intern/manta.c
M	source/blender/blenloader/intern/readfile.c
M	source/blender/blenloader/intern/versioning_legacy.c
M	source/blender/blenloader/intern/writefile.c
M	source/blender/makesdna/DNA_manta_types.h
M	source/blender/makesdna/DNA_modifier_types.h
M	source/blender/makesdna/DNA_particle_types.h
M	source/blender/makesrna/intern/rna_manta.c
M	source/blender/makesrna/intern/rna_modifier.c
M	source/blender/modifiers/intern/MOD_manta.c

===================================================================

diff --git a/source/blender/blenkernel/intern/manta.c b/source/blender/blenkernel/intern/manta.c
index b1fa55c3eba..93ccec01e83 100644
--- a/source/blender/blenkernel/intern/manta.c
+++ b/source/blender/blenkernel/intern/manta.c
@@ -552,7 +552,7 @@ static bool mantaModifier_init(
     return true;
   }
   else if (mmd->type & MOD_MANTA_TYPE_EFFEC) {
-    if (!mmd->effec) {
+    if (!mmd->effector) {
       mantaModifier_createType(mmd);
     }
     mmd->time = scene_framenr;
@@ -617,58 +617,60 @@ static void mantaModifier_freeFlow(MantaModifierData *mmd)
 
 static void mantaModifier_freeEffector(MantaModifierData *mmd)
 {
-  if (mmd->effec) {
-    if (mmd->effec->mesh) {
-      BKE_id_free(NULL, mmd->effec->mesh);
+  if (mmd->effector) {
+    if (mmd->effector->mesh) {
+      BKE_id_free(NULL, mmd->effector->mesh);
     }
-    mmd->effec->mesh = NULL;
+    mmd->effector->mesh = NULL;
 
-    if (mmd->effec->verts_old) {
-      MEM_freeN(mmd->effec->verts_old);
+    if (mmd->effector->verts_old) {
+      MEM_freeN(mmd->effector->verts_old);
     }
-    mmd->effec->verts_old = NULL;
-    mmd->effec->numverts = 0;
+    mmd->effector->verts_old = NULL;
+    mmd->effector->numverts = 0;
 
-    MEM_freeN(mmd->effec);
-    mmd->effec = NULL;
+    MEM_freeN(mmd->effector);
+    mmd->effector = NULL;
   }
 }
 
 static void mantaModifier_reset_ex(struct MantaModifierData *mmd, bool need_lock)
 {
-  if (mmd) {
-    if (mmd->domain) {
-      if (mmd->domain->fluid) {
-        if (need_lock) {
-          BLI_rw_mutex_lock(mmd->domain->fluid_mutex, THREAD_LOCK_WRITE);
-        }
-
-        manta_free(mmd->domain->fluid);
-        mmd->domain->fluid = NULL;
+  if (!mmd) {
+    return;
+  }
 
-        if (need_lock) {
-          BLI_rw_mutex_unlock(mmd->domain->fluid_mutex);
-        }
+  if (mmd->domain) {
+    if (mmd->domain->fluid) {
+      if (need_lock) {
+        BLI_rw_mutex_lock(mmd->domain->fluid_mutex, THREAD_LOCK_WRITE);
       }
 
-      mmd->time = -1;
-      mmd->domain->total_cells = 0;
-      mmd->domain->active_fields = 0;
-    }
-    else if (mmd->flow) {
-      if (mmd->flow->verts_old) {
-        MEM_freeN(mmd->flow->verts_old);
+      manta_free(mmd->domain->fluid);
+      mmd->domain->fluid = NULL;
+
+      if (need_lock) {
+        BLI_rw_mutex_unlock(mmd->domain->fluid_mutex);
       }
-      mmd->flow->verts_old = NULL;
-      mmd->flow->numverts = 0;
     }
-    else if (mmd->effec) {
-      if (mmd->effec->verts_old) {
-        MEM_freeN(mmd->effec->verts_old);
-      }
-      mmd->effec->verts_old = NULL;
-      mmd->effec->numverts = 0;
+
+    mmd->time = -1;
+    mmd->domain->total_cells = 0;
+    mmd->domain->active_fields = 0;
+  }
+  else if (mmd->flow) {
+    if (mmd->flow->verts_old) {
+      MEM_freeN(mmd->flow->verts_old);
+    }
+    mmd->flow->verts_old = NULL;
+    mmd->flow->numverts = 0;
+  }
+  else if (mmd->effector) {
+    if (mmd->effector->verts_old) {
+      MEM_freeN(mmd->effector->verts_old);
     }
+    mmd->effector->verts_old = NULL;
+    mmd->effector->numverts = 0;
   }
 }
 
@@ -679,11 +681,13 @@ void mantaModifier_reset(struct MantaModifierData *mmd)
 
 void mantaModifier_free(MantaModifierData *mmd)
 {
-  if (mmd) {
-    mantaModifier_freeDomain(mmd);
-    mantaModifier_freeFlow(mmd);
-    mantaModifier_freeEffector(mmd);
+  if (!mmd) {
+    return;
   }
+
+  mantaModifier_freeDomain(mmd);
+  mantaModifier_freeFlow(mmd);
+  mantaModifier_freeEffector(mmd);
 }
 
 void mantaModifier_createType(struct MantaModifierData *mmd)
@@ -703,9 +707,9 @@ void mantaModifier_createType(struct MantaModifierData *mmd)
     mmd->domain->effector_weights = BKE_effector_add_weights(NULL);
     mmd->domain->fluid = NULL;
     mmd->domain->fluid_mutex = BLI_rw_mutex_alloc();
-    mmd->domain->eff_group = NULL;
+    mmd->domain->force_group = NULL;
     mmd->domain->fluid_group = NULL;
-    mmd->domain->coll_group = NULL;
+    mmd->domain->effector_group = NULL;
 
     /* adaptive domain options */
     mmd->domain->adapt_margin = 4;
@@ -910,23 +914,23 @@ void mantaModifier_createType(struct MantaModifierData *mmd)
     mmd->flow->flags = FLUID_FLOW_ABSOLUTE | FLUID_FLOW_USE_PART_SIZE | FLUID_FLOW_USE_INFLOW;
   }
   else if (mmd->type & MOD_MANTA_TYPE_EFFEC) {
-    if (mmd->effec) {
+    if (mmd->effector) {
       mantaModifier_freeEffector(mmd);
     }
 
     /* effector object data */
-    mmd->effec = MEM_callocN(sizeof(MantaCollSettings), "MantaColl");
-    mmd->effec->mmd = mmd;
-    mmd->effec->mesh = NULL;
-    mmd->effec->verts_old = NULL;
-    mmd->effec->numverts = 0;
-    mmd->effec->surface_distance = 0.0f;
-    mmd->effec->type = FLUID_EFFECTOR_TYPE_COLLISION;
-    mmd->effec->flags = 0;
+    mmd->effector = MEM_callocN(sizeof(MantaEffectorSettings), "MantaEffector");
+    mmd->effector->mmd = mmd;
+    mmd->effector->mesh = NULL;
+    mmd->effector->verts_old = NULL;
+    mmd->effector->numverts = 0;
+    mmd->effector->surface_distance = 0.0f;
+    mmd->effector->type = FLUID_EFFECTOR_TYPE_COLLISION;
+    mmd->effector->flags = 0;
 
     /* guiding options */
-    mmd->effec->guiding_mode = FLUID_EFFECTOR_GUIDING_MAXIMUM;
-    mmd->effec->vel_multi = 1.0f;
+    mmd->effector->guiding_mode = FLUID_EFFECTOR_GUIDING_MAXIMUM;
+    mmd->effector->vel_multi = 1.0f;
   }
 }
 
@@ -945,8 +949,8 @@ void mantaModifier_copy(const struct MantaModifierData *mmd,
 
     /* domain object data */
     tmds->fluid_group = mds->fluid_group;
-    tmds->eff_group = mds->eff_group;
-    tmds->coll_group = mds->coll_group;
+    tmds->force_group = mds->force_group;
+    tmds->effector_group = mds->effector_group;
     if (tmds->effector_weights) {
       MEM_freeN(tmds->effector_weights);
     }
@@ -1144,16 +1148,16 @@ void mantaModifier_copy(const struct MantaModifierData *mmd,
     tmfs->texture_type = mfs->texture_type;
     tmfs->flags = mfs->flags;
   }
-  else if (tmmd->effec) {
-    MantaCollSettings *tmcs = tmmd->effec;
-    MantaCollSettings *mcs = mmd->effec;
+  else if (tmmd->effector) {
+    MantaEffectorSettings *tmes = tmmd->effector;
+    MantaEffectorSettings *mes = mmd->effector;
 
-    tmcs->surface_distance = mcs->surface_distance;
-    tmcs->type = mcs->type;
+    tmes->surface_distance = mes->surface_distance;
+    tmes->type = mes->type;
 
     /* guiding options */
-    tmcs->guiding_mode = mcs->guiding_mode;
-    tmcs->vel_multi = mcs->vel_multi;
+    tmes->guiding_mode = mes->guiding_mode;
+    tmes->vel_multi = mes->vel_multi;
   }
 }
 
@@ -1198,7 +1202,7 @@ static int get_light(ViewLayer *view_layer, float *light)
 
 typedef struct ObstaclesFromDMData {
   MantaDomainSettings *mds;
-  MantaCollSettings *mcs;
+  MantaEffectorSettings *mes;
   const MVert *mvert;
   const MLoop *mloop;
   const MLoopTri *looptri;
@@ -1264,10 +1268,10 @@ static void obstacles_from_mesh_task_cb(void *__restrict userdata,
                            weights);
 
           /* Guiding has additional velocity multiplier */
-          if (data->mcs->type == FLUID_EFFECTOR_TYPE_GUIDE) {
-            mul_v3_fl(hit_vel, data->mcs->vel_multi);
+          if (data->mes->type == FLUID_EFFECTOR_TYPE_GUIDE) {
+            mul_v3_fl(hit_vel, data->mes->vel_multi);
 
-            switch (data->mcs->guiding_mode) {
+            switch (data->mes->guiding_mode) {
               case FLUID_EFFECTOR_GUIDING_AVERAGED:
                 data->velocityX[index] = (data->velocityX[index] + hit_vel[0]) * 0.5f;
                 data->velocityY[index] = (data->velocityY[index] + hit_vel[1]) * 0.5f;
@@ -1293,14 +1297,14 @@ static void obstacles_from_mesh_task_cb(void *__restrict userdata,
           }
           else {
             /* Apply (i.e. add) effector object velocity */
-            data->velocityX[index] += (data->mcs->type == FLUID_EFFECTOR_TYPE_GUIDE) ?
-                                          hit_vel[0] * data->mcs->vel_multi :
+            data->velocityX[index] += (data->mes->type == FLUID_EFFECTOR_TYPE_GUIDE) ?
+                                          hit_vel[0] * data->mes->vel_multi :
                                           hit_vel[0];
-            data->velocityY[index] += (data->mcs->type == FLUID_EFFECTOR_TYPE_GUIDE) ?
-                                          hit_vel[1] * data->mcs->vel_multi :
+            data->velocityY[index] += (data->mes->type == FLUID_EFFECTOR_TYPE_GUIDE) ?
+                                          hit_vel[1] * data->mes->vel_multi :
                                           hit_vel[1];
-            data->velocityZ[index] += (data->mcs->type == FLUID_EFFECTOR_TYPE_GUIDE) ?
-                                          hit_vel[2] * data->mcs->vel_multi :
+            data->velocityZ[index] += (data->mes->type == FLUID_EFFECTOR_TYPE_GUIDE) ?
+                                          hit_vel[2] * data->mes->vel_multi :
                                           hit_vel[2];
 #if 0
             /* Debugging: Print object velocities. */
@@ -1316,8 +1320,8 @@ static void obstacles_from_mesh_task_cb(void *__restrict userdata,
                               data->distances_map,
                               data->tree,
                               ray_start,
-                              data->mcs->surface_distance,
-                              data->mcs->flags & FLUID_FLOW_USE_PLANE_INIT);
+                              data->mes->surface_distance,
+                              data->mes->flags & FLUID_FLOW_USE_PLANE_INIT);
 
         /* Ensure that num objects are also counted inside object. But dont count twice (see object
          * inc for nearest point) */
@@ -1331,7 +1335,7 @@ static void obstacles_from_mesh_task_cb(void *__restrict userdata,
 
 static void obstacles_from_mesh(Object *coll_ob,
                                 MantaDomainSettings *mds,
-                                MantaCollSettings *mcs,
+                                MantaEffectorSettings *mes,
                                 float *distances_map,
                                 float *velocityX,
                                 float *velocityY,
@@ -1339,7 +1343,7 @@ static void obstacles_from_mesh(Object *coll_ob,
                                 int *num_objects,
                                 float dt)
 {
-  if (!mc

@@ Diff output truncated at 10240 characters. @@



More information about the Bf-blender-cvs mailing list