Merge branch 'blender-v2.82-release'
authorPhilipp Oeser <info@graphics-engineer.com>
Wed, 29 Jan 2020 19:38:12 +0000 (20:38 +0100)
committerPhilipp Oeser <info@graphics-engineer.com>
Wed, 29 Jan 2020 19:38:12 +0000 (20:38 +0100)
.gitignore
intern/mantaflow/intern/strings/liquid_script.h
intern/mantaflow/intern/strings/smoke_script.h
release/scripts/startup/bl_operators/object_quick_effects.py
release/scripts/startup/bl_ui/properties_physics_fluid.py
source/blender/blenkernel/intern/fluid.c
source/blender/editors/physics/physics_fluid.c
source/blender/makesrna/intern/rna_fluid.c

index a62802c42fb92d22ae0a0665ecb8989413d1fdb1..b1f351255b7c4a3989a89bf38a2d8ac3fd7293c5 100644 (file)
@@ -42,4 +42,7 @@ Desktop.ini
 /build_files/build_environment/downloads
 
 # in-source buildbot signing configuration
-/build_files/buildbot/codesign/config_server.py
\ No newline at end of file
+/build_files/buildbot/codesign/config_server.py
+
+# smoke simulation noise tile (generated)
+waveletNoiseTile.bin
index 6cbbf06f0d292259d42d05f0b8f3ee585cb2474d..bb42b781c199847291c9cf2aa70f80163a683449 100644 (file)
@@ -175,9 +175,6 @@ def liquid_adaptive_step_$ID$(framenr):\n\
         extrapolateLsSimple(phi=phiObs_s$ID$, distance=int(res_s$ID$/2), inside=True)\n\
         extrapolateLsSimple(phi=phiObs_s$ID$, distance=int(res_s$ID$/2), inside=False)\n\
     \n\
-    mantaMsg('Initializing fluid levelset')\n\
-    extrapolateLsSimple(phi=phiIn_s$ID$, distance=int(res_s$ID$/2), inside=True)\n\
-    extrapolateLsSimple(phi=phiIn_s$ID$, distance=int(res_s$ID$/2), inside=False)\n\
     phi_s$ID$.join(phiIn_s$ID$)\n\
     \n\
     if using_obstacle_s$ID$:\n\
index 9277923fa7a741fda09da7bea73218b9b1965bb6..ad966503fd1801cf870fcde82c052eb060fe8179 100644 (file)
@@ -288,10 +288,6 @@ def smoke_adaptive_step_$ID$(framenr):\n\
         extrapolateLsSimple(phi=phiObs_s$ID$, distance=int(res_s$ID$/2), inside=True)\n\
         extrapolateLsSimple(phi=phiObs_s$ID$, distance=int(res_s$ID$/2), inside=False)\n\
     \n\
-    mantaMsg('Initializing fluid levelset')\n\
-    extrapolateLsSimple(phi=phiIn_s$ID$, distance=int(res_s$ID$/2), inside=True)\n\
-    extrapolateLsSimple(phi=phiIn_s$ID$, distance=int(res_s$ID$/2), inside=False)\n\
-    \n\
     if using_outflow_s$ID$:\n\
         phiOut_s$ID$.join(phiOutIn_s$ID$)\n\
     \n\
index 009ae53fa80f6271e90548fec6056411f5e7af18..71153ba8b74b7e8b75a3bdc051f3d214900487ee 100644 (file)
@@ -466,6 +466,13 @@ class QuickLiquid(Operator):
             self.report({'ERROR'}, "Select at least one mesh object")
             return {'CANCELLED'}
 
+        # set shading type to wireframe so that liquid particles are visible
+        for area in bpy.context.screen.areas:
+            if area.type == 'VIEW_3D':
+                for space in area.spaces:
+                    if space.type == 'VIEW_3D':
+                        space.shading.type = 'WIREFRAME'
+
         for obj in mesh_objects:
             fake_context["object"] = obj
             # make each selected object a liquid flow
index c1b8ae1a36a57da05454a1c2509352274fb7ed49..28c9895f53bb5528dce885d3b260e6e436c2135e 100644 (file)
@@ -105,6 +105,16 @@ class PhysicButtonsPanel:
         if (flow.flow_behavior == 'OUTFLOW'):
             return True
 
+    @staticmethod
+    def poll_fluid_flow_liquid(context):
+        if not PhysicButtonsPanel.poll_fluid_flow(context):
+            return False
+
+        md = context.fluid
+        flow = md.flow_settings
+        if (flow.flow_type == 'LIQUID'):
+            return True
+
 
 class PHYSICS_PT_fluid(PhysicButtonsPanel, Panel):
     bl_label = "Fluid"
@@ -323,9 +333,9 @@ class PHYSICS_PT_smoke(PhysicButtonsPanel, Panel):
         flow = layout.grid_flow(row_major=True, columns=0, even_columns=True, even_rows=False, align=False)
         flow.enabled = not is_baking_any and not has_baked_data
 
-        col = flow.column()
-        col.prop(domain, "alpha")
-        col.prop(domain, "beta", text="Temperature Diff.")
+        col = flow.column(align=True)
+        col.prop(domain, "alpha", text="Buoyancy Density")
+        col.prop(domain, "beta", text="Heat")
         col = flow.column()
         col.prop(domain, "vorticity")
 
@@ -399,14 +409,12 @@ class PHYSICS_PT_fire(PhysicButtonsPanel, Panel):
 
         col = flow.column()
         col.prop(domain, "burning_rate", text="Reaction Speed")
-        col = flow.column()
+        col = flow.column(align=True)
         col.prop(domain, "flame_smoke", text="Flame Smoke")
-        col = flow.column()
-        col.prop(domain, "flame_vorticity", text="Flame Vorticity")
-        col = flow.column()
-        col.prop(domain, "flame_ignition", text="Temperature Ignition")
-        col = flow.column()
-        col.prop(domain, "flame_max_temp", text="Maximum Temperature")
+        col.prop(domain, "flame_vorticity", text="Vorticity")
+        col = flow.column(align=True)
+        col.prop(domain, "flame_max_temp", text="Temperature Maximum")
+        col.prop(domain, "flame_ignition", text="Minimum")
         col = flow.column()
         col.prop(domain, "flame_smoke_color", text="Flame Color")
 
@@ -495,10 +503,10 @@ class PHYSICS_PT_flow_source(PhysicButtonsPanel, Panel):
         col = grid.column()
         if flow.flow_source == 'MESH':
             col.prop(flow, "use_plane_init", text="Is Planar")
-            col.prop(flow, "surface_distance", text="Surface Thickness")
+            col.prop(flow, "surface_distance", text="Surface Emission")
             if flow.flow_type in {'SMOKE', 'BOTH', 'FIRE'}:
                 col = grid.column()
-                col.prop(flow, "volume_density", text="Volume Density")
+                col.prop(flow, "volume_density", text="Volume Emission")
 
         if flow.flow_source == 'PARTICLES':
             col.prop(flow, "use_particle_size", text="Set Size")
@@ -562,6 +570,9 @@ class PHYSICS_PT_flow_texture(PhysicButtonsPanel, Panel):
         if PhysicButtonsPanel.poll_fluid_flow_outflow(context):
             return False
 
+        if PhysicButtonsPanel.poll_fluid_flow_liquid(context):
+            return False
+
         return (context.engine in cls.COMPAT_ENGINES)
 
     def draw_header(self, context):
index 51e6039f86fe3e252cd7468c770dfd599be86f23..12c65027e25dcbf53a0c2098ae63423a735eab2a 100644 (file)
@@ -630,10 +630,10 @@ static void obstacles_from_mesh_task_cb(void *__restrict userdata,
   ObstaclesFromDMData *data = userdata;
   FluidDomainSettings *mds = data->mds;
 
-  /* slightly rounded-up sqrt(3 * (0.5)^2) == max. distance of cell boundary along the diagonal */
-  const float surface_distance = 2.0f;  // 0.867f;
-  /* Note: Use larger surface distance to cover larger area with obvel. Manta will use these obvels
-   * and extrapolate them (inside and outside obstacle) */
+  /* Distance between two opposing vertices in a unit cube.
+   * I.e. the unit cube diagonal or sqrt(3).
+   * This value is our nearest neighbour search distance. */
+  const float surface_distance = 1.732;
 
   for (int x = mds->res_min[0]; x < mds->res_max[0]; x++) {
     for (int y = mds->res_min[1]; y < mds->res_max[1]; y++) {
@@ -647,7 +647,7 @@ static void obstacles_from_mesh_task_cb(void *__restrict userdata,
                         surface_distance; /* find_nearest uses squared distance */
       bool has_inc_obj = false;
 
-      /* find the nearest point on the mesh */
+      /* Find the nearest point on the mesh. */
       if (BLI_bvhtree_find_nearest(
               data->tree->tree, ray_start, &nearest, data->tree->nearest_callback, data->tree) !=
           -1) {
@@ -1019,10 +1019,8 @@ static void update_obstacles(Depsgraph *depsgraph,
 
 typedef struct EmissionMap {
   float *influence;
-  float *influence_high;
   float *velocity;
   float *distances;
-  float *distances_high;
   int min[3], max[3], res[3];
   int hmin[3], hmax[3], hres[3];
   int total_cells, valid;
@@ -1079,7 +1077,7 @@ static void clamp_bounds_in_domain(FluidDomainSettings *mds,
   }
 }
 
-static void em_allocateData(EmissionMap *em, bool use_velocity, int hires_mul)
+static void em_allocateData(EmissionMap *em, bool use_velocity)
 {
   int i, res[3];
 
@@ -1101,23 +1099,6 @@ static void em_allocateData(EmissionMap *em, bool use_velocity, int hires_mul)
   /* Initialize to infinity. */
   memset(em->distances, 0x7f7f7f7f, sizeof(float) * em->total_cells);
 
-  /* Allocate high resolution map if required. */
-  if (hires_mul > 1) {
-    int total_cells_high = em->total_cells * (hires_mul * hires_mul * hires_mul);
-
-    for (i = 0; i < 3; i++) {
-      em->hmin[i] = em->min[i] * hires_mul;
-      em->hmax[i] = em->max[i] * hires_mul;
-      em->hres[i] = em->res[i] * hires_mul;
-    }
-
-    em->influence_high = MEM_calloc_arrayN(
-        total_cells_high, sizeof(float), "manta_flow_influence_high");
-    em->distances_high = MEM_malloc_arrayN(
-        total_cells_high, sizeof(float), "manta_flow_distances_high");
-    /* Initialize to infinity. */
-    memset(em->distances_high, 0x7f7f7f7f, sizeof(float) * total_cells_high);
-  }
   em->valid = true;
 }
 
@@ -1126,22 +1107,15 @@ static void em_freeData(EmissionMap *em)
   if (em->influence) {
     MEM_freeN(em->influence);
   }
-  if (em->influence_high) {
-    MEM_freeN(em->influence_high);
-  }
   if (em->velocity) {
     MEM_freeN(em->velocity);
   }
   if (em->distances) {
     MEM_freeN(em->distances);
   }
-  if (em->distances_high) {
-    MEM_freeN(em->distances_high);
-  }
 }
 
-static void em_combineMaps(
-    EmissionMap *output, EmissionMap *em2, int hires_multiplier, int additive, float sample_size)
+static void em_combineMaps(EmissionMap *output, EmissionMap *em2, int additive, float sample_size)
 {
   int i, x, y, z;
 
@@ -1161,7 +1135,7 @@ static void em_combineMaps(
     }
   }
   /* allocate output map */
-  em_allocateData(output, (em1.velocity || em2->velocity), hires_multiplier);
+  em_allocateData(output, (em1.velocity || em2->velocity));
 
   /* base resolution inputs */
   for (x = output->min[0]; x < output->max[0]; x++) {
@@ -1217,48 +1191,6 @@ static void em_combineMaps(
     }
   }
 
-  /* initialize high resolution input if available */
-  if (output->influence_high) {
-    for (x = output->hmin[0]; x < output->hmax[0]; x++) {
-      for (y = output->hmin[1]; y < output->hmax[1]; y++) {
-        for (z = output->hmin[2]; z < output->hmax[2]; z++) {
-          int index_out = manta_get_index(x - output->hmin[0],
-                                          output->hres[0],
-                                          y - output->hmin[1],
-                                          output->hres[1],
-                                          z - output->hmin[2]);
-
-          /* initialize with first input if in range */
-          if (x >= em1.hmin[0] && x < em1.hmax[0] && y >= em1.hmin[1] && y < em1.hmax[1] &&
-              z >= em1.hmin[2] && z < em1.hmax[2]) {
-            int index_in = manta_get_index(
-                x - em1.hmin[0], em1.hres[0], y - em1.hmin[1], em1.hres[1], z - em1.hmin[2]);
-            /* values */
-            output->influence_high[index_out] = em1.influence_high[index_in];
-          }
-
-          /* apply second input if in range */
-          if (x >= em2->hmin[0] && x < em2->hmax[0] && y >= em2->hmin[1] && y < em2->hmax[1] &&
-              z >= em2->hmin[2] && z < em2->hmax[2]) {
-            int index_in = manta_get_index(
-                x - em2->hmin[0], em2->hres[0], y - em2->hmin[1], em2->hres[1], z - em2->hmin[2]);
-
-            /* values */
-            if (additive) {
-              output->influence_high[index_out] += em2->distances_high[index_in] * sample_size;
-            }
-            else {
-              output->distances_high[index_out] = MAX2(em2->distances_high[index_in],
-                                                       output->distances_high[index_out]);
-            }
-            output->distances_high[index_out] = MIN2(em2->distances_high[index_in],
-                                                     output->distances_high[index_out]);
-          }
-        }  // high res loop
-      }
-    }
-  }
-
   /* free original data */
   em_freeData(&em1);
 }
@@ -1266,17 +1198,13 @@ static void em_combineMaps(
 typedef struct EmitFromParticlesData {
   FluidFlowSettings *mfs;
   KDTree_3d *tree;
-  int hires_multiplier;
 
   EmissionMap *em;
   float *particle_vel;
-  float hr;
-
   int *min, *max, *res;
 
   float solid;
   float smooth;
-  float hr_smooth;
 } EmitFromParticlesData;
 
 static void emit_from_particles_task_cb(void *__restrict userdata,
@@ -1286,62 +1214,26 @@ static void emit_from_particles_task_cb(void *__restrict userdata,
   EmitFromParticlesData *data = userdata;
   FluidFlowSettings *mfs = data->mfs;
   EmissionMap *em = data->em;
-  const int hires_multiplier = data->hires_multiplier;
 
   for (int x = data->min[0]; x < data->max[0]; x++) {
     for (int y = data->min[1]; y < data->max[1]; y++) {
-      /* Take low res samples where possible. */
-      if (hires_multiplier <= 1 ||
-          !(x % hires_multiplier || y % hires_multiplier || z % hires_multiplier)) {
-        /* Get low res space coordinates. */
-        float inv_multiplier = 1.0f / hires_multiplier;
-        const int lx = x * inv_multiplier;
-        const int ly = y * inv_multiplier;
-        const int lz = z * inv_multiplier;
-
-        const int index = manta_get_index(
-            lx - em->min[0], em->res[0], ly - em->min[1], em->res[1], lz - em->min[2]);
-        const float ray_start[3] = {((float)lx) + 0.5f, ((float)ly) + 0.5f, ((float)lz) + 0.5f};
-
-        /* Find particle distance from the kdtree. */
-        KDTreeNearest_3d nearest;
-        const float range = data->solid + data->smooth;
-        BLI_kdtree_3d_find_nearest(data->tree, ray_start, &nearest);
-
-        if (nearest.dist < range) {
-          em->influence[index] = (nearest.dist < data->solid) ?
-                                     1.0f :
-                                     (1.0f - (nearest.dist - data->solid) / data->smooth);
-          /* Uses particle velocity as initial velocity for smoke. */
-          if (mfs->flags & FLUID_FLOW_INITVELOCITY &&
-              (mfs->psys->part->phystype != PART_PHYS_NO)) {
-            madd_v3_v3fl(
-                &em->velocity[index * 3], &data->particle_vel[nearest.index * 3], mfs->vel_multi);
-          }
-        }
-      }
-
-      /* Take high res samples if required. */
-      if (hires_multiplier > 1) {
-        /* get low res space coordinates */
-        const float lx = ((float)x) * data->hr;
-        const float ly = ((float)y) * data->hr;
-        const float lz = ((float)z) * data->hr;
-
-        const int index = manta_get_index(
-            x - data->min[0], data->res[0], y - data->min[1], data->res[1], z - data->min[2]);
-        const float ray_start[3] = {
-            lx + 0.5f * data->hr, ly + 0.5f * data->hr, lz + 0.5f * data->hr};
-
-        /* Find particle distance from the kdtree. */
-        KDTreeNearest_3d nearest;
-        const float range = data->solid + data->hr_smooth;
-        BLI_kdtree_3d_find_nearest(data->tree, ray_start, &nearest);
-
-        if (nearest.dist < range) {
-          em->influence_high[index] = (nearest.dist < data->solid) ?
-                                          1.0f :
-                                          (1.0f - (nearest.dist - data->solid) / data->smooth);
+      const int index = manta_get_index(
+          x - em->min[0], em->res[0], y - em->min[1], em->res[1], z - em->min[2]);
+      const float ray_start[3] = {((float)x) + 0.5f, ((float)y) + 0.5f, ((float)z) + 0.5f};
+
+      /* Find particle distance from the kdtree. */
+      KDTreeNearest_3d nearest;
+      const float range = data->solid + data->smooth;
+      BLI_kdtree_3d_find_nearest(data->tree, ray_start, &nearest);
+
+      if (nearest.dist < range) {
+        em->influence[index] = (nearest.dist < data->solid) ?
+                                   1.0f :
+                                   (1.0f - (nearest.dist - data->solid) / data->smooth);
+        /* Uses particle velocity as initial velocity for smoke. */
+        if (mfs->flags & FLUID_FLOW_INITVELOCITY && (mfs->psys->part->phystype != PART_PHYS_NO)) {
+          madd_v3_v3fl(
+              &em->velocity[index * 3], &data->particle_vel[nearest.index * 3], mfs->vel_multi);
         }
       }
     }
@@ -1371,7 +1263,6 @@ static void emit_from_particles(Object *flow_ob,
     /* radius based flow */
     const float solid = mfs->particle_size * 0.5f;
     const float smooth = 0.5f; /* add 0.5 cells of linear falloff to reduce aliasing */
-    int hires_multiplier = 1;
     KDTree_3d *tree = NULL;
 
     sim.depsgraph = depsgraph;
@@ -1408,12 +1299,6 @@ static void emit_from_particles(Object *flow_ob,
     /* setup particle radius emission if enabled */
     if (mfs->flags & FLUID_FLOW_USE_PART_SIZE) {
       tree = BLI_kdtree_3d_new(psys->totpart + psys->totchild);
-
-      /* check need for high resolution map */
-      if ((mds->flags & FLUID_DOMAIN_USE_NOISE) && (mds->highres_sampling == SM_HRES_FULLSAMPLE)) {
-        hires_multiplier = mds->noise_scale;
-      }
-
       bounds_margin = (int)ceil(solid + smooth);
     }
 
@@ -1461,7 +1346,7 @@ static void emit_from_particles(Object *flow_ob,
 
     /* set emission map */
     clamp_bounds_in_domain(mds, em->min, em->max, NULL, NULL, bounds_margin, dt);
-    em_allocateData(em, mfs->flags & FLUID_FLOW_INITVELOCITY, hires_multiplier);
+    em_allocateData(em, mfs->flags & FLUID_FLOW_INITVELOCITY);
 
     if (!(mfs->flags & FLUID_FLOW_USE_PART_SIZE)) {
       for (p = 0; p < valid_particles; p++) {
@@ -1496,16 +1381,12 @@ static void emit_from_particles(Object *flow_ob,
     }
     else if (valid_particles > 0) {  // FLUID_FLOW_USE_PART_SIZE
       int min[3], max[3], res[3];
-      const float hr = 1.0f / ((float)hires_multiplier);
-      /* Slightly adjust high res anti-alias smoothness based on number of divisions
-       * to allow smaller details but yet not differing too much from the low res size. */
-      const float hr_smooth = smooth * powf(hr, 1.0f / 3.0f);
 
       /* setup loop bounds */
       for (int i = 0; i < 3; i++) {
-        min[i] = em->min[i] * hires_multiplier;
-        max[i] = em->max[i] * hires_multiplier;
-        res[i] = em->res[i] * hires_multiplier;
+        min[i] = em->min[i];
+        max[i] = em->max[i];
+        res[i] = em->res[i];
       }
 
       BLI_kdtree_3d_balance(tree);
@@ -1513,8 +1394,6 @@ static void emit_from_particles(Object *flow_ob,
       EmitFromParticlesData data = {
           .mfs = mfs,
           .tree = tree,
-          .hires_multiplier = hires_multiplier,
-          .hr = hr,
           .em = em,
           .particle_vel = particle_vel,
           .min = min,
@@ -1522,7 +1401,6 @@ static void emit_from_particles(Object *flow_ob,
           .res = res,
           .solid = solid,
           .smooth = smooth,
-          .hr_smooth = hr_smooth,
       };
 
       TaskParallelSettings settings;
@@ -1556,11 +1434,12 @@ static void update_mesh_distances(int index,
 {
   float min_dist = PHI_MAX;
 
-  /* Ensure that planes get initialized correctly. */
+  /* a) Planar initialization */
   if (use_plane_init) {
     BVHTreeNearest nearest = {0};
     nearest.index = -1;
-    nearest.dist_sq = surface_thickness;
+    nearest.dist_sq = surface_thickness *
+                      surface_thickness; /* find_nearest uses squared distance */
 
     if (BLI_bvhtree_find_nearest(
             tree_data->tree, ray_start, &nearest, tree_data->nearest_callback, tree_data) != -1) {
@@ -1568,12 +1447,14 @@ static void update_mesh_distances(int index,
       sub_v3_v3v3(ray, ray_start, nearest.co);
       min_dist = len_v3(ray);
       min_dist = (-1.0f) * fabsf(min_dist);
-      mesh_distances[index] = MIN2(mesh_distances[index], min_dist);
+      mesh_distances[index] = min_dist;
     }
     return;
   }
 
-  /* First pass: Ray-casts in 26 directions
+  /* b) Volumetric initialization: 1) Ray-casts around mesh object. */
+
+  /* Ray-casts in 26 directions.
    * (6 main axis + 12 quadrant diagonals (2D) + 8 octant diagonals (3D)). */
   float ray_dirs[26][3] = {
       {1.0f, 0.0f, 0.0f},   {0.0f, 1.0f, 0.0f},   {0.0f, 0.0f, 1.0f},  {-1.0f, 0.0f, 0.0f},
@@ -1585,8 +1466,9 @@ static void update_mesh_distances(int index,
       {-1.0f, 1.0f, -1.0f}, {-1.0f, -1.0f, -1.0f}};
   size_t ray_cnt = sizeof ray_dirs / sizeof ray_dirs[0];
 
-  /* Count for ray misses (no face hit) and cases where ray direction matches face normal
-   * direction. */
+  /* Count ray mesh misses (i.e. no face hit) and cases where the ray direction matches the face
+   * normal direction. From this information it can be derived whether a cell is inside or outside
+   * the mesh. */
   int miss_cnt = 0, dir_cnt = 0;
   min_dist = PHI_MAX;
 
@@ -1604,14 +1486,13 @@ static void update_mesh_distances(int index,
                          tree_data->raycast_callback,
                          tree_data);
 
-    /* Ray did not hit mesh. Current point definitely not inside mesh. Inside mesh all rays have to
-     * hit. */
+    /* Ray did not hit mesh.
+     * Current point definitely not inside mesh. Inside mesh as all rays have to hit. */
     if (hit_tree.index == -1) {
       miss_cnt++;
-      continue;
     }
 
-    /* Ray and normal are in pointing opposite directions. */
+    /* Ray and normal are pointing in opposite directions. */
     if (dot_v3v3(ray_dirs[i], hit_tree.no) <= 0) {
       dir_cnt++;
     }
@@ -1621,25 +1502,30 @@ static void update_mesh_distances(int index,
     }
   }
 
-  /* Point lies inside mesh. Use negative sign for distance value. */
+  /* Point lies inside mesh. Use negative sign for distance value.
+   * This "if statement" has 2 conditions that can be true for points outside mesh. */
   if (!(miss_cnt > 0 || dir_cnt == ray_cnt)) {
     min_dist = (-1.0f) * fabsf(min_dist);
   }
 
-  /* Update global distance array but ensure that older entries are not overridden. */
-  mesh_distances[index] = MIN2(mesh_distances[index], min_dist);
+  /* Update global distance array with distance value. */
+  mesh_distances[index] = min_dist;
+
+  /* b) Volumetric initialization: 2) Use nearest neighbor search on mesh surface. */
 
-  /* Second pass: Use nearest neighbor search on mesh surface. */
+  /* Distance between two opposing vertices in a unit cube.
+   * I.e. the unit cube diagonal or sqrt(3).
+   * This value is our nearest neighbour search distance. */
+  const float surface_distance = 1.732;
   BVHTreeNearest nearest = {0};
   nearest.index = -1;
-  nearest.dist_sq = 5;
+  nearest.dist_sq = surface_distance * surface_distance; /* find_nearest uses squared distance. */
 
   if (BLI_bvhtree_find_nearest(
           tree_data->tree, ray_start, &nearest, tree_data->nearest_callback, tree_data) != -1) {
     float ray[3] = {0};
     sub_v3_v3v3(ray, nearest.co, ray_start);
     min_dist = len_v3(ray);
-    //    CLAMP(min_dist, 0.5, min_dist);
 
     BVHTreeRayHit hit_tree = {0};
     hit_tree.index = -1;
@@ -1652,22 +1538,23 @@ static void update_mesh_distances(int index,
     /* Only proceed if casted ray hit the mesh surface. */
     if (hit_tree.index != -1) {
 
-      /* Ray and normal are in pointing same directions: Point must lie inside mesh. */
+      /* Ray and normal are pointing in the same direction: Point must lie inside mesh. */
       if (dot_v3v3(ray, hit_tree.no) > 0) {
         min_dist = (-1.0f) * fabsf(min_dist);
       }
 
-      /* Update distance value with more accurate one from this nearest neighbor search.
-       * Skip if new value would be outside and current value has inside value already. */
-      if (!(min_dist > 0 && mesh_distances[index] <= 0)) {
-        mesh_distances[index] = min_dist;
-      }
+      /* Update distance map with more accurate distance from this nearest neighbor search. */
+      mesh_distances[index] = min_dist;
     }
   }
 
+  /* Subtract optional surface thickness value and virtually increase the object size. */
   if (surface_thickness) {
     mesh_distances[index] -= surface_thickness;
   }
+
+  /* Sanity check: Ensure that distances don't explode. */
+  CLAMP(mesh_distances[index], -PHI_MAX, PHI_MAX);
 }
 
 static void sample_mesh(FluidFlowSettings *mfs,
@@ -1695,16 +1582,23 @@ static void sample_mesh(FluidFlowSettings *mfs,
   BVHTreeNearest nearest = {0};
 
   float volume_factor = 0.0f;
-  float sample_str = 0.0f;
+  float emission_strength = 0.0f;
 
   hit.index = -1;
   hit.dist = PHI_MAX;
   nearest.index = -1;
-  nearest.dist_sq = mfs->surface_distance *
-                    mfs->surface_distance; /* find_nearest uses squared distance */
 
-  /* Check volume collision */
-  if (mfs->volume_density) {
+  /* Distance between two opposing vertices in a unit cube.
+   * I.e. the unit cube diagonal or sqrt(3).
+   * This value is our nearest neighbour search distance. */
+  const float surface_distance = 1.732;
+  nearest.dist_sq = surface_distance * surface_distance; /* find_nearest uses squared distance. */
+
+  bool is_gas_flow = (mfs->type == FLUID_FLOW_TYPE_SMOKE || mfs->type == FLUID_FLOW_TYPE_FIRE ||
+                      mfs->type == FLUID_FLOW_TYPE_SMOKEFIRE);
+
+  /* Emission inside the flow object. */
+  if (is_gas_flow && mfs->volume_density) {
     if (BLI_bvhtree_ray_cast(tree_data->tree,
                              ray_start,
                              ray_dir,
@@ -1713,11 +1607,10 @@ static void sample_mesh(FluidFlowSettings *mfs,
                              tree_data->raycast_callback,
                              tree_data) != -1) {
       float dot = ray_dir[0] * hit.no[0] + ray_dir[1] * hit.no[1] + ray_dir[2] * hit.no[2];
-      /* If ray and hit face normal are facing same direction
-       * hit point is inside a closed mesh. */
+      /* If ray and hit face normal are facing same direction hit point is inside a closed mesh. */
       if (dot >= 0) {
-        /* Also cast a ray in opposite direction to make sure
-         * point is at least surrounded by two faces */
+        /* Also cast a ray in opposite direction to make sure point is at least surrounded by two
+         * faces. */
         negate_v3(ray_dir);
         hit.index = -1;
         hit.dist = PHI_MAX;
@@ -1736,48 +1629,36 @@ static void sample_mesh(FluidFlowSettings *mfs,
     }
   }
 
-  /* find the nearest point on the mesh */
+  /* Find the nearest point on the mesh. */
   if (BLI_bvhtree_find_nearest(
           tree_data->tree, ray_start, &nearest, tree_data->nearest_callback, tree_data) != -1) {
     float weights[3];
     int v1, v2, v3, f_index = nearest.index;
     float n1[3], n2[3], n3[3], hit_normal[3];
 
-    /* emit from surface based on distance */
-    if (mfs->surface_distance) {
-      sample_str = sqrtf(nearest.dist_sq) / mfs->surface_distance;
-      CLAMP(sample_str, 0.0f, 1.0f);
-      sample_str = pow(1.0f - sample_str, 0.5f);
-    }
-    else {
-      sample_str = 0.0f;
-    }
-
-    /* calculate barycentric weights for nearest point */
+    /* Calculate barycentric weights for nearest point. */
     v1 = mloop[mlooptri[f_index].tri[0]].v;
     v2 = mloop[mlooptri[f_index].tri[1]].v;
     v3 = mloop[mlooptri[f_index].tri[2]].v;
     interp_weights_tri_v3(weights, mvert[v1].co, mvert[v2].co, mvert[v3].co, nearest.co);
 
+    /* Initial velocity of flow object. */
     if (mfs->flags & FLUID_FLOW_INITVELOCITY && velocity_map) {
-      /* apply normal directional velocity */
+      /* Apply normal directional velocity. */
       if (mfs->vel_normal) {
-        /* interpolate vertex normal vectors to get nearest point normal */
+        /* Interpolate vertex normal vectors to get nearest point normal. */
         normal_short_to_float_v3(n1, mvert[v1].no);
         normal_short_to_float_v3(n2, mvert[v2].no);
         normal_short_to_float_v3(n3, mvert[v3].no);
         interp_v3_v3v3v3(hit_normal, n1, n2, n3, weights);
         normalize_v3(hit_normal);
-        /* apply normal directional and random velocity
-         * - TODO: random disabled for now since it doesn't really work well
-         *   as pressure calc smoothens it out. */
+
+        /* Apply normal directional velocity. */
         velocity_map[index * 3] += hit_normal[0] * mfs->vel_normal * 0.25f;
         velocity_map[index * 3 + 1] += hit_normal[1] * mfs->vel_normal * 0.25f;
         velocity_map[index * 3 + 2] += hit_normal[2] * mfs->vel_normal * 0.25f;
-        /* TODO: for fire emitted from mesh surface we can use
-         * Vf = Vs + (Ps/Pf - 1)*S to model gaseous expansion from solid to fuel */
       }
-      /* apply object velocity */
+      /* Apply object velocity. */
       if (has_velocity && mfs->vel_multi) {
         float hit_vel[3];
         interp_v3_v3v3v3(
@@ -1795,50 +1676,59 @@ static void sample_mesh(FluidFlowSettings *mfs,
       velocity_map[index * 3 + 2] += mfs->vel_coord[2];
     }
 
-    /* apply vertex group influence if used */
-    if (defgrp_index != -1 && dvert) {
-      float weight_mask = defvert_find_weight(&dvert[v1], defgrp_index) * weights[0] +
-                          defvert_find_weight(&dvert[v2], defgrp_index) * weights[1] +
-                          defvert_find_weight(&dvert[v3], defgrp_index) * weights[2];
-      sample_str *= weight_mask;
-    }
-
-    /* apply emission texture */
-    if ((mfs->flags & FLUID_FLOW_TEXTUREEMIT) && mfs->noise_texture) {
-      float tex_co[3] = {0};
-      TexResult texres;
+    /* Compute emission strength for smoke flow. */
+    if (is_gas_flow) {
+      /* Emission from surface is based on UI configurable distance value. */
+      if (mfs->surface_distance) {
+        emission_strength = sqrtf(nearest.dist_sq) / mfs->surface_distance;
+        CLAMP(emission_strength, 0.0f, 1.0f);
+        emission_strength = pow(1.0f - emission_strength, 0.5f);
+      }
+      else {
+        emission_strength = 0.0f;
+      }
 
-      if (mfs->texture_type == FLUID_FLOW_TEXTURE_MAP_AUTO) {
-        tex_co[0] = ((x - flow_center[0]) / base_res[0]) / mfs->texture_size;
-        tex_co[1] = ((y - flow_center[1]) / base_res[1]) / mfs->texture_size;
-        tex_co[2] = ((z - flow_center[2]) / base_res[2] - mfs->texture_offset) / mfs->texture_size;
+      /* Apply vertex group influence if it is being used. */
+      if (defgrp_index != -1 && dvert) {
+        float weight_mask = defvert_find_weight(&dvert[v1], defgrp_index) * weights[0] +
+                            defvert_find_weight(&dvert[v2], defgrp_index) * weights[1] +
+                            defvert_find_weight(&dvert[v3], defgrp_index) * weights[2];
+        emission_strength *= weight_mask;
       }
-      else if (mloopuv) {
-        const float *uv[3];
-        uv[0] = mloopuv[mlooptri[f_index].tri[0]].uv;
-        uv[1] = mloopuv[mlooptri[f_index].tri[1]].uv;
-        uv[2] = mloopuv[mlooptri[f_index].tri[2]].uv;
-
-        interp_v2_v2v2v2(tex_co, UNPACK3(uv), weights);
-
-        /* map between -1.0f and 1.0f */
-        tex_co[0] = tex_co[0] * 2.0f - 1.0f;
-        tex_co[1] = tex_co[1] * 2.0f - 1.0f;
-        tex_co[2] = mfs->texture_offset;
+
+      /* Apply emission texture. */
+      if ((mfs->flags & FLUID_FLOW_TEXTUREEMIT) && mfs->noise_texture) {
+        float tex_co[3] = {0};
+        TexResult texres;
+
+        if (mfs->texture_type == FLUID_FLOW_TEXTURE_MAP_AUTO) {
+          tex_co[0] = ((x - flow_center[0]) / base_res[0]) / mfs->texture_size;
+          tex_co[1] = ((y - flow_center[1]) / base_res[1]) / mfs->texture_size;
+          tex_co[2] = ((z - flow_center[2]) / base_res[2] - mfs->texture_offset) /
+                      mfs->texture_size;
+        }
+        else if (mloopuv) {
+          const float *uv[3];
+          uv[0] = mloopuv[mlooptri[f_index].tri[0]].uv;
+          uv[1] = mloopuv[mlooptri[f_index].tri[1]].uv;
+          uv[2] = mloopuv[mlooptri[f_index].tri[2]].uv;
+
+          interp_v2_v2v2v2(tex_co, UNPACK3(uv), weights);
+
+          /* Map texure coord between -1.0f and 1.0f. */
+          tex_co[0] = tex_co[0] * 2.0f - 1.0f;
+          tex_co[1] = tex_co[1] * 2.0f - 1.0f;
+          tex_co[2] = mfs->texture_offset;
+        }
+        texres.nor = NULL;
+        BKE_texture_get_value(NULL, mfs->noise_texture, tex_co, &texres, false);
+        emission_strength *= texres.tin;
       }
-      texres.nor = NULL;
-      BKE_texture_get_value(NULL, mfs->noise_texture, tex_co, &texres, false);
-      sample_str *= texres.tin;
     }
   }
 
-  /* multiply initial velocity by emitter influence */
-  if (mfs->flags & FLUID_FLOW_INITVELOCITY && velocity_map) {
-    mul_v3_fl(&velocity_map[index * 3], sample_str);
-  }
-
-  /* apply final influence based on volume factor */
-  influence_map[index] = MAX2(volume_factor, sample_str);
+  /* Apply final influence value but also consider volume initialization factor. */
+  influence_map[index] = MAX2(volume_factor, emission_strength);
 }
 
 typedef struct EmitFromDMData {
@@ -1852,9 +1742,6 @@ typedef struct EmitFromDMData {
   int defgrp_index;
 
   BVHTreeFromMesh *tree;
-  int hires_multiplier;
-  float hr;
-
   EmissionMap *em;
   bool has_velocity;
   float *vert_vel;
@@ -1869,23 +1756,17 @@ static void emit_from_mesh_task_cb(void *__restrict userdata,
 {
   EmitFromDMData *data = userdata;
   EmissionMap *em = data->em;
-  const int hires_multiplier = data->hires_multiplier;
 
   for (int x = data->min[0]; x < data->max[0]; x++) {
     for (int y = data->min[1]; y < data->max[1]; y++) {
-      /* take low res samples where possible */
-      if (hires_multiplier <= 1 ||
-          !(x % hires_multiplier || y % hires_multiplier || z % hires_multiplier)) {
-        /* get low res space coordinates */
-        const int lx = x / hires_multiplier;
-        const int ly = y / hires_multiplier;
-        const int lz = z / hires_multiplier;
-
-        const int index = manta_get_index(
-            lx - em->min[0], em->res[0], ly - em->min[1], em->res[1], lz - em->min[2]);
-        const float ray_start[3] = {((float)lx) + 0.5f, ((float)ly) + 0.5f, ((float)lz) + 0.5f};
-
-        /* Emission for smoke and fire. Result in em->influence. Also, calculate invels */
+      const int index = manta_get_index(
+          x - em->min[0], em->res[0], y - em->min[1], em->res[1], z - em->min[2]);
+      const float ray_start[3] = {((float)x) + 0.5f, ((float)y) + 0.5f, ((float)z) + 0.5f};
+
+      /* Compute emission only for flow objects that produce fluid (i.e. skip outflow objects).
+       * Result in em->influence. Also computes initial velocities. Result in em->velocity. */
+      if ((data->mfs->behavior == FLUID_FLOW_BEHAVIOR_GEOMETRY) ||
+          (data->mfs->behavior == FLUID_FLOW_BEHAVIOR_INFLOW)) {
         sample_mesh(data->mfs,
                     data->mvert,
                     data->mloop,
@@ -1902,59 +1783,18 @@ static void emit_from_mesh_task_cb(void *__restrict userdata,
                     data->has_velocity,
                     data->defgrp_index,
                     data->dvert,
-                    (float)lx,
-                    (float)ly,
-                    (float)lz);
-
-        /* Calculate levelset from meshes. Result in em->distances */
-        update_mesh_distances(index,
-                              em->distances,
-                              data->tree,
-                              ray_start,
-                              data->mfs->surface_distance,
-                              data->mfs->flags & FLUID_FLOW_USE_PLANE_INIT);
+                    (float)x,
+                    (float)y,
+                    (float)z);
       }
 
-      /* take high res samples if required */
-      if (hires_multiplier > 1) {
-        /* get low res space coordinates */
-        const float lx = ((float)x) * data->hr;
-        const float ly = ((float)y) * data->hr;
-        const float lz = ((float)z) * data->hr;
-
-        const int index = manta_get_index(
-            x - data->min[0], data->res[0], y - data->min[1], data->res[1], z - data->min[2]);
-        const float ray_start[3] = {
-            lx + 0.5f * data->hr,
-            ly + 0.5f * data->hr,
-            lz + 0.5f * data->hr,
-        };
-
-        /* Emission for smoke and fire high. Result in em->influence_high */
-        if (data->mfs->type == FLUID_FLOW_TYPE_SMOKE || data->mfs->type == FLUID_FLOW_TYPE_FIRE ||
-            data->mfs->type == FLUID_FLOW_TYPE_SMOKEFIRE) {
-          sample_mesh(data->mfs,
-                      data->mvert,
-                      data->mloop,
-                      data->mlooptri,
-                      data->mloopuv,
-                      em->influence_high,
-                      NULL,
-                      index,
-                      data->mds->base_res,
-                      data->flow_center,
-                      data->tree,
-                      ray_start,
-                      data->vert_vel,
-                      data->has_velocity,
-                      data->defgrp_index,
-                      data->dvert,
-                      /* x,y,z needs to be always lowres */
-                      lx,
-                      ly,
-                      lz);
-        }
-      }
+      /* Calculate levelset values from meshes. Result in em->distances. */
+      update_mesh_distances(index,
+                            em->distances,
+                            data->tree,
+                            ray_start,
+                            data->mfs->surface_distance,
+                            data->mfs->flags & FLUID_FLOW_USE_PLANE_INIT);
     }
   }
 }
@@ -1978,11 +1818,9 @@ static void emit_from_mesh(
     int defgrp_index = mfs->vgroup_density - 1;
     float flow_center[3] = {0};
     int min[3], max[3], res[3];
-    int hires_multiplier = 1;
 
-    /* copy mesh for thread safety because we modify it,
-     * main issue is its VertArray being modified, then replaced and freed
-     */
+    /* Copy mesh for thread safety as we modify it.
+     * Main issue is its VertArray being modified, then replaced and freed. */
     me = BKE_mesh_copy_for_eval(mfs->mesh, true);
 
     /* Duplicate vertices to modify. */
@@ -2014,23 +1852,22 @@ static void emit_from_mesh(
       }
     }
 
-    /*  Transform mesh vertices to
-     *   domain grid space for fast lookups */
+    /* Transform mesh vertices to domain grid space for fast lookups */
     for (i = 0; i < numverts; i++) {
       float n[3];
 
-      /* vert pos */
+      /* Vertex position. */
       mul_m4_v3(flow_ob->obmat, mvert[i].co);
       manta_pos_to_cell(mds, mvert[i].co);
 
-      /* vert normal */
+      /* Vertex normal. */
       normal_short_to_float_v3(n, mvert[i].no);
       mul_mat3_m4_v3(flow_ob->obmat, n);
       mul_mat3_m4_v3(mds->imat, n);
       normalize_v3(n);
       normal_float_to_short_v3(mvert[i].no, n);
 
-      /* vert velocity */
+      /* Vertex velocity. */
       if (mfs->flags & FLUID_FLOW_INITVELOCITY) {
         float co[3];
         add_v3fl_v3fl_v3i(co, mvert[i].co, mds->shift);
@@ -2041,31 +1878,26 @@ static void emit_from_mesh(
         copy_v3_v3(&mfs->verts_old[i * 3], co);
       }
 
-      /* calculate emission map bounds */
+      /* Calculate emission map bounds. */
       em_boundInsert(em, mvert[i].co);
     }
     mul_m4_v3(flow_ob->obmat, flow_center);
     manta_pos_to_cell(mds, flow_center);
 
-    /* check need for high resolution map */
-    if ((mds->flags & FLUID_DOMAIN_USE_NOISE) && (mds->highres_sampling == SM_HRES_FULLSAMPLE)) {
-      hires_multiplier = mds->noise_scale;
-    }
-
-    /* set emission map */
-    clamp_bounds_in_domain(
-        mds, em->min, em->max, NULL, NULL, (int)ceil(mfs->surface_distance), dt);
-    em_allocateData(em, mfs->flags & FLUID_FLOW_INITVELOCITY, hires_multiplier);
+    /* Set emission map.
+     * Use 3 cell diagonals as margin (3 * 1.732 = 5.196). */
+    int bounds_margin = (int)ceil(5.196);
+    clamp_bounds_in_domain(mds, em->min, em->max, NULL, NULL, bounds_margin, dt);
+    em_allocateData(em, mfs->flags & FLUID_FLOW_INITVELOCITY);
 
-    /* setup loop bounds */
+    /* Setup loop bounds. */
     for (i = 0; i < 3; i++) {
-      min[i] = em->min[i] * hires_multiplier;
-      max[i] = em->max[i] * hires_multiplier;
-      res[i] = em->res[i] * hires_multiplier;
+      min[i] = em->min[i];
+      max[i] = em->max[i];
+      res[i] = em->res[i];
     }
 
     if (BKE_bvhtree_from_mesh_get(&tree_data, me, BVHTREE_FROM_LOOPTRI, 4)) {
-      const float hr = 1.0f / ((float)hires_multiplier);
 
       EmitFromDMData data = {
           .mds = mds,
@@ -2077,8 +1909,6 @@ static void emit_from_mesh(
           .dvert = dvert,
           .defgrp_index = defgrp_index,
           .tree = &tree_data,
-          .hires_multiplier = hires_multiplier,
-          .hr = hr,
           .em = em,
           .has_velocity = has_velocity,
           .vert_vel = vert_vel,
@@ -2093,7 +1923,7 @@ static void emit_from_mesh(
       settings.min_iter_per_thread = 2;
       BLI_task_parallel_range(min[2], max[2], &data, emit_from_mesh_task_cb, &settings);
     }
-    /* free bvh tree */
+    /* Free bvh tree. */
     free_bvhtree_from_mesh(&tree_data);
 
     if (vert_vel) {
@@ -2409,60 +2239,55 @@ BLI_INLINE void apply_inflow_fields(FluidFlowSettings *mfs,
                                     float *phi_in,
                                     float *emission_in)
 {
-  /* add inflow */
+  /* Set levelset value for liquid inflow.
+   * Ensure that distance value is "joined" into the levelset. */
   if (phi_in) {
-    phi_in[index] = distance_value;
+    phi_in[index] = MIN2(distance_value, phi_in[index]);
   }
 
-  /* save emission value for manta inflow */
+  /* Set emission value for smoke inflow.
+   * Ensure that emission value is "maximised". */
   if (emission_in) {
-    emission_in[index] = emission_value;
+    emission_in[index] = MAX2(emission_value, emission_in[index]);
   }
 
-  /* add smoke inflow */
+  /* Set inflow for smoke from here on. */
   int absolute_flow = (mfs->flags & FLUID_FLOW_ABSOLUTE);
   float dens_old = (density) ? density[index] : 0.0;
   // float fuel_old = (fuel) ? fuel[index] : 0.0f;  /* UNUSED */
   float dens_flow = (mfs->type == FLUID_FLOW_TYPE_FIRE) ? 0.0f : emission_value * mfs->density;
   float fuel_flow = (fuel) ? emission_value * mfs->fuel_amount : 0.0f;
-  /* add heat */
+  /* Set heat inflow. */
   if (heat && heat_in) {
     if (emission_value > 0.0f) {
       heat_in[index] = ADD_IF_LOWER(heat[index], mfs->temperature);
-      /* Scale inflow by dt/frame-length.
-       * This is to ensure that adaptive steps don't apply too much emission. */
-    }
-    else {
-      heat_in[index] = heat[index];
     }
   }
 
-  /* set density and fuel - absolute mode */
+  /* Set density and fuel - absolute mode. */
   if (absolute_flow) {
     if (density && density_in) {
-      density_in[index] = density[index];
       if (mfs->type != FLUID_FLOW_TYPE_FIRE && dens_flow > density[index]) {
-        density_in[index] = dens_flow;
+        /* Use MAX2 to preserve values from other emitters at this cell. */
+        density_in[index] = MAX2(dens_flow, density_in[index]);
       }
     }
     if (fuel && fuel_in) {
-      fuel_in[index] = fuel[index];
       if (mfs->type != FLUID_FLOW_TYPE_SMOKE && fuel_flow && fuel_flow > fuel[index]) {
-        fuel_in[index] = fuel_flow;
+        /* Use MAX2 to preserve values from other emitters at this cell. */
+        fuel_in[index] = MAX2(fuel_flow, fuel_in[index]);
       }
     }
   }
-  /* set density and fuel - additive mode */
+  /* Set density and fuel - additive mode. */
   else {
     if (density && density_in) {
-      density_in[index] = density[index];
       if (mfs->type != FLUID_FLOW_TYPE_FIRE) {
         density_in[index] += dens_flow;
         CLAMP(density_in[index], 0.0f, 1.0f);
       }
     }
     if (fuel && fuel_in) {
-      fuel_in[index] = fuel[index];
       if (mfs->type != FLUID_FLOW_TYPE_SMOKE && mfs->fuel_amount) {
         fuel_in[index] += fuel_flow;
         CLAMP(fuel_in[index], 0.0f, 10.0f);
@@ -2470,12 +2295,8 @@ BLI_INLINE void apply_inflow_fields(FluidFlowSettings *mfs,
     }
   }
 
-  /* set color */
+  /* Set color. */
   if (color_r && color_r_in) {
-    color_r_in[index] = color_r[index];
-    color_g_in[index] = color_g[index];
-    color_b_in[index] = color_b[index];
-
     if (dens_flow) {
       float total_dens = density[index] / (dens_old + dens_flow);
       color_r_in[index] = (color_r[index] + mfs->color[0] * dens_flow) * total_dens;
@@ -2484,7 +2305,7 @@ BLI_INLINE void apply_inflow_fields(FluidFlowSettings *mfs,
     }
   }
 
-  /* set fire reaction coordinate */
+  /* Set fire reaction coordinate. */
   if (fuel && fuel_in) {
     /* Instead of using 1.0 for all new fuel add slight falloff to reduce flow blocky-ness. */
     float value = 1.0f - pow2f(1.0f - emission_value);
@@ -2494,9 +2315,6 @@ BLI_INLINE void apply_inflow_fields(FluidFlowSettings *mfs,
       react_in[index] = value * f + (1.0f - f) * react[index];
       CLAMP(react_in[index], 0.0f, value);
     }
-    else {
-      react_in[index] = react[index];
-    }
   }
 }
 
@@ -2618,37 +2436,49 @@ static void update_flowsfluids(struct Depsgraph *depsgraph,
   flowobjs = BKE_collision_objects_create(
       depsgraph, ob, mds->fluid_group, &numflowobj, eModifierType_Fluid);
 
-  /* Update all flow related flags and ensure that corresponding grids get initialized */
+  /* Update all flow related flags and ensure that corresponding grids get initialized. */
   update_flowsflags(mds, flowobjs, numflowobj);
 
-  /* init emission maps for each flow */
+  /* Initialize emission maps for each flow. */
   emaps = MEM_callocN(sizeof(struct EmissionMap) * numflowobj, "manta_flow_maps");
 
-  /* Prepare flow emission maps */
+  /* Prepare flow emission maps. */
   for (flow_index = 0; flow_index < numflowobj; flow_index++) {
     Object *flowobj = flowobjs[flow_index];
     FluidModifierData *mmd2 = (FluidModifierData *)modifiers_findByType(flowobj,
                                                                         eModifierType_Fluid);
 
-    /* Check for initialized smoke object */
+    /* Check for initialized smoke object. */
     if ((mmd2->type & MOD_FLUID_TYPE_FLOW) && mmd2->flow) {
       FluidFlowSettings *mfs = mmd2->flow;
       int subframes = mfs->subframes;
       EmissionMap *em = &emaps[flow_index];
 
+      /* Optimization: No need to compute emission value if it won't be applied. */
+      if (mfs->behavior == FLUID_FLOW_BEHAVIOR_GEOMETRY && !is_first_frame) {
+        continue;
+      }
+      /* Optimization: Skip flow object if it does not "belong" to this domain type. */
+      if (mfs->type == FLUID_FLOW_TYPE_LIQUID && mds->type == FLUID_DOMAIN_TYPE_GAS) {
+        continue;
+      }
+      if ((mfs->type == FLUID_FLOW_TYPE_SMOKE || mfs->type == FLUID_FLOW_TYPE_FIRE ||
+           mfs->type == FLUID_FLOW_TYPE_SMOKEFIRE) &&
+          mds->type == FLUID_DOMAIN_TYPE_LIQUID) {
+        continue;
+      }
+
       /* Length of one adaptive frame. If using adaptive stepping, length is smaller than actual
        * frame length */
       float adaptframe_length = time_per_frame / frame_length;
       /* Adaptive frame length as percentage */
       CLAMP(adaptframe_length, 0.0f, 1.0f);
 
-      /* Further splitting because of emission subframe: If no subframes present, sample_size is 1
-       */
+      /* More splitting because of emission subframe: If no subframes present, sample_size is 1. */
       float sample_size = 1.0f / (float)(subframes + 1);
-      int hires_multiplier = 1;
 
       /* First frame cannot have any subframes because there is (obviously) no previous frame from
-       * where subframes could come from */
+       * where subframes could come from. */
       if (is_first_frame) {
         subframes = 0;
       }
@@ -2659,7 +2489,7 @@ static void update_flowsfluids(struct Depsgraph *depsgraph,
       /* Emission loop. When not using subframes this will loop only once. */
       for (subframe = subframes; subframe >= 0; subframe--) {
 
-        /* Temporary emission map used when subframes are enabled, i.e. at least one subframe */
+        /* Temporary emission map used when subframes are enabled, i.e. at least one subframe. */
         EmissionMap em_temp = {NULL};
 
         /* Set scene time */
@@ -2670,22 +2500,22 @@ static void update_flowsfluids(struct Depsgraph *depsgraph,
           scene->r.cfra = frame - 1;
         }
         /* Last frame in this loop (subframe == suframes). Can be real end frame or in between
-         * frames (adaptive frame) */
+         * frames (adaptive frame). */
         else {
           /* Handle adaptive subframe (ie has subframe fraction). Need to set according scene
-           * subframe parameter */
+           * subframe parameter. */
           if (time_per_frame < frame_length) {
             scene->r.subframe = adaptframe_length;
             scene->r.cfra = frame - 1;
           }
           /* Handle absolute endframe (ie no subframe fraction). Need to set the scene subframe
-           * parameter to 0 and advance current scene frame */
+           * parameter to 0 and advance current scene frame. */
           else {
             scene->r.subframe = 0.0f;
             scene->r.cfra = frame;
           }
         }
-        /* Sanity check: subframe portion must be between 0 and 1 */
+        /* Sanity check: subframe portion must be between 0 and 1. */
         CLAMP(scene->r.subframe, 0.0f, 1.0f);
 #  ifdef DEBUG_PRINT
         /* Debugging: Print subframe information. */
@@ -2700,11 +2530,11 @@ static void update_flowsfluids(struct Depsgraph *depsgraph,
         /* Update frame time, this is considering current subframe fraction
          * BLI_mutex_lock() called in manta_step(), so safe to update subframe here
          * TODO (sebbas): Using BKE_scene_frame_get(scene) instead of new DEG_get_ctime(depsgraph)
-         * as subframes don't work with the latter yet */
+         * as subframes don't work with the latter yet. */
         BKE_object_modifier_update_subframe(
             depsgraph, scene, flowobj, true, 5, BKE_scene_frame_get(scene), eModifierType_Fluid);
 
-        /* Emission from particles */
+        /* Emission from particles. */
         if (mfs->source == FLUID_FLOW_SOURCE_PARTICLES) {
           if (subframes) {
             emit_from_particles(flowobj, mds, mfs, &em_temp, depsgraph, scene, subframe_dt);
@@ -2712,12 +2542,8 @@ static void update_flowsfluids(struct Depsgraph *depsgraph,
           else {
             emit_from_particles(flowobj, mds, mfs, em, depsgraph, scene, subframe_dt);
           }
-
-          if (!(mfs->flags & FLUID_FLOW_USE_PART_SIZE)) {
-            hires_multiplier = 1;
-          }
         }
-        /* Emission from mesh */
+        /* Emission from mesh. */
         else if (mfs->source == FLUID_FLOW_SOURCE_MESH) {
           if (subframes) {
             emit_from_mesh(flowobj, mds, mfs, &em_temp, subframe_dt);
@@ -2731,11 +2557,10 @@ static void update_flowsfluids(struct Depsgraph *depsgraph,
         }
 
         /* If this we emitted with temp emission map in this loop (subframe emission), we combine
-         * the temp map with the original emission map */
+         * the temp map with the original emission map. */
         if (subframes) {
-          /* Combine emission maps */
-          em_combineMaps(
-              em, &em_temp, hires_multiplier, !(mfs->flags & FLUID_FLOW_ABSOLUTE), sample_size);
+          /* Combine emission maps. */
+          em_combineMaps(em, &em_temp, !(mfs->flags & FLUID_FLOW_ABSOLUTE), sample_size);
           em_freeData(&em_temp);
         }
       }
@@ -2750,7 +2575,7 @@ static void update_flowsfluids(struct Depsgraph *depsgraph,
          dt);
 #  endif
 
-  /* Adjust domain size if needed. Only do this once for every frame */
+  /* Adjust domain size if needed. Only do this once for every frame. */
   if (mds->type == FLUID_DOMAIN_TYPE_GAS && mds->flags & FLUID_DOMAIN_USE_ADAPTIVE_DOMAIN) {
     adaptive_domain_adjust(mds, ob, emaps, numflowobj, dt);
   }
@@ -2779,7 +2604,7 @@ static void update_flowsfluids(struct Depsgraph *depsgraph,
   float *velz_initial = manta_get_in_velocity_z(mds->fluid);
   uint z;
 
-  /* Grid reset before writing again */
+  /* Grid reset before writing again. */
   for (z = 0; z < mds->res[0] * mds->res[1] * mds->res[2]; z++) {
     if (phi_in) {
       phi_in[z] = PHI_MAX;
@@ -2787,20 +2612,21 @@ static void update_flowsfluids(struct Depsgraph *depsgraph,
     if (phiout_in) {
       phiout_in[z] = PHI_MAX;
     }
+    /* Sync smoke inflow grids with their counterparts (simulation grids). */
     if (density_in) {
-      density_in[z] = 0.0f;
+      density_in[z] = density[z];
     }
     if (heat_in) {
-      heat_in[z] = 0.0f;
+      heat_in[z] = heat[z];
     }
     if (color_r_in) {
-      color_r_in[z] = 0.0f;
-      color_g_in[z] = 0.0f;
-      color_b_in[z] = 0.0f;
+      color_r_in[z] = color_r[z];
+      color_g_in[z] = color_b[z];
+      color_b_in[z] = color_g[z];
     }
     if (fuel_in) {
-      fuel_in[z] = 0.0f;
-      react_in[z] = 0.0f;
+      fuel_in[z] = fuel[z];
+      react_in[z] = react[z];
     }
     if (emission_in) {
       emission_in[z] = 0.0f;
@@ -2812,13 +2638,13 @@ static void update_flowsfluids(struct Depsgraph *depsgraph,
     }
   }
 
-  /* Apply emission data */
+  /* Apply emission data for every flow object. */
   for (flow_index = 0; flow_index < numflowobj; flow_index++) {
     Object *flowobj = flowobjs[flow_index];
     FluidModifierData *mmd2 = (FluidModifierData *)modifiers_findByType(flowobj,
                                                                         eModifierType_Fluid);
 
-    // check for initialized flow object
+    /* Check for initialized flow object. */
     if ((mmd2->type & MOD_FLUID_TYPE_FLOW) && mmd2->flow) {
       FluidFlowSettings *mfs = mmd2->flow;
       EmissionMap *em = &emaps[flow_index];
@@ -2829,28 +2655,29 @@ static void update_flowsfluids(struct Depsgraph *depsgraph,
       int gx, gy, gz, ex, ey, ez, dx, dy, dz;
       size_t e_index, d_index;
 
-      // loop through every emission map cell
+      /* Loop through every emission map cell. */
       for (gx = em->min[0]; gx < em->max[0]; gx++) {
         for (gy = em->min[1]; gy < em->max[1]; gy++) {
           for (gz = em->min[2]; gz < em->max[2]; gz++) {
-            /* get emission map index */
+            /* Compute emission map index. */
             ex = gx - em->min[0];
             ey = gy - em->min[1];
             ez = gz - em->min[2];
             e_index = manta_get_index(ex, em->res[0], ey, em->res[1], ez);
 
-            /* get domain index */
+            /* Get domain index. */
             dx = gx - mds->res_min[0];
             dy = gy - mds->res_min[1];
             dz = gz - mds->res_min[2];
             d_index = manta_get_index(dx, mds->res[0], dy, mds->res[1], dz);
-            /* make sure emission cell is inside the new domain boundary */
+            /* Make sure emission cell is inside the new domain boundary. */
             if (dx < 0 || dy < 0 || dz < 0 || dx >= mds->res[0] || dy >= mds->res[1] ||
                 dz >= mds->res[2]) {
               continue;
             }
 
-            if (mfs->behavior == FLUID_FLOW_BEHAVIOR_OUTFLOW) {  // outflow
+            /* Delete fluid in outflow regions. */
+            if (mfs->behavior == FLUID_FLOW_BEHAVIOR_OUTFLOW) {
               apply_outflow_fields(d_index,
                                    distance_map[e_index],
                                    density_in,
@@ -2862,6 +2689,7 @@ static void update_flowsfluids(struct Depsgraph *depsgraph,
                                    color_b_in,
                                    phiout_in);
             }
+            /* Do not apply inflow after the first frame when in geometry mode. */
             else if (mfs->behavior == FLUID_FLOW_BEHAVIOR_GEOMETRY && !is_first_frame) {
               apply_inflow_fields(mfs,
                                   0.0f,
@@ -2884,8 +2712,9 @@ static void update_flowsfluids(struct Depsgraph *depsgraph,
                                   phi_in,
                                   emission_in);
             }
+            /* Main inflow application. */
             else if (mfs->behavior == FLUID_FLOW_BEHAVIOR_INFLOW ||
-                     mfs->behavior == FLUID_FLOW_BEHAVIOR_GEOMETRY) {  // inflow
+                     mfs->behavior == FLUID_FLOW_BEHAVIOR_GEOMETRY) {
               /* only apply inflow if enabled */
               if (mfs->flags & FLUID_FLOW_USE_INFLOW) {
                 apply_inflow_fields(mfs,
@@ -2908,7 +2737,6 @@ static void update_flowsfluids(struct Depsgraph *depsgraph,
                                     color_b,
                                     phi_in,
                                     emission_in);
-                /* initial velocity */
                 if (mfs->flags & FLUID_FLOW_INITVELOCITY) {
                   velx_initial[d_index] = velocity_map[e_index * 3];
                   vely_initial[d_index] = velocity_map[e_index * 3 + 1];
@@ -2916,14 +2744,11 @@ static void update_flowsfluids(struct Depsgraph *depsgraph,
                 }
               }
             }
-          }  // low res loop
+          }
         }
-      }
-
-      // free emission maps
+      } /* End of flow emission map loop. */
       em_freeData(em);
-
-    }  // end emission
+    } /* End of flow object loop. */
   }
 
   BKE_collision_objects_free(flowobjs);
index 8fa72d554be2476b851a139059710f23c6034603..63979e247bf93f0037d18aa4c1a6633ea9fc3dc0 100644 (file)
@@ -454,6 +454,9 @@ static void fluid_free_endjob(void *customdata)
   BKE_spacedata_draw_locks(false);
   WM_set_locked_interface(G_MAIN->wm.first, false);
 
+  /* Reflect the now empty cache in the viewport too. */
+  DEG_id_tag_update(&job->ob->id, ID_RECALC_GEOMETRY);
+
   /* Free was successful:
    *  Report for ended free job and how long it took */
   if (job->success) {
index 0e819b555e8878719a8f8bd12970a1522aa9bd7d..3c29f8ec8c07c12b3fefc7b1b684dd691b505a4b 100644 (file)
@@ -152,22 +152,6 @@ static bool rna_Fluid_parts_exists(PointerRNA *ptr, int ptype)
   return false;
 }
 
-static void rna_Fluid_draw_type_update(Main *UNUSED(bmain),
-                                       Scene *UNUSED(scene),
-                                       struct PointerRNA *ptr)
-{
-  Object *ob = (Object *)ptr->owner_id;
-  FluidDomainSettings *settings = (FluidDomainSettings *)ptr->data;
-
-  /* Wireframe mode more convenient when particles present */
-  if (settings->particle_type == 0) {
-    ob->dt = OB_SOLID;
-  }
-  else {
-    ob->dt = OB_WIRE;
-  }
-}
-
 static void rna_Fluid_flip_parts_update(Main *bmain, Scene *scene, PointerRNA *ptr)
 {
   Object *ob = (Object *)ptr->owner_id;
@@ -182,19 +166,14 @@ static void rna_Fluid_flip_parts_update(Main *bmain, Scene *scene, PointerRNA *p
   }
 
   if (ob->type == OB_MESH && !exists) {
-    rna_Fluid_parts_create(bmain,
-                           ptr,
-                           "FlipParticleSettings",
-                           "FLIP Particles",
-                           "FLIP Particle System",
-                           PART_FLUID_FLIP);
+    rna_Fluid_parts_create(
+        bmain, ptr, "LiquidParticleSettings", "Liquid", "Liquid Particle System", PART_FLUID_FLIP);
     mmd->domain->particle_type |= FLUID_DOMAIN_PARTICLE_FLIP;
   }
   else {
     rna_Fluid_parts_delete(ptr, PART_FLUID_FLIP);
     mmd->domain->particle_type &= ~FLUID_DOMAIN_PARTICLE_FLIP;
   }
-  rna_Fluid_draw_type_update(NULL, NULL, ptr);
   rna_Fluid_update(bmain, scene, ptr);
 }
 
@@ -206,19 +185,14 @@ static void rna_Fluid_spray_parts_update(Main *bmain, Scene *UNUSED(scene), Poin
   bool exists = rna_Fluid_parts_exists(ptr, PART_FLUID_SPRAY);
 
   if (ob->type == OB_MESH && !exists) {
-    rna_Fluid_parts_create(bmain,
-                           ptr,
-                           "SprayParticleSettings",
-                           "Spray Particles",
-                           "Spray Particle System",
-                           PART_FLUID_SPRAY);
+    rna_Fluid_parts_create(
+        bmain, ptr, "SprayParticleSettings", "Spray", "Spray Particle System", PART_FLUID_SPRAY);
     mmd->domain->particle_type |= FLUID_DOMAIN_PARTICLE_SPRAY;
   }
   else {
     rna_Fluid_parts_delete(ptr, PART_FLUID_SPRAY);
     mmd->domain->particle_type &= ~FLUID_DOMAIN_PARTICLE_SPRAY;
   }
-  rna_Fluid_draw_type_update(NULL, NULL, ptr);
 }
 
 static void rna_Fluid_bubble_parts_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
@@ -232,7 +206,7 @@ static void rna_Fluid_bubble_parts_update(Main *bmain, Scene *UNUSED(scene), Poi
     rna_Fluid_parts_create(bmain,
                            ptr,
                            "BubbleParticleSettings",
-                           "Bubble Particles",
+                           "Bubbles",
                            "Bubble Particle System",
                            PART_FLUID_BUBBLE);
     mmd->domain->particle_type |= FLUID_DOMAIN_PARTICLE_BUBBLE;
@@ -241,7 +215,6 @@ static void rna_Fluid_bubble_parts_update(Main *bmain, Scene *UNUSED(scene), Poi
     rna_Fluid_parts_delete(ptr, PART_FLUID_BUBBLE);
     mmd->domain->particle_type &= ~FLUID_DOMAIN_PARTICLE_BUBBLE;
   }
-  rna_Fluid_draw_type_update(NULL, NULL, ptr);
 }
 
 static void rna_Fluid_foam_parts_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
@@ -252,19 +225,14 @@ static void rna_Fluid_foam_parts_update(Main *bmain, Scene *UNUSED(scene), Point
   bool exists = rna_Fluid_parts_exists(ptr, PART_FLUID_FOAM);
 
   if (ob->type == OB_MESH && !exists) {
-    rna_Fluid_parts_create(bmain,
-                           ptr,
-                           "FoamParticleSettings",
-                           "Foam Particles",
-                           "Foam Particle System",
-                           PART_FLUID_FOAM);
+    rna_Fluid_parts_create(
+        bmain, ptr, "FoamParticleSettings", "Foam", "Foam Particle System", PART_FLUID_FOAM);
     mmd->domain->particle_type |= FLUID_DOMAIN_PARTICLE_FOAM;
   }
   else {
     rna_Fluid_parts_delete(ptr, PART_FLUID_FOAM);
     mmd->domain->particle_type &= ~FLUID_DOMAIN_PARTICLE_FOAM;
   }
-  rna_Fluid_draw_type_update(NULL, NULL, ptr);
 }
 
 static void rna_Fluid_tracer_parts_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
@@ -287,7 +255,6 @@ static void rna_Fluid_tracer_parts_update(Main *bmain, Scene *UNUSED(scene), Poi
     rna_Fluid_parts_delete(ptr, PART_FLUID_TRACER);
     mmd->domain->particle_type &= ~FLUID_DOMAIN_PARTICLE_TRACER;
   }
-  rna_Fluid_draw_type_update(NULL, NULL, ptr);
 }
 
 static void rna_Fluid_combined_export_update(Main *bmain, Scene *scene, PointerRNA *ptr)
@@ -422,7 +389,6 @@ static void rna_Fluid_combined_export_update(Main *bmain, Scene *scene, PointerR
     // sanity check, should not occur
     printf("ERROR: Unexpected combined export setting encountered!");
   }
-  rna_Fluid_draw_type_update(NULL, NULL, ptr);
 }
 
 static void rna_Fluid_cachetype_mesh_set(struct PointerRNA *ptr, int value)
@@ -1018,13 +984,13 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna)
        "MODULAR",
        0,
        "Modular",
-       "Bake every stage of the simulation on its own. Pausing and resuming possible"},
+       "Bake every stage of the simulation separately. Pausing and resuming possible"},
       {FLUID_DOMAIN_CACHE_FINAL,
        "FINAL",
        0,
        "Final",
-       "Bake the entire simulation at once. Only produces the most essential cache files. Pausing "
-       "and resuming not possible"},
+       "Bake the entire simulation at once. Only generates the most essential cache files. "
+       "Pausing and resuming not possible"},
       {0, NULL, 0, NULL, NULL}};
 
   static const EnumPropertyItem smoke_data_depth_items[] = {
@@ -1054,7 +1020,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna)
        0,
        "Domain",
        "Use a fluid domain for guiding (domain needs to be baked already so that velocities can "
-       "be extracted but can be of any type)"},
+       "be extracted). Guiding domain can be of any type (i.e. gas or liquid)"},
       {FLUID_DOMAIN_GUIDE_SRC_EFFECTOR,
        "EFFECTOR",
        0,
@@ -1310,7 +1276,11 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna)
   RNA_def_property_int_sdna(prop, NULL, "maxres");
   RNA_def_property_range(prop, 6, 10000);
   RNA_def_property_ui_range(prop, 24, 10000, 2, -1);
-  RNA_def_property_ui_text(prop, "Max Res", "Resolution used for the fluid domain");
+  RNA_def_property_ui_text(
+      prop,
+      "Maximum Resolution",
+      "Resolution used for the fluid domain. Value corresponds to the longest domain side "
+      "(resolution for other domain sides is calculated automatically)");
   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
   RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset");
 
@@ -1366,8 +1336,8 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna)
   RNA_def_property_ui_range(prop, -5.0, 5.0, 0.02, 5);
   RNA_def_property_ui_text(
       prop,
-      "Density",
-      "How much density affects smoke motion (higher value results in faster rising smoke)");
+      "Buoyancy Density",
+      "Buoyant force based on smoke density (higher value results in faster rising smoke)");
   RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache");
 
   prop = RNA_def_property(srna, "beta", PROP_FLOAT, PROP_NONE);
@@ -1376,21 +1346,24 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna)
   RNA_def_property_ui_range(prop, -5.0, 5.0, 0.02, 5);
   RNA_def_property_ui_text(
       prop,
-      "Heat",
-      "How much heat affects smoke motion (higher value results in faster rising smoke)");
+      "Buoyancy Heat",
+      "Buoyant force based on smoke heat (higher value results in faster rising smoke)");
   RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache");
 
   prop = RNA_def_property(srna, "dissolve_speed", PROP_INT, PROP_NONE);
   RNA_def_property_int_sdna(prop, NULL, "diss_speed");
   RNA_def_property_range(prop, 1.0, 10000.0);
   RNA_def_property_ui_range(prop, 1.0, 10000.0, 1, -1);
-  RNA_def_property_ui_text(prop, "Dissolve Speed", "Dissolve Speed");
+  RNA_def_property_ui_text(
+      prop,
+      "Dissolve Speed",
+      "Determine how quickly the smoke dissolves (higher value makes smoke disappear faster)");
   RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache");
 
   prop = RNA_def_property(srna, "vorticity", PROP_FLOAT, PROP_NONE);
   RNA_def_property_float_sdna(prop, NULL, "vorticity");
   RNA_def_property_range(prop, 0.0, 4.0);
-  RNA_def_property_ui_text(prop, "Vorticity", "Amount of turbulence/rotation in fluid");
+  RNA_def_property_ui_text(prop, "Vorticity", "Amount of turbulence and rotation in smoke");
   RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache");
 
   prop = RNA_def_property(srna, "highres_sampling", PROP_ENUM, PROP_NONE);
@@ -1400,12 +1373,15 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna)
 
   prop = RNA_def_property(srna, "use_dissolve_smoke", PROP_BOOLEAN, PROP_NONE);
   RNA_def_property_boolean_sdna(prop, NULL, "flags", FLUID_DOMAIN_USE_DISSOLVE);
-  RNA_def_property_ui_text(prop, "Dissolve Smoke", "Enable smoke to disappear over time");
+  RNA_def_property_ui_text(prop, "Dissolve Smoke", "Let smoke disappear over time");
   RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache");
 
   prop = RNA_def_property(srna, "use_dissolve_smoke_log", PROP_BOOLEAN, PROP_NONE);
   RNA_def_property_boolean_sdna(prop, NULL, "flags", FLUID_DOMAIN_USE_DISSOLVE_LOG);
-  RNA_def_property_ui_text(prop, "Logarithmic dissolve", "Using 1/x ");
+  RNA_def_property_ui_text(
+      prop,
+      "Logarithmic Dissolve",
+      "Dissolve smoke in a logarithmic fashion. Dissolves quickly at first, but lingers longer");
   RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache");
 
   /* flame options */
@@ -1414,7 +1390,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna)
   RNA_def_property_range(prop, 0.01, 4.0);
   RNA_def_property_ui_range(prop, 0.01, 2.0, 1.0, 5);
   RNA_def_property_ui_text(
-      prop, "Speed", "Speed of the burning reaction (use larger values for smaller flame)");
+      prop, "Speed", "Speed of the burning reaction (higher value results in smaller flames)");
   RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache");
 
   prop = RNA_def_property(srna, "flame_smoke", PROP_FLOAT, PROP_NONE);
@@ -1432,13 +1408,19 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna)
   prop = RNA_def_property(srna, "flame_ignition", PROP_FLOAT, PROP_NONE);
   RNA_def_property_range(prop, 0.5, 5.0);
   RNA_def_property_ui_range(prop, 0.5, 2.5, 1.0, 5);
-  RNA_def_property_ui_text(prop, "Ignition", "Minimum temperature of flames");
+  RNA_def_property_ui_text(
+      prop,
+      "Minimum",
+      "Minimum temperature of the flames (higher value results in faster rising flames)");
   RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache");
 
   prop = RNA_def_property(srna, "flame_max_temp", PROP_FLOAT, PROP_NONE);
   RNA_def_property_range(prop, 1.0, 10.0);
   RNA_def_property_ui_range(prop, 1.0, 5.0, 1.0, 5);
-  RNA_def_property_ui_text(prop, "Maximum", "Maximum temperature of flames");
+  RNA_def_property_ui_text(
+      prop,
+      "Maximum",
+      "Maximum temperature of the flames (higher value results in faster rising flames)");
   RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache");
 
   prop = RNA_def_property(srna, "flame_smoke_color", PROP_FLOAT, PROP_COLOR_GAMMA);
@@ -1473,8 +1455,8 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna)
   RNA_def_property_ui_range(prop, 1, 10, 1, -1);
   RNA_def_property_ui_text(prop,
                            "Noise Scale",
-                           "Scale underlying noise grids by this factor. Noise grids have size "
-                           "factor times base resolution");
+                           "The noise simulation is scaled up by this factor (compared to the "
+                           "base resolution of the domain)");
   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
   RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset");
 
@@ -1482,7 +1464,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna)
   RNA_def_property_enum_sdna(prop, NULL, "noise_type");
   RNA_def_property_enum_items(prop, prop_noise_type_items);
   RNA_def_property_ui_text(
-      prop, "Noise Method", "Noise method which is used for creating the high resolution");
+      prop, "Noise Method", "Noise method which is used during the high-res simulation");
   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
   RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset");
 
@@ -1543,7 +1525,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna)
   RNA_def_property_ui_text(
       prop,
       "Radius",
-      "Particle radius factor. Use this parameter when the simulation appears to leak volume");
+      "Particle radius factor. Adjust this parameter when the simulation appears to leak volume");
   RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache");
 
   prop = RNA_def_property(srna, "particle_band_width", PROP_FLOAT, PROP_NONE);
@@ -1556,7 +1538,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna)
 
   prop = RNA_def_property(srna, "use_flip_particles", PROP_BOOLEAN, PROP_NONE);
   RNA_def_property_boolean_sdna(prop, NULL, "particle_type", FLUID_DOMAIN_PARTICLE_FLIP);
-  RNA_def_property_ui_text(prop, "FLIP", "Create FLIP particle system");
+  RNA_def_property_ui_text(prop, "FLIP", "Create liquid particle system");
   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Fluid_flip_parts_update");
 
@@ -1646,8 +1628,9 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna)
   RNA_def_property_ui_range(prop, 1, 10, 1, -1);
   RNA_def_property_ui_text(prop,
                            "Mesh scale",
-                           "Scale underlying mesh grids by this factor. Mesh grids have size "
-                           "factor times base resolution");
+                           "The mesh simulation is scaled up by this factor (compared to the base "
+                           "resolution of the domain). For best meshing, it is recommended to "
+                           "adjust the mesh particle radius alongside this value");
   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
   RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset");
 
@@ -1673,19 +1656,19 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna)
 
   prop = RNA_def_property(srna, "use_speed_vectors", PROP_BOOLEAN, PROP_NONE);
   RNA_def_property_boolean_sdna(prop, NULL, "flags", FLUID_DOMAIN_USE_SPEED_VECTORS);
-  RNA_def_property_ui_text(
-      prop,
-      "Speed Vectors",
-      "Generate speed vectors (will be loaded automatically during render for motion blur)");
+  RNA_def_property_ui_text(prop,
+                           "Speed Vectors",
+                           "Caches velocities of mesh vertices. These will be used "
+                           "(automatically) when rendering with motion blur enabled");
   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
   RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset");
 
   prop = RNA_def_property(srna, "mesh_particle_radius", PROP_FLOAT, PROP_NONE);
   RNA_def_property_range(prop, 0.0, 10.0);
-  RNA_def_property_ui_text(
-      prop,
-      "Radius",
-      "Particle radius factor (higher value results in larger (meshed) particles)");
+  RNA_def_property_ui_text(prop,
+                           "Radius",
+                           "Particle radius factor (higher value results in larger (meshed) "
+                           "particles). Needs to be adjusted after changing the mesh scale");
   RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache");
 
   /*  secondary particles options */
@@ -1694,36 +1677,36 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna)
   RNA_def_property_range(prop, 0.0, 1000.0);
   RNA_def_property_ui_range(prop, 0.0, 1000.0, 100.0, 3);
   RNA_def_property_ui_text(prop,
-                           "tauMin_wc",
+                           "Minimum Wave Crest Potential",
                            "Lower clamping threshold for marking fluid cells as wave crests "
-                           "(lower values result in more marked cells)");
+                           "(lower value results in more marked cells)");
   RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache");
 
   prop = RNA_def_property(srna, "sndparticle_tau_max_wc", PROP_FLOAT, PROP_NONE);
   RNA_def_property_range(prop, 0.0, 1000.0);
   RNA_def_property_ui_range(prop, 0.0, 1000.0, 100.0, 3);
   RNA_def_property_ui_text(prop,
-                           "tauMax_wc",
+                           "Maximum Wave Crest Potential",
                            "Upper clamping threshold for marking fluid cells as wave crests "
-                           "(higher values result in less marked cells)");
+                           "(higher value results in less marked cells)");
   RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache");
 
   prop = RNA_def_property(srna, "sndparticle_tau_min_ta", PROP_FLOAT, PROP_NONE);
   RNA_def_property_range(prop, 0.0, 1000.0);
   RNA_def_property_ui_range(prop, 0.0, 10000.0, 100.0, 3);
   RNA_def_property_ui_text(prop,
-                           "tauMin_ta",
+                           "Minimum Trapped Air Potential",
                            "Lower clamping threshold for marking fluid cells where air is trapped "
-                           "(lower values result in more marked cells)");
+                           "(lower value results in more marked cells)");
   RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache");
 
   prop = RNA_def_property(srna, "sndparticle_tau_max_ta", PROP_FLOAT, PROP_NONE);
   RNA_def_property_range(prop, 0.0, 1000.0);
   RNA_def_property_ui_range(prop, 0.0, 1000.0, 100.0, 3);
   RNA_def_property_ui_text(prop,
-                           "tauMax_ta",
+                           "Maximum Trapped Air Potential",
                            "Upper clamping threshold for marking fluid cells where air is trapped "
-                           "(higher values result in less marked cells)");
+                           "(highe value results in less marked cells)");
   RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache");
 
   prop = RNA_def_property(srna, "sndparticle_tau_min_k", PROP_FLOAT, PROP_NONE);
@@ -1743,7 +1726,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna)
       prop,
       "tauMax_k",
       "Upper clamping threshold that indicates the fluid speed where cells no longer emit more "
-      "particles (higher values result in generally less particles)");
+      "particles (higher value results in generally less particles)");
   RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache");
 
   prop = RNA_def_property(srna, "sndparticle_k_wc", PROP_INT, PROP_NONE);
@@ -1766,8 +1749,8 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna)
   RNA_def_property_range(prop, 0.0, 100.0);
   RNA_def_property_ui_range(prop, 0.0, 100.0, 10.0, 2);
   RNA_def_property_ui_text(prop,
-                           "Buoyancy",
-                           "Amount of buoyancy force that rises bubbles (high values result in "
+                           "Bubble Buoyancy",
+                           "Amount of buoyancy force that rises bubbles (high value results in "
                            "bubble movement mainly upwards)");
   RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache");
 
@@ -1775,21 +1758,21 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna)
   RNA_def_property_range(prop, 0.0, 100.0);
   RNA_def_property_ui_range(prop, 0.0, 100.0, 10.0, 2);
   RNA_def_property_ui_text(prop,
-                           "Drag",
+                           "Bubble Drag",
                            "Amount of drag force that moves bubbles along with the fluid (high "
-                           "values result in bubble movement mainly along with the fluid)");
+                           "value results in bubble movement mainly along with the fluid)");
   RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache");
 
   prop = RNA_def_property(srna, "sndparticle_l_min", PROP_FLOAT, PROP_NONE);
   RNA_def_property_range(prop, 0.0, 10000.0);
   RNA_def_property_ui_range(prop, 0.0, 10000.0, 100.0, 1);
-  RNA_def_property_ui_text(prop, "Lifetime(min)", "Lowest possible particle lifetime");
+  RNA_def_property_ui_text(prop, "Minimum Lifetime", "Lowest possible particle lifetime");
   RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache");
 
   prop = RNA_def_property(srna, "sndparticle_l_max", PROP_FLOAT, PROP_NONE);
   RNA_def_property_range(prop, 0.0, 10000.0);
   RNA_def_property_ui_range(prop, 0.0, 10000.0, 100.0, 1);
-  RNA_def_property_ui_text(prop, "Lifetime(max)", "Highest possible particle lifetime");
+  RNA_def_property_ui_text(prop, "Maximum Lifetime", "Highest possible particle lifetime");
   RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache");
 
   prop = RNA_def_property(srna, "sndparticle_boundary", PROP_ENUM, PROP_NONE);
@@ -1833,9 +1816,9 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna)
   RNA_def_property_range(prop, 1, 100);
   RNA_def_property_ui_range(prop, 1, 10, 1, -1);
   RNA_def_property_ui_text(prop,
-                           "Mesh scale",
-                           "Scale underlying particle grids by this factor. Particle grids have "
-                           "size factor times base resolution");
+                           "Particle scale",
+                           "The particle simulation is scaled up by this factor (compared to the "
+                           "base resolution of the domain)");
   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
   RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset");
 
@@ -1883,7 +1866,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna)
   RNA_def_property_ui_text(
       prop,
       "Weight",
-      "Guiding velocity factor (higher value results in bigger guiding velocities)");
+      "Guiding velocity factor (higher value results in greater guiding velocities)");
   RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset");
 
   prop = RNA_def_property(srna, "guide_source", PROP_ENUM, PROP_NONE);
@@ -2059,7 +2042,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna)
   RNA_def_property_float_sdna(prop, NULL, "cfl_condition");
   RNA_def_property_range(prop, 0.0, 10.0);
   RNA_def_property_ui_text(
-      prop, "CFL", "Maximal velocity per cell (higher value results in larger timesteps)");
+      prop, "CFL", "Maximal velocity per cell (higher value results in greater timesteps)");
   RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache");
 
   prop = RNA_def_property(srna, "use_adaptive_timesteps", PROP_BOOLEAN, PROP_NONE);
@@ -2388,18 +2371,28 @@ static void rna_def_fluid_flow_settings(BlenderRNA *brna)
   prop = RNA_def_property(srna, "volume_density", PROP_FLOAT, PROP_NONE);
   RNA_def_property_range(prop, 0.0, 1.0);
   RNA_def_property_ui_range(prop, 0.0, 1.0, 0.05, 5);
-  RNA_def_property_ui_text(prop, "Volume", "Factor for smoke emitted from inside the mesh volume");
+  RNA_def_property_ui_text(prop,
+                           "Volume Emission",
+                           "Controls fluid emission from within the mesh (higher value results in "
+                           "greater emissions from inside the mesh)");
   RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset");
 
   prop = RNA_def_property(srna, "surface_distance", PROP_FLOAT, PROP_NONE);
   RNA_def_property_range(prop, 0.0, 10.0);
   RNA_def_property_ui_range(prop, 0.0, 10.0, 0.05, 5);
-  RNA_def_property_ui_text(prop, "Surface", "Maximum distance from mesh surface to emit fluid");
+  RNA_def_property_ui_text(prop,
+                           "Surface Emission",
+                           "Controls fluid emission from the mesh surface (higher value results "
+                           "in emission further away from the mesh surface");
   RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset");
 
   prop = RNA_def_property(srna, "use_plane_init", PROP_BOOLEAN, PROP_NONE);
   RNA_def_property_boolean_sdna(prop, NULL, "flags", FLUID_FLOW_USE_PLANE_INIT);
-  RNA_def_property_ui_text(prop, "Is Planar", "Treat this object as a planar, unclosed mesh");
+  RNA_def_property_ui_text(
+      prop,
+      "Is Planar",
+      "Treat this object as a planar and unclosed mesh. Fluid will only be emitted from the mesh "
+      "surface and based on the surface emission value");
   RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset");
 
   prop = RNA_def_property(srna, "particle_size", PROP_FLOAT, PROP_NONE);