Mantaflow [Part 6]: Updates in /blender/source
authorSebastián Barschkis <sebbas@sebbas.org>
Mon, 16 Dec 2019 14:50:14 +0000 (15:50 +0100)
committerSebastián Barschkis <sebbas@sebbas.org>
Mon, 16 Dec 2019 15:37:01 +0000 (16:37 +0100)
A collection of smaller changes that are required in the /blender/source files. A lot of them are also due to variable renaming.

Reviewed By: sergey

Maniphest Tasks: T59995

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

79 files changed:
extern/CMakeLists.txt
extern/mantaflow/CMakeLists.txt [new file with mode: 0644]
intern/CMakeLists.txt
intern/cycles/blender/blender_mesh.cpp
intern/cycles/blender/blender_session.cpp
intern/cycles/blender/blender_util.h
release/datafiles/blender_icons16/icon16_mod_fluid.dat [moved from release/datafiles/blender_icons16/icon16_mod_smoke.dat with 100% similarity]
release/datafiles/blender_icons32/icon32_mod_fluid.dat [moved from release/datafiles/blender_icons32/icon32_mod_smoke.dat with 100% similarity]
release/datafiles/locale
source/blender/CMakeLists.txt
source/blender/alembic/intern/abc_exporter.cc
source/blender/blenkernel/BKE_fluid.h [new file with mode: 0644]
source/blender/blenkernel/BKE_fluidsim.h [deleted file]
source/blender/blenkernel/BKE_pointcache.h
source/blender/blenkernel/BKE_smoke.h [deleted file]
source/blender/blenkernel/CMakeLists.txt
source/blender/blenkernel/intern/bpath.c
source/blender/blenkernel/intern/dynamicpaint.c
source/blender/blenkernel/intern/effect.c
source/blender/blenkernel/intern/fluidsim.c [deleted file]
source/blender/blenkernel/intern/modifier.c
source/blender/blenkernel/intern/object.c
source/blender/blenkernel/intern/particle.c
source/blender/blenkernel/intern/pointcache.c
source/blender/blenkernel/intern/smoke.c [deleted file]
source/blender/blenloader/intern/readfile.c
source/blender/blenloader/intern/versioning_250.c
source/blender/blenloader/intern/versioning_260.c
source/blender/blenloader/intern/versioning_270.c
source/blender/blenloader/intern/versioning_legacy.c
source/blender/blenloader/intern/writefile.c
source/blender/depsgraph/intern/depsgraph_physics.cc
source/blender/draw/engines/eevee/eevee_volumes.c
source/blender/draw/engines/overlay/overlay_extra.c
source/blender/draw/engines/overlay/shaders/volume_velocity_vert.glsl
source/blender/draw/engines/workbench/workbench_deferred.c
source/blender/draw/engines/workbench/workbench_forward.c
source/blender/draw/engines/workbench/workbench_volume.c
source/blender/editors/datafiles/CMakeLists.txt
source/blender/editors/include/UI_icons.h
source/blender/editors/interface/interface_templates.c
source/blender/editors/physics/CMakeLists.txt
source/blender/editors/physics/particle_object.c
source/blender/editors/physics/physics_intern.h
source/blender/editors/physics/physics_ops.c
source/blender/editors/space_buttons/buttons_context.c
source/blender/editors/space_outliner/outliner_draw.c
source/blender/editors/space_view3d/CMakeLists.txt
source/blender/gpencil_modifiers/CMakeLists.txt
source/blender/gpu/CMakeLists.txt
source/blender/gpu/GPU_draw.h
source/blender/gpu/intern/gpu_draw.c
source/blender/makesdna/DNA_modifier_types.h
source/blender/makesdna/DNA_object_types.h
source/blender/makesdna/DNA_particle_types.h
source/blender/makesdna/DNA_smoke_types.h [deleted file]
source/blender/makesdna/intern/makesdna.c
source/blender/makesrna/RNA_access.h
source/blender/makesrna/intern/CMakeLists.txt
source/blender/makesrna/intern/makesrna.c
source/blender/makesrna/intern/rna_fluidsim.c [deleted file]
source/blender/makesrna/intern/rna_gpencil_modifier.c
source/blender/makesrna/intern/rna_internal.h
source/blender/makesrna/intern/rna_modifier.c
source/blender/makesrna/intern/rna_object_force.c
source/blender/makesrna/intern/rna_particle.c
source/blender/makesrna/intern/rna_smoke.c [deleted file]
source/blender/modifiers/CMakeLists.txt
source/blender/modifiers/MOD_modifiertypes.h
source/blender/modifiers/intern/MOD_fluid.c [moved from source/blender/modifiers/intern/MOD_smoke.c with 56% similarity]
source/blender/modifiers/intern/MOD_fluidsim.c [deleted file]
source/blender/modifiers/intern/MOD_fluidsim_util.c [deleted file]
source/blender/modifiers/intern/MOD_fluidsim_util.h [deleted file]
source/blender/modifiers/intern/MOD_util.c
source/blender/python/intern/CMakeLists.txt
source/blender/python/intern/bpy_app_build_options.c
source/blender/python/intern/bpy_interface.c
source/blender/render/CMakeLists.txt
source/blender/shader_fx/CMakeLists.txt

index b985a39106b15e2f49cce8f76fba95c7bfa04004..e79aba0e9889109b3087506153a54bb1eea57a93 100644 (file)
@@ -105,3 +105,7 @@ if(WITH_QUADRIFLOW)
   set(QUADRIFLOW_CMAKE_CFG ${CMAKE_CURRENT_SOURCE_DIR}/quadriflow/blender_config.cmake)
   add_subdirectory(quadriflow)
 endif()
+
+if(WITH_MOD_FLUID)
+  add_subdirectory(mantaflow)
+endif()
diff --git a/extern/mantaflow/CMakeLists.txt b/extern/mantaflow/CMakeLists.txt
new file mode 100644 (file)
index 0000000..72ce920
--- /dev/null
@@ -0,0 +1,203 @@
+# ***** BEGIN GPL LICENSE BLOCK *****
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# The Original Code is Copyright (C) 2016, Blender Foundation
+# All rights reserved.
+#
+# The Original Code is: all of this file.
+#
+# Contributor(s): Sebastian Barschkis (sebbas)
+#
+# ***** END GPL LICENSE BLOCK *****
+
+set(MANTAVERSION "0.12")
+
+add_definitions(-DWITH_FLUID=1)
+
+set(MANTA_DEP
+  dependencies
+)
+set(MANTA_HLP
+  helper
+)
+set(MANTA_PP
+  preprocessed
+)
+
+if(WITH_TBB)
+  add_definitions(-DTBB=1)
+endif()
+
+if(WITH_OPENVDB)
+  add_definitions(-DOPENVDB=1)
+endif()
+
+set(INC
+  ${MANTA_PP}
+  ${MANTA_PP}/fileio
+  ${MANTA_PP}/python
+  ${MANTA_PP}/plugin
+  ${MANTA_HLP}/pwrapper
+  ${MANTA_HLP}/util
+  ${MANTA_DEP}/cnpy
+)
+
+set(INC_SYS
+  ${PYTHON_INCLUDE_DIRS}
+  ${ZLIB_INCLUDE_DIRS}
+)
+
+if(WITH_TBB)
+  list(APPEND INC_SYS
+    ${TBB_INCLUDE_DIRS}
+  )
+endif()
+
+if(WITH_OPENVDB)
+  list(APPEND INC_SYS
+    ${BOOST_INCLUDE_DIR}
+    ${OPENEXR_INCLUDE_DIRS}
+    ${OPENVDB_INCLUDE_DIRS}
+  )
+endif()
+
+set(SRC
+  ${MANTA_DEP}/cnpy/cnpy.cpp
+  ${MANTA_DEP}/cnpy/cnpy.h
+
+  ${MANTA_PP}/commonkernels.h
+  ${MANTA_PP}/commonkernels.h.reg.cpp
+  ${MANTA_PP}/conjugategrad.cpp
+  ${MANTA_PP}/conjugategrad.h
+  ${MANTA_PP}/conjugategrad.h.reg.cpp
+  ${MANTA_PP}/edgecollapse.cpp
+  ${MANTA_PP}/edgecollapse.h
+  ${MANTA_PP}/edgecollapse.h.reg.cpp
+  ${MANTA_PP}/fastmarch.cpp
+  ${MANTA_PP}/fastmarch.h
+  ${MANTA_PP}/fastmarch.h.reg.cpp
+  ${MANTA_PP}/fileio/iogrids.cpp
+  ${MANTA_PP}/fileio/iomeshes.cpp
+  ${MANTA_PP}/fileio/ioparticles.cpp
+  ${MANTA_PP}/fileio/mantaio.h
+  ${MANTA_PP}/fileio/mantaio.h.reg.cpp
+  ${MANTA_PP}/fluidsolver.cpp
+  ${MANTA_PP}/fluidsolver.h
+  ${MANTA_PP}/fluidsolver.h.reg.cpp
+  ${MANTA_PP}/general.cpp
+  ${MANTA_PP}/general.h
+  ${MANTA_PP}/general.h.reg.cpp
+  ${MANTA_PP}/gitinfo.h
+  ${MANTA_PP}/grid.cpp
+  ${MANTA_PP}/grid.h
+  ${MANTA_PP}/grid.h.reg.cpp
+  ${MANTA_PP}/grid4d.cpp
+  ${MANTA_PP}/grid4d.h
+  ${MANTA_PP}/grid4d.h.reg.cpp
+  ${MANTA_PP}/kernel.cpp
+  ${MANTA_PP}/kernel.h
+  ${MANTA_PP}/kernel.h.reg.cpp
+  ${MANTA_PP}/levelset.cpp
+  ${MANTA_PP}/levelset.h
+  ${MANTA_PP}/levelset.h.reg.cpp
+  ${MANTA_PP}/mesh.cpp
+  ${MANTA_PP}/mesh.h
+  ${MANTA_PP}/mesh.h.reg.cpp
+  ${MANTA_PP}/movingobs.cpp
+  ${MANTA_PP}/movingobs.h
+  ${MANTA_PP}/movingobs.h.reg.cpp
+  ${MANTA_PP}/multigrid.cpp
+  ${MANTA_PP}/multigrid.h
+  ${MANTA_PP}/multigrid.h.reg.cpp
+  ${MANTA_PP}/noisefield.cpp
+  ${MANTA_PP}/noisefield.h
+  ${MANTA_PP}/noisefield.h.reg.cpp
+  ${MANTA_PP}/particle.cpp
+  ${MANTA_PP}/particle.h
+  ${MANTA_PP}/particle.h.reg.cpp
+  ${MANTA_PP}/plugin/advection.cpp
+  ${MANTA_PP}/plugin/apic.cpp
+  ${MANTA_PP}/plugin/extforces.cpp
+  ${MANTA_PP}/plugin/fire.cpp
+  ${MANTA_PP}/plugin/flip.cpp
+  ${MANTA_PP}/plugin/fluidguiding.cpp
+  ${MANTA_PP}/plugin/initplugins.cpp
+  ${MANTA_PP}/plugin/kepsilon.cpp
+  ${MANTA_PP}/plugin/meshplugins.cpp
+# TODO (sebbas): add numpy to libraries
+#   ${MANTA_PP}/plugin/numpyconvert.cpp
+  ${MANTA_PP}/plugin/pressure.cpp
+  ${MANTA_PP}/plugin/ptsplugins.cpp
+  ${MANTA_PP}/plugin/secondaryparticles.cpp
+  ${MANTA_PP}/plugin/surfaceturbulence.cpp
+# TODO (sebbas): add numpy to libraries
+#   ${MANTA_PP}/plugin/tfplugins.cpp
+  ${MANTA_PP}/plugin/vortexplugins.cpp
+  ${MANTA_PP}/plugin/waveletturbulence.cpp
+  ${MANTA_PP}/plugin/waves.cpp
+  ${MANTA_PP}/python/defines.py
+  ${MANTA_PP}/python/defines.py.reg.cpp
+  ${MANTA_PP}/registration.cpp
+  ${MANTA_PP}/shapes.cpp
+  ${MANTA_PP}/shapes.h
+  ${MANTA_PP}/shapes.h.reg.cpp
+  ${MANTA_PP}/test.cpp
+  ${MANTA_PP}/timing.cpp
+  ${MANTA_PP}/timing.h
+  ${MANTA_PP}/timing.h.reg.cpp
+  ${MANTA_PP}/turbulencepart.cpp
+  ${MANTA_PP}/turbulencepart.h
+  ${MANTA_PP}/turbulencepart.h.reg.cpp
+  ${MANTA_PP}/vortexpart.cpp
+  ${MANTA_PP}/vortexpart.h
+  ${MANTA_PP}/vortexpart.h.reg.cpp
+  ${MANTA_PP}/vortexsheet.cpp
+  ${MANTA_PP}/vortexsheet.h
+  ${MANTA_PP}/vortexsheet.h.reg.cpp
+
+  ${MANTA_HLP}/pwrapper/manta.h
+# TODO (sebbas): add numpy to libraries
+#  ${MANTA_HLP}/pwrapper/numpyWrap.cpp
+#  ${MANTA_HLP}/pwrapper/numpyWrap.h
+  ${MANTA_HLP}/pwrapper/pclass.cpp
+  ${MANTA_HLP}/pwrapper/pclass.h
+  ${MANTA_HLP}/pwrapper/pconvert.cpp
+  ${MANTA_HLP}/pwrapper/pconvert.h
+  ${MANTA_HLP}/pwrapper/pvec3.cpp
+  ${MANTA_HLP}/pwrapper/pythonInclude.h
+  ${MANTA_HLP}/pwrapper/registry.cpp
+  ${MANTA_HLP}/pwrapper/registry.h
+  ${MANTA_HLP}/util/integrator.h
+  ${MANTA_HLP}/util/interpol.h
+  ${MANTA_HLP}/util/interpolHigh.h
+  ${MANTA_HLP}/util/matrixbase.h
+  ${MANTA_HLP}/util/mcubes.h
+  ${MANTA_HLP}/util/quaternion.h
+  ${MANTA_HLP}/util/randomstream.h
+  ${MANTA_HLP}/util/rcmatrix.h
+  ${MANTA_HLP}/util/simpleimage.cpp
+  ${MANTA_HLP}/util/simpleimage.h
+  ${MANTA_HLP}/util/solvana.h
+  ${MANTA_HLP}/util/vector4d.cpp
+  ${MANTA_HLP}/util/vector4d.h
+  ${MANTA_HLP}/util/vectorbase.cpp
+  ${MANTA_HLP}/util/vectorbase.h
+)
+
+set(LIB
+)
+
+blender_add_lib(extern_mantaflow "${SRC}" "${INC}" "${INC_SYS}" "${LIB}")
index e6b561c39b94a9452e9d4781e27ed546676d6c41..a5605e875a86aa23ef6770818e896259a75b1525 100644 (file)
@@ -40,14 +40,6 @@ if(WITH_MOD_REMESH)
   add_subdirectory(dualcon)
 endif()
 
-if(WITH_MOD_FLUID)
-  add_subdirectory(elbeem)
-endif()
-
-if(WITH_MOD_SMOKE)
-  add_subdirectory(smoke)
-endif()
-
 if(WITH_IK_SOLVER)
   add_subdirectory(iksolver)
 endif()
@@ -73,6 +65,10 @@ if(WIN32)
   add_subdirectory(utfconv)
 endif()
 
+if(WITH_MOD_FLUID)
+  add_subdirectory(mantaflow)
+endif()
+
 if(WITH_OPENVDB)
   add_subdirectory(openvdb)
 endif()
index 5c28404e745311541227eca6f04d073c8d3e4787..b18f9a37948cc0ae779d3c73e76dfd8242849bff 100644 (file)
@@ -283,7 +283,7 @@ static void mikk_compute_tangents(
 static void create_mesh_volume_attribute(
     BL::Object &b_ob, Mesh *mesh, ImageManager *image_manager, AttributeStandard std, float frame)
 {
-  BL::SmokeDomainSettings b_domain = object_smoke_domain_find(b_ob);
+  BL::FluidDomainSettings b_domain = object_fluid_domain_find(b_ob);
 
   if (!b_domain)
     return;
@@ -930,13 +930,13 @@ static void sync_mesh_fluid_motion(BL::Object &b_ob, Scene *scene, Mesh *mesh)
   if (scene->need_motion() == Scene::MOTION_NONE)
     return;
 
-  BL::DomainFluidSettings b_fluid_domain = object_fluid_domain_find(b_ob);
+  BL::FluidDomainSettings b_fluid_domain = object_fluid_domain_find(b_ob);
 
   if (!b_fluid_domain)
     return;
 
   /* If the mesh has modifiers following the fluid domain we can't export motion. */
-  if (b_fluid_domain.fluid_mesh_vertices.length() != mesh->verts.size())
+  if (b_fluid_domain.mesh_vertices.length() != mesh->verts.size())
     return;
 
   /* Find or add attribute */
@@ -953,13 +953,12 @@ static void sync_mesh_fluid_motion(BL::Object &b_ob, Scene *scene, Mesh *mesh)
     float relative_time = motion_times[step] * scene->motion_shutter_time() * 0.5f;
     float3 *mP = attr_mP->data_float3() + step * mesh->verts.size();
 
-    BL::DomainFluidSettings::fluid_mesh_vertices_iterator fvi;
+    BL::FluidDomainSettings::mesh_vertices_iterator svi;
     int i = 0;
 
-    for (b_fluid_domain.fluid_mesh_vertices.begin(fvi);
-         fvi != b_fluid_domain.fluid_mesh_vertices.end();
-         ++fvi, ++i) {
-      mP[i] = P[i] + get_float3(fvi->velocity()) * relative_time;
+    for (b_fluid_domain.mesh_vertices.begin(svi); svi != b_fluid_domain.mesh_vertices.end();
+         ++svi, ++i) {
+      mP[i] = P[i] + get_float3(svi->velocity()) * relative_time;
     }
   }
 }
@@ -1099,7 +1098,7 @@ Mesh *BlenderSync::sync_mesh(BL::Depsgraph &b_depsgraph,
   }
   mesh->geometry_flags = requested_geometry_flags;
 
-  /* fluid motion */
+  /* mesh fluid motion mantaflow */
   sync_mesh_fluid_motion(b_ob, scene, mesh);
 
   /* tag update */
@@ -1148,8 +1147,8 @@ void BlenderSync::sync_mesh_motion(BL::Depsgraph &b_depsgraph,
    * would need a more extensive check to see which objects are animated */
   BL::Mesh b_mesh(PointerRNA_NULL);
 
-  /* fluid motion is exported immediate with mesh, skip here */
-  BL::DomainFluidSettings b_fluid_domain = object_fluid_domain_find(b_ob);
+  /* manta motion is exported immediate with mesh, skip here */
+  BL::FluidDomainSettings b_fluid_domain = object_fluid_domain_find(b_ob);
   if (b_fluid_domain)
     return;
 
index 78fb49db6c8d974358b2799cddd57c0a0f523ac0..26b04babce2f3c802815c1683162cff0000032f2 100644 (file)
@@ -1158,7 +1158,7 @@ void BlenderSession::builtin_image_info(const string &builtin_name,
   else if (b_id.is_a(&RNA_Object)) {
     /* smoke volume data */
     BL::Object b_ob(b_id);
-    BL::SmokeDomainSettings b_domain = object_smoke_domain_find(b_ob);
+    BL::FluidDomainSettings b_domain = object_fluid_domain_find(b_ob);
 
     metadata.is_float = true;
     metadata.depth = 1;
@@ -1180,7 +1180,7 @@ void BlenderSession::builtin_image_info(const string &builtin_name,
       return;
 
     int3 resolution = get_int3(b_domain.domain_resolution());
-    int amplify = (b_domain.use_high_resolution()) ? b_domain.amplify() + 1 : 1;
+    int amplify = (b_domain.use_noise()) ? b_domain.noise_scale() : 1;
 
     /* Velocity and heat data is always low-resolution. */
     if (builtin_name == Attribute::standard_name(ATTR_STD_VOLUME_VELOCITY) ||
@@ -1339,14 +1339,14 @@ bool BlenderSession::builtin_image_float_pixels(const string &builtin_name,
   else if (b_id.is_a(&RNA_Object)) {
     /* smoke volume data */
     BL::Object b_ob(b_id);
-    BL::SmokeDomainSettings b_domain = object_smoke_domain_find(b_ob);
+    BL::FluidDomainSettings b_domain = object_fluid_domain_find(b_ob);
 
     if (!b_domain) {
       return false;
     }
 
     int3 resolution = get_int3(b_domain.domain_resolution());
-    int length, amplify = (b_domain.use_high_resolution()) ? b_domain.amplify() + 1 : 1;
+    int length, amplify = (b_domain.use_noise()) ? b_domain.noise_scale() : 1;
 
     /* Velocity and heat data is always low-resolution. */
     if (builtin_name == Attribute::standard_name(ATTR_STD_VOLUME_VELOCITY) ||
@@ -1360,47 +1360,47 @@ bool BlenderSession::builtin_image_float_pixels(const string &builtin_name,
     const size_t num_pixels = ((size_t)width) * height * depth;
 
     if (builtin_name == Attribute::standard_name(ATTR_STD_VOLUME_DENSITY)) {
-      SmokeDomainSettings_density_grid_get_length(&b_domain.ptr, &length);
+      FluidDomainSettings_density_grid_get_length(&b_domain.ptr, &length);
       if (length == num_pixels) {
-        SmokeDomainSettings_density_grid_get(&b_domain.ptr, pixels);
+        FluidDomainSettings_density_grid_get(&b_domain.ptr, pixels);
         return true;
       }
     }
     else if (builtin_name == Attribute::standard_name(ATTR_STD_VOLUME_FLAME)) {
       /* this is in range 0..1, and interpreted by the OpenGL smoke viewer
        * as 1500..3000 K with the first part faded to zero density */
-      SmokeDomainSettings_flame_grid_get_length(&b_domain.ptr, &length);
+      FluidDomainSettings_flame_grid_get_length(&b_domain.ptr, &length);
       if (length == num_pixels) {
-        SmokeDomainSettings_flame_grid_get(&b_domain.ptr, pixels);
+        FluidDomainSettings_flame_grid_get(&b_domain.ptr, pixels);
         return true;
       }
     }
     else if (builtin_name == Attribute::standard_name(ATTR_STD_VOLUME_COLOR)) {
       /* the RGB is "premultiplied" by density for better interpolation results */
-      SmokeDomainSettings_color_grid_get_length(&b_domain.ptr, &length);
+      FluidDomainSettings_color_grid_get_length(&b_domain.ptr, &length);
       if (length == num_pixels * 4) {
-        SmokeDomainSettings_color_grid_get(&b_domain.ptr, pixels);
+        FluidDomainSettings_color_grid_get(&b_domain.ptr, pixels);
         return true;
       }
     }
     else if (builtin_name == Attribute::standard_name(ATTR_STD_VOLUME_VELOCITY)) {
-      SmokeDomainSettings_velocity_grid_get_length(&b_domain.ptr, &length);
+      FluidDomainSettings_velocity_grid_get_length(&b_domain.ptr, &length);
       if (length == num_pixels * 3) {
-        SmokeDomainSettings_velocity_grid_get(&b_domain.ptr, pixels);
+        FluidDomainSettings_velocity_grid_get(&b_domain.ptr, pixels);
         return true;
       }
     }
     else if (builtin_name == Attribute::standard_name(ATTR_STD_VOLUME_HEAT)) {
-      SmokeDomainSettings_heat_grid_get_length(&b_domain.ptr, &length);
+      FluidDomainSettings_heat_grid_get_length(&b_domain.ptr, &length);
       if (length == num_pixels) {
-        SmokeDomainSettings_heat_grid_get(&b_domain.ptr, pixels);
+        FluidDomainSettings_heat_grid_get(&b_domain.ptr, pixels);
         return true;
       }
     }
     else if (builtin_name == Attribute::standard_name(ATTR_STD_VOLUME_TEMPERATURE)) {
-      SmokeDomainSettings_temperature_grid_get_length(&b_domain.ptr, &length);
+      FluidDomainSettings_temperature_grid_get_length(&b_domain.ptr, &length);
       if (length == num_pixels) {
-        SmokeDomainSettings_temperature_grid_get(&b_domain.ptr, pixels);
+        FluidDomainSettings_temperature_grid_get(&b_domain.ptr, pixels);
         return true;
       }
     }
index fa7646840c9dc5c431788f549ab75ee265e0f9e7..2c3e279a8d8b60a3274f77739c33e77c75a71ae5 100644 (file)
@@ -537,37 +537,20 @@ static inline bool object_use_deform_motion(BL::Object &b_parent, BL::Object &b_
   return use_deform_motion;
 }
 
-static inline BL::SmokeDomainSettings object_smoke_domain_find(BL::Object &b_ob)
+static inline BL::FluidDomainSettings object_fluid_domain_find(BL::Object &b_ob)
 {
   BL::Object::modifiers_iterator b_mod;
 
   for (b_ob.modifiers.begin(b_mod); b_mod != b_ob.modifiers.end(); ++b_mod) {
-    if (b_mod->is_a(&RNA_SmokeModifier)) {
-      BL::SmokeModifier b_smd(*b_mod);
+    if (b_mod->is_a(&RNA_FluidModifier)) {
+      BL::FluidModifier b_mmd(*b_mod);
 
-      if (b_smd.smoke_type() == BL::SmokeModifier::smoke_type_DOMAIN)
-        return b_smd.domain_settings();
+      if (b_mmd.fluid_type() == BL::FluidModifier::fluid_type_DOMAIN)
+        return b_mmd.domain_settings();
     }
   }
 
-  return BL::SmokeDomainSettings(PointerRNA_NULL);
-}
-
-static inline BL::DomainFluidSettings object_fluid_domain_find(BL::Object b_ob)
-{
-  BL::Object::modifiers_iterator b_mod;
-
-  for (b_ob.modifiers.begin(b_mod); b_mod != b_ob.modifiers.end(); ++b_mod) {
-    if (b_mod->is_a(&RNA_FluidSimulationModifier)) {
-      BL::FluidSimulationModifier b_fmd(*b_mod);
-      BL::FluidSettings fss = b_fmd.settings();
-
-      if (fss.type() == BL::FluidSettings::type_DOMAIN)
-        return (BL::DomainFluidSettings)b_fmd.settings();
-    }
-  }
-
-  return BL::DomainFluidSettings(PointerRNA_NULL);
+  return BL::FluidDomainSettings(PointerRNA_NULL);
 }
 
 static inline Mesh::SubdivisionType object_subdivision_type(BL::Object &b_ob,
index b0b6396312e7ceb78826d423f8f152ddba01c039..8a05b618f031582c006c6f62b9e60619ab3eef8b 160000 (submodule)
@@ -1 +1 @@
-Subproject commit b0b6396312e7ceb78826d423f8f152ddba01c039
+Subproject commit 8a05b618f031582c006c6f62b9e60619ab3eef8b
index 68d7b6d9b2de456b7d933db98812a1a0277cfb21..f6536692add0d3cead209e5da7592bf794261420 100644 (file)
@@ -53,6 +53,7 @@ set(SRC_DNA_INC
   ${CMAKE_CURRENT_SOURCE_DIR}/makesdna/DNA_linestyle_types.h
   ${CMAKE_CURRENT_SOURCE_DIR}/makesdna/DNA_listBase.h
   ${CMAKE_CURRENT_SOURCE_DIR}/makesdna/DNA_mask_types.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/makesdna/DNA_fluid_types.h
   ${CMAKE_CURRENT_SOURCE_DIR}/makesdna/DNA_material_types.h
   ${CMAKE_CURRENT_SOURCE_DIR}/makesdna/DNA_mesh_types.h
   ${CMAKE_CURRENT_SOURCE_DIR}/makesdna/DNA_meshdata_types.h
@@ -75,7 +76,6 @@ set(SRC_DNA_INC
   ${CMAKE_CURRENT_SOURCE_DIR}/makesdna/DNA_sdna_types.h
   ${CMAKE_CURRENT_SOURCE_DIR}/makesdna/DNA_sequence_types.h
   ${CMAKE_CURRENT_SOURCE_DIR}/makesdna/DNA_shader_fx_types.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/makesdna/DNA_smoke_types.h
   ${CMAKE_CURRENT_SOURCE_DIR}/makesdna/DNA_sound_types.h
   ${CMAKE_CURRENT_SOURCE_DIR}/makesdna/DNA_space_types.h
   ${CMAKE_CURRENT_SOURCE_DIR}/makesdna/DNA_speaker_types.h
index d422a3c023ec591143167e3b8cc34100e8ebd583..5d9f92432d1055dcb37e6b635131cd7b53566133 100644 (file)
@@ -42,6 +42,7 @@ extern "C" {
 #include "DNA_object_types.h"
 #include "DNA_scene_types.h"
 #include "DNA_space_types.h" /* for FILE_MAX */
+#include "DNA_fluid_types.h"
 
 #include "BLI_string.h"
 
@@ -105,11 +106,12 @@ ExportSettings::ExportSettings()
 
 static bool object_is_smoke_sim(Object *ob)
 {
-  ModifierData *md = modifiers_findByType(ob, eModifierType_Smoke);
+  ModifierData *md = modifiers_findByType(ob, eModifierType_Fluid);
 
   if (md) {
-    SmokeModifierData *smd = reinterpret_cast<SmokeModifierData *>(md);
-    return (smd->type == MOD_SMOKE_TYPE_DOMAIN);
+    FluidModifierData *smd = reinterpret_cast<FluidModifierData *>(md);
+    return (smd->type == MOD_FLUID_TYPE_DOMAIN && smd->domain &&
+            smd->domain->type == FLUID_DOMAIN_TYPE_GAS);
   }
 
   return false;
@@ -553,7 +555,10 @@ void AbcExporter::createParticleSystemsWriters(Object *ob, AbcTransformWriter *x
       m_settings.export_child_hairs = true;
       m_shapes.push_back(new AbcHairWriter(ob, xform, m_shape_sampling_index, m_settings, psys));
     }
-    else if (m_settings.export_particles && psys->part->type == PART_EMITTER) {
+    else if (m_settings.export_particles &&
+             (psys->part->type & PART_EMITTER || psys->part->type & PART_FLUID_FLIP ||
+              psys->part->type & PART_FLUID_SPRAY || psys->part->type & PART_FLUID_BUBBLE ||
+              psys->part->type & PART_FLUID_FOAM || psys->part->type & PART_FLUID_TRACER)) {
       m_shapes.push_back(new AbcPointsWriter(ob, xform, m_shape_sampling_index, m_settings, psys));
     }
   }
diff --git a/source/blender/blenkernel/BKE_fluid.h b/source/blender/blenkernel/BKE_fluid.h
new file mode 100644 (file)
index 0000000..8ada379
--- /dev/null
@@ -0,0 +1,69 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The Original Code is Copyright (C) Blender Foundation.
+ * All rights reserved.
+ */
+
+#ifndef __BKE_FLUID_H__
+#define __BKE_FLUID_H__
+
+/** \file
+ * \ingroup bke
+ */
+
+struct Scene;
+struct FluidDomainSettings;
+struct FluidModifierData;
+
+typedef float (*bresenham_callback)(
+    float *result, float *input, int res[3], int *pixel, float *tRay, float correct);
+
+struct Mesh *fluidModifier_do(struct FluidModifierData *mmd,
+                              struct Depsgraph *depsgraph,
+                              struct Scene *scene,
+                              struct Object *ob,
+                              struct Mesh *me);
+
+void fluidModifier_free(struct FluidModifierData *mmd);
+void fluidModifier_reset(struct FluidModifierData *mmd);
+void fluidModifier_createType(struct FluidModifierData *mmd);
+void fluidModifier_copy(const struct FluidModifierData *mmd,
+                        struct FluidModifierData *tmmd,
+                        const int flag);
+
+void BKE_fluid_reallocate_fluid(struct FluidDomainSettings *mds, int res[3], int free_old);
+void BKE_fluid_reallocate_copy_fluid(struct FluidDomainSettings *mds,
+                                     int o_res[3],
+                                     int n_res[3],
+                                     int o_min[3],
+                                     int n_min[3],
+                                     int o_max[3],
+                                     int o_shift[3],
+                                     int n_shift[3]);
+void BKE_fluid_cache_free(struct FluidDomainSettings *mds, struct Object *ob, int cache_map);
+
+float BKE_fluid_get_velocity_at(struct Object *ob, float position[3], float velocity[3]);
+int BKE_fluid_get_data_flags(struct FluidDomainSettings *mds);
+
+void BKE_fluid_create_particle_system(struct Main *bmain,
+                                      struct Object *ob,
+                                      const char *pset_name,
+                                      const char *parts_name,
+                                      const char *psys_name,
+                                      const int psys_type);
+void BKE_fluid_delete_particle_system(struct Object *ob, const int particle_type);
+
+#endif /* __BKE_FLUID_H__ */
diff --git a/source/blender/blenkernel/BKE_fluidsim.h b/source/blender/blenkernel/BKE_fluidsim.h
deleted file mode 100644 (file)
index d44c88c..0000000
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * The Original Code is Copyright (C) Blender Foundation
- * All rights reserved.
- */
-
-#ifndef __BKE_FLUIDSIM_H__
-#define __BKE_FLUIDSIM_H__
-
-/** \file
- * \ingroup bke
- */
-
-struct Depsgraph;
-struct FluidsimSettings;
-struct MVert;
-struct Object;
-struct Scene;
-
-/* old interface */
-
-void initElbeemMesh(struct Depsgraph *depsgraph,
-                    struct Scene *scene,
-                    struct Object *ob,
-                    int *numVertices,
-                    float **vertices,
-                    int *numTriangles,
-                    int **triangles,
-                    int useGlobalCoords,
-                    int modifierIndex);
-
-/* bounding box & memory estimate */
-void fluid_get_bb(
-    struct MVert *mvert, int totvert, float obmat[4][4], float start[3], float size[3]);
-
-void fluid_estimate_memory(struct Object *ob, struct FluidsimSettings *fss, char *value);
-
-#endif
index 6ce60081f5b54dedec173ac8baccd4eab90b74b8..2ebe485419aea333edc8f858789cc7ee1ec9e0f0 100644 (file)
@@ -83,7 +83,7 @@ struct ParticleSystem;
 struct PointCache;
 struct RigidBodyWorld;
 struct Scene;
-struct SmokeModifierData;
+struct FluidModifierData;
 struct SoftBody;
 struct ViewLayer;
 
@@ -286,7 +286,7 @@ void BKE_ptcache_make_particle_key(struct ParticleKey *key, int index, void **da
 void BKE_ptcache_id_from_softbody(PTCacheID *pid, struct Object *ob, struct SoftBody *sb);
 void BKE_ptcache_id_from_particles(PTCacheID *pid, struct Object *ob, struct ParticleSystem *psys);
 void BKE_ptcache_id_from_cloth(PTCacheID *pid, struct Object *ob, struct ClothModifierData *clmd);
-void BKE_ptcache_id_from_smoke(PTCacheID *pid, struct Object *ob, struct SmokeModifierData *smd);
+void BKE_ptcache_id_from_smoke(PTCacheID *pid, struct Object *ob, struct FluidModifierData *mmd);
 void BKE_ptcache_id_from_dynamicpaint(PTCacheID *pid,
                                       struct Object *ob,
                                       struct DynamicPaintSurface *surface);
diff --git a/source/blender/blenkernel/BKE_smoke.h b/source/blender/blenkernel/BKE_smoke.h
deleted file mode 100644 (file)
index 10632d4..0000000
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * The Original Code is Copyright (C) Blender Foundation.
- * All rights reserved.
- */
-
-#ifndef __BKE_SMOKE_H__
-#define __BKE_SMOKE_H__
-
-/** \file
- * \ingroup bke
- */
-
-struct Scene;
-struct SmokeDomainSettings;
-struct SmokeModifierData;
-
-typedef float (*bresenham_callback)(
-    float *result, float *input, int res[3], int *pixel, float *tRay, float correct);
-
-struct Mesh *smokeModifier_do(struct SmokeModifierData *smd,
-                              struct Depsgraph *depsgraph,
-                              struct Scene *scene,
-                              struct Object *ob,
-                              struct Mesh *me);
-
-void smokeModifier_free(struct SmokeModifierData *smd);
-void smokeModifier_reset(struct SmokeModifierData *smd);
-void smokeModifier_reset_turbulence(struct SmokeModifierData *smd);
-void smokeModifier_createType(struct SmokeModifierData *smd);
-void smokeModifier_copy(const struct SmokeModifierData *smd,
-                        struct SmokeModifierData *tsmd,
-                        const int flag);
-
-void BKE_smoke_reallocate_fluid(struct SmokeDomainSettings *sds,
-                                float dx,
-                                int res[3],
-                                int free_old);
-void BKE_smoke_reallocate_highres_fluid(struct SmokeDomainSettings *sds,
-                                        float dx,
-                                        int res[3],
-                                        int free_old);
-
-float BKE_smoke_get_velocity_at(struct Object *ob, float position[3], float velocity[3]);
-int BKE_smoke_get_data_flags(struct SmokeDomainSettings *sds);
-
-bool BKE_smoke_show_highres(struct Scene *scene, struct SmokeDomainSettings *sds);
-
-#endif /* __BKE_SMOKE_H__ */
index 88a3629ea3fac9cde8053636f5edafeaff854669..ad84a1b579c05618b4f4260163f58dc10b2d7300 100644 (file)
@@ -45,11 +45,11 @@ set(INC
   ../../../intern/atomic
   ../../../intern/clog
   ../../../intern/libmv
+  ../../../intern/mantaflow/extern
   ../../../intern/memutil
   ../../../intern/mikktspace
   ../../../intern/opensubdiv
   ../../../extern/curve_fit_nd
-  ../../../intern/smoke/extern
 
   # dna_type_offsets.h
   ${CMAKE_CURRENT_BINARY_DIR}/../makesdna/intern
@@ -114,7 +114,6 @@ set(SRC
   intern/editmesh_tangent.c
   intern/effect.c
   intern/fcurve.c
-  intern/fluidsim.c
   intern/fmodifier.c
   intern/font.c
   intern/freestyle.c
@@ -144,6 +143,7 @@ set(SRC
   intern/lightprobe.c
   intern/linestyle.c
   intern/main.c
+  intern/fluid.c
   intern/mask.c
   intern/mask_evaluate.c
   intern/mask_rasterize.c
@@ -198,7 +198,6 @@ set(SRC
   intern/sequencer.c
   intern/shader_fx.c
   intern/shrinkwrap.c
-  intern/smoke.c
   intern/softbody.c
   intern/sound.c
   intern/speaker.c
@@ -281,7 +280,6 @@ set(SRC
   BKE_editmesh_tangent.h
   BKE_effect.h
   BKE_fcurve.h
-  BKE_fluidsim.h
   BKE_font.h
   BKE_freestyle.h
   BKE_global.h
@@ -307,6 +305,7 @@ set(SRC
   BKE_lightprobe.h
   BKE_linestyle.h
   BKE_main.h
+  BKE_fluid.h
   BKE_mask.h
   BKE_material.h
   BKE_mball.h
@@ -341,7 +340,6 @@ set(SRC
   BKE_sequencer.h
   BKE_shader_fx.h
   BKE_shrinkwrap.h
-  BKE_smoke.h
   BKE_softbody.h
   BKE_sound.h
   BKE_speaker.h
@@ -526,20 +524,10 @@ if(WITH_PYTHON)
 endif()
 
 if(WITH_MOD_FLUID)
-  list(APPEND INC
-    ../../../intern/elbeem/extern
-  )
-  list(APPEND LIB
-    bf_intern_elbeem
-  )
-  add_definitions(-DWITH_MOD_FLUID)
-endif()
-
-if(WITH_MOD_SMOKE)
   list(APPEND LIB
-    bf_intern_smoke
+    bf_intern_mantaflow
   )
-  add_definitions(-DWITH_SMOKE)
+  add_definitions(-DWITH_FLUID)
 endif()
 
 if(WITH_MOD_OCEANSIM)
index de7837cdd90bee180361562fd40075245e06a060..90b26f8c2883870cbc2d272e4f490befa306a718 100644 (file)
@@ -59,7 +59,7 @@
 #include "DNA_texture_types.h"
 #include "DNA_vfont_types.h"
 #include "DNA_scene_types.h"
-#include "DNA_smoke_types.h"
+#include "DNA_fluid_types.h"
 #include "DNA_freestyle_types.h"
 
 #include "BLI_blenlib.h"
@@ -498,10 +498,10 @@ void BKE_bpath_traverse_id(
             rewrite_path_fixed(fluidmd->fss->surfdataPath, visit_cb, absbase, bpath_user_data);
           }
         }
-        else if (md->type == eModifierType_Smoke) {
-          SmokeModifierData *smd = (SmokeModifierData *)md;
-          if (smd->type & MOD_SMOKE_TYPE_DOMAIN) {
-            BPATH_TRAVERSE_POINTCACHE(smd->domain->ptcaches[0]);
+        else if (md->type == eModifierType_Fluid) {
+          FluidModifierData *mmd = (FluidModifierData *)md;
+          if (mmd->type & MOD_FLUID_TYPE_DOMAIN && mmd->domain) {
+            rewrite_path_fixed(mmd->domain->cache_directory, visit_cb, absbase, bpath_user_data);
           }
         }
         else if (md->type == eModifierType_Cloth) {
index 91b169590ac81b1eba94b204882e2438c5e6f50e..74a523bfbdc8620cbbb823937fb9f6b7b2446862 100644 (file)
@@ -6278,7 +6278,14 @@ static int dynamicPaint_doStep(Depsgraph *depsgraph,
 
           /* Apply brush on the surface depending on it's collision type */
           if (brush->psys && brush->psys->part &&
-              ELEM(brush->psys->part->type, PART_EMITTER, PART_FLUID) &&
+              ELEM(brush->psys->part->type,
+                   PART_EMITTER,
+                   PART_FLUID,
+                   PART_FLUID_FLIP,
+                   PART_FLUID_SPRAY,
+                   PART_FLUID_BUBBLE,
+                   PART_FLUID_FOAM,
+                   PART_FLUID_TRACER) &&
               psys_check_enabled(brushObj, brush->psys, for_render)) {
             /* Paint a particle system */
             dynamicPaint_paintParticles(surface, brush->psys, brush, timescale);
index ffab82b75af4716f1a050132b93ef2854a199330..91f831106750240e92f55416054d373b75b84c33 100644 (file)
@@ -62,7 +62,7 @@
 #include "BKE_object.h"
 #include "BKE_particle.h"
 #include "BKE_scene.h"
-#include "BKE_smoke.h"
+#include "BKE_fluid.h"
 
 #include "DEG_depsgraph.h"
 #include "DEG_depsgraph_physics.h"
 #include "RE_render_ext.h"
 #include "RE_shader_ext.h"
 
-/* fluid sim particle import */
-#ifdef WITH_MOD_FLUID
-#  include "LBM_fluidsim.h"
-#  include <zlib.h>
-#  include <string.h>
-#endif  // WITH_MOD_FLUID
-
 EffectorWeights *BKE_effector_add_weights(Collection *collection)
 {
   EffectorWeights *weights = MEM_callocN(sizeof(EffectorWeights), "EffectorWeights");
@@ -1033,7 +1026,7 @@ static void do_physical_effector(EffectorCache *eff,
       zero_v3(force);
       if (pd->f_source) {
         float density;
-        if ((density = BKE_smoke_get_velocity_at(pd->f_source, point->loc, force)) >= 0.0f) {
+        if ((density = BKE_fluid_get_velocity_at(pd->f_source, point->loc, force)) >= 0.0f) {
           float influence = strength * efd->falloff;
           if (pd->flag & PFIELD_SMOKE_DENSITY) {
             influence *= density;
diff --git a/source/blender/blenkernel/intern/fluidsim.c b/source/blender/blenkernel/intern/fluidsim.c
deleted file mode 100644 (file)
index 994e00f..0000000
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * The Original Code is Copyright (C) Blender Foundation
- * All rights reserved.
- */
-
-/** \file
- * \ingroup bke
- */
-
-#include "MEM_guardedalloc.h"
-
-#include "DNA_mesh_types.h"
-#include "DNA_meshdata_types.h"
-#include "DNA_object_types.h"
-
-#include "BLI_math.h"
-
-#include "BKE_customdata.h"
-#include "BKE_fluidsim.h"
-#include "BKE_library.h"
-#include "BKE_mesh_runtime.h"
-
-/* ************************* fluidsim bobj file handling **************************** */
-
-//-------------------------------------------------------------------------------
-// file handling
-//-------------------------------------------------------------------------------
-
-void initElbeemMesh(struct Depsgraph *depsgraph,
-                    struct Scene *scene,
-                    struct Object *ob,
-                    int *numVertices,
-                    float **vertices,
-                    int *numTriangles,
-                    int **triangles,
-                    int useGlobalCoords,
-                    int modifierIndex)
-{
-  Mesh *mesh;
-  const MVert *mvert;
-  const MLoop *mloop;
-  const MLoopTri *looptri, *lt;
-  int i, mvert_num, looptri_num;
-  float *verts;
-  int *tris;
-
-  mesh = mesh_create_eval_final_index_render(
-      depsgraph, scene, ob, &CD_MASK_BAREMESH, modifierIndex);
-
-  mvert = mesh->mvert;
-  mloop = mesh->mloop;
-  looptri = BKE_mesh_runtime_looptri_ensure(mesh);
-  mvert_num = mesh->totvert;
-  looptri_num = mesh->runtime.looptris.len;
-
-  *numVertices = mvert_num;
-  verts = MEM_mallocN(mvert_num * sizeof(float[3]), "elbeemmesh_vertices");
-  for (i = 0; i < mvert_num; i++) {
-    copy_v3_v3(&verts[i * 3], mvert[i].co);
-    if (useGlobalCoords) {
-      mul_m4_v3(ob->obmat, &verts[i * 3]);
-    }
-  }
-  *vertices = verts;
-
-  *numTriangles = looptri_num;
-  tris = MEM_mallocN(looptri_num * sizeof(int[3]), "elbeemmesh_triangles");
-  for (i = 0, lt = looptri; i < looptri_num; i++, lt++) {
-    tris[(i * 3) + 0] = mloop[lt->tri[0]].v;
-    tris[(i * 3) + 1] = mloop[lt->tri[1]].v;
-    tris[(i * 3) + 2] = mloop[lt->tri[2]].v;
-  }
-  *triangles = tris;
-
-  BKE_id_free(NULL, mesh);
-}
index fd7d2fd4a030d23c99ce30fb72b8792edf0988d5..f51cf2bc2b49709a7f58c591d1e77b9d484caa69 100644 (file)
@@ -108,7 +108,9 @@ void BKE_modifier_init(void)
 const ModifierTypeInfo *modifierType_getInfo(ModifierType type)
 {
   /* type unsigned, no need to check < 0 */
-  if (type < NUM_MODIFIER_TYPES && modifier_types[type]->name[0] != '\0') {
+  if (type < NUM_MODIFIER_TYPES && modifier_types[type] &&
+    modifier_types[type]->name[0] != '\0')
+  {
     return modifier_types[type];
   }
   else {
index 08890965ecea3f022df96dff740b80eefe2acc9c..10553e73d8d74c969ae29838874f47f1fcb26231 100644 (file)
@@ -39,6 +39,7 @@
 #include "DNA_key_types.h"
 #include "DNA_light_types.h"
 #include "DNA_lattice_types.h"
+#include "DNA_fluid_types.h"
 #include "DNA_material_types.h"
 #include "DNA_meta_types.h"
 #include "DNA_mesh_types.h"
@@ -48,7 +49,6 @@
 #include "DNA_screen_types.h"
 #include "DNA_sequence_types.h"
 #include "DNA_shader_fx_types.h"
-#include "DNA_smoke_types.h"
 #include "DNA_space_types.h"
 #include "DNA_view3d_types.h"
 #include "DNA_world_types.h"
 
 #include "DRW_engine.h"
 
-#ifdef WITH_MOD_FLUID
-#  include "LBM_fluidsim.h"
-#endif
-
 #ifdef WITH_PYTHON
 #  include "BPY_extern.h"
 #endif
@@ -1130,13 +1126,13 @@ void BKE_object_copy_particlesystems(Object *ob_dst, const Object *ob_src, const
           }
         }
       }
-      else if (md->type == eModifierType_Smoke) {
-        SmokeModifierData *smd = (SmokeModifierData *)md;
+      else if (md->type == eModifierType_Fluid) {
+        FluidModifierData *mmd = (FluidModifierData *)md;
 
-        if (smd->type == MOD_SMOKE_TYPE_FLOW) {
-          if (smd->flow) {
-            if (smd->flow->psys == psys) {
-              smd->flow->psys = npsys;
+        if (mmd->type == MOD_FLUID_TYPE_FLOW) {
+          if (mmd->flow) {
+            if (mmd->flow->psys == psys) {
+              mmd->flow->psys = npsys;
             }
           }
         }
@@ -4380,10 +4376,10 @@ bool BKE_object_modifier_update_subframe(Depsgraph *depsgraph,
       return true;
     }
   }
-  else if (type == eModifierType_Smoke) {
-    SmokeModifierData *smd = (SmokeModifierData *)md;
+  else if (type == eModifierType_Fluid) {
+    FluidModifierData *mmd = (FluidModifierData *)md;
 
-    if (smd && (smd->type & MOD_SMOKE_TYPE_DOMAIN) != 0) {
+    if (mmd && (mmd->type & MOD_FLUID_TYPE_DOMAIN) != 0) {
       return true;
     }
   }
index 096142b988959c3c4c95fa8433108116fe9a7e2d..ded38cf562f6db118feaa4765253ce701020bebf 100644 (file)
@@ -34,7 +34,7 @@
 #include "DNA_mesh_types.h"
 #include "DNA_meshdata_types.h"
 #include "DNA_particle_types.h"
-#include "DNA_smoke_types.h"
+#include "DNA_fluid_types.h"
 #include "DNA_scene_types.h"
 #include "DNA_dynamicpaint_types.h"
 
@@ -360,6 +360,11 @@ bool psys_check_enabled(Object *ob, ParticleSystem *psys, const bool use_render_
   }
 
   psmd = psys_get_modifier(ob, psys);
+
+  if (!psmd) {
+    return 0;
+  }
+
   if (use_render_params) {
     if (!(psmd->modifier.mode & eModifierMode_Render)) {
       return 0;
@@ -3577,12 +3582,12 @@ void object_remove_particle_system(Main *bmain, Scene *UNUSED(scene), Object *ob
     return;
   }
 
-  /* clear all other appearances of this pointer (like on smoke flow modifier) */
-  if ((md = modifiers_findByType(ob, eModifierType_Smoke))) {
-    SmokeModifierData *smd = (SmokeModifierData *)md;
-    if ((smd->type == MOD_SMOKE_TYPE_FLOW) && smd->flow && smd->flow->psys) {
-      if (smd->flow->psys == psys) {
-        smd->flow->psys = NULL;
+  /* clear all other appearances of this pointer (like on manta flow modifier) */
+  if ((md = modifiers_findByType(ob, eModifierType_Fluid))) {
+    FluidModifierData *mmd = (FluidModifierData *)md;
+    if ((mmd->type == MOD_FLUID_TYPE_FLOW) && mmd->flow && mmd->flow->psys) {
+      if (mmd->flow->psys == psys) {
+        mmd->flow->psys = NULL;
       }
     }
   }
index 7ae5f91c615c2a5d10001629f14218bdd24af189..5e1611cb3f95817ebcb1a94e0f305bf2708c98ce 100644 (file)
@@ -40,7 +40,7 @@
 #include "DNA_particle_types.h"
 #include "DNA_rigidbody_types.h"
 #include "DNA_scene_types.h"
-#include "DNA_smoke_types.h"
+#include "DNA_fluid_types.h"
 
 #include "BLI_blenlib.h"
 #include "BLI_math.h"
@@ -64,7 +64,7 @@
 #include "BKE_particle.h"
 #include "BKE_pointcache.h"
 #include "BKE_scene.h"
-#include "BKE_smoke.h"
+#include "BKE_fluid.h"
 #include "BKE_softbody.h"
 
 #include "BIK_api.h"
@@ -591,11 +591,11 @@ static void ptcache_cloth_error(void *cloth_v, const char *message)
 /* Smoke functions */
 static int ptcache_smoke_totpoint(void *smoke_v, int UNUSED(cfra))
 {
-  SmokeModifierData *smd = (SmokeModifierData *)smoke_v;
-  SmokeDomainSettings *sds = smd->domain;
+  FluidModifierData *mmd = (FluidModifierData *)smoke_v;
+  FluidDomainSettings *mds = mmd->domain;
 
-  if (sds->fluid) {
-    return sds->base_res[0] * sds->base_res[1] * sds->base_res[2];
+  if (mds->fluid) {
+    return mds->base_res[0] * mds->base_res[1] * mds->base_res[2];
   }
   else {
     return 0;
@@ -604,28 +604,28 @@ static int ptcache_smoke_totpoint(void *smoke_v, int UNUSED(cfra))
 
 static void ptcache_smoke_error(void *smoke_v, const char *message)
 {
-  SmokeModifierData *smd = (SmokeModifierData *)smoke_v;
-  modifier_setError(&smd->modifier, "%s", message);
+  FluidModifierData *mmd = (FluidModifierData *)smoke_v;
+  modifier_setError(&mmd->modifier, "%s", message);
 }
 
 #  define SMOKE_CACHE_VERSION "1.04"
 
 static int ptcache_smoke_write(PTCacheFile *pf, void *smoke_v)
 {
-  SmokeModifierData *smd = (SmokeModifierData *)smoke_v;
-  SmokeDomainSettings *sds = smd->domain;
+  FluidModifierData *mmd = (FluidModifierData *)smoke_v;
+  FluidDomainSettings *mds = mmd->domain;
   int ret = 0;
-  int fluid_fields = BKE_smoke_get_data_flags(sds);
+  int fluid_fields = BKE_fluid_get_data_flags(mds);
 
   /* version header */
   ptcache_file_write(pf, SMOKE_CACHE_VERSION, 4, sizeof(char));
   ptcache_file_write(pf, &fluid_fields, 1, sizeof(int));
-  ptcache_file_write(pf, &sds->active_fields, 1, sizeof(int));
-  ptcache_file_write(pf, &sds->res, 3, sizeof(int));
-  ptcache_file_write(pf, &sds->dx, 1, sizeof(float));
+  ptcache_file_write(pf, &mds->active_fields, 1, sizeof(int));
+  ptcache_file_write(pf, &mds->res, 3, sizeof(int));
+  ptcache_file_write(pf, &mds->dx, 1, sizeof(float));
 
-  if (sds->fluid) {
-    size_t res = sds->res[0] * sds->res[1] * sds->res[2];
+  if (mds->fluid) {
+    size_t res = mds->res[0] * mds->res[1] * mds->res[2];
     float dt, dx, *dens, *react, *fuel, *flame, *heat, *heatold, *vx, *vy, *vz, *r, *g, *b;
     unsigned char *obstacles;
     unsigned int in_len = sizeof(float) * (unsigned int)res;
@@ -633,11 +633,11 @@ static int ptcache_smoke_write(PTCacheFile *pf, void *smoke_v)
                                                       "pointcache_lzo_buffer");
     // int mode = res >= 1000000 ? 2 : 1;
     int mode = 1;  // light
-    if (sds->cache_comp == SM_CACHE_HEAVY) {
+    if (mds->cache_comp == SM_CACHE_HEAVY) {
       mode = 2;  // heavy
     }
 
-    smoke_export(sds->fluid,
+    smoke_export(mds->fluid,
                  &dt,
                  &dx,
                  &dens,
@@ -652,20 +652,21 @@ static int ptcache_smoke_write(PTCacheFile *pf, void *smoke_v)
                  &r,
                  &g,
                  &b,
-                 &obstacles);
+                 &obstacles,
+                 NULL);
 
-    ptcache_file_compressed_write(pf, (unsigned char *)sds->shadow, in_len, out, mode);
+    ptcache_file_compressed_write(pf, (unsigned char *)mds->shadow, in_len, out, mode);
     ptcache_file_compressed_write(pf, (unsigned char *)dens, in_len, out, mode);
-    if (fluid_fields & SM_ACTIVE_HEAT) {
+    if (fluid_fields & FLUID_DOMAIN_ACTIVE_HEAT) {
       ptcache_file_compressed_write(pf, (unsigned char *)heat, in_len, out, mode);
       ptcache_file_compressed_write(pf, (unsigned char *)heatold, in_len, out, mode);
     }
-    if (fluid_fields & SM_ACTIVE_FIRE) {
+    if (fluid_fields & FLUID_DOMAIN_ACTIVE_FIRE) {
       ptcache_file_compressed_write(pf, (unsigned char *)flame, in_len, out, mode);
       ptcache_file_compressed_write(pf, (unsigned char *)fuel, in_len, out, mode);
       ptcache_file_compressed_write(pf, (unsigned char *)react, in_len, out, mode);
     }
-    if (fluid_fields & SM_ACTIVE_COLORS) {
+    if (fluid_fields & FLUID_DOMAIN_ACTIVE_COLORS) {
       ptcache_file_compressed_write(pf, (unsigned char *)r, in_len, out, mode);
       ptcache_file_compressed_write(pf, (unsigned char *)g, in_len, out, mode);
       ptcache_file_compressed_write(pf, (unsigned char *)b, in_len, out, mode);
@@ -676,52 +677,52 @@ static int ptcache_smoke_write(PTCacheFile *pf, void *smoke_v)
     ptcache_file_compressed_write(pf, (unsigned char *)obstacles, (unsigned int)res, out, mode);
     ptcache_file_write(pf, &dt, 1, sizeof(float));
     ptcache_file_write(pf, &dx, 1, sizeof(float));
-    ptcache_file_write(pf, &sds->p0, 3, sizeof(float));
-    ptcache_file_write(pf, &sds->p1, 3, sizeof(float));
-    ptcache_file_write(pf, &sds->dp0, 3, sizeof(float));
-    ptcache_file_write(pf, &sds->shift, 3, sizeof(int));
-    ptcache_file_write(pf, &sds->obj_shift_f, 3, sizeof(float));
-    ptcache_file_write(pf, &sds->obmat, 16, sizeof(float));
-    ptcache_file_write(pf, &sds->base_res, 3, sizeof(int));
-    ptcache_file_write(pf, &sds->res_min, 3, sizeof(int));
-    ptcache_file_write(pf, &sds->res_max, 3, sizeof(int));
-    ptcache_file_write(pf, &sds->active_color, 3, sizeof(float));
+    ptcache_file_write(pf, &mds->p0, 3, sizeof(float));
+    ptcache_file_write(pf, &mds->p1, 3, sizeof(float));
+    ptcache_file_write(pf, &mds->dp0, 3, sizeof(float));
+    ptcache_file_write(pf, &mds->shift, 3, sizeof(int));
+    ptcache_file_write(pf, &mds->obj_shift_f, 3, sizeof(float));
+    ptcache_file_write(pf, &mds->obmat, 16, sizeof(float));
+    ptcache_file_write(pf, &mds->base_res, 3, sizeof(int));
+    ptcache_file_write(pf, &mds->res_min, 3, sizeof(int));
+    ptcache_file_write(pf, &mds->res_max, 3, sizeof(int));
+    ptcache_file_write(pf, &mds->active_color, 3, sizeof(float));
 
     MEM_freeN(out);
 
     ret = 1;
   }
 
-  if (sds->wt) {
+  if (mds->wt) {
     int res_big_array[3];
     int res_big;
-    int res = sds->res[0] * sds->res[1] * sds->res[2];
+    int res = mds->res[0] * mds->res[1] * mds->res[2];
     float *dens, *react, *fuel, *flame, *tcu, *tcv, *tcw, *r, *g, *b;
     unsigned int in_len = sizeof(float) * (unsigned int)res;
     unsigned int in_len_big;
     unsigned char *out;
     int mode;
 
-    smoke_turbulence_get_res(sds->wt, res_big_array);
+    smoke_turbulence_get_res(mds->wt, res_big_array);
     res_big = res_big_array[0] * res_big_array[1] * res_big_array[2];
     // mode =  res_big >= 1000000 ? 2 : 1;
     mode = 1;  // light
-    if (sds->cache_high_comp == SM_CACHE_HEAVY) {
+    if (mds->cache_high_comp == SM_CACHE_HEAVY) {
       mode = 2;  // heavy
     }
 
     in_len_big = sizeof(float) * (unsigned int)res_big;
 
-    smoke_turbulence_export(sds->wt, &dens, &react, &flame, &fuel, &r, &g, &b, &tcu, &tcv, &tcw);
+    smoke_turbulence_export(mds->wt, &dens, &react, &flame, &fuel, &r, &g, &b, &tcu, &tcv, &tcw);
 
     out = (unsigned char *)MEM_callocN(LZO_OUT_LEN(in_len_big), "pointcache_lzo_buffer");
     ptcache_file_compressed_write(pf, (unsigned char *)dens, in_len_big, out, mode);
-    if (fluid_fields & SM_ACTIVE_FIRE) {
+    if (fluid_fields & FLUID_DOMAIN_ACTIVE_FIRE) {
       ptcache_file_compressed_write(pf, (unsigned char *)flame, in_len_big, out, mode);
       ptcache_file_compressed_write(pf, (unsigned char *)fuel, in_len_big, out, mode);
       ptcache_file_compressed_write(pf, (unsigned char *)react, in_len_big, out, mode);
     }
-    if (fluid_fields & SM_ACTIVE_COLORS) {
+    if (fluid_fields & FLUID_DOMAIN_ACTIVE_COLORS) {
       ptcache_file_compressed_write(pf, (unsigned char *)r, in_len_big, out, mode);
       ptcache_file_compressed_write(pf, (unsigned char *)g, in_len_big, out, mode);
       ptcache_file_compressed_write(pf, (unsigned char *)b, in_len_big, out, mode);
@@ -743,24 +744,24 @@ static int ptcache_smoke_write(PTCacheFile *pf, void *smoke_v)
 /* read old smoke cache from 2.64 */
 static int ptcache_smoke_read_old(PTCacheFile *pf, void *smoke_v)
 {
-  SmokeModifierData *smd = (SmokeModifierData *)smoke_v;
-  SmokeDomainSettings *sds = smd->domain;
+  FluidModifierData *mmd = (FluidModifierData *)smoke_v;
+  FluidDomainSettings *mds = mmd->domain;
 
-  if (sds->fluid) {
-    const size_t res = sds->res[0] * sds->res[1] * sds->res[2];
+  if (mds->fluid) {
+    const size_t res = mds->res[0] * mds->res[1] * mds->res[2];
     const unsigned int out_len = (unsigned int)res * sizeof(float);
     float dt, dx, *dens, *heat, *heatold, *vx, *vy, *vz;
     unsigned char *obstacles;
     float *tmp_array = MEM_callocN(out_len, "Smoke old cache tmp");
 
-    int fluid_fields = BKE_smoke_get_data_flags(sds);
+    int fluid_fields = BKE_fluid_get_data_flags(mds);
 
     /* Part part of the new cache header */
-    sds->active_color[0] = 0.7f;
-    sds->active_color[1] = 0.7f;
-    sds->active_color[2] = 0.7f;
+    mds->active_color[0] = 0.7f;
+    mds->active_color[1] = 0.7f;
+    mds->active_color[2] = 0.7f;
 
-    smoke_export(sds->fluid,
+    smoke_export(mds->fluid,
                  &dt,
                  &dx,
                  &dens,
@@ -775,13 +776,14 @@ static int ptcache_smoke_read_old(PTCacheFile *pf, void *smoke_v)
                  NULL,
                  NULL,
                  NULL,
-                 &obstacles);
+                 &obstacles,
+                 NULL);
 
-    ptcache_file_compressed_read(pf, (unsigned char *)sds->shadow, out_len);
+    ptcache_file_compressed_read(pf, (unsigned char *)mds->shadow, out_len);
     ptcache_file_compressed_read(pf, (unsigned char *)dens, out_len);
     ptcache_file_compressed_read(pf, (unsigned char *)tmp_array, out_len);
 
-    if (fluid_fields & SM_ACTIVE_HEAT) {
+    if (fluid_fields & FLUID_DOMAIN_ACTIVE_HEAT) {
       ptcache_file_compressed_read(pf, (unsigned char *)heat, out_len);
       ptcache_file_compressed_read(pf, (unsigned char *)heatold, out_len);
     }
@@ -801,19 +803,19 @@ static int ptcache_smoke_read_old(PTCacheFile *pf, void *smoke_v)
 
     MEM_freeN(tmp_array);
 
-    if (pf->data_types & (1 << BPHYS_DATA_SMOKE_HIGH) && sds->wt) {
+    if (pf->data_types & (1 << BPHYS_DATA_SMOKE_HIGH) && mds->wt) {
       int res_big, res_big_array[3];
       float *tcu, *tcv, *tcw;
       unsigned int out_len_big;
       unsigned char *tmp_array_big;
-      smoke_turbulence_get_res(sds->wt, res_big_array);
+      smoke_turbulence_get_res(mds->wt, res_big_array);
       res_big = res_big_array[0] * res_big_array[1] * res_big_array[2];
       out_len_big = sizeof(float) * (unsigned int)res_big;
 
       tmp_array_big = MEM_callocN(out_len_big, "Smoke old cache tmp");
 
       smoke_turbulence_export(
-          sds->wt, &dens, NULL, NULL, NULL, NULL, NULL, NULL, &tcu, &tcv, &tcw);
+          mds->wt, &dens, NULL, NULL, NULL, NULL, NULL, NULL, &tcu, &tcv, &tcw);
 
       ptcache_file_compressed_read(pf, (unsigned char *)dens, out_len_big);
       ptcache_file_compressed_read(pf, (unsigned char *)tmp_array_big, out_len_big);
@@ -831,12 +833,12 @@ static int ptcache_smoke_read_old(PTCacheFile *pf, void *smoke_v)
 
 static int ptcache_smoke_read(PTCacheFile *pf, void *smoke_v)
 {
-  SmokeModifierData *smd = (SmokeModifierData *)smoke_v;
-  SmokeDomainSettings *sds = smd->domain;
+  FluidModifierData *mmd = (FluidModifierData *)smoke_v;
+  FluidDomainSettings *mds = mmd->domain;
   char version[4];
   int ch_res[3];
   float ch_dx;
-  int fluid_fields = BKE_smoke_get_data_flags(sds);
+  int fluid_fields = BKE_fluid_get_data_flags(mds);
   int cache_fields = 0;
   int active_fields = 0;
   int reallocate = 0;
@@ -856,8 +858,8 @@ static int ptcache_smoke_read(PTCacheFile *pf, void *smoke_v)
   ptcache_file_read(pf, &ch_dx, 1, sizeof(float));
 
   /* check if resolution has changed */
-  if (sds->res[0] != ch_res[0] || sds->res[1] != ch_res[1] || sds->res[2] != ch_res[2]) {
-    if (sds->flags & MOD_SMOKE_ADAPTIVE_DOMAIN) {
+  if (mds->res[0] != ch_res[0] || mds->res[1] != ch_res[1] || mds->res[2] != ch_res[2]) {
+    if (mds->flags & FLUID_DOMAIN_USE_ADAPTIVE_DOMAIN) {
       reallocate = 1;
     }
     else {
@@ -865,29 +867,26 @@ static int ptcache_smoke_read(PTCacheFile *pf, void *smoke_v)
     }
   }
   /* check if active fields have changed */
-  if (fluid_fields != cache_fields || active_fields != sds->active_fields) {
+  if (fluid_fields != cache_fields || active_fields != mds->active_fields) {
     reallocate = 1;
   }
 
   /* reallocate fluid if needed*/
   if (reallocate) {
-    sds->active_fields = active_fields | cache_fields;
-    BKE_smoke_reallocate_fluid(sds, ch_dx, ch_res, 1);
-    sds->dx = ch_dx;
-    copy_v3_v3_int(sds->res, ch_res);
-    sds->total_cells = ch_res[0] * ch_res[1] * ch_res[2];
-    if (sds->flags & MOD_SMOKE_HIGHRES) {
-      BKE_smoke_reallocate_highres_fluid(sds, ch_dx, ch_res, 1);
-    }
+    mds->active_fields = active_fields | cache_fields;
+    BKE_fluid_reallocate_fluid(mds, ch_res, 1);
+    mds->dx = ch_dx;
+    copy_v3_v3_int(mds->res, ch_res);
+    mds->total_cells = ch_res[0] * ch_res[1] * ch_res[2];
   }
 
-  if (sds->fluid) {
-    size_t res = sds->res[0] * sds->res[1] * sds->res[2];
+  if (mds->fluid) {
+    size_t res = mds->res[0] * mds->res[1] * mds->res[2];
     float dt, dx, *dens, *react, *fuel, *flame, *heat, *heatold, *vx, *vy, *vz, *r, *g, *b;
     unsigned char *obstacles;
     unsigned int out_len = (unsigned int)res * sizeof(float);
 
-    smoke_export(sds->fluid,
+    smoke_export(mds->fluid,
                  &dt,
                  &dx,
                  &dens,
@@ -902,20 +901,21 @@ static int ptcache_smoke_read(PTCacheFile *pf, void *smoke_v)
                  &r,
                  &g,
                  &b,
-                 &obstacles);
+                 &obstacles,
+                 NULL);
 
-    ptcache_file_compressed_read(pf, (unsigned char *)sds->shadow, out_len);
+    ptcache_file_compressed_read(pf, (unsigned char *)mds->shadow, out_len);
     ptcache_file_compressed_read(pf, (unsigned char *)dens, out_len);
-    if (cache_fields & SM_ACTIVE_HEAT) {
+    if (cache_fields & FLUID_DOMAIN_ACTIVE_HEAT) {
       ptcache_file_compressed_read(pf, (unsigned char *)heat, out_len);
       ptcache_file_compressed_read(pf, (unsigned char *)heatold, out_len);
     }
-    if (cache_fields & SM_ACTIVE_FIRE) {
+    if (cache_fields & FLUID_DOMAIN_ACTIVE_FIRE) {
       ptcache_file_compressed_read(pf, (unsigned char *)flame, out_len);
       ptcache_file_compressed_read(pf, (unsigned char *)fuel, out_len);
       ptcache_file_compressed_read(pf, (unsigned char *)react, out_len);
     }
-    if (cache_fields & SM_ACTIVE_COLORS) {
+    if (cache_fields & FLUID_DOMAIN_ACTIVE_COLORS) {
       ptcache_file_compressed_read(pf, (unsigned char *)r, out_len);
       ptcache_file_compressed_read(pf, (unsigned char *)g, out_len);
       ptcache_file_compressed_read(pf, (unsigned char *)b, out_len);
@@ -926,38 +926,38 @@ static int ptcache_smoke_read(PTCacheFile *pf, void *smoke_v)
     ptcache_file_compressed_read(pf, (unsigned char *)obstacles, (unsigned int)res);
     ptcache_file_read(pf, &dt, 1, sizeof(float));
     ptcache_file_read(pf, &dx, 1, sizeof(float));
-    ptcache_file_read(pf, &sds->p0, 3, sizeof(float));
-    ptcache_file_read(pf, &sds->p1, 3, sizeof(float));
-    ptcache_file_read(pf, &sds->dp0, 3, sizeof(float));
-    ptcache_file_read(pf, &sds->shift, 3, sizeof(int));
-    ptcache_file_read(pf, &sds->obj_shift_f, 3, sizeof(float));
-    ptcache_file_read(pf, &sds->obmat, 16, sizeof(float));
-    ptcache_file_read(pf, &sds->base_res, 3, sizeof(int));
-    ptcache_file_read(pf, &sds->res_min, 3, sizeof(int));
-    ptcache_file_read(pf, &sds->res_max, 3, sizeof(int));
-    ptcache_file_read(pf, &sds->active_color, 3, sizeof(float));
-  }
-
-  if (pf->data_types & (1 << BPHYS_DATA_SMOKE_HIGH) && sds->wt) {
-    int res = sds->res[0] * sds->res[1] * sds->res[2];
+    ptcache_file_read(pf, &mds->p0, 3, sizeof(float));
+    ptcache_file_read(pf, &mds->p1, 3, sizeof(float));
+    ptcache_file_read(pf, &mds->dp0, 3, sizeof(float));
+    ptcache_file_read(pf, &mds->shift, 3, sizeof(int));
+    ptcache_file_read(pf, &mds->obj_shift_f, 3, sizeof(float));
+    ptcache_file_read(pf, &mds->obmat, 16, sizeof(float));
+    ptcache_file_read(pf, &mds->base_res, 3, sizeof(int));
+    ptcache_file_read(pf, &mds->res_min, 3, sizeof(int));
+    ptcache_file_read(pf, &mds->res_max, 3, sizeof(int));
+    ptcache_file_read(pf, &mds->active_color, 3, sizeof(float));
+  }
+
+  if (pf->data_types & (1 << BPHYS_DATA_SMOKE_HIGH) && mds->wt) {
+    int res = mds->res[0] * mds->res[1] * mds->res[2];
     int res_big, res_big_array[3];
     float *dens, *react, *fuel, *flame, *tcu, *tcv, *tcw, *r, *g, *b;
     unsigned int out_len = sizeof(float) * (unsigned int)res;
     unsigned int out_len_big;
 
-    smoke_turbulence_get_res(sds->wt, res_big_array);
+    smoke_turbulence_get_res(mds->wt, res_big_array);
     res_big = res_big_array[0] * res_big_array[1] * res_big_array[2];
     out_len_big = sizeof(float) * (unsigned int)res_big;
 
-    smoke_turbulence_export(sds->wt, &dens, &react, &flame, &fuel, &r, &g, &b, &tcu, &tcv, &tcw);
+    smoke_turbulence_export(mds->wt, &dens, &react, &flame, &fuel, &r, &g, &b, &tcu, &tcv, &tcw);
 
     ptcache_file_compressed_read(pf, (unsigned char *)dens, out_len_big);
-    if (cache_fields & SM_ACTIVE_FIRE) {
+    if (cache_fields & FLUID_DOMAIN_ACTIVE_FIRE) {
       ptcache_file_compressed_read(pf, (unsigned char *)flame, out_len_big);
       ptcache_file_compressed_read(pf, (unsigned char *)fuel, out_len_big);
       ptcache_file_compressed_read(pf, (unsigned char *)react, out_len_big);
     }
-    if (cache_fields & SM_ACTIVE_COLORS) {
+    if (cache_fields & FLUID_DOMAIN_ACTIVE_COLORS) {
       ptcache_file_compressed_read(pf, (unsigned char *)r, out_len_big);
       ptcache_file_compressed_read(pf, (unsigned char *)g, out_len_big);
       ptcache_file_compressed_read(pf, (unsigned char *)b, out_len_big);
@@ -984,101 +984,101 @@ static int ptcache_smoke_read(PTCacheFile *pf, void *smoke_v)
  * with `vs` = voxel size, and `px, py, pz`,
  * the min position of the domain's bounding box.
  */
-static void compute_fluid_matrices(SmokeDomainSettings *sds)
+static void compute_fluid_matrices(FluidDomainSettings *mds)
 {
   float bbox_min[3];
 
-  copy_v3_v3(bbox_min, sds->p0);
+  copy_v3_v3(bbox_min, mds->p0);
 
-  if (sds->flags & MOD_SMOKE_ADAPTIVE_DOMAIN) {
-    bbox_min[0] += (sds->cell_size[0] * (float)sds->res_min[0]);
-    bbox_min[1] += (sds->cell_size[1] * (float)sds->res_min[1]);
-    bbox_min[2] += (sds->cell_size[2] * (float)sds->res_min[2]);
-    add_v3_v3(bbox_min, sds->obj_shift_f);
+  if (mds->flags & FLUID_DOMAIN_USE_ADAPTIVE_DOMAIN) {
+    bbox_min[0] += (mds->cell_size[0] * (float)mds->res_min[0]);
+    bbox_min[1] += (mds->cell_size[1] * (float)mds->res_min[1]);
+    bbox_min[2] += (mds->cell_size[2] * (float)mds->res_min[2]);
+    add_v3_v3(bbox_min, mds->obj_shift_f);
   }
 
   /* construct low res matrix */
-  size_to_mat4(sds->fluidmat, sds->cell_size);
-  copy_v3_v3(sds->fluidmat[3], bbox_min);
+  size_to_mat4(mds->fluidmat, mds->cell_size);
+  copy_v3_v3(mds->fluidmat[3], bbox_min);
 
   /* The smoke simulator stores voxels cell-centered, whilst VDB is node
    * centered, so we offset the matrix by half a voxel to compensate. */
-  madd_v3_v3fl(sds->fluidmat[3], sds->cell_size, 0.5f);
+  madd_v3_v3fl(mds->fluidmat[3], mds->cell_size, 0.5f);
 
-  mul_m4_m4m4(sds->fluidmat, sds->obmat, sds->fluidmat);
+  mul_m4_m4m4(mds->fluidmat, mds->obmat, mds->fluidmat);
 
-  if (sds->wt) {
+  if (mds->wt) {
     float voxel_size_high[3];
     /* construct high res matrix */
-    mul_v3_v3fl(voxel_size_high, sds->cell_size, 1.0f / (float)(sds->amplify + 1));
-    size_to_mat4(sds->fluidmat_wt, voxel_size_high);
-    copy_v3_v3(sds->fluidmat_wt[3], bbox_min);
+    mul_v3_v3fl(voxel_size_high, mds->cell_size, 1.0f / (float)(mds->amplify + 1));
+    size_to_mat4(mds->fluidmat_wt, voxel_size_high);
+    copy_v3_v3(mds->fluidmat_wt[3], bbox_min);
 
     /* Same here, add half a voxel to adjust the position of the fluid. */
-    madd_v3_v3fl(sds->fluidmat_wt[3], voxel_size_high, 0.5f);
+    madd_v3_v3fl(mds->fluidmat_wt[3], voxel_size_high, 0.5f);
 
-    mul_m4_m4m4(sds->fluidmat_wt, sds->obmat, sds->fluidmat_wt);
+    mul_m4_m4m4(mds->fluidmat_wt, mds->obmat, mds->fluidmat_wt);
   }
 }
 
 static int ptcache_smoke_openvdb_write(struct OpenVDBWriter *writer, void *smoke_v)
 {
-  SmokeModifierData *smd = (SmokeModifierData *)smoke_v;
-  SmokeDomainSettings *sds = smd->domain;
-
-  OpenVDBWriter_set_flags(writer, sds->openvdb_comp, (sds->data_depth == 16));
-
-  OpenVDBWriter_add_meta_int(writer, "blender/smoke/active_fields", sds->active_fields);
-  OpenVDBWriter_add_meta_v3_int(writer, "blender/smoke/resolution", sds->res);
-  OpenVDBWriter_add_meta_v3_int(writer, "blender/smoke/min_resolution", sds->res_min);
-  OpenVDBWriter_add_meta_v3_int(writer, "blender/smoke/max_resolution", sds->res_max);
-  OpenVDBWriter_add_meta_v3_int(writer, "blender/smoke/base_resolution", sds->base_res);
-  OpenVDBWriter_add_meta_v3(writer, "blender/smoke/min_bbox", sds->p0);
-  OpenVDBWriter_add_meta_v3(writer, "blender/smoke/max_bbox", sds->p1);
-  OpenVDBWriter_add_meta_v3(writer, "blender/smoke/dp0", sds->dp0);
-  OpenVDBWriter_add_meta_v3_int(writer, "blender/smoke/shift", sds->shift);
-  OpenVDBWriter_add_meta_v3(writer, "blender/smoke/obj_shift_f", sds->obj_shift_f);
-  OpenVDBWriter_add_meta_v3(writer, "blender/smoke/active_color", sds->active_color);
-  OpenVDBWriter_add_meta_mat4(writer, "blender/smoke/obmat", sds->obmat);
-
-  int fluid_fields = BKE_smoke_get_data_flags(sds);
+  FluidModifierData *mmd = (FluidModifierData *)smoke_v;
+  FluidDomainSettings *mds = mmd->domain;
+
+  OpenVDBWriter_set_flags(writer, mds->openvdb_comp, (mds->data_depth == 16));
+
+  OpenVDBWriter_add_meta_int(writer, "blender/smoke/active_fields", mds->active_fields);
+  OpenVDBWriter_add_meta_v3_int(writer, "blender/smoke/resolution", mds->res);
+  OpenVDBWriter_add_meta_v3_int(writer, "blender/smoke/min_resolution", mds->res_min);
+  OpenVDBWriter_add_meta_v3_int(writer, "blender/smoke/max_resolution", mds->res_max);
+  OpenVDBWriter_add_meta_v3_int(writer, "blender/smoke/base_resolution", mds->base_res);
+  OpenVDBWriter_add_meta_v3(writer, "blender/smoke/min_bbox", mds->p0);
+  OpenVDBWriter_add_meta_v3(writer, "blender/smoke/max_bbox", mds->p1);
+  OpenVDBWriter_add_meta_v3(writer, "blender/smoke/dp0", mds->dp0);
+  OpenVDBWriter_add_meta_v3_int(writer, "blender/smoke/shift", mds->shift);
+  OpenVDBWriter_add_meta_v3(writer, "blender/smoke/obj_shift_f", mds->obj_shift_f);
+  OpenVDBWriter_add_meta_v3(writer, "blender/smoke/active_color", mds->active_color);
+  OpenVDBWriter_add_meta_mat4(writer, "blender/smoke/obmat", mds->obmat);
+
+  int fluid_fields = BKE_fluid_get_data_flags(mds);
 
   struct OpenVDBFloatGrid *clip_grid = NULL;
 
-  compute_fluid_matrices(sds);
+  compute_fluid_matrices(mds);
 
   OpenVDBWriter_add_meta_int(writer, "blender/smoke/fluid_fields", fluid_fields);
 
-  if (sds->wt) {
+  if (mds->wt) {
     struct OpenVDBFloatGrid *wt_density_grid;
     float *dens, *react, *fuel, *flame, *tcu, *tcv, *tcw, *r, *g, *b;
 
-    smoke_turbulence_export(sds->wt, &dens, &react, &flame, &fuel, &r, &g, &b, &tcu, &tcv, &tcw);
+    smoke_turbulence_export(mds->wt, &dens, &react, &flame, &fuel, &r, &g, &b, &tcu, &tcv, &tcw);
 
     wt_density_grid = OpenVDB_export_grid_fl(
-        writer, "density", dens, sds->res_wt, sds->fluidmat_wt, sds->clipping, NULL);
+        writer, "density", dens, mds->res_wt, mds->fluidmat_wt, mds->clipping, NULL);
     clip_grid = wt_density_grid;
 
-    if (fluid_fields & SM_ACTIVE_FIRE) {
+    if (fluid_fields & FLUID_DOMAIN_ACTIVE_FIRE) {
       OpenVDB_export_grid_fl(
-          writer, "flame", flame, sds->res_wt, sds->fluidmat_wt, sds->clipping, wt_density_grid);
+          writer, "flame", flame, mds->res_wt, mds->fluidmat_wt, mds->clipping, wt_density_grid);
       OpenVDB_export_grid_fl(
-          writer, "fuel", fuel, sds->res_wt, sds->fluidmat_wt, sds->clipping, wt_density_grid);
+          writer, "fuel", fuel, mds->res_wt, mds->fluidmat_wt, mds->clipping, wt_density_grid);
       OpenVDB_export_grid_fl(
-          writer, "react", react, sds->res_wt, sds->fluidmat_wt, sds->clipping, wt_density_grid);
+          writer, "react", react, mds->res_wt, mds->fluidmat_wt, mds->clipping, wt_density_grid);
     }
 
-    if (fluid_fields & SM_ACTIVE_COLORS) {
+    if (fluid_fields & FLUID_DOMAIN_ACTIVE_COLORS) {
       OpenVDB_export_grid_vec(writer,
                               "color",
                               r,
                               g,
                               b,
-                              sds->res_wt,
-                              sds->fluidmat_wt,
+                              mds->res_wt,
+                              mds->fluidmat_wt,
                               VEC_INVARIANT,
                               true,
-                              sds->clipping,
+                              mds->clipping,
                               wt_density_grid);
     }
 
@@ -1087,20 +1087,20 @@ static int ptcache_smoke_openvdb_write(struct OpenVDBWriter *writer, void *smoke
                             tcu,
                             tcv,
                             tcw,
-                            sds->res,
-                            sds->fluidmat,
+                            mds->res,
+                            mds->fluidmat,
                             VEC_INVARIANT,
                             false,
-                            sds->clipping,
+                            mds->clipping,
                             wt_density_grid);
   }
 
-  if (sds->fluid) {
+  if (mds->fluid) {
     struct OpenVDBFloatGrid *density_grid;
     float dt, dx, *dens, *react, *fuel, *flame, *heat, *heatold, *vx, *vy, *vz, *r, *g, *b;
     unsigned char *obstacles;
 
-    smoke_export(sds->fluid,
+    smoke_export(mds->fluid,
                  &dt,
                  &dx,
                  &dens,
@@ -1115,50 +1115,51 @@ static int ptcache_smoke_openvdb_write(struct OpenVDBWriter *writer, void *smoke
                  &r,
                  &g,
                  &b,
-                 &obstacles);
+                 &obstacles,
+                 NULL);
 
     OpenVDBWriter_add_meta_fl(writer, "blender/smoke/dx", dx);
     OpenVDBWriter_add_meta_fl(writer, "blender/smoke/dt", dt);
 
-    const char *name = (!sds->wt) ? "density" : "density_low";
+    const char *name = (!mds->wt) ? "density" : "density_low";
     density_grid = OpenVDB_export_grid_fl(
-        writer, name, dens, sds->res, sds->fluidmat, sds->clipping, NULL);
-    clip_grid = sds->wt ? clip_grid : density_grid;
+        writer, name, dens, mds->res, mds->fluidmat, mds->clipping, NULL);
+    clip_grid = mds->wt ? clip_grid : density_grid;
 
     OpenVDB_export_grid_fl(
-        writer, "shadow", sds->shadow, sds->res, sds->fluidmat, sds->clipping, NULL);
+        writer, "shadow", mds->shadow, mds->res, mds->fluidmat, mds->clipping, NULL);
 
-    if (fluid_fields & SM_ACTIVE_HEAT) {
+    if (fluid_fields & FLUID_DOMAIN_ACTIVE_HEAT) {
       OpenVDB_export_grid_fl(
-          writer, "heat", heat, sds->res, sds->fluidmat, sds->clipping, clip_grid);
+          writer, "heat", heat, mds->res, mds->fluidmat, mds->clipping, clip_grid);
       OpenVDB_export_grid_fl(
-          writer, "heat_old", heatold, sds->res, sds->fluidmat, sds->clipping, clip_grid);
+          writer, "heat_old", heatold, mds->res, mds->fluidmat, mds->clipping, clip_grid);
     }
 
-    if (fluid_fields & SM_ACTIVE_FIRE) {
-      name = (!sds->wt) ? "flame" : "flame_low";
+    if (fluid_fields & FLUID_DOMAIN_ACTIVE_FIRE) {
+      name = (!mds->wt) ? "flame" : "flame_low";
       OpenVDB_export_grid_fl(
-          writer, name, flame, sds->res, sds->fluidmat, sds->clipping, density_grid);
-      name = (!sds->wt) ? "fuel" : "fuel_low";
+          writer, name, flame, mds->res, mds->fluidmat, mds->clipping, density_grid);
+      name = (!mds->wt) ? "fuel" : "fuel_low";
       OpenVDB_export_grid_fl(
-          writer, name, fuel, sds->res, sds->fluidmat, sds->clipping, density_grid);
-      name = (!sds->wt) ? "react" : "react_low";
+          writer, name, fuel, mds->res, mds->fluidmat, mds->clipping, density_grid);
+      name = (!mds->wt) ? "react" : "react_low";
       OpenVDB_export_grid_fl(
-          writer, name, react, sds->res, sds->fluidmat, sds->clipping, density_grid);
+          writer, name, react, mds->res, mds->fluidmat, mds->clipping, density_grid);
     }
 
-    if (fluid_fields & SM_ACTIVE_COLORS) {
-      name = (!sds->wt) ? "color" : "color_low";
+    if (fluid_fields & FLUID_DOMAIN_ACTIVE_COLORS) {
+      name = (!mds->wt) ? "color" : "color_low";
       OpenVDB_export_grid_vec(writer,
                               name,
                               r,
                               g,
                               b,
-                              sds->res,
-                              sds->fluidmat,
+                              mds->res,
+                              mds->fluidmat,
                               VEC_INVARIANT,
                               true,
-                              sds->clipping,
+                              mds->clipping,
                               density_grid);
     }
 
@@ -1167,14 +1168,14 @@ static int ptcache_smoke_openvdb_write(struct OpenVDBWriter *writer, void *smoke
                             vx,
                             vy,
                             vz,
-                            sds->res,
-                            sds->fluidmat,
+                            mds->res,
+                            mds->fluidmat,
                             VEC_CONTRAVARIANT_RELATIVE,
                             false,
-                            sds->clipping,
+                            mds->clipping,
                             clip_grid);
     OpenVDB_export_grid_ch(
-        writer, "obstacles", obstacles, sds->res, sds->fluidmat, sds->clipping, NULL);
+        writer, "obstacles", obstacles, mds->res, mds->fluidmat, mds->clipping, NULL);
   }
 
   return 1;
@@ -1182,38 +1183,38 @@ static int ptcache_smoke_openvdb_write(struct OpenVDBWriter *writer, void *smoke
 
 static int ptcache_smoke_openvdb_read(struct OpenVDBReader *reader, void *smoke_v)
 {
-  SmokeModifierData *smd = (SmokeModifierData *)smoke_v;
+  FluidModifierData *mmd = (FluidModifierData *)smoke_v;
 
-  if (!smd) {
+  if (!mmd) {
     return 0;
   }
 
-  SmokeDomainSettings *sds = smd->domain;
+  FluidDomainSettings *mds = mmd->domain;
 
-  int fluid_fields = BKE_smoke_get_data_flags(sds);
+  int fluid_fields = BKE_fluid_get_data_flags(mds);
   int active_fields, cache_fields = 0;
   int cache_res[3];
   float cache_dx;
   bool reallocate = false;
 
-  OpenVDBReader_get_meta_v3_int(reader, "blender/smoke/min_resolution", sds->res_min);
-  OpenVDBReader_get_meta_v3_int(reader, "blender/smoke/max_resolution", sds->res_max);
-  OpenVDBReader_get_meta_v3_int(reader, "blender/smoke/base_resolution", sds->base_res);
-  OpenVDBReader_get_meta_v3(reader, "blender/smoke/min_bbox", sds->p0);
-  OpenVDBReader_get_meta_v3(reader, "blender/smoke/max_bbox", sds->p1);
-  OpenVDBReader_get_meta_v3(reader, "blender/smoke/dp0", sds->dp0);
-  OpenVDBReader_get_meta_v3_int(reader, "blender/smoke/shift", sds->shift);
-  OpenVDBReader_get_meta_v3(reader, "blender/smoke/obj_shift_f", sds->obj_shift_f);
-  OpenVDBReader_get_meta_v3(reader, "blender/smoke/active_color", sds->active_color);
-  OpenVDBReader_get_meta_mat4(reader, "blender/smoke/obmat", sds->obmat);
+  OpenVDBReader_get_meta_v3_int(reader, "blender/smoke/min_resolution", mds->res_min);
+  OpenVDBReader_get_meta_v3_int(reader, "blender/smoke/max_resolution", mds->res_max);
+  OpenVDBReader_get_meta_v3_int(reader, "blender/smoke/base_resolution", mds->base_res);
+  OpenVDBReader_get_meta_v3(reader, "blender/smoke/min_bbox", mds->p0);
+  OpenVDBReader_get_meta_v3(reader, "blender/smoke/max_bbox", mds->p1);
+  OpenVDBReader_get_meta_v3(reader, "blender/smoke/dp0", mds->dp0);
+  OpenVDBReader_get_meta_v3_int(reader, "blender/smoke/shift", mds->shift);
+  OpenVDBReader_get_meta_v3(reader, "blender/smoke/obj_shift_f", mds->obj_shift_f);
+  OpenVDBReader_get_meta_v3(reader, "blender/smoke/active_color", mds->active_color);
+  OpenVDBReader_get_meta_mat4(reader, "blender/smoke/obmat", mds->obmat);
   OpenVDBReader_get_meta_int(reader, "blender/smoke/fluid_fields", &cache_fields);
   OpenVDBReader_get_meta_int(reader, "blender/smoke/active_fields", &active_fields);
   OpenVDBReader_get_meta_fl(reader, "blender/smoke/dx", &cache_dx);
   OpenVDBReader_get_meta_v3_int(reader, "blender/smoke/resolution", cache_res);
 
   /* check if resolution has changed */
-  if (sds->res[0] != cache_res[0] || sds->res[1] != cache_res[1] || sds->res[2] != cache_res[2]) {
-    if (sds->flags & MOD_SMOKE_ADAPTIVE_DOMAIN) {
+  if (mds->res[0] != cache_res[0] || mds->res[1] != cache_res[1] || mds->res[2] != cache_res[2]) {
+    if (mds->flags & FLUID_DOMAIN_USE_ADAPTIVE_DOMAIN) {
       reallocate = true;
     }
     else {
@@ -1222,28 +1223,24 @@ static int ptcache_smoke_openvdb_read(struct OpenVDBReader *reader, void *smoke_
   }
 
   /* check if active fields have changed */
-  if ((fluid_fields != cache_fields) || (active_fields != sds->active_fields)) {
+  if ((fluid_fields != cache_fields) || (active_fields != mds->active_fields)) {
     reallocate = true;
   }
 
   /* reallocate fluid if needed*/
   if (reallocate) {
-    sds->active_fields = active_fields | cache_fields;
-    BKE_smoke_reallocate_fluid(sds, cache_dx, cache_res, 1);
-    sds->dx = cache_dx;
-    copy_v3_v3_int(sds->res, cache_res);
-    sds->total_cells = cache_res[0] * cache_res[1] * cache_res[2];
-
-    if (sds->flags & MOD_SMOKE_HIGHRES) {
-      BKE_smoke_reallocate_highres_fluid(sds, cache_dx, cache_res, 1);
-    }
+    mds->active_fields = active_fields | cache_fields;
+    BKE_fluid_reallocate_fluid(mds, cache_dx, cache_res, 1);
+    mds->dx = cache_dx;
+    copy_v3_v3_int(mds->res, cache_res);
+    mds->total_cells = cache_res[0] * cache_res[1] * cache_res[2];
   }
 
-  if (sds->fluid) {
+  if (mds->fluid) {
     float dt, dx, *dens, *react, *fuel, *flame, *heat, *heatold, *vx, *vy, *vz, *r, *g, *b;
     unsigned char *obstacles;
 
-    smoke_export(sds->fluid,
+    smoke_export(mds->fluid,
                  &dt,
                  &dx,
                  &dens,
@@ -1258,56 +1255,57 @@ static int ptcache_smoke_openvdb_read(struct OpenVDBReader *reader, void *smoke_
                  &r,
                  &g,
                  &b,
-                 &obstacles);
+                 &obstacles,
+                 NULL);
 
     OpenVDBReader_get_meta_fl(reader, "blender/smoke/dt", &dt);
 
-    OpenVDB_import_grid_fl(reader, "shadow", &sds->shadow, sds->res);
+    OpenVDB_import_grid_fl(reader, "shadow", &mds->shadow, mds->res);
 
-    const char *name = (!sds->wt) ? "density" : "density_low";
-    OpenVDB_import_grid_fl(reader, name, &dens, sds->res);
+    const char *name = (!mds->wt) ? "density" : "density_low";
+    OpenVDB_import_grid_fl(reader, name, &dens, mds->res);
 
-    if (cache_fields & SM_ACTIVE_HEAT) {
-      OpenVDB_import_grid_fl(reader, "heat", &heat, sds->res);
-      OpenVDB_import_grid_fl(reader, "heat_old", &heatold, sds->res);
+    if (cache_fields & FLUID_DOMAIN_ACTIVE_HEAT) {
+      OpenVDB_import_grid_fl(reader, "heat", &heat, mds->res);
+      OpenVDB_import_grid_fl(reader, "heat_old", &heatold, mds->res);
     }
 
-    if (cache_fields & SM_ACTIVE_FIRE) {
-      name = (!sds->wt) ? "flame" : "flame_low";
-      OpenVDB_import_grid_fl(reader, name, &flame, sds->res);
-      name = (!sds->wt) ? "fuel" : "fuel_low";
-      OpenVDB_import_grid_fl(reader, name, &fuel, sds->res);
-      name = (!sds->wt) ? "react" : "react_low";
-      OpenVDB_import_grid_fl(reader, name, &react, sds->res);
+    if (cache_fields & FLUID_DOMAIN_ACTIVE_FIRE) {
+      name = (!mds->wt) ? "flame" : "flame_low";
+      OpenVDB_import_grid_fl(reader, name, &flame, mds->res);
+      name = (!mds->wt) ? "fuel" : "fuel_low";
+      OpenVDB_import_grid_fl(reader, name, &fuel, mds->res);
+      name = (!mds->wt) ? "react" : "react_low";
+      OpenVDB_import_grid_fl(reader, name, &react, mds->res);
     }
 
-    if (cache_fields & SM_ACTIVE_COLORS) {
-      name = (!sds->wt) ? "color" : "color_low";
-      OpenVDB_import_grid_vec(reader, name, &r, &g, &b, sds->res);
+    if (cache_fields & FLUID_DOMAIN_ACTIVE_COLORS) {
+      name = (!mds->wt) ? "color" : "color_low";
+      OpenVDB_import_grid_vec(reader, name, &r, &g, &b, mds->res);
     }
 
-    OpenVDB_import_grid_vec(reader, "velocity", &vx, &vy, &vz, sds->res);
-    OpenVDB_import_grid_ch(reader, "obstacles", &obstacles, sds->res);
+    OpenVDB_import_grid_vec(reader, "velocity", &vx, &vy, &vz, mds->res);
+    OpenVDB_import_grid_ch(reader, "obstacles", &obstacles, mds->res);
   }
 
-  if (sds->wt) {
+  if (mds->wt) {
     float *dens, *react, *fuel, *flame, *tcu, *tcv, *tcw, *r, *g, *b;
 
-    smoke_turbulence_export(sds->wt, &dens, &react, &flame, &fuel, &r, &g, &b, &tcu, &tcv, &tcw);
+    smoke_turbulence_export(mds->wt, &dens, &react, &flame, &fuel, &r, &g, &b, &tcu, &tcv, &tcw);
 
-    OpenVDB_import_grid_fl(reader, "density", &dens, sds->res_wt);
+    OpenVDB_import_grid_fl(reader, "density", &dens, mds->res_wt);
 
-    if (cache_fields & SM_ACTIVE_FIRE) {
-      OpenVDB_import_grid_fl(reader, "flame", &flame, sds->res_wt);
-      OpenVDB_import_grid_fl(reader, "fuel", &fuel, sds->res_wt);
-      OpenVDB_import_grid_fl(reader, "react", &react, sds->res_wt);
+    if (cache_fields & FLUID_DOMAIN_ACTIVE_FIRE) {
+      OpenVDB_import_grid_fl(reader, "flame", &flame, mds->res_wt);
+      OpenVDB_import_grid_fl(reader, "fuel", &fuel, mds->res_wt);
+      OpenVDB_import_grid_fl(reader, "react", &react, mds->res_wt);
     }
 
-    if (cache_fields & SM_ACTIVE_COLORS) {
-      OpenVDB_import_grid_vec(reader, "color", &r, &g, &b, sds->res_wt);
+    if (cache_fields & FLUID_DOMAIN_ACTIVE_COLORS) {
+      OpenVDB_import_grid_vec(reader, "color", &r, &g, &b, mds->res_wt);
     }
 
-    OpenVDB_import_grid_vec(reader, "texture coordinates", &tcu, &tcv, &tcw, sds->res);
+    OpenVDB_import_grid_vec(reader, "texture coordinates", &tcu, &tcv, &tcw, mds->res);
   }
 
   OpenVDBReader_free(reader);
@@ -1698,21 +1696,21 @@ void BKE_ptcache_id_from_cloth(PTCacheID *pid, Object *ob, ClothModifierData *cl
   pid->max_step = 1;
   pid->file_type = PTCACHE_FILE_PTCACHE;
 }
-void BKE_ptcache_id_from_smoke(PTCacheID *pid, struct Object *ob, struct SmokeModifierData *smd)
+void BKE_ptcache_id_from_smoke(PTCacheID *pid, struct Object *ob, struct FluidModifierData *mmd)
 {
-  SmokeDomainSettings *sds = smd->domain;
+  FluidDomainSettings *mds = mmd->domain;
 
   memset(pid, 0, sizeof(PTCacheID));
 
   pid->ob = ob;
-  pid->calldata = smd;
+  pid->calldata = mmd;
 
   pid->type = PTCACHE_TYPE_SMOKE_DOMAIN;
-  pid->stack_index = sds->point_cache[0]->index;
+  pid->stack_index = mds->point_cache[0]->index;
 
-  pid->cache = sds->point_cache[0];
-  pid->cache_ptr = &(sds->point_cache[0]);
-  pid->ptcaches = &(sds->ptcaches[0]);
+  pid->cache = mds->point_cache[0];
+  pid->cache_ptr = &(mds->point_cache[0]);
+  pid->ptcaches = &(mds->ptcaches[0]);
 
   pid->totpoint = pid->totwrite = ptcache_smoke_totpoint;
   pid->error = ptcache_smoke_error;
@@ -1737,16 +1735,16 @@ void BKE_ptcache_id_from_smoke(PTCacheID *pid, struct Object *ob, struct SmokeMo
   pid->data_types = 0;
   pid->info_types = 0;
 
-  if (sds->fluid) {
+  if (mds->fluid) {
     pid->data_types |= (1 << BPHYS_DATA_SMOKE_LOW);
-  }
-  if (sds->wt) {
-    pid->data_types |= (1 << BPHYS_DATA_SMOKE_HIGH);
+    if (mds->flags & FLUID_DOMAIN_USE_NOISE) {
+      pid->data_types |= (1 << BPHYS_DATA_SMOKE_HIGH);
+    }
   }
 
   pid->default_step = 1;
   pid->max_step = 1;
-  pid->file_type = smd->domain->cache_file_format;
+  pid->file_type = mmd->domain->cache_file_format;
 }
 
 void BKE_ptcache_id_from_dynamicpaint(PTCacheID *pid, Object *ob, DynamicPaintSurface *surface)
@@ -1908,10 +1906,10 @@ static bool foreach_object_modifier_ptcache(Object *object,
         return false;
       }
     }
-    else if (md->type == eModifierType_Smoke) {
-      SmokeModifierData *smd = (SmokeModifierData *)md;
-      if (smd->type & MOD_SMOKE_TYPE_DOMAIN) {
-        BKE_ptcache_id_from_smoke(&pid, object, (SmokeModifierData *)md);
+    else if (md->type == eModifierType_Fluid) {
+      FluidModifierData *mmd = (FluidModifierData *)md;
+      if (mmd->type & MOD_FLUID_TYPE_DOMAIN) {
+        BKE_ptcache_id_from_smoke(&pid, object, (FluidModifierData *)md);
         if (!callback(&pid, callback_user_data)) {
           return false;
         }
@@ -3741,10 +3739,10 @@ int BKE_ptcache_object_reset(Scene *scene, Object *ob, int mode)
       BKE_ptcache_id_from_cloth(&pid, ob, (ClothModifierData *)md);
       reset |= BKE_ptcache_id_reset(scene, &pid, mode);
     }
-    if (md->type == eModifierType_Smoke) {
-      SmokeModifierData *smd = (SmokeModifierData *)md;
-      if (smd->type & MOD_SMOKE_TYPE_DOMAIN) {
-        BKE_ptcache_id_from_smoke(&pid, ob, (SmokeModifierData *)md);
+    if (md->type == eModifierType_Fluid) {
+      FluidModifierData *mmd = (FluidModifierData *)md;
+      if (mmd->type & MOD_FLUID_TYPE_DOMAIN) {
+        BKE_ptcache_id_from_smoke(&pid, ob, (FluidModifierData *)md);
         reset |= BKE_ptcache_id_reset(scene, &pid, mode);
       }
     }
diff --git a/source/blender/blenkernel/intern/smoke.c b/source/blender/blenkernel/intern/smoke.c
deleted file mode 100644 (file)
index 4c3b7a6..0000000
+++ /dev/null
@@ -1,3654 +0,0 @@
-/*
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * The Original Code is Copyright (C) Blender Foundation.
- * All rights reserved.
- */
-
-/** \file
- * \ingroup bke
- */
-
-/* Part of the code copied from elbeem fluid library, copyright by Nils Thuerey */
-
-#include "MEM_guardedalloc.h"
-
-#include <float.h>
-#include <math.h>
-#include <stdio.h>
-#include <string.h> /* memset */
-
-#include "BLI_blenlib.h"
-#include "BLI_math.h"
-#include "BLI_kdopbvh.h"
-#include "BLI_threads.h"
-#include "BLI_utildefines.h"
-
-#include "DNA_anim_types.h"
-#include "DNA_armature_types.h"
-#include "DNA_constraint_types.h"
-#include "DNA_customdata_types.h"
-#include "DNA_light_types.h"
-#include "DNA_mesh_types.h"
-#include "DNA_meshdata_types.h"
-#include "DNA_modifier_types.h"
-#include "DNA_object_types.h"
-#include "DNA_particle_types.h"
-#include "DNA_scene_types.h"
-#include "DNA_smoke_types.h"
-
-#include "BKE_appdir.h"
-#include "BKE_animsys.h"
-#include "BKE_armature.h"
-#include "BKE_bvhutils.h"
-#include "BKE_collision.h"
-#include "BKE_colortools.h"
-#include "BKE_constraint.h"
-#include "BKE_customdata.h"
-#include "BKE_deform.h"
-#include "BKE_effect.h"
-#include "BKE_library.h"
-#include "BKE_mesh.h"
-#include "BKE_mesh_runtime.h"
-#include "BKE_modifier.h"
-#include "BKE_object.h"
-#include "BKE_particle.h"
-#include "BKE_pointcache.h"
-#include "BKE_scene.h"
-#include "BKE_smoke.h"
-#include "BKE_texture.h"
-
-#include "DEG_depsgraph.h"
-#include "DEG_depsgraph_query.h"
-
-#include "RE_shader_ext.h"
-
-#include "GPU_glew.h"
-
-/* UNUSED so far, may be enabled later */
-/* #define USE_SMOKE_COLLISION_DM */
-
-//#define DEBUG_TIME
-
-#include "smoke_API.h"
-
-#ifdef DEBUG_TIME
-#  include "PIL_time.h"
-#endif
-
-#ifdef WITH_SMOKE
-#  include "BLI_task.h"
-#  include "BLI_kdtree.h"
-#  include "BLI_voxel.h"
-
-static ThreadMutex object_update_lock = BLI_MUTEX_INITIALIZER;
-
-struct Mesh;
-struct Object;
-struct Scene;
-struct SmokeModifierData;
-
-// timestep default value for nice appearance 0.1f
-#  define DT_DEFAULT 0.1f
-
-#  define ADD_IF_LOWER_POS(a, b) (min_ff((a) + (b), max_ff((a), (b))))
-#  define ADD_IF_LOWER_NEG(a, b) (max_ff((a) + (b), min_ff((a), (b))))
-#  define ADD_IF_LOWER(a, b) (((b) > 0) ? ADD_IF_LOWER_POS((a), (b)) : ADD_IF_LOWER_NEG((a), (b)))
-
-#else /* WITH_SMOKE */
-
-/* Stubs to use when smoke is disabled */
-struct WTURBULENCE *smoke_turbulence_init(int *UNUSED(res),
-                                          int UNUSED(amplify),
-                                          int UNUSED(noisetype),
-                                          const char *UNUSED(noisefile_path),
-                                          int UNUSED(use_fire),
-                                          int UNUSED(use_colors))
-{
-  return NULL;
-}
-
-void smoke_free(struct FLUID_3D *UNUSED(fluid))
-{
-}
-float *smoke_get_density(struct FLUID_3D *UNUSED(fluid))
-{
-  return NULL;
-}
-void smoke_turbulence_free(struct WTURBULENCE *UNUSED(wt))
-{
-}
-void smoke_initWaveletBlenderRNA(struct WTURBULENCE *UNUSED(wt), float *UNUSED(strength))
-{
-}
-void smoke_initBlenderRNA(struct FLUID_3D *UNUSED(fluid),
-                          float *UNUSED(alpha),
-                          float *UNUSED(beta),
-                          float *UNUSED(dt_factor),
-                          float *UNUSED(vorticity),
-                          int *UNUSED(border_colli),
-                          float *UNUSED(burning_rate),
-                          float *UNUSED(flame_smoke),
-                          float *UNUSED(flame_smoke_color),
-                          float *UNUSED(flame_vorticity),
-                          float *UNUSED(flame_ignition_temp),
-                          float *UNUSED(flame_max_temp))
-{
-}
-struct Mesh *smokeModifier_do(SmokeModifierData *UNUSED(smd),
-                              Depsgraph *UNUSED(depsgraph),
-                              Scene *UNUSED(scene),
-                              Object *UNUSED(ob),
-                              Mesh *UNUSED(me))
-{
-  return NULL;
-}
-float BKE_smoke_get_velocity_at(struct Object *UNUSED(ob),
-                                float UNUSED(position[3]),
-                                float UNUSED(velocity[3]))
-{
-  return 0.0f;
-}
-
-#endif /* WITH_SMOKE */
-
-#ifdef WITH_SMOKE
-
-void BKE_smoke_reallocate_fluid(SmokeDomainSettings *sds, float dx, int res[3], int free_old)
-{
-  int use_heat = (sds->active_fields & SM_ACTIVE_HEAT);
-  int use_fire = (sds->active_fields & SM_ACTIVE_FIRE);
-  int use_colors = (sds->active_fields & SM_ACTIVE_COLORS);
-
-  if (free_old && sds->fluid) {
-    smoke_free(sds->fluid);
-  }
-  if (!min_iii(res[0], res[1], res[2])) {
-    sds->fluid = NULL;
-    return;
-  }
-  sds->fluid = smoke_init(res, dx, DT_DEFAULT, use_heat, use_fire, use_colors);
-  smoke_initBlenderRNA(sds->fluid,
-                       &(sds->alpha),
-                       &(sds->beta),
-                       &(sds->time_scale),
-                       &(sds->vorticity),
-                       &(sds->border_collisions),
-                       &(sds->burning_rate),
-                       &(sds->flame_smoke),
-                       sds->flame_smoke_color,
-                       &(sds->flame_vorticity),
-                       &(sds->flame_ignition),
-                       &(sds->flame_max_temp));
-
-  /* reallocate shadow buffer */
-  if (sds->shadow) {
-    MEM_freeN(sds->shadow);
-  }
-  sds->shadow = MEM_callocN(sizeof(float) * res[0] * res[1] * res[2], "SmokeDomainShadow");
-}
-
-void BKE_smoke_reallocate_highres_fluid(SmokeDomainSettings *sds,
-                                        float dx,
-                                        int res[3],
-                                        int free_old)
-{
-  int use_fire = (sds->active_fields & (SM_ACTIVE_HEAT | SM_ACTIVE_FIRE));
-  int use_colors = (sds->active_fields & SM_ACTIVE_COLORS);
-
-  if (free_old && sds->wt) {
-    smoke_turbulence_free(sds->wt);
-  }
-  if (!min_iii(res[0], res[1], res[2])) {
-    sds->wt = NULL;
-    return;
-  }
-
-  /* smoke_turbulence_init uses non-threadsafe functions from fftw3 lib (like fftw_plan & co). */
-  BLI_thread_lock(LOCK_FFTW);
-
-  sds->wt = smoke_turbulence_init(
-      res, sds->amplify + 1, sds->noise, BKE_tempdir_session(), use_fire, use_colors);
-
-  BLI_thread_unlock(LOCK_FFTW);
-
-  sds->res_wt[0] = res[0] * (sds->amplify + 1);
-  sds->res_wt[1] = res[1] * (sds->amplify + 1);
-  sds->res_wt[2] = res[2] * (sds->amplify + 1);
-  sds->dx_wt = dx / (sds->amplify + 1);
-  smoke_initWaveletBlenderRNA(sds->wt, &(sds->strength));
-}
-
-/* convert global position to domain cell space */
-static void smoke_pos_to_cell(SmokeDomainSettings *sds, float pos[3])
-{
-  mul_m4_v3(sds->imat, pos);
-  sub_v3_v3(pos, sds->p0);
-  pos[0] *= 1.0f / sds->cell_size[0];
-  pos[1] *= 1.0f / sds->cell_size[1];
-  pos[2] *= 1.0f / sds->cell_size[2];
-}
-
-/* set domain transformations and base resolution from object mesh */
-static void smoke_set_domain_from_mesh(SmokeDomainSettings *sds,
-                                       Object *ob,
-                                       Mesh *me,
-                                       bool init_resolution)
-{
-  size_t i;
-  float min[3] = {FLT_MAX, FLT_MAX, FLT_MAX}, max[3] = {-FLT_MAX, -FLT_MAX, -FLT_MAX};
-  float size[3];
-  MVert *verts = me->mvert;
-  float scale = 0.0;
-  int res;
-
-  res = sds->maxres;
-
-  // get BB of domain
-  for (i = 0; i < me->totvert; i++) {
-    // min BB
-    min[0] = MIN2(min[0], verts[i].co[0]);
-    min[1] = MIN2(min[1], verts[i].co[1]);
-    min[2] = MIN2(min[2], verts[i].co[2]);
-
-    // max BB
-    max[0] = MAX2(max[0], verts[i].co[0]);
-    max[1] = MAX2(max[1], verts[i].co[1]);
-    max[2] = MAX2(max[2], verts[i].co[2]);
-  }
-
-  /* set domain bounds */
-  copy_v3_v3(sds->p0, min);
-  copy_v3_v3(sds->p1, max);
-  sds->dx = 1.0f / res;
-
-  /* calculate domain dimensions */
-  sub_v3_v3v3(size, max, min);
-  if (init_resolution) {
-    zero_v3_int(sds->base_res);
-    copy_v3_v3(sds->cell_size, size);
-  }
-  /* apply object scale */
-  for (i = 0; i < 3; i++) {
-    size[i] = fabsf(size[i] * ob->scale[i]);
-  }
-  copy_v3_v3(sds->global_size, size);
-  copy_v3_v3(sds->dp0, min);
-
-  invert_m4_m4(sds->imat, ob->obmat);
-
-  // prevent crash when initializing a plane as domain
-  if (!init_resolution || (size[0] < FLT_EPSILON) || (size[1] < FLT_EPSILON) ||
-      (size[2] < FLT_EPSILON)) {
-    return;
-  }
-
-  /* define grid resolutions from longest domain side */
-  if (size[0] >= MAX2(size[1], size[2])) {
-    scale = res / size[0];
-    sds->scale = size[0] / fabsf(ob->scale[0]);
-    sds->base_res[0] = res;
-    sds->base_res[1] = max_ii((int)(size[1] * scale + 0.5f), 4);
-    sds->base_res[2] = max_ii((int)(size[2] * scale + 0.5f), 4);
-  }
-  else if (size[1] >= MAX2(size[0], size[2])) {
-    scale = res / size[1];
-    sds->scale = size[1] / fabsf(ob->scale[1]);
-    sds->base_res[0] = max_ii((int)(size[0] * scale + 0.5f), 4);
-    sds->base_res[1] = res;
-    sds->base_res[2] = max_ii((int)(size[2] * scale + 0.5f), 4);
-  }
-  else {
-    scale = res / size[2];
-    sds->scale = size[2] / fabsf(ob->scale[2]);
-    sds->base_res[0] = max_ii((int)(size[0] * scale + 0.5f), 4);
-    sds->base_res[1] = max_ii((int)(size[1] * scale + 0.5f), 4);
-    sds->base_res[2] = res;
-  }
-
-  /* set cell size */
-  sds->cell_size[0] /= (float)sds->base_res[0];
-  sds->cell_size[1] /= (float)sds->base_res[1];
-  sds->cell_size[2] /= (float)sds->base_res[2];
-}
-
-static int smokeModifier_init(SmokeModifierData *smd, Object *ob, int scene_framenr, Mesh *me)
-{
-  if ((smd->type & MOD_SMOKE_TYPE_DOMAIN) && smd->domain && !smd->domain->fluid) {
-    SmokeDomainSettings *sds = smd->domain;
-    int res[3];
-    /* set domain dimensions from mesh */
-    smoke_set_domain_from_mesh(sds, ob, me, true);
-    /* reset domain values */
-    zero_v3_int(sds->shift);
-    zero_v3(sds->shift_f);
-    add_v3_fl(sds->shift_f, 0.5f);
-    zero_v3(sds->prev_loc);
-    mul_m4_v3(ob->obmat, sds->prev_loc);
-    copy_m4_m4(sds->obmat, ob->obmat);
-
-    /* set resolutions */
-    if (smd->domain->flags & MOD_SMOKE_ADAPTIVE_DOMAIN) {
-      res[0] = res[1] = res[2] = 1; /* use minimum res for adaptive init */
-    }
-    else {
-      copy_v3_v3_int(res, sds->base_res);
-    }
-    copy_v3_v3_int(sds->res, res);
-    sds->total_cells = sds->res[0] * sds->res[1] * sds->res[2];
-    sds->res_min[0] = sds->res_min[1] = sds->res_min[2] = 0;
-    copy_v3_v3_int(sds->res_max, res);
-
-    /* allocate fluid */
-    BKE_smoke_reallocate_fluid(sds, sds->dx, sds->res, 0);
-
-    smd->time = scene_framenr;
-
-    /* allocate highres fluid */
-    if (sds->flags & MOD_SMOKE_HIGHRES) {
-      BKE_smoke_reallocate_highres_fluid(sds, sds->dx, sds->res, 0);
-    }
-    /* allocate shadow buffer */
-    if (!sds->shadow) {
-      sds->shadow = MEM_callocN(sizeof(float) * sds->res[0] * sds->res[1] * sds->res[2],
-                                "SmokeDomainShadow");
-    }
-    return 1;
-  }
-  else if ((smd->type & MOD_SMOKE_TYPE_FLOW) && smd->flow) {
-    smd->time = scene_framenr;
-
-    return 1;
-  }
-  else if ((smd->type & MOD_SMOKE_TYPE_COLL)) {
-    if (!smd->coll) {
-      smokeModifier_createType(smd);
-    }
-
-    smd->time = scene_framenr;
-
-    return 1;
-  }
-
-  return 2;
-}
-
-#endif /* WITH_SMOKE */
-
-static void smokeModifier_freeDomain(SmokeModifierData *smd)
-{
-  if (smd->domain) {
-    if (smd->domain->shadow) {
-      MEM_freeN(smd->domain->shadow);
-    }
-    smd->domain->shadow = NULL;
-
-    if (smd->domain->fluid) {
-      smoke_free(smd->domain->fluid);
-    }
-
-    if (smd->domain->fluid_mutex) {
-      BLI_rw_mutex_free(smd->domain->fluid_mutex);
-    }
-
-    if (smd->domain->wt) {
-      smoke_turbulence_free(smd->domain->wt);
-    }
-
-    if (smd->domain->effector_weights) {
-      MEM_freeN(smd->domain->effector_weights);
-    }
-    smd->domain->effector_weights = NULL;
-
-    if (!(smd->modifier.flag & eModifierFlag_SharedCaches)) {
-      BKE_ptcache_free_list(&(smd->domain->ptcaches[0]));
-      smd->domain->point_cache[0] = NULL;
-    }
-
-    if (smd->domain->coba) {
-      MEM_freeN(smd->domain->coba);
-    }
-
-    MEM_freeN(smd->domain);
-    smd->domain = NULL;
-  }
-}
-
-static void smokeModifier_freeFlow(SmokeModifierData *smd)
-{
-  if (smd->flow) {
-    if (smd->flow->mesh) {
-      BKE_id_free(NULL, smd->flow->mesh);
-    }
-    if (smd->flow->verts_old) {
-      MEM_freeN(smd->flow->verts_old);
-    }
-    MEM_freeN(smd->flow);
-    smd->flow = NULL;
-  }
-}
-
-static void smokeModifier_freeCollision(SmokeModifierData *smd)
-{
-  if (smd->coll) {
-    SmokeCollSettings *scs = smd->coll;
-
-    if (scs->numverts) {
-      if (scs->verts_old) {
-        MEM_freeN(scs->verts_old);
-        scs->verts_old = NULL;
-      }
-    }
-
-    if (smd->coll->mesh) {
-      BKE_id_free(NULL, smd->coll->mesh);
-    }
-    smd->coll->mesh = NULL;
-
-    MEM_freeN(smd->coll);
-    smd->coll = NULL;
-  }
-}
-
-void smokeModifier_reset_turbulence(struct SmokeModifierData *smd)
-{
-  if (smd && smd->domain && smd->domain->wt) {
-    smoke_turbulence_free(smd->domain->wt);
-    smd->domain->wt = NULL;
-  }
-}
-
-static void smokeModifier_reset_ex(struct SmokeModifierData *smd, bool need_lock)
-{
-  if (smd) {
-    if (smd->domain) {
-      if (smd->domain->shadow) {
-        MEM_freeN(smd->domain->shadow);
-      }
-      smd->domain->shadow = NULL;
-
-      if (smd->domain->fluid) {
-        if (need_lock) {
-          BLI_rw_mutex_lock(smd->domain->fluid_mutex, THREAD_LOCK_WRITE);
-        }
-
-        smoke_free(smd->domain->fluid);
-        smd->domain->fluid = NULL;
-
-        if (need_lock) {
-          BLI_rw_mutex_unlock(smd->domain->fluid_mutex);
-        }
-      }
-
-      smokeModifier_reset_turbulence(smd);
-
-      smd->time = -1;
-      smd->domain->total_cells = 0;
-      smd->domain->active_fields = 0;
-    }
-    else if (smd->flow) {
-      if (smd->flow->verts_old) {
-        MEM_freeN(smd->flow->verts_old);
-      }
-      smd->flow->verts_old = NULL;
-      smd->flow->numverts = 0;
-    }
-    else if (smd->coll) {
-      SmokeCollSettings *scs = smd->coll;
-
-      if (scs->numverts && scs->verts_old) {
-        MEM_freeN(scs->verts_old);
-        scs->verts_old = NULL;
-      }
-    }
-  }
-}
-
-void smokeModifier_reset(struct SmokeModifierData *smd)
-{
-  smokeModifier_reset_ex(smd, true);
-}
-
-void smokeModifier_free(SmokeModifierData *smd)
-{
-  if (smd) {
-    smokeModifier_freeDomain(smd);
-    smokeModifier_freeFlow(smd);
-    smokeModifier_freeCollision(smd);
-  }
-}
-
-void smokeModifier_createType(struct SmokeModifierData *smd)
-{
-  if (smd) {
-    if (smd->type & MOD_SMOKE_TYPE_DOMAIN) {
-      if (smd->domain) {
-        smokeModifier_freeDomain(smd);
-      }
-
-      smd->domain = MEM_callocN(sizeof(SmokeDomainSettings), "SmokeDomain");
-
-      smd->domain->smd = smd;
-
-      smd->domain->point_cache[0] = BKE_ptcache_add(&(smd->domain->ptcaches[0]));
-      smd->domain->point_cache[0]->flag |= PTCACHE_DISK_CACHE;
-      smd->domain->point_cache[0]->step = 1;
-
-      /* Deprecated */
-      smd->domain->point_cache[1] = NULL;
-      BLI_listbase_clear(&smd->domain->ptcaches[1]);
-      /* set some standard values */
-      smd->domain->fluid = NULL;
-      smd->domain->fluid_mutex = BLI_rw_mutex_alloc();
-      smd->domain->wt = NULL;
-      smd->domain->eff_group = NULL;
-      smd->domain->fluid_group = NULL;
-      smd->domain->coll_group = NULL;
-      smd->domain->maxres = 32;
-      smd->domain->amplify = 1;
-      smd->domain->alpha = -0.001;
-      smd->domain->beta = 0.1;
-      smd->domain->time_scale = 1.0;
-      smd->domain->vorticity = 2.0;
-      smd->domain->border_collisions = SM_BORDER_OPEN;  // open domain
-      smd->domain->flags = MOD_SMOKE_DISSOLVE_LOG;
-      smd->domain->highres_sampling = SM_HRES_FULLSAMPLE;
-      smd->domain->strength = 2.0;
-      smd->domain->noise = MOD_SMOKE_NOISEWAVE;
-      smd->domain->diss_speed = 5;
-      smd->domain->active_fields = 0;
-
-      smd->domain->adapt_margin = 4;
-      smd->domain->adapt_res = 0;
-      smd->domain->adapt_threshold = 0.02f;
-
-      smd->domain->burning_rate = 0.75f;
-      smd->domain->flame_smoke = 1.0f;
-      smd->domain->flame_vorticity = 0.5f;
-      smd->domain->flame_ignition = 1.5f;
-      smd->domain->flame_max_temp = 3.0f;
-      /* color */
-      smd->domain->flame_smoke_color[0] = 0.7f;
-      smd->domain->flame_smoke_color[1] = 0.7f;
-      smd->domain->flame_smoke_color[2] = 0.7f;
-
-      smd->domain->viewsettings = MOD_SMOKE_VIEW_SHOW_HIGHRES;
-      smd->domain->effector_weights = BKE_effector_add_weights(NULL);
-
-#ifdef WITH_OPENVDB_BLOSC
-      smd->domain->openvdb_comp = VDB_COMPRESSION_BLOSC;
-#else
-      smd->domain->openvdb_comp = VDB_COMPRESSION_ZIP;
-#endif
-      smd->domain->data_depth = 0;
-      smd->domain->cache_file_format = PTCACHE_FILE_PTCACHE;
-
-      smd->domain->display_thickness = 1.0f;
-      smd->domain->slice_method = MOD_SMOKE_SLICE_VIEW_ALIGNED;
-      smd->domain->axis_slice_method = AXIS_SLICE_FULL;
-      smd->domain->slice_per_voxel = 5.0f;
-      smd->domain->slice_depth = 0.5f;
-      smd->domain->slice_axis = 0;
-      smd->domain->vector_scale = 1.0f;
-
-      smd->domain->coba = NULL;
-      smd->domain->coba_field = FLUID_FIELD_DENSITY;
-
-      smd->domain->clipping = 1e-3f;
-    }
-    else if (smd->type & MOD_SMOKE_TYPE_FLOW) {
-      if (smd->flow) {
-        smokeModifier_freeFlow(smd);
-      }
-
-      smd->flow = MEM_callocN(sizeof(SmokeFlowSettings), "SmokeFlow");
-
-      smd->flow->smd = smd;
-
-      /* set some standard values */
-      smd->flow->density = 1.0f;
-      smd->flow->fuel_amount = 1.0f;
-      smd->flow->temp = 1.0f;
-      smd->flow->flags = MOD_SMOKE_FLOW_ABSOLUTE | MOD_SMOKE_FLOW_USE_PART_SIZE;
-      smd->flow->vel_multi = 1.0f;
-      smd->flow->volume_density = 0.0f;
-      smd->flow->surface_distance = 1.5f;
-      smd->flow->source = MOD_SMOKE_FLOW_SOURCE_MESH;
-      smd->flow->texture_size = 1.0f;
-      smd->flow->particle_size = 1.0f;
-      smd->flow->subframes = 0;
-
-      smd->flow->color[0] = 0.7f;
-      smd->flow->color[1] = 0.7f;
-      smd->flow->color[2] = 0.7f;
-
-      smd->flow->mesh = NULL;
-      smd->flow->psys = NULL;
-    }
-    else if (smd->type & MOD_SMOKE_TYPE_COLL) {
-      if (smd->coll) {
-        smokeModifier_freeCollision(smd);
-      }
-
-      smd->coll = MEM_callocN(sizeof(SmokeCollSettings), "SmokeColl");
-
-      smd->coll->smd = smd;
-      smd->coll->verts_old = NULL;
-      smd->coll->numverts = 0;
-      smd->coll->type = 0;  // static obstacle
-      smd->coll->mesh = NULL;
-    }
-  }
-}
-
-void smokeModifier_copy(const struct SmokeModifierData *smd,
-                        struct SmokeModifierData *tsmd,
-                        const int flag)
-{
-  tsmd->type = smd->type;
-  tsmd->time = smd->time;
-
-  smokeModifier_createType(tsmd);
-
-  if (tsmd->domain) {
-    SmokeDomainSettings *tsds = tsmd->domain;
-    SmokeDomainSettings *sds = smd->domain;
-
-    BKE_ptcache_free_list(&(tsds->ptcaches[0]));
-
-    if (flag & LIB_ID_CREATE_NO_MAIN) {
-      /* Share the cache with the original object's modifier. */
-      tsmd->modifier.flag |= eModifierFlag_SharedCaches;
-      tsds->point_cache[0] = sds->point_cache[0];
-      tsds->ptcaches[0] = sds->ptcaches[0];
-    }
-    else {
-      tsds->point_cache[0] = BKE_ptcache_copy_list(
-          &(tsds->ptcaches[0]), &(sds->ptcaches[0]), flag);
-    }
-
-    tsds->fluid_group = sds->fluid_group;
-    tsds->coll_group = sds->coll_group;
-
-    tsds->adapt_margin = sds->adapt_margin;
-    tsds->adapt_res = sds->adapt_res;
-    tsds->adapt_threshold = sds->adapt_threshold;
-
-    tsds->alpha = sds->alpha;
-    tsds->beta = sds->beta;
-    tsds->amplify = sds->amplify;
-    tsds->maxres = sds->maxres;
-    tsds->flags = sds->flags;
-    tsds->highres_sampling = sds->highres_sampling;
-    tsds->viewsettings = sds->viewsettings;
-    tsds->noise = sds->noise;
-    tsds->diss_speed = sds->diss_speed;
-    tsds->strength = sds->strength;
-
-    tsds->border_collisions = sds->border_collisions;
-    tsds->vorticity = sds->vorticity;
-    tsds->time_scale = sds->time_scale;
-
-    tsds->burning_rate = sds->burning_rate;
-    tsds->flame_smoke = sds->flame_smoke;
-    tsds->flame_vorticity = sds->flame_vorticity;
-    tsds->flame_ignition = sds->flame_ignition;
-    tsds->flame_max_temp = sds->flame_max_temp;
-    copy_v3_v3(tsds->flame_smoke_color, sds->flame_smoke_color);
-
-    MEM_freeN(tsds->effector_weights);
-    tsds->effector_weights = MEM_dupallocN(sds->effector_weights);
-    tsds->openvdb_comp = sds->openvdb_comp;
-    tsds->data_depth = sds->data_depth;
-    tsds->cache_file_format = sds->cache_file_format;
-
-    tsds->display_thickness = sds->display_thickness;
-    tsds->slice_method = sds->slice_method;
-    tsds->axis_slice_method = sds->axis_slice_method;
-    tsds->slice_per_voxel = sds->slice_per_voxel;
-    tsds->slice_depth = sds->slice_depth;
-    tsds->slice_axis = sds->slice_axis;
-    tsds->interp_method = sds->interp_method;
-    tsds->draw_velocity = sds->draw_velocity;
-    tsds->vector_draw_type = sds->vector_draw_type;
-    tsds->vector_scale = sds->vector_scale;
-
-    tsds->use_coba = sds->use_coba;
-    tsds->coba_field = sds->coba_field;
-    if (sds->coba) {
-      tsds->coba = MEM_dupallocN(sds->coba);
-    }
-
-    tsds->clipping = sds->clipping;
-  }
-  else if (tsmd->flow) {
-    SmokeFlowSettings *tsfs = tsmd->flow;
-    SmokeFlowSettings *sfs = smd->flow;
-
-    tsfs->psys = sfs->psys;
-    tsfs->noise_texture = sfs->noise_texture;
-
-    tsfs->vel_multi = sfs->vel_multi;
-    tsfs->vel_normal = sfs->vel_normal;
-    tsfs->vel_random = sfs->vel_random;
-
-    tsfs->density = sfs->density;
-    copy_v3_v3(tsfs->color, sfs->color);
-    tsfs->fuel_amount = sfs->fuel_amount;
-    tsfs->temp = sfs->temp;
-    tsfs->volume_density = sfs->volume_density;
-    tsfs->surface_distance = sfs->surface_distance;
-    tsfs->particle_size = sfs->particle_size;
-    tsfs->subframes = sfs->subframes;
-
-    tsfs->texture_size = sfs->texture_size;
-    tsfs->texture_offset = sfs->texture_offset;
-    BLI_strncpy(tsfs->uvlayer_name, sfs->uvlayer_name, sizeof(tsfs->uvlayer_name));
-    tsfs->vgroup_density = sfs->vgroup_density;
-
-    tsfs->type = sfs->type;
-    tsfs->source = sfs->source;
-    tsfs->texture_type = sfs->texture_type;
-    tsfs->flags = sfs->flags;
-  }
-  else if (tsmd->coll) {
-    /* leave it as initialized, collision settings is mostly caches */
-  }
-}
-
-#ifdef WITH_SMOKE
-
-// forward declaration
-static void smoke_calc_transparency(SmokeDomainSettings *sds, ViewLayer *view_layer);
-static float calc_voxel_transp(
-    float *result, float *input, int res[3], int *pixel, float *tRay, float correct);
-
-static int get_light(ViewLayer *view_layer, float *light)
-{
-  Base *base_tmp = NULL;
-  int found_light = 0;
-
-  // try to find a lamp, preferably local
-  for (base_tmp = FIRSTBASE(view_layer); base_tmp; base_tmp = base_tmp->next) {
-    if (base_tmp->object->type == OB_LAMP) {
-      Light *la = base_tmp->object->data;
-
-      if (la->type == LA_LOCAL) {
-        copy_v3_v3(light, base_tmp->object->obmat[3]);
-        return 1;
-      }
-      else if (!found_light) {
-        copy_v3_v3(light, base_tmp->object->obmat[3]);
-        found_light = 1;
-      }
-    }
-  }
-
-  return found_light;
-}
-
-/**********************************************************
- * Obstacles
- **********************************************************/
-
-typedef struct ObstaclesFromDMData {
-  SmokeDomainSettings *sds;
-  const MVert *mvert;
-  const MLoop *mloop;
-  const MLoopTri *looptri;
-  BVHTreeFromMesh *tree;
-  unsigned char *obstacle_map;
-
-  bool has_velocity;
-  float *vert_vel;
-  float *velocityX, *velocityY, *velocityZ;
-  int *num_obstacles;
-} ObstaclesFromDMData;
-
-static void obstacles_from_mesh_task_cb(void *__restrict userdata,
-                                        const int z,
-                                        const TaskParallelTLS *__restrict UNUSED(tls))
-{
-  ObstaclesFromDMData *data = userdata;
-  SmokeDomainSettings *sds = data->sds;
-
-  /* slightly rounded-up sqrt(3 * (0.5)^2) == max. distance of cell boundary along the diagonal */
-  const float surface_distance = 0.867f;
-
-  for (int x = sds->res_min[0]; x < sds->res_max[0]; x++) {
-    for (int y = sds->res_min[1]; y < sds->res_max[1]; y++) {
-      const int index = smoke_get_index(
-          x - sds->res_min[0], sds->res[0], y - sds->res_min[1], sds->res[1], z - sds->res_min[2]);
-
-      float ray_start[3] = {(float)x + 0.5f, (float)y + 0.5f, (float)z + 0.5f};
-      BVHTreeNearest nearest = {0};
-      nearest.index = -1;
-      nearest.dist_sq = surface_distance *
-                        surface_distance; /* find_nearest uses squared distance */
-
-      /* 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) {
-        const MLoopTri *lt = &data->looptri[nearest.index];
-        float weights[3];
-        int v1, v2, v3;
-
-        /* calculate barycentric weights for nearest point */
-        v1 = data->mloop[lt->tri[0]].v;
-        v2 = data->mloop[lt->tri[1]].v;
-        v3 = data->mloop[lt->tri[2]].v;
-        interp_weights_tri_v3(
-            weights, data->mvert[v1].co, data->mvert[v2].co, data->mvert[v3].co, nearest.co);
-
-        // DG TODO
-        if (data->has_velocity) {
-          /* apply object velocity */
-          {
-            float hit_vel[3];
-            interp_v3_v3v3v3(hit_vel,
-                             &data->vert_vel[v1 * 3],
-                             &data->vert_vel[v2 * 3],
-                             &data->vert_vel[v3 * 3],
-                             weights);
-            data->velocityX[index] += hit_vel[0];
-            data->velocityY[index] += hit_vel[1];
-            data->velocityZ[index] += hit_vel[2];
-          }
-        }
-
-        /* tag obstacle cells */
-        data->obstacle_map[index] = 1;
-
-        if (data->has_velocity) {
-          data->obstacle_map[index] |= 8;
-          data->num_obstacles[index]++;
-        }
-      }
-    }
-  }
-}
-
-static void obstacles_from_mesh(Object *coll_ob,
-                                SmokeDomainSettings *sds,
-                                SmokeCollSettings *scs,
-                                unsigned char *obstacle_map,
-                                float *velocityX,
-                                float *velocityY,
-                                float *velocityZ,
-                                int *num_obstacles,
-                                float dt)
-{
-  if (!scs->mesh) {
-    return;
-  }
-  {
-    Mesh *me = NULL;
-    MVert *mvert = NULL;
-    const MLoopTri *looptri;
-    const MLoop *mloop;
-    BVHTreeFromMesh treeData = {NULL};
-    int numverts, i;
-
-    float *vert_vel = NULL;
-    bool has_velocity = false;
-
-    me = BKE_mesh_copy_for_eval(scs->mesh, true);
-    BKE_mesh_ensure_normals(me);
-    mvert = me->mvert;
-    mloop = me->mloop;
-    looptri = BKE_mesh_runtime_looptri_ensure(me);
-    numverts = me->totvert;
-
-    // DG TODO
-    // if (scs->type > SM_COLL_STATIC)
-    // if line above is used, the code is in trouble if the object moves
-    // but is declared as "does not move".
-
-    {
-      vert_vel = MEM_callocN(sizeof(float) * numverts * 3, "smoke_obs_velocity");
-
-      if (scs->numverts != numverts || !scs->verts_old) {
-        if (scs->verts_old) {
-          MEM_freeN(scs->verts_old);
-        }
-
-        scs->verts_old = MEM_callocN(sizeof(float) * numverts * 3, "smoke_obs_verts_old");
-        scs->numverts = numverts;
-      }
-      else {
-        has_velocity = true;
-      }
-    }
-
-    /*  Transform collider vertices to
-     *   domain grid space for fast lookups */
-    for (i = 0; i < numverts; i++) {
-      float n[3];
-      float co[3];
-
-      /* vert pos */
-      mul_m4_v3(coll_ob->obmat, mvert[i].co);
-      smoke_pos_to_cell(sds, mvert[i].co);
-
-      /* vert normal */
-      normal_short_to_float_v3(n, mvert[i].no);
-      mul_mat3_m4_v3(coll_ob->obmat, n);
-      mul_mat3_m4_v3(sds->imat, n);
-      normalize_v3(n);
-      normal_float_to_short_v3(mvert[i].no, n);
-
-      /* vert velocity */
-      add_v3fl_v3fl_v3i(co, mvert[i].co, sds->shift);
-      if (has_velocity) {
-        sub_v3_v3v3(&vert_vel[i * 3], co, &scs->verts_old[i * 3]);
-        mul_v3_fl(&vert_vel[i * 3], sds->dx / dt);
-      }
-      copy_v3_v3(&scs->verts_old[i * 3], co);
-    }
-
-    if (BKE_bvhtree_from_mesh_get(&treeData, me, BVHTREE_FROM_LOOPTRI, 4)) {
-      ObstaclesFromDMData data = {
-          .sds = sds,
-          .mvert = mvert,
-          .mloop = mloop,
-          .looptri = looptri,
-          .tree = &treeData,
-          .obstacle_map = obstacle_map,
-          .has_velocity = has_velocity,
-          .vert_vel = vert_vel,
-          .velocityX = velocityX,
-          .velocityY = velocityY,
-          .velocityZ = velocityZ,
-          .num_obstacles = num_obstacles,
-      };
-      TaskParallelSettings settings;
-      BLI_parallel_range_settings_defaults(&settings);
-      settings.scheduling_mode = TASK_SCHEDULING_DYNAMIC;
-      BLI_task_parallel_range(
-          sds->res_min[2], sds->res_max[2], &data, obstacles_from_mesh_task_cb, &settings);
-    }
-    /* free bvh tree */
-    free_bvhtree_from_mesh(&treeData);
-    BKE_id_free(NULL, me);
-
-    if (vert_vel) {
-      MEM_freeN(vert_vel);
-    }
-  }
-}
-
-/* Animated obstacles: dx_step = ((x_new - x_old) / totalsteps) * substep */
-static void update_obstacles(Depsgraph *depsgraph,
-                             Object *ob,
-                             SmokeDomainSettings *sds,
-                             float dt,
-                             int UNUSED(substep),
-                             int UNUSED(totalsteps))
-{
-  Object **collobjs = NULL;
-  unsigned int numcollobj = 0;
-
-  unsigned int collIndex;
-  unsigned char *obstacles = smoke_get_obstacle(sds->fluid);
-  float *velx = NULL;
-  float *vely = NULL;
-  float *velz = NULL;
-  float *velxOrig = smoke_get_velocity_x(sds->fluid);
-  float *velyOrig = smoke_get_velocity_y(sds->fluid);
-  float *velzOrig = smoke_get_velocity_z(sds->fluid);
-  float *density = smoke_get_density(sds->fluid);
-  float *fuel = smoke_get_fuel(sds->fluid);
-  float *flame = smoke_get_flame(sds->fluid);
-  float *r = smoke_get_color_r(sds->fluid);
-  float *g = smoke_get_color_g(sds->fluid);
-  float *b = smoke_get_color_b(sds->fluid);
-  unsigned int z;
-
-  int *num_obstacles = MEM_callocN(sizeof(int) * sds->res[0] * sds->res[1] * sds->res[2],
-                                   "smoke_num_obstacles");
-
-  smoke_get_ob_velocity(sds->fluid, &velx, &vely, &velz);
-
-  // TODO: delete old obstacle flags
-  for (z = 0; z < sds->res[0] * sds->res[1] * sds->res[2]; z++) {
-    if (obstacles[z] & 8)  // Do not delete static obstacles
-    {
-      obstacles[z] = 0;
-    }
-
-    velx[z] = 0;
-    vely[z] = 0;
-    velz[z] = 0;
-  }
-
-  collobjs = BKE_collision_objects_create(
-      depsgraph, ob, sds->coll_group, &numcollobj, eModifierType_Smoke);
-
-  // update obstacle tags in cells
-  for (collIndex = 0; collIndex < numcollobj; collIndex++) {
-    Object *collob = collobjs[collIndex];
-    SmokeModifierData *smd2 = (SmokeModifierData *)modifiers_findByType(collob,
-                                                                        eModifierType_Smoke);
-
-    // DG TODO: check if modifier is active?
-
-    if ((smd2->type & MOD_SMOKE_TYPE_COLL) && smd2->coll) {
-      SmokeCollSettings *scs = smd2->coll;
-      obstacles_from_mesh(collob, sds, scs, obstacles, velx, vely, velz, num_obstacles, dt);
-    }
-  }
-
-  BKE_collision_objects_free(collobjs);
-
-  /* obstacle cells should not contain any velocity from the smoke simulation */
-  for (z = 0; z < sds->res[0] * sds->res[1] * sds->res[2]; z++) {
-    if (obstacles[z]) {
-      velxOrig[z] = 0;
-      velyOrig[z] = 0;
-      velzOrig[z] = 0;
-      density[z] = 0;
-      if (fuel) {
-        fuel[z] = 0;
-        flame[z] = 0;
-      }
-      if (r) {
-        r[z] = 0;
-        g[z] = 0;
-        b[z] = 0;
-      }
-    }
-    /* average velocities from multiple obstacles in one cell */
-    if (num_obstacles[z]) {
-      velx[z] /= num_obstacles[z];
-      vely[z] /= num_obstacles[z];
-      velz[z] /= num_obstacles[z];
-    }
-  }
-
-  MEM_freeN(num_obstacles);
-}
-
-/**********************************************************
- * Flow emission code
- **********************************************************/
-
-typedef struct EmissionMap {
-  float *influence;
-  float *influence_high;
-  float *velocity;
-  int min[3], max[3], res[3];
-  int hmin[3], hmax[3], hres[3];
-  int total_cells, valid;
-} EmissionMap;
-
-static void em_boundInsert(EmissionMap *em, float point[3])
-{
-  int i = 0;
-  if (!em->valid) {
-    for (; i < 3; i++) {
-      em->min[i] = (int)floor(point[i]);
-      em->max[i] = (int)ceil(point[i]);
-    }
-    em->valid = 1;
-  }
-  else {
-    for (; i < 3; i++) {
-      if (point[i] < em->min[i]) {
-        em->min[i] = (int)floor(point[i]);
-      }
-      if (point[i] > em->max[i]) {
-        em->max[i] = (int)ceil(point[i]);
-      }
-    }
-  }
-}
-
-static void clampBoundsInDomain(SmokeDomainSettings *sds,
-                                int min[3],
-                                int max[3],
-                                float *min_vel,
-                                float *max_vel,
-                                int margin,
-                                float dt)
-{
-  int i;
-  for (i = 0; i < 3; i++) {
-    int adapt = (sds->flags & MOD_SMOKE_ADAPTIVE_DOMAIN) ? sds->adapt_res : 0;
-    /* add margin */
-    min[i] -= margin;
-    max[i] += margin;
-
-    /* adapt to velocity */
-    if (min_vel && min_vel[i] < 0.0f) {
-      min[i] += (int)floor(min_vel[i] * dt);
-    }
-    if (max_vel && max_vel[i] > 0.0f) {
-      max[i] += (int)ceil(max_vel[i] * dt);
-    }
-
-    /* clamp within domain max size */
-    CLAMP(min[i], -adapt, sds->base_res[i] + adapt);
-    CLAMP(max[i], -adapt, sds->base_res[i] + adapt);
-  }
-}
-
-static void em_allocateData(EmissionMap *em, bool use_velocity, int hires_mul)
-{
-  int i, res[3];
-
-  for (i = 0; i < 3; i++) {
-    res[i] = em->max[i] - em->min[i];
-    if (res[i] <= 0) {
-      return;
-    }
-  }
-  em->total_cells = res[0] * res[1] * res[2];
-  copy_v3_v3_int(em->res, res);
-
-  em->influence = MEM_callocN(sizeof(float) * em->total_cells, "smoke_flow_influence");
-  if (use_velocity) {
-    em->velocity = MEM_callocN(sizeof(float) * em->total_cells * 3, "smoke_flow_velocity");
-  }
-
-  /* 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_callocN(sizeof(float) * total_cells_high,
-                                     "smoke_flow_influence_high");
-  }
-  em->valid = 1;
-}
-
-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);
-  }
-}
-
-static void em_combineMaps(
-    EmissionMap *output, EmissionMap *em2, int hires_multiplier, int additive, float sample_size)
-{
-  int i, x, y, z;
-
-  /* copyfill input 1 struct and clear output for new allocation */
-  EmissionMap em1;
-  memcpy(&em1, output, sizeof(EmissionMap));
-  memset(output, 0, sizeof(EmissionMap));
-
-  for (i = 0; i < 3; i++) {
-    if (em1.valid) {
-      output->min[i] = MIN2(em1.min[i], em2->min[i]);
-      output->max[i] = MAX2(em1.max[i], em2->max[i]);
-    }
-    else {
-      output->min[i] = em2->min[i];
-      output->max[i] = em2->max[i];
-    }
-  }
-  /* allocate output map */
-  em_allocateData(output, (em1.velocity || em2->velocity), hires_multiplier);
-
-  /* base resolution inputs */
-  for (x = output->min[0]; x < output->max[0]; x++) {
-    for (y = output->min[1]; y < output->max[1]; y++) {
-      for (z = output->min[2]; z < output->max[2]; z++) {
-        int index_out = smoke_get_index(x - output->min[0],
-                                        output->res[0],
-                                        y - output->min[1],
-                                        output->res[1],
-                                        z - output->min[2]);
-
-        /* initialize with first input if in range */
-        if (x >= em1.min[0] && x < em1.max[0] && y >= em1.min[1] && y < em1.max[1] &&
-            z >= em1.min[2] && z < em1.max[2]) {
-          int index_in = smoke_get_index(
-              x - em1.min[0], em1.res[0], y - em1.min[1], em1.res[1], z - em1.min[2]);
-
-          /* values */
-          output->influence[index_out] = em1.influence[index_in];
-          if (output->velocity && em1.velocity) {
-            copy_v3_v3(&output->velocity[index_out * 3], &em1.velocity[index_in * 3]);
-          }
-        }
-
-        /* apply second input if in range */
-        if (x >= em2->min[0] && x < em2->max[0] && y >= em2->min[1] && y < em2->max[1] &&
-            z >= em2->min[2] && z < em2->max[2]) {
-          int index_in = smoke_get_index(
-              x - em2->min[0], em2->res[0], y - em2->min[1], em2->res[1], z - em2->min[2]);
-
-          /* values */
-          if (additive) {
-            output->influence[index_out] += em2->influence[index_in] * sample_size;
-          }
-          else {
-            output->influence[index_out] = MAX2(em2->influence[index_in],
-                                                output->influence[index_out]);
-          }
-          if (output->velocity && em2->velocity) {
-            /* last sample replaces the velocity */
-            output->velocity[index_out * 3] = ADD_IF_LOWER(output->velocity[index_out * 3],
-                                                           em2->velocity[index_in * 3]);
-            output->velocity[index_out * 3 + 1] = ADD_IF_LOWER(output->velocity[index_out * 3 + 1],
-                                                               em2->velocity[index_in * 3 + 1]);
-            output->velocity[index_out * 3 + 2] = ADD_IF_LOWER(output->velocity[index_out * 3 + 2],
-                                                               em2->velocity[index_in * 3 + 2]);
-          }
-        }
-      }  // low res loop
-    }
-  }
-
-  /* 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 = smoke_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 = smoke_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 = smoke_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->influence_high[index_in] * sample_size;
-            }
-            else {
-              output->influence_high[index_out] = MAX2(em2->influence_high[index_in],
-                                                       output->influence_high[index_out]);
-            }
-          }
-        }  // high res loop
-      }
-    }
-  }
-
-  /* free original data */
-  em_freeData(&em1);
-}
-
-typedef struct EmitFromParticlesData {
-  SmokeFlowSettings *sfs;
-  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,
-                                        const int z,
-                                        const TaskParallelTLS *__restrict UNUSED(tls))
-{
-  EmitFromParticlesData *data = userdata;
-  SmokeFlowSettings *sfs = data->sfs;
-  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 = smoke_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 (sfs->flags & MOD_SMOKE_FLOW_INITVELOCITY &&
-              (sfs->psys->part->phystype != PART_PHYS_NO)) {
-            madd_v3_v3fl(
-                &em->velocity[index * 3], &data->particle_vel[nearest.index * 3], sfs->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 = smoke_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);
-        }
-      }
-    }
-  }
-}
-
-static void emit_from_particles(Object *flow_ob,
-                                SmokeDomainSettings *sds,
-                                SmokeFlowSettings *sfs,
-                                EmissionMap *em,
-                                Depsgraph *depsgraph,
-                                Scene *scene,
-                                float dt)
-{
-  /* Is particle system selected. */
-  if (sfs && sfs->psys && sfs->psys->part &&
-      ELEM(sfs->psys->part->type, PART_EMITTER, PART_FLUID)) {
-    ParticleSimulationData sim;
-    ParticleSystem *psys = sfs->psys;
-    float *particle_pos;
-    float *particle_vel;
-    int totpart = psys->totpart, totchild;
-    int p = 0;
-    int valid_particles = 0;
-    int bounds_margin = 1;
-
-    /* radius based flow */
-    const float solid = sfs->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;
-    sim.scene = scene;
-    sim.ob = flow_ob;
-    sim.psys = psys;
-    sim.psys->lattice_deform_data = psys_create_lattice_deform_data(&sim);
-
-    /* prepare curvemapping tables */
-    if ((psys->part->child_flag & PART_CHILD_USE_CLUMP_CURVE) && psys->part->clumpcurve) {
-      BKE_curvemapping_changed_all(psys->part->clumpcurve);
-    }
-    if ((psys->part->child_flag & PART_CHILD_USE_ROUGH_CURVE) && psys->part->roughcurve) {
-      BKE_curvemapping_changed_all(psys->part->roughcurve);
-    }
-    if ((psys->part->child_flag & PART_CHILD_USE_TWIST_CURVE) && psys->part->twistcurve) {
-      BKE_curvemapping_changed_all(psys->part->twistcurve);
-    }
-
-    /* initialize particle cache */
-    if (psys->part->type == PART_HAIR) {
-      // TODO: PART_HAIR not supported whatsoever
-      totchild = 0;
-    }
-    else {
-      totchild = psys->totchild * psys->part->disp / 100;
-    }
-
-    particle_pos = MEM_callocN(sizeof(float) * (totpart + totchild) * 3, "smoke_flow_particles");
-    particle_vel = MEM_callocN(sizeof(float) * (totpart + totchild) * 3, "smoke_flow_particles");
-
-    /* setup particle radius emission if enabled */
-    if (sfs->flags & MOD_SMOKE_FLOW_USE_PART_SIZE) {
-      tree = BLI_kdtree_3d_new(psys->totpart + psys->totchild);
-
-      /* check need for high resolution map */
-      if ((sds->flags & MOD_SMOKE_HIGHRES) && (sds->highres_sampling == SM_HRES_FULLSAMPLE)) {
-        hires_multiplier = sds->amplify + 1;
-      }
-
-      bounds_margin = (int)ceil(solid + smooth);
-    }
-
-    /* calculate local position for each particle */
-    for (p = 0; p < totpart + totchild; p++) {
-      ParticleKey state;
-      float *pos;
-      if (p < totpart) {
-        if (psys->particles[p].flag & (PARS_NO_DISP | PARS_UNEXIST)) {
-          continue;
-        }
-      }
-      else {
-        /* handle child particle */
-        ChildParticle *cpa = &psys->child[p - totpart];
-        if (psys->particles[cpa->parent].flag & (PARS_NO_DISP | PARS_UNEXIST)) {
-          continue;
-        }
-      }
-
-      /* DEG_get_ctime(depsgraph) does not give subframe time */
-      state.time = BKE_scene_frame_get(scene);
-      if (psys_get_particle_state(&sim, p, &state, 0) == 0) {
-        continue;
-      }
-
-      /* location */
-      pos = &particle_pos[valid_particles * 3];
-      copy_v3_v3(pos, state.co);
-      smoke_pos_to_cell(sds, pos);
-
-      /* velocity */
-      copy_v3_v3(&particle_vel[valid_particles * 3], state.vel);
-      mul_mat3_m4_v3(sds->imat, &particle_vel[valid_particles * 3]);
-
-      if (sfs->flags & MOD_SMOKE_FLOW_USE_PART_SIZE) {
-        BLI_kdtree_3d_insert(tree, valid_particles, pos);
-      }
-
-      /* calculate emission map bounds */
-      em_boundInsert(em, pos);
-      valid_particles++;
-    }
-
-    /* set emission map */
-    clampBoundsInDomain(sds, em->min, em->max, NULL, NULL, bounds_margin, dt);
-    em_allocateData(em, sfs->flags & MOD_SMOKE_FLOW_INITVELOCITY, hires_multiplier);
-
-    if (!(sfs->flags & MOD_SMOKE_FLOW_USE_PART_SIZE)) {
-      for (p = 0; p < valid_particles; p++) {
-        int cell[3];
-        size_t i = 0;
-        size_t index = 0;
-        int badcell = 0;
-
-        /* 1. get corresponding cell */
-        cell[0] = floor(particle_pos[p * 3]) - em->min[0];
-        cell[1] = floor(particle_pos[p * 3 + 1]) - em->min[1];
-        cell[2] = floor(particle_pos[p * 3 + 2]) - em->min[2];
-        /* check if cell is valid (in the domain boundary) */
-        for (i = 0; i < 3; i++) {
-          if ((cell[i] > em->res[i] - 1) || (cell[i] < 0)) {
-            badcell = 1;
-            break;
-          }
-        }
-        if (badcell) {
-          continue;
-        }
-        /* get cell index */
-        index = smoke_get_index(cell[0], em->res[0], cell[1], em->res[1], cell[2]);
-        /* Add influence to emission map */
-        em->influence[index] = 1.0f;
-        /* Uses particle velocity as initial velocity for smoke */
-        if (sfs->flags & MOD_SMOKE_FLOW_INITVELOCITY && (psys->part->phystype != PART_PHYS_NO)) {
-          madd_v3_v3fl(&em->velocity[index * 3], &particle_vel[p * 3], sfs->vel_multi);
-        }
-      }  // particles loop
-    }
-    else if (valid_particles > 0) {  // MOD_SMOKE_FLOW_USE_PART_SIZE
-      int min[3], max[3], res[3];
-      const float hr = 1.0f / ((float)hires_multiplier);
-      /* slightly adjust high res antialias 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;
-      }
-
-      BLI_kdtree_3d_balance(tree);
-
-      EmitFromParticlesData data = {
-          .sfs = sfs,
-          .tree = tree,
-          .hires_multiplier = hires_multiplier,
-          .hr = hr,
-          .em = em,
-          .particle_vel = particle_vel,
-          .min = min,
-          .max = max,
-          .res = res,
-          .solid = solid,
-          .smooth = smooth,
-          .hr_smooth = hr_smooth,
-      };
-
-      TaskParallelSettings settings;
-      BLI_parallel_range_settings_defaults(&settings);
-      settings.scheduling_mode = TASK_SCHEDULING_DYNAMIC;
-      BLI_task_parallel_range(min[2], max[2], &data, emit_from_particles_task_cb, &settings);
-    }
-
-    if (sfs->flags & MOD_SMOKE_FLOW_USE_PART_SIZE) {
-      BLI_kdtree_3d_free(tree);
-    }
-
-    /* free data */
-    if (particle_pos) {
-      MEM_freeN(particle_pos);
-    }
-    if (particle_vel) {
-      MEM_freeN(particle_vel);
-    }
-  }
-}
-
-static void sample_mesh(SmokeFlowSettings *sfs,
-                        const MVert *mvert,
-                        const MLoop *mloop,
-                        const MLoopTri *mlooptri,
-                        const MLoopUV *mloopuv,
-                        float *influence_map,
-                        float *velocity_map,
-                        int index,
-                        const int base_res[3],
-                        float flow_center[3],
-                        BVHTreeFromMesh *treeData,
-                        const float ray_start[3],
-                        const float *vert_vel,
-                        bool has_velocity,
-                        int defgrp_index,
-                        MDeformVert *dvert,
-                        float x,
-                        float y,
-                        float z)
-{
-  float ray_dir[3] = {1.0f, 0.0f, 0.0f};
-  BVHTreeRayHit hit = {0};
-  BVHTreeNearest nearest = {0};
-
-  float volume_factor = 0.0f;
-  float sample_str = 0.0f;
-
-  hit.index = -1;
-  hit.dist = 9999;
-  nearest.index = -1;
-  nearest.dist_sq = sfs->surface_distance *
-                    sfs->surface_distance; /* find_nearest uses squared distance */
-
-  /* Check volume collision */
-  if (sfs->volume_density) {
-    if (BLI_bvhtree_ray_cast(treeData->tree,
-                             ray_start,
-                             ray_dir,
-                             0.0f,
-                             &hit,
-                             treeData->raycast_callback,
-                             treeData) != -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 (dot >= 0) {
-        /* 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 = 9999;
-
-        BLI_bvhtree_ray_cast(
-            treeData->tree, ray_start, ray_dir, 0.0f, &hit, treeData->raycast_callback, treeData);
-        if (hit.index != -1) {
-          volume_factor = sfs->volume_density;
-        }
-      }
-    }
-  }
-
-  /* find the nearest point on the mesh */
-  if (BLI_bvhtree_find_nearest(
-          treeData->tree, ray_start, &nearest, treeData->nearest_callback, treeData) != -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 (sfs->surface_distance) {
-      sample_str = sqrtf(nearest.dist_sq) / sfs->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 */
-    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);
-
-    if (sfs->flags & MOD_SMOKE_FLOW_INITVELOCITY && velocity_map) {
-      /* apply normal directional velocity */
-      if (sfs->vel_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. */
-        velocity_map[index * 3] += hit_normal[0] * sfs->vel_normal * 0.25f;
-        velocity_map[index * 3 + 1] += hit_normal[1] * sfs->vel_normal * 0.25f;
-        velocity_map[index * 3 + 2] += hit_normal[2] * sfs->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 */
-      if (has_velocity && sfs->vel_multi) {
-        float hit_vel[3];
-        interp_v3_v3v3v3(
-            hit_vel, &vert_vel[v1 * 3], &vert_vel[v2 * 3], &vert_vel[v3 * 3], weights);
-        velocity_map[index * 3] += hit_vel[0] * sfs->vel_multi;
-        velocity_map[index * 3 + 1] += hit_vel[1] * sfs->vel_multi;
-        velocity_map[index * 3 + 2] += hit_vel[2] * sfs->vel_multi;
-      }
-    }
-
-    /* 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 ((sfs->flags & MOD_SMOKE_FLOW_TEXTUREEMIT) && sfs->noise_texture) {
-      float tex_co[3] = {0};
-      TexResult texres;
-
-      if (sfs->texture_type == MOD_SMOKE_FLOW_TEXTURE_MAP_AUTO) {
-        tex_co[0] = ((x - flow_center[0]) / base_res[0]) / sfs->texture_size;
-        tex_co[1] = ((y - flow_center[1]) / base_res[1]) / sfs->texture_size;
-        tex_co[2] = ((z - flow_center[2]) / base_res[2] - sfs->texture_offset) / sfs->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 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] = sfs->texture_offset;
-      }
-      texres.nor = NULL;
-      BKE_texture_get_value(NULL, sfs->noise_texture, tex_co, &texres, false);
-      sample_str *= texres.tin;
-    }
-  }
-
-  /* multiply initial velocity by emitter influence */
-  if (sfs->flags & MOD_SMOKE_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);
-}
-
-typedef struct EmitFromDMData {
-  SmokeDomainSettings *sds;
-  SmokeFlowSettings *sfs;
-  const MVert *mvert;
-  const MLoop *mloop;
-  const MLoopTri *mlooptri;
-  const MLoopUV *mloopuv;
-  MDeformVert *dvert;
-  int defgrp_index;
-
-  BVHTreeFromMesh *tree;
-  int hires_multiplier;
-  float hr;
-
-  EmissionMap *em;
-  bool has_velocity;
-  float *vert_vel;
-
-  float *flow_center;
-  int *min, *max, *res;
-} EmitFromDMData;
-
-static void emit_from_mesh_task_cb(void *__restrict userdata,
-                                   const int z,
-                                   const TaskParallelTLS *__restrict UNUSED(tls))
-{
-  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 = smoke_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};
-
-        sample_mesh(data->sfs,
-                    data->mvert,
-                    data->mloop,
-                    data->mlooptri,
-                    data->mloopuv,
-                    em->influence,
-                    em->velocity,
-                    index,
-                    data->sds->base_res,
-                    data->flow_center,
-                    data->tree,
-                    ray_start,
-                    data->vert_vel,
-                    data->has_velocity,
-                    data->defgrp_index,
-                    data->dvert,
-                    (float)lx,
-                    (float)ly,
-                    (float)lz);
-      }
-
-      /* 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 = smoke_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,
-        };
-
-        sample_mesh(data->sfs,
-                    data->mvert,
-                    data->mloop,
-                    data->mlooptri,
-                    data->mloopuv,
-                    em->influence_high,
-                    NULL,
-                    index,
-                    data->sds->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);
-      }
-    }
-  }
-}
-
-static void emit_from_mesh(
-    Object *flow_ob, SmokeDomainSettings *sds, SmokeFlowSettings *sfs, EmissionMap *em, float dt)
-{
-  if (sfs->mesh) {
-    Mesh *me;
-    int defgrp_index = sfs->vgroup_density - 1;
-    MDeformVert *dvert = NULL;
-    MVert *mvert = NULL;
-    const MLoopTri *mlooptri = NULL;
-    const MLoopUV *mloopuv = NULL;
-    const MLoop *mloop = NULL;
-    BVHTreeFromMesh treeData = {NULL};
-    int numOfVerts, i;
-    float flow_center[3] = {0};
-
-    float *vert_vel = NULL;
-    int has_velocity = 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
-     */
-    me = BKE_mesh_copy_for_eval(sfs->mesh, true);
-
-    /* Duplicate vertices to modify. */
-    if (me->mvert) {
-      me->mvert = MEM_dupallocN(me->mvert);
-      CustomData_set_layer(&me->vdata, CD_MVERT, me->mvert);
-    }
-
-    BKE_mesh_ensure_normals(me);
-    mvert = me->mvert;
-    numOfVerts = me->totvert;
-    dvert = CustomData_get_layer(&me->vdata, CD_MDEFORMVERT);
-    mloopuv = CustomData_get_layer_named(&me->ldata, CD_MLOOPUV, sfs->uvlayer_name);
-    mloop = me->mloop;
-    mlooptri = BKE_mesh_runtime_looptri_ensure(me);
-
-    if (sfs->flags & MOD_SMOKE_FLOW_INITVELOCITY) {
-      vert_vel = MEM_callocN(sizeof(float) * numOfVerts * 3, "smoke_flow_velocity");
-
-      if (sfs->numverts != numOfVerts || !sfs->verts_old) {
-        if (sfs->verts_old) {
-          MEM_freeN(sfs->verts_old);
-        }
-        sfs->verts_old = MEM_callocN(sizeof(float) * numOfVerts * 3, "smoke_flow_verts_old");
-        sfs->numverts = numOfVerts;
-      }
-      else {
-        has_velocity = 1;
-      }
-    }
-
-    /*  Transform mesh vertices to
-     *   domain grid space for fast lookups */
-    for (i = 0; i < numOfVerts; i++) {
-      float n[3];
-      /* vert pos */
-      mul_m4_v3(flow_ob->obmat, mvert[i].co);
-      smoke_pos_to_cell(sds, mvert[i].co);
-      /* vert normal */
-      normal_short_to_float_v3(n, mvert[i].no);
-      mul_mat3_m4_v3(flow_ob->obmat, n);
-      mul_mat3_m4_v3(sds->imat, n);
-      normalize_v3(n);
-      normal_float_to_short_v3(mvert[i].no, n);
-      /* vert velocity */
-      if (sfs->flags & MOD_SMOKE_FLOW_INITVELOCITY) {
-        float co[3];
-        add_v3fl_v3fl_v3i(co, mvert[i].co, sds->shift);
-        if (has_velocity) {
-          sub_v3_v3v3(&vert_vel[i * 3], co, &sfs->verts_old[i * 3]);
-          mul_v3_fl(&vert_vel[i * 3], sds->dx / dt);
-        }
-        copy_v3_v3(&sfs->verts_old[i * 3], co);
-      }
-
-      /* calculate emission map bounds */
-      em_boundInsert(em, mvert[i].co);
-    }
-    mul_m4_v3(flow_ob->obmat, flow_center);
-    smoke_pos_to_cell(sds, flow_center);
-
-    /* check need for high resolution map */
-    if ((sds->flags & MOD_SMOKE_HIGHRES) && (sds->highres_sampling == SM_HRES_FULLSAMPLE)) {
-      hires_multiplier = sds->amplify + 1;
-    }
-
-    /* set emission map */
-    clampBoundsInDomain(sds, em->min, em->max, NULL, NULL, (int)ceil(sfs->surface_distance), dt);
-    em_allocateData(em, sfs->flags & MOD_SMOKE_FLOW_INITVELOCITY, hires_multiplier);
-
-    /* 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;
-    }
-
-    if (BKE_bvhtree_from_mesh_get(&treeData, me, BVHTREE_FROM_LOOPTRI, 4)) {
-      const float hr = 1.0f / ((float)hires_multiplier);
-
-      EmitFromDMData data = {
-          .sds = sds,
-          .sfs = sfs,
-          .mvert = mvert,
-          .mloop = mloop,
-          .mlooptri = mlooptri,
-          .mloopuv = mloopuv,
-          .dvert = dvert,
-          .defgrp_index = defgrp_index,
-          .tree = &treeData,
-          .hires_multiplier = hires_multiplier,
-          .hr = hr,
-          .em = em,
-          .has_velocity = has_velocity,
-          .vert_vel = vert_vel,
-          .flow_center = flow_center,
-          .min = min,
-          .max = max,
-          .res = res,
-      };
-
-      TaskParallelSettings settings;
-      BLI_parallel_range_settings_defaults(&settings);
-      settings.scheduling_mode = TASK_SCHEDULING_DYNAMIC;
-      BLI_task_parallel_range(min[2], max[2], &data, emit_from_mesh_task_cb, &settings);
-    }
-    /* free bvh tree */
-    free_bvhtree_from_mesh(&treeData);
-
-    if (vert_vel) {
-      MEM_freeN(vert_vel);
-    }
-
-    if (me->mvert) {
-      MEM_freeN(me->mvert);
-    }
-    BKE_id_free(NULL, me);
-  }
-}
-
-/**********************************************************
- *  Smoke step
- **********************************************************/
-
-static void adjustDomainResolution(SmokeDomainSettings *sds,
-                                   int new_shift[3],
-                                   EmissionMap *emaps,
-                                   unsigned int numflowobj,
-                                   float dt)
-{
-  const int block_size = sds->amplify + 1;
-  int min[3] = {32767, 32767, 32767}, max[3] = {-32767, -32767, -32767}, res[3];
-  int total_cells = 1, res_changed = 0, shift_changed = 0;
-  float min_vel[3], max_vel[3];
-  int x, y, z;
-  float *density = smoke_get_density(sds->fluid);
-  float *fuel = smoke_get_fuel(sds->fluid);
-  float *bigdensity = smoke_turbulence_get_density(sds->wt);
-  float *bigfuel = smoke_turbulence_get_fuel(sds->wt);
-  float *vx = smoke_get_velocity_x(sds->fluid);
-  float *vy = smoke_get_velocity_y(sds->fluid);
-  float *vz = smoke_get_velocity_z(sds->fluid);
-  int wt_res[3];
-
-  if (sds->flags & MOD_SMOKE_HIGHRES && sds->wt) {
-    smoke_turbulence_get_res(sds->wt, wt_res);
-  }
-
-  INIT_MINMAX(min_vel, max_vel);
-
-  /* Calculate bounds for current domain content */
-  for (x = sds->res_min[0]; x < sds->res_max[0]; x++) {
-    for (y = sds->res_min[1]; y < sds->res_max[1]; y++) {
-      for (z = sds->res_min[2]; z < sds->res_max[2]; z++) {
-        int xn = x - new_shift[0];
-        int yn = y - new_shift[1];
-        int zn = z - new_shift[2];
-        int index;
-        float max_den;
-
-        /* skip if cell already belongs to new area */
-        if (xn >= min[0] && xn <= max[0] && yn >= min[1] && yn <= max[1] && zn >= min[2] &&
-            zn <= max[2]) {
-          continue;
-        }
-
-        index = smoke_get_index(x - sds->res_min[0],
-                                sds->res[0],
-                                y - sds->res_min[1],
-                                sds->res[1],
-                                z - sds->res_min[2]);
-        max_den = (fuel) ? MAX2(density[index], fuel[index]) : density[index];
-
-        /* check high resolution bounds if max density isnt already high enough */
-        if (max_den < sds->adapt_threshold && sds->flags & MOD_SMOKE_HIGHRES && sds->wt) {
-          int i, j, k;
-          /* high res grid index */
-          int xx = (x - sds->res_min[0]) * block_size;
-          int yy = (y - sds->res_min[1]) * block_size;
-          int zz = (z - sds->res_min[2]) * block_size;
-
-          for (i = 0; i < block_size; i++) {
-            for (j = 0; j < block_size; j++) {
-              for (k = 0; k < block_size; k++) {
-                int big_index = smoke_get_index(xx + i, wt_res[0], yy + j, wt_res[1], zz + k);
-                float den = (bigfuel) ? MAX2(bigdensity[big_index], bigfuel[big_index]) :
-                                        bigdensity[big_index];
-                if (den > max_den) {
-                  max_den = den;
-                }
-              }
-            }
-          }
-        }
-
-        /* content bounds (use shifted coordinates) */
-        if (max_den >= sds->adapt_threshold) {
-          if (min[0] > xn) {
-            min[0] = xn;
-          }
-          if (min[1] > yn) {
-            min[1] = yn;
-          }
-          if (min[2] > zn) {
-            min[2] = zn;
-          }
-          if (max[0] < xn) {
-            max[0] = xn;
-          }
-          if (max[1] < yn) {
-            max[1] = yn;
-          }
-          if (max[2] < zn) {
-            max[2] = zn;
-          }
-        }
-
-        /* velocity bounds */
-        if (min_vel[0] > vx[index]) {
-          min_vel[0] = vx[index];
-        }
-        if (min_vel[1] > vy[index]) {
-          min_vel[1] = vy[index];
-        }
-        if (min_vel[2] > vz[index]) {
-          min_vel[2] = vz[index];
-        }
-        if (max_vel[0] < vx[index]) {
-          max_vel[0] = vx[index];
-        }
-        if (max_vel[1] < vy[index]) {
-          max_vel[1] = vy[index];
-        }
-        if (max_vel[2] < vz[index]) {
-          max_vel[2] = vz[index];
-        }
-      }
-    }
-  }
-
-  /* also apply emission maps */
-  for (int i = 0; i < numflowobj; i++) {
-    EmissionMap *em = &emaps[i];
-
-    for (x = em->min[0]; x < em->max[0]; x++) {
-      for (y = em->min[1]; y < em->max[1]; y++) {
-        for (z = em->min[2]; z < em->max[2]; z++) {
-          int index = smoke_get_index(
-              x - em->min[0], em->res[0], y - em->min[1], em->res[1], z - em->min[2]);
-          float max_den = em->influence[index];
-
-          /* density bounds */
-          if (max_den >= sds->adapt_threshold) {
-            if (min[0] > x) {
-              min[0] = x;
-            }
-            if (min[1] > y) {
-              min[1] = y;
-            }
-            if (min[2] > z) {
-              min[2] = z;
-            }
-            if (max[0] < x) {
-              max[0] = x;
-            }
-            if (max[1] < y) {
-              max[1] = y;
-            }
-            if (max[2] < z) {
-              max[2] = z;
-            }
-          }
-        }
-      }
-    }
-  }
-
-  /* calculate new bounds based on these values */
-  mul_v3_fl(min_vel, 1.0f / sds->dx);
-  mul_v3_fl(max_vel, 1.0f / sds->dx);
-  clampBoundsInDomain(sds, min, max, min_vel, max_vel, sds->adapt_margin + 1, dt);
-
-  for (int i = 0; i < 3; i++) {
-    /* calculate new resolution */
-    res[i] = max[i] - min[i];
-    total_cells *= res[i];
-
-    if (new_shift[i]) {
-      shift_changed = 1;
-    }
-
-    /* if no content set minimum dimensions */
-    if (res[i] <= 0) {
-      int j;
-      for (j = 0; j < 3; j++) {
-        min[j] = 0;
-        max[j] = 1;
-        res[j] = 1;
-      }
-      res_changed = 1;
-      total_cells = 1;
-      break;
-    }
-    if (min[i] != sds->res_min[i] || max[i] != sds->res_max[i]) {
-      res_changed = 1;
-    }
-  }
-
-  if (res_changed || shift_changed) {
-    struct FLUID_3D *fluid_old = sds->fluid;
-    struct WTURBULENCE *turb_old = sds->wt;
-    /* allocate new fluid data */
-    BKE_smoke_reallocate_fluid(sds, sds->dx, res, 0);
-    if (sds->flags & MOD_SMOKE_HIGHRES) {
-      BKE_smoke_reallocate_highres_fluid(sds, sds->dx, res, 0);
-    }
-
-    /* copy values from old fluid to new */
-    if (sds->total_cells > 1 && total_cells > 1) {
-      /* low res smoke */
-      float *o_dens, *o_react, *o_flame, *o_fuel, *o_heat, *o_heatold, *o_vx, *o_vy, *o_vz, *o_r,
-          *o_g, *o_b;
-      float *n_dens, *n_react, *n_flame, *n_fuel, *n_heat, *n_heatold, *n_vx, *n_vy, *n_vz, *n_r,
-          *n_g, *n_b;
-      float dummy;
-      unsigned char *dummy_p;
-      /* high res smoke */
-      int wt_res_old[3];
-      float *o_wt_dens, *o_wt_react, *o_wt_flame, *o_wt_fuel, *o_wt_tcu, *o_wt_tcv, *o_wt_tcw,
-          *o_wt_r, *o_wt_g, *o_wt_b;
-      float *n_wt_dens, *n_wt_react, *n_wt_flame, *n_wt_fuel, *n_wt_tcu, *n_wt_tcv, *n_wt_tcw,
-          *n_wt_r, *n_wt_g, *n_wt_b;
-
-      smoke_export(fluid_old,
-                   &dummy,
-                   &dummy,
-                   &o_dens,
-                   &o_react,
-                   &o_flame,
-                   &o_fuel,
-                   &o_heat,
-                   &o_heatold,
-                   &o_vx,
-                   &o_vy,
-                   &o_vz,
-                   &o_r,
-                   &o_g,
-                   &o_b,
-                   &dummy_p);
-      smoke_export(sds->fluid,
-                   &dummy,
-                   &dummy,
-                   &n_dens,
-                   &n_react,
-                   &n_flame,
-                   &n_fuel,
-                   &n_heat,
-                   &n_heatold,
-                   &n_vx,
-                   &n_vy,
-                   &n_vz,
-                   &n_r,
-                   &n_g,
-                   &n_b,
-                   &dummy_p);
-
-      if (sds->flags & MOD_SMOKE_HIGHRES) {
-        smoke_turbulence_export(turb_old,
-                                &o_wt_dens,
-                                &o_wt_react,
-                                &o_wt_flame,
-                                &o_wt_fuel,
-                                &o_wt_r,
-                                &o_wt_g,
-                                &o_wt_b,
-                                &o_wt_tcu,
-                                &o_wt_tcv,
-                                &o_wt_tcw);
-        smoke_turbulence_get_res(turb_old, wt_res_old);
-        smoke_turbulence_export(sds->wt,
-                                &n_wt_dens,
-                                &n_wt_react,
-                                &n_wt_flame,
-                                &n_wt_fuel,
-                                &n_wt_r,
-                                &n_wt_g,
-                                &n_wt_b,
-                                &n_wt_tcu,
-                                &n_wt_tcv,
-                                &n_wt_tcw);
-      }
-
-      for (x = sds->res_min[0]; x < sds->res_max[0]; x++) {
-        for (y = sds->res_min[1]; y < sds->res_max[1]; y++) {
-          for (z = sds->res_min[2]; z < sds->res_max[2]; z++) {
-            /* old grid index */
-            int xo = x - sds->res_min[0];
-            int yo = y - sds->res_min[1];
-            int zo = z - sds->res_min[2];
-            int index_old = smoke_get_index(xo, sds->res[0], yo, sds->res[1], zo);
-            /* new grid index */
-            int xn = x - min[0] - new_shift[0];
-            int yn = y - min[1] - new_shift[1];
-            int zn = z - min[2] - new_shift[2];
-            int index_new = smoke_get_index(xn, res[0], yn, res[1], zn);
-
-            /* skip if outside new domain */
-            if (xn < 0 || xn >= res[0] || yn < 0 || yn >= res[1] || zn < 0 || zn >= res[2]) {
-              continue;
-            }
-
-            /* copy data */
-            n_dens[index_new] = o_dens[index_old];
-            /* heat */
-            if (n_heat && o_heat) {
-              n_heat[index_new] = o_heat[index_old];
-              n_heatold[index_new] = o_heatold[index_old];
-            }
-            /* fuel */
-            if (n_fuel && o_fuel) {
-              n_flame[index_new] = o_flame[index_old];
-              n_fuel[index_new] = o_fuel[index_old];
-              n_react[index_new] = o_react[index_old];
-            }
-            /* color */
-            if (o_r && n_r) {
-              n_r[index_new] = o_r[index_old];
-              n_g[index_new] = o_g[index_old];
-              n_b[index_new] = o_b[index_old];
-            }
-            n_vx[index_new] = o_vx[index_old];
-            n_vy[index_new] = o_vy[index_old];
-            n_vz[index_new] = o_vz[index_old];
-
-            if (sds->flags & MOD_SMOKE_HIGHRES && turb_old) {
-              int i, j, k;
-              /* old grid index */
-              int xx_o = xo * block_size;
-              int yy_o = yo * block_size;
-              int zz_o = zo * block_size;
-              /* new grid index */
-              int xx_n = xn * block_size;
-              int yy_n = yn * block_size;
-              int zz_n = zn * block_size;
-
-              n_wt_tcu[index_new] = o_wt_tcu[index_old];
-              n_wt_tcv[index_new] = o_wt_tcv[index_old];
-              n_wt_tcw[index_new] = o_wt_tcw[index_old];
-
-              for (i = 0; i < block_size; i++) {
-                for (j = 0; j < block_size; j++) {
-                  for (k = 0; k < block_size; k++) {
-                    int big_index_old = smoke_get_index(
-                        xx_o + i, wt_res_old[0], yy_o + j, wt_res_old[1], zz_o + k);
-                    int big_index_new = smoke_get_index(
-                        xx_n + i, sds->res_wt[0], yy_n + j, sds->res_wt[1], zz_n + k);
-                    /* copy data */
-                    n_wt_dens[big_index_new] = o_wt_dens[big_index_old];
-                    if (n_wt_flame && o_wt_flame) {
-                      n_wt_flame[big_index_new] = o_wt_flame[big_index_old];
-                      n_wt_fuel[big_index_new] = o_wt_fuel[big_index_old];
-                      n_wt_react[big_index_new] = o_wt_react[big_index_old];
-                    }
-                    if (n_wt_r && o_wt_r) {
-                      n_wt_r[big_index_new] = o_wt_r[big_index_old];
-                      n_wt_g[big_index_new] = o_wt_g[big_index_old];
-                      n_wt_b[big_index_new] = o_wt_b[big_index_old];
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-    smoke_free(fluid_old);
-    if (turb_old) {
-      smoke_turbulence_free(turb_old);
-    }
-
-    /* set new domain dimensions */
-    copy_v3_v3_int(sds->res_min, min);
-    copy_v3_v3_int(sds->res_max, max);
-    copy_v3_v3_int(sds->res, res);
-    sds->total_cells = total_cells;
-  }
-}
-
-BLI_INLINE void apply_outflow_fields(int index,
-                                     float *density,
-                                     float *heat,
-                                     float *fuel,
-                                     float *react,
-                                     float *color_r,
-                                     float *color_g,
-                                     float *color_b)
-{
-  density[index] = 0.f;
-  if (heat) {
-    heat[index] = 0.f;
-  }
-  if (fuel) {
-    fuel[index] = 0.f;
-    react[index] = 0.f;
-  }
-  if (color_r) {
-    color_r[index] = 0.f;
-    color_g[index] = 0.f;
-    color_b[index] = 0.f;
-  }
-}
-
-BLI_INLINE void apply_inflow_fields(SmokeFlowSettings *sfs,
-                                    float emission_value,
-                                    int index,
-                                    float *density,
-                                    float *heat,
-                                    float *fuel,
-                                    float *react,
-                                    float *color_r,
-                                    float *color_g,
-                                    float *color_b)
-{
-  int absolute_flow = (sfs->flags & MOD_SMOKE_FLOW_ABSOLUTE);
-  float dens_old = density[index];
-  // float fuel_old = (fuel) ? fuel[index] : 0.0f;  /* UNUSED */
-  float dens_flow = (sfs->type == MOD_SMOKE_FLOW_TYPE_FIRE) ? 0.0f : emission_value * sfs->density;
-  float fuel_flow = emission_value * sfs->fuel_amount;
-  /* add heat */
-  if (heat && emission_value > 0.0f) {
-    heat[index] = ADD_IF_LOWER(heat[index], sfs->temp);
-  }
-  /* absolute */
-  if (absolute_flow) {
-    if (sfs->type != MOD_SMOKE_FLOW_TYPE_FIRE) {
-      if (dens_flow > density[index]) {
-        density[index] = dens_flow;
-      }
-    }
-    if (sfs->type != MOD_SMOKE_FLOW_TYPE_SMOKE && fuel && fuel_flow) {
-      if (fuel_flow > fuel[index]) {
-        fuel[index] = fuel_flow;
-      }
-    }
-  }
-  /* additive */
-  else {
-    if (sfs->type != MOD_SMOKE_FLOW_TYPE_FIRE) {
-      density[index] += dens_flow;
-      CLAMP(density[index], 0.0f, 1.0f);
-    }
-    if (sfs->type != MOD_SMOKE_FLOW_TYPE_SMOKE && fuel && sfs->fuel_amount) {
-      fuel[index] += fuel_flow;
-      CLAMP(fuel[index], 0.0f, 10.0f);
-    }
-  }
-
-  /* set color */
-  if (color_r && dens_flow) {
-    float total_dens = density[index] / (dens_old + dens_flow);
-    color_r[index] = (color_r[index] + sfs->color[0] * dens_flow) * total_dens;
-    color_g[index] = (color_g[index] + sfs->color[1] * dens_flow) * total_dens;
-    color_b[index] = (color_b[index] + sfs->color[2] * dens_flow) * total_dens;
-  }
-
-  /* set fire reaction coordinate */
-  if (fuel && fuel[index] > FLT_EPSILON) {
-    /* instead of using 1.0 for all new fuel add slight falloff
-     * to reduce flow blockiness */
-    float value = 1.0f - pow2f(1.0f - emission_value);
-
-    if (value > react[index]) {
-      float f = fuel_flow / fuel[index];
-      react[index] = value * f + (1.0f - f) * react[index];
-      CLAMP(react[index], 0.0f, value);
-    }
-  }
-}
-
-static void update_flowsfluids(
-    Depsgraph *depsgraph, Scene *scene, Object *ob, SmokeDomainSettings *sds, float dt)
-{
-  Object **flowobjs = NULL;
-  EmissionMap *emaps = NULL;
-  unsigned int numflowobj = 0;
-  unsigned int flowIndex;
-  int new_shift[3] = {0};
-  int active_fields = sds->active_fields;
-
-  /* calculate domain shift for current frame if using adaptive domain */
-  if (sds->flags & MOD_SMOKE_ADAPTIVE_DOMAIN) {
-    int total_shift[3];
-    float frame_shift_f[3];
-    float ob_loc[3] = {0};
-
-    mul_m4_v3(ob->obmat, ob_loc);
-
-    sub_v3_v3v3(frame_shift_f, ob_loc, sds->prev_loc);
-    copy_v3_v3(sds->prev_loc, ob_loc);
-    /* convert global space shift to local "cell" space */
-    mul_mat3_m4_v3(sds->imat, frame_shift_f);
-    frame_shift_f[0] = frame_shift_f[0] / sds->cell_size[0];
-    frame_shift_f[1] = frame_shift_f[1] / sds->cell_size[1];
-    frame_shift_f[2] = frame_shift_f[2] / sds->cell_size[2];
-    /* add to total shift */
-    add_v3_v3(sds->shift_f, frame_shift_f);
-    /* convert to integer */
-    total_shift[0] = (int)(floorf(sds->shift_f[0]));
-    total_shift[1] = (int)(floorf(sds->shift_f[1]));
-    total_shift[2] = (int)(floorf(sds->shift_f[2]));
-    sub_v3_v3v3_int(new_shift, total_shift, sds->shift);
-    copy_v3_v3_int(sds->shift, total_shift);
-
-    /* calculate new domain boundary points so that smoke doesn't slide on sub-cell movement */
-    sds->p0[0] = sds->dp0[0] - sds->cell_size[0] * (sds->shift_f[0] - total_shift[0] - 0.5f);
-    sds->p0[1] = sds->dp0[1] - sds->cell_size[1] * (sds->shift_f[1] - total_shift[1] - 0.5f);
-    sds->p0[2] = sds->dp0[2] - sds->cell_size[2] * (sds->shift_f[2] - total_shift[2] - 0.5f);
-    sds->p1[0] = sds->p0[0] + sds->cell_size[0] * sds->base_res[0];
-    sds->p1[1] = sds->p0[1] + sds->cell_size[1] * sds->base_res[1];
-    sds->p1[2] = sds->p0[2] + sds->cell_size[2] * sds->base_res[2];
-  }
-
-  flowobjs = BKE_collision_objects_create(
-      depsgraph, ob, sds->fluid_group, &numflowobj, eModifierType_Smoke);
-
-  /* init emission maps for each flow */
-  emaps = MEM_callocN(sizeof(struct EmissionMap) * numflowobj, "smoke_flow_maps");
-
-  /* Prepare flow emission maps */
-  for (flowIndex = 0; flowIndex < numflowobj; flowIndex++) {
-    Object *collob = flowobjs[flowIndex];
-    SmokeModifierData *smd2 = (SmokeModifierData *)modifiers_findByType(collob,
-                                                                        eModifierType_Smoke);
-
-    // check for initialized smoke object
-    if ((smd2->type & MOD_SMOKE_TYPE_FLOW) && smd2->flow) {
-      // we got nice flow object
-      SmokeFlowSettings *sfs = smd2->flow;
-      int subframes = sfs->subframes;
-      EmissionMap *em = &emaps[flowIndex];
-
-      /* just sample flow directly to emission map if no subframes */
-      if (!subframes) {
-        if (sfs->source == MOD_SMOKE_FLOW_SOURCE_PARTICLES) {
-          emit_from_particles(collob, sds, sfs, em, depsgraph, scene, dt);
-        }
-        else {
-          emit_from_mesh(collob, sds, sfs, em, dt);
-        }
-      }
-      /* sample subframes */
-      else {
-        int scene_frame = (int)DEG_get_ctime(depsgraph);
-        // float scene_subframe = scene->r.subframe;  // UNUSED
-        int subframe;
-        for (subframe = 0; subframe <= subframes; subframe++) {
-          EmissionMap em_temp = {NULL};
-          float sample_size = 1.0f / (float)(subframes + 1);
-          float prev_frame_pos = sample_size * (float)(subframe + 1);
-          float sdt = dt * sample_size;
-          int hires_multiplier = 1;
-
-          if ((sds->flags & MOD_SMOKE_HIGHRES) && (sds->highres_sampling == SM_HRES_FULLSAMPLE)) {
-            hires_multiplier = sds->amplify + 1;
-          }
-
-          /* set scene frame to match previous frame + subframe
-           * or use current frame for last sample */
-          if (subframe < subframes) {
-            scene->r.cfra = scene_frame - 1;
-            scene->r.subframe = prev_frame_pos;
-          }
-          else {
-            scene->r.cfra = scene_frame;
-            scene->r.subframe = 0.0f;
-          }
-
-          /* update flow object frame */
-          BLI_mutex_lock(&object_update_lock);
-          BKE_object_modifier_update_subframe(
-              depsgraph, scene, collob, true, 5, BKE_scene_frame_get(scene), eModifierType_Smoke);
-          BLI_mutex_unlock(&object_update_lock);
-
-          if (sfs->source == MOD_SMOKE_FLOW_SOURCE_PARTICLES) {
-            /* emit_from_particles() updates timestep internally */
-            emit_from_particles(collob, sds, sfs, &em_temp, depsgraph, scene, sdt);
-            if (!(sfs->flags & MOD_SMOKE_FLOW_USE_PART_SIZE)) {
-              hires_multiplier = 1;
-            }
-          }
-          else { /* MOD_SMOKE_FLOW_SOURCE_MESH */
-            /* apply flow */
-            emit_from_mesh(collob, sds, sfs, &em_temp, sdt);
-          }
-
-          /* combine emission maps */
-          em_combineMaps(em,
-                         &em_temp,
-                         hires_multiplier,
-                         !(sfs->flags & MOD_SMOKE_FLOW_ABSOLUTE),
-                         sample_size);
-          em_freeData(&em_temp);
-        }
-      }
-
-      /* update required data fields */
-      if (em->total_cells && sfs->type != MOD_SMOKE_FLOW_TYPE_OUTFLOW) {
-        /* activate heat field if flow produces any heat */
-        if (sfs->temp) {
-          active_fields |= SM_ACTIVE_HEAT;
-        }
-        /* activate fuel field if flow adds any fuel */
-        if (sfs->type != MOD_SMOKE_FLOW_TYPE_SMOKE && sfs->fuel_amount) {
-          active_fields |= SM_ACTIVE_FIRE;
-        }
-        /* activate color field if flows add smoke with varying colors */
-        if (sfs->type != MOD_SMOKE_FLOW_TYPE_FIRE && sfs->density) {
-          if (!(active_fields & SM_ACTIVE_COLOR_SET)) {
-            copy_v3_v3(sds->active_color, sfs->color);
-            active_fields |= SM_ACTIVE_COLOR_SET;
-          }
-          else if (!equals_v3v3(sds->active_color, sfs->color)) {
-            copy_v3_v3(sds->active_color, sfs->color);
-            active_fields |= SM_ACTIVE_COLORS;
-          }
-        }
-      }
-    }
-  }
-
-  /* monitor active fields based on domain settings */
-  /* if domain has fire, activate new fields if required */
-  if (active_fields & SM_ACTIVE_FIRE) {
-    /* heat is always needed for fire */
-    active_fields |= SM_ACTIVE_HEAT;
-    /* also activate colors if domain smoke color differs from active color */
-    if (!(active_fields & SM_ACTIVE_COLOR_SET)) {
-      copy_v3_v3(sds->active_color, sds->flame_smoke_color);
-      active_fields |= SM_ACTIVE_COLOR_SET;
-    }
-    else if (!equals_v3v3(sds->active_color, sds->flame_smoke_color)) {
-      copy_v3_v3(sds->active_color, sds->flame_smoke_color);
-      active_fields |= SM_ACTIVE_COLORS;
-    }
-  }
-
-  /* Adjust domain size if needed */
-  if (sds->flags & MOD_SMOKE_ADAPTIVE_DOMAIN) {
-    adjustDomainResolution(sds, new_shift, emaps, numflowobj, dt);
-  }
-
-  /* Initialize new data fields if any */
-  if (active_fields & SM_ACTIVE_HEAT) {
-    smoke_ensure_heat(sds->fluid);
-  }
-  if (active_fields & SM_ACTIVE_FIRE) {
-    smoke_ensure_fire(sds->fluid, sds->wt);
-  }
-  if (active_fields & SM_ACTIVE_COLORS) {
-    /* initialize all smoke with "active_color" */
-    smoke_ensure_colors(
-        sds->fluid, sds->wt, sds->active_color[0], sds->active_color[1], sds->active_color[2]);
-  }
-  sds->active_fields = active_fields;
-
-  /* Apply emission data */
-  if (sds->fluid) {
-    for (flowIndex = 0; flowIndex < numflowobj; flowIndex++) {
-      Object *collob = flowobjs[flowIndex];
-      SmokeModifierData *smd2 = (SmokeModifierData *)modifiers_findByType(collob,
-                                                                          eModifierType_Smoke);
-
-      // check for initialized smoke object
-      if ((smd2->type & MOD_SMOKE_TYPE_FLOW) && smd2->flow) {
-        // we got nice flow object
-        SmokeFlowSettings *sfs = smd2->flow;
-        EmissionMap *em = &emaps[flowIndex];
-
-        float *density = smoke_get_density(sds->fluid);
-        float *color_r = smoke_get_color_r(sds->fluid);
-        float *color_g = smoke_get_color_g(sds->fluid);
-        float *color_b = smoke_get_color_b(sds->fluid);
-        float *fuel = smoke_get_fuel(sds->fluid);
-        float *react = smoke_get_react(sds->fluid);
-        float *bigdensity = smoke_turbulence_get_density(sds->wt);
-        float *bigfuel = smoke_turbulence_get_fuel(sds->wt);
-        float *bigreact = smoke_turbulence_get_react(sds->wt);
-        float *bigcolor_r = smoke_turbulence_get_color_r(sds->wt);
-        float *bigcolor_g = smoke_turbulence_get_color_g(sds->wt);
-        float *bigcolor_b = smoke_turbulence_get_color_b(sds->wt);
-        float *heat = smoke_get_heat(sds->fluid);
-        float *velocity_x = smoke_get_velocity_x(sds->fluid);
-        float *velocity_y = smoke_get_velocity_y(sds->fluid);
-        float *velocity_z = smoke_get_velocity_z(sds->fluid);
-        // unsigned char *obstacle = smoke_get_obstacle(sds->fluid);
-        // DG TODO UNUSED unsigned char *obstacleAnim = smoke_get_obstacle_anim(sds->fluid);
-        int bigres[3];
-        float *velocity_map = em->velocity;
-        float *emission_map = em->influence;
-        float *emission_map_high = em->influence_high;
-
-        int ii, jj, kk, gx, gy, gz, ex, ey, ez, dx, dy, dz, block_size;
-        size_t e_index, d_index, index_big;
-
-        // 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 */
-              ex = gx - em->min[0];
-              ey = gy - em->min[1];
-              ez = gz - em->min[2];
-              e_index = smoke_get_index(ex, em->res[0], ey, em->res[1], ez);
-
-              /* get domain index */
-              dx = gx - sds->res_min[0];
-              dy = gy - sds->res_min[1];
-              dz = gz - sds->res_min[2];
-              d_index = smoke_get_index(dx, sds->res[0], dy, sds->res[1], dz);
-              /* make sure emission cell is inside the new domain boundary */
-              if (dx < 0 || dy < 0 || dz < 0 || dx >= sds->res[0] || dy >= sds->res[1] ||
-                  dz >= sds->res[2]) {
-                continue;
-              }
-
-              if (sfs->type == MOD_SMOKE_FLOW_TYPE_OUTFLOW) {  // outflow
-                apply_outflow_fields(
-                    d_index, density, heat, fuel, react, color_r, color_g, color_b);
-              }
-              else {  // inflow
-                apply_inflow_fields(sfs,
-                                    emission_map[e_index],
-                                    d_index,
-                                    density,
-                                    heat,
-                                    fuel,
-                                    react,
-                                    color_r,
-                                    color_g,
-                                    color_b);
-
-                /* initial velocity */
-                if (sfs->flags & MOD_SMOKE_FLOW_INITVELOCITY) {
-                  velocity_x[d_index] = ADD_IF_LOWER(velocity_x[d_index],
-                                                     velocity_map[e_index * 3]);
-                  velocity_y[d_index] = ADD_IF_LOWER(velocity_y[d_index],
-                                                     velocity_map[e_index * 3 + 1]);
-                  velocity_z[d_index] = ADD_IF_LOWER(velocity_z[d_index],
-                                                     velocity_map[e_index * 3 + 2]);
-                }
-              }
-
-              /* loop through high res blocks if high res enabled */
-              if (bigdensity) {
-                /* Neighbor cell emission densities
-                 * (for high resolution smoke smooth interpolation). */
-                float c000, c001, c010, c011, c100, c101, c110, c111;
-
-                smoke_turbulence_get_res(sds->wt, bigres);
-                block_size = sds->amplify + 1;  // high res block size
-
-                c000 = (ex > 0 && ey > 0 && ez > 0) ?
-                           emission_map[smoke_get_index(
-                               ex - 1, em->res[0], ey - 1, em->res[1], ez - 1)] :
-                           0;
-                c001 =
-                    (ex > 0 && ey > 0) ?
-                        emission_map[smoke_get_index(ex - 1, em->res[0], ey - 1, em->res[1], ez)] :
-                        0;
-                c010 =
-                    (ex > 0 && ez > 0) ?
-                        emission_map[smoke_get_index(ex - 1, em->res[0], ey, em->res[1], ez - 1)] :
-                        0;
-                c011 = (ex > 0) ?
-                           emission_map[smoke_get_index(ex - 1, em->res[0], ey, em->res[1], ez)] :
-                           0;
-
-                c100 =
-                    (ey > 0 && ez > 0) ?
-                        emission_map[smoke_get_index(ex, em->res[0], ey - 1, em->res[1], ez - 1)] :
-                        0;
-                c101 = (ey > 0) ?
-                           emission_map[smoke_get_index(ex, em->res[0], ey - 1, em->res[1], ez)] :
-                           0;
-                c110 = (ez > 0) ?
-                           emission_map[smoke_get_index(ex, em->res[0], ey, em->res[1], ez - 1)] :
-                           0;
-                c111 = emission_map[smoke_get_index(
-                    ex, em->res[0], ey, em->res[1], ez)];  // this cell
-
-                for (ii = 0; ii < block_size; ii++) {
-                  for (jj = 0; jj < block_size; jj++) {
-                    for (kk = 0; kk < block_size; kk++) {
-
-                      float fx, fy, fz, interpolated_value;
-                      int shift_x = 0, shift_y = 0, shift_z = 0;
-
-                      /* Use full sample emission map if enabled and available */
-                      if ((sds->highres_sampling == SM_HRES_FULLSAMPLE) && emission_map_high) {
-                        interpolated_value =
-                            emission_map_high[smoke_get_index(ex * block_size + ii,
-                                                              em->res[0] * block_size,
-                                                              ey * block_size + jj,
-                                                              em->res[1] * block_size,
-                                                              ez * block_size + kk)];  // this cell
-                      }
-                      else if (sds->highres_sampling == SM_HRES_NEAREST) {
-                        /* without interpolation use same low resolution
-                         * block value for all hi-res blocks */
-                        interpolated_value = c111;
-                      }
-                      /* Fall back to interpolated */
-                      else {
-                        /* get relative block position
-                         * for interpolation smoothing */
-                        fx = (float)ii / block_size + 0.5f / block_size;
-                        fy = (float)jj / block_size + 0.5f / block_size;
-                        fz = (float)kk / block_size + 0.5f / block_size;
-
-                        /* calculate trilinear interpolation */
-                        interpolated_value = c000 * (1 - fx) * (1 - fy) * (1 - fz) +
-                                             c100 * fx * (1 - fy) * (1 - fz) +
-                                             c010 * (1 - fx) * fy * (1 - fz) +
-                                             c001 * (1 - fx) * (1 - fy) * fz +
-                                             c101 * fx * (1 - fy) * fz +
-                                             c011 * (1 - fx) * fy * fz +
-                                             c110 * fx * fy * (1 - fz) + c111 * fx * fy * fz;
-
-                        /* add some contrast / sharpness
-                         * depending on hi-res block size */
-                        interpolated_value = (interpolated_value - 0.4f) * (block_size / 2) + 0.4f;
-                        CLAMP(interpolated_value, 0.0f, 1.0f);
-
-                        /* shift smoke block index
-                         * (because pixel center is actually
-                         * in halfway of the low res block) */
-                        shift_x = (dx < 1) ? 0 : block_size / 2;
-                        shift_y = (dy < 1) ? 0 : block_size / 2;
-                        shift_z = (dz < 1) ? 0 : block_size / 2;
-                      }
-
-                      /* get shifted index for current high resolution block */
-                      index_big = smoke_get_index(block_size * dx + ii - shift_x,
-                                                  bigres[0],
-                                                  block_size * dy + jj - shift_y,
-                                                  bigres[1],
-                                                  block_size * dz + kk - shift_z);
-
-                      if (sfs->type == MOD_SMOKE_FLOW_TYPE_OUTFLOW) {  // outflow
-                        if (interpolated_value) {
-                          apply_outflow_fields(index_big,
-                                               bigdensity,
-                                               NULL,
-                                               bigfuel,
-                                               bigreact,
-                                               bigcolor_r,
-                                               bigcolor_g,
-                                               bigcolor_b);
-                        }
-                      }
-                      else {  // inflow
-                        apply_inflow_fields(sfs,
-                                            interpolated_value,
-                                            index_big,
-                                            bigdensity,
-                                            NULL,
-                                            bigfuel,
-                                            bigreact,
-                                            bigcolor_r,
-                                            bigcolor_g,
-                                            bigcolor_b);
-                      }
-                    }  // hires loop
-                  }
-                }
-              }  // bigdensity
-            }    // low res loop
-          }
-        }
-
-        // free emission maps
-        em_freeData(em);
-
-      }  // end emission
-    }
-  }
-
-  BKE_collision_objects_free(flowobjs);
-  if (emaps) {
-    MEM_freeN(emaps);
-  }
-}
-
-typedef struct UpdateEffectorsData {
-  Scene *scene;
-  SmokeDomainSettings *sds;
-  ListBase *effectors;
-
-  float *density;
-  float *fuel;
-  float *force_x;
-  float *force_y;
-  float *force_z;
-  float *velocity_x;
-  float *velocity_y;
-  float *velocity_z;
-  unsigned char *obstacle;
-} UpdateEffectorsData;
-
-static void update_effectors_task_cb(void *__restrict userdata,
-                                     const int x,
-                                     const TaskParallelTLS *__restrict UNUSED(tls))
-{
-  UpdateEffectorsData *data = userdata;
-  SmokeDomainSettings *sds = data->sds;
-
-  for (int y = 0; y < sds->res[1]; y++) {
-    for (int z = 0; z < sds->res[2]; z++) {
-      EffectedPoint epoint;
-      float mag;
-      float voxelCenter[3] = {0, 0, 0}, vel[3] = {0, 0, 0}, retvel[3] = {0, 0, 0};
-      const unsigned int index = smoke_get_index(x, sds->res[0], y, sds->res[1], z);
-
-      if (((data->fuel ? MAX2(data->density[index], data->fuel[index]) : data->density[index]) <
-           FLT_EPSILON) ||
-          data->obstacle[index]) {
-        continue;
-      }
-
-      vel[0] = data->velocity_x[index];
-      vel[1] = data->velocity_y[index];
-      vel[2] = data->velocity_z[index];
-
-      /* convert vel to global space */
-      mag = len_v3(vel);
-      mul_mat3_m4_v3(sds->obmat, vel);
-      normalize_v3(vel);
-      mul_v3_fl(vel, mag);
-
-      voxelCenter[0] = sds->p0[0] + sds->cell_size[0] * ((float)(x + sds->res_min[0]) + 0.5f);
-      voxelCenter[1] = sds->p0[1] + sds->cell_size[1] * ((float)(y + sds->res_min[1]) + 0.5f);
-      voxelCenter[2] = sds->p0[2] + sds->cell_size[2] * ((float)(z + sds->res_min[2]) + 0.5f);
-      mul_m4_v3(sds->obmat, voxelCenter);
-
-      pd_point_from_loc(data->scene, voxelCenter, vel, index, &epoint);
-      BKE_effectors_apply(data->effectors, NULL, sds->effector_weights, &epoint, retvel, NULL);
-
-      /* convert retvel to local space */
-      mag = len_v3(retvel);
-      mul_mat3_m4_v3(sds->imat, retvel);
-      normalize_v3(retvel);
-      mul_v3_fl(retvel, mag);
-
-      // TODO dg - do in force!
-      data->force_x[index] = min_ff(max_ff(-1.0f, retvel[0] * 0.2f), 1.0f);
-      data->force_y[index] = min_ff(max_ff(-1.0f, retvel[1] * 0.2f), 1.0f);
-      data->force_z[index] = min_ff(max_ff(-1.0f, retvel[2] * 0.2f), 1.0f);
-    }
-  }
-}
-
-static void update_effectors(
-    Depsgraph *depsgraph, Scene *scene, Object *ob, SmokeDomainSettings *sds, float UNUSED(dt))
-{
-  ListBase *effectors;
-  /* make sure smoke flow influence is 0.0f */
-  sds->effector_weights->weight[PFIELD_SMOKEFLOW] = 0.0f;
-  effectors = BKE_effectors_create(depsgraph, ob, NULL, sds->effector_weights);
-
-  if (effectors) {
-    // precalculate wind forces
-    UpdateEffectorsData data;
-    data.scene = scene;
-    data.sds = sds;
-    data.effectors = effectors;
-    data.density = smoke_get_density(sds->fluid);
-    data.fuel = smoke_get_fuel(sds->fluid);
-    data.force_x = smoke_get_force_x(sds->fluid);
-    data.force_y = smoke_get_force_y(sds->fluid);
-    data.force_z = smoke_get_force_z(sds->fluid);
-    data.velocity_x = smoke_get_velocity_x(sds->fluid);
-    data.velocity_y = smoke_get_velocity_y(sds->fluid);
-    data.velocity_z = smoke_get_velocity_z(sds->fluid);
-    data.obstacle = smoke_get_obstacle(sds->fluid);
-
-    TaskParallelSettings settings;
-    BLI_parallel_range_settings_defaults(&settings);
-    settings.scheduling_mode = TASK_SCHEDULING_DYNAMIC;
-    BLI_task_parallel_range(0, sds->res[0], &data, update_effectors_task_cb, &settings);
-  }
-
-  BKE_effectors_free(effectors);
-}
-
-static void step(Depsgraph *depsgraph,
-                 Scene *scene,
-                 Object *ob,
-                 SmokeModifierData *smd,
-                 Mesh *domain_me,
-                 float fps)
-{
-  SmokeDomainSettings *sds = smd->domain;
-  /* stability values copied from wturbulence.cpp */
-  const int maxSubSteps = 25;
-  float maxVel;
-  // maxVel should be 1.5 (1.5 cell max movement) * dx (cell size)
-
-  float dt;
-  float maxVelMag = 0.0f;
-  int totalSubsteps;
-  int substep = 0;
-  float dtSubdiv;
-  float gravity[3] = {0.0f, 0.0f, -1.0f};
-  float gravity_mag;
-
-  /* update object state */
-  invert_m4_m4(sds->imat, ob->obmat);
-  copy_m4_m4(sds->obmat, ob->obmat);
-  smoke_set_domain_from_mesh(sds, ob, domain_me, (sds->flags & MOD_SMOKE_ADAPTIVE_DOMAIN) != 0);
-
-  /* use global gravity if enabled */
-  if (scene->physics_settings.flag & PHYS_GLOBAL_GRAVITY) {
-    copy_v3_v3(gravity, scene->physics_settings.gravity);
-    /* map default value to 1.0 */
-    mul_v3_fl(gravity, 1.0f / 9.810f);
-  }
-  /* convert gravity to domain space */
-  gravity_mag = len_v3(gravity);
-  mul_mat3_m4_v3(sds->imat, gravity);
-  normalize_v3(gravity);
-  mul_v3_fl(gravity, gravity_mag);
-
-  /* adapt timestep for different framerates, dt = 0.1 is at 25fps */
-  dt = DT_DEFAULT * (25.0f / fps);
-  // maximum timestep/"CFL" constraint: dt < 5.0 *dx / maxVel
-  maxVel = (sds->dx * 5.0f);
-
-  maxVelMag = sqrtf(maxVelMag) * dt * sds->time_scale;
-  totalSubsteps = (int)((maxVelMag / maxVel) + 1.0f); /* always round up */
-  totalSubsteps = (totalSubsteps < 1) ? 1 : totalSubsteps;
-  totalSubsteps = (totalSubsteps > maxSubSteps) ? maxSubSteps : totalSubsteps;
-
-  /* Disable substeps for now, since it results in numerical instability */
-  totalSubsteps = 1.0f;
-
-  dtSubdiv = (float)dt / (float)totalSubsteps;
-
-  // printf("totalSubsteps: %d, maxVelMag: %f, dt: %f\n", totalSubsteps, maxVelMag, dt);
-
-  for (substep = 0; substep < totalSubsteps; substep++) {
-    // calc animated obstacle velocities
-    update_flowsfluids(depsgraph, scene, ob, sds, dtSubdiv);
-    update_obstacles(depsgraph, ob, sds, dtSubdiv, substep, totalSubsteps);
-
-    if (sds->total_cells > 1) {
-      // DG TODO? problem --> uses forces instead of velocity,
-      // need to check how they need to be changed with variable dt.
-      update_effectors(depsgraph, scene, ob, sds, dtSubdiv);
-      smoke_step(sds->fluid, gravity, dtSubdiv);
-    }
-  }
-}
-
-static Mesh *createDomainGeometry(SmokeDomainSettings *sds, Object *ob)
-{
-  Mesh *result;
-  MVert *mverts;
-  MPoly *mpolys;
-  MLoop *mloops;
-  float min[3];
-  float max[3];
-  float *co;
-  MPoly *mp;
-  MLoop *ml;
-
-  int num_verts = 8;
-  int num_faces = 6;
-  int i;
-  float ob_loc[3] = {0};
-  float ob_cache_loc[3] = {0};
-
-  /* dont generate any mesh if there isnt any content */
-  if (sds->total_cells <= 1) {
-    num_verts = 0;
-    num_faces = 0;
-  }
-
-  result = BKE_mesh_new_nomain(num_verts, 0, 0, num_faces * 4, num_faces);
-  mverts = result->mvert;
-  mpolys = result->mpoly;
-  mloops = result->mloop;
-
-  if (num_verts) {
-    /* volume bounds */
-    madd_v3fl_v3fl_v3fl_v3i(min, sds->p0, sds->cell_size, sds->res_min);
-    madd_v3fl_v3fl_v3fl_v3i(max, sds->p0, sds->cell_size, sds->res_max);
-
-    /* set vertices */
-    /* top slab */
-    co = mverts[0].co;
-    co[0] = min[0];
-    co[1] = min[1];
-    co[2] = max[2];
-    co = mverts[1].co;
-    co[0] = max[0];
-    co[1] = min[1];
-    co[2] = max[2];
-    co = mverts[2].co;
-    co[0] = max[0];
-    co[1] = max[1];
-    co[2] = max[2];
-    co = mverts[3].co;
-    co[0] = min[0];
-    co[1] = max[1];
-    co[2] = max[2];
-    /* bottom slab */
-    co = mverts[4].co;
-    co[0] = min[0];
-    co[1] = min[1];
-    co[2] = min[2];
-    co = mverts[5].co;
-    co[0] = max[0];
-    co[1] = min[1];
-    co[2] = min[2];
-    co = mverts[6].co;
-    co[0] = max[0];
-    co[1] = max[1];
-    co[2] = min[2];
-    co = mverts[7].co;
-    co[0] = min[0];
-    co[1] = max[1];
-    co[2] = min[2];
-
-    /* create faces */
-    /* top */
-    mp = &mpolys[0];
-    ml = &mloops[0 * 4];
-    mp->loopstart = 0 * 4;
-    mp->totloop = 4;
-    ml[0].v = 0;
-    ml[1].v = 1;
-    ml[2].v = 2;
-    ml[3].v = 3;
-    /* right */
-    mp = &mpolys[1];
-    ml = &mloops[1 * 4];
-    mp->loopstart = 1 * 4;
-    mp->totloop = 4;
-    ml[0].v = 2;
-    ml[1].v = 1;
-    ml[2].v = 5;
-    ml[3].v = 6;
-    /* bottom */
-    mp = &mpolys[2];
-    ml = &mloops[2 * 4];
-    mp->loopstart = 2 * 4;
-    mp->totloop = 4;
-    ml[0].v = 7;
-    ml[1].v = 6;
-    ml[2].v = 5;
-    ml[3].v = 4;
-    /* left */
-    mp = &mpolys[3];
-    ml = &mloops[3 * 4];
-    mp->loopstart = 3 * 4;
-    mp->totloop = 4;
-    ml[0].v = 0;
-    ml[1].v = 3;
-    ml[2].v = 7;
-    ml[3].v = 4;
-    /* front */
-    mp = &mpolys[4];
-    ml = &mloops[4 * 4];
-    mp->loopstart = 4 * 4;
-    mp->totloop = 4;
-    ml[0].v = 3;
-    ml[1].v = 2;
-    ml[2].v = 6;
-    ml[3].v = 7;
-    /* back */
-    mp = &mpolys[5];
-    ml = &mloops[5 * 4];
-    mp->loopstart = 5 * 4;
-    mp->totloop = 4;
-    ml[0].v = 1;
-    ml[1].v = 0;
-    ml[2].v = 4;
-    ml[3].v = 5;
-
-    /* calculate required shift to match domain's global position
-     * it was originally simulated at (if object moves without smoke step) */
-    invert_m4_m4(ob->imat, ob->obmat);
-    mul_m4_v3(ob->obmat, ob_loc);
-    mul_m4_v3(sds->obmat, ob_cache_loc);
-    sub_v3_v3v3(sds->obj_shift_f, ob_cache_loc, ob_loc);
-    /* convert shift to local space and apply to vertices */
-    mul_mat3_m4_v3(ob->imat, sds->obj_shift_f);
-    /* apply */
-    for (i = 0; i < num_verts; i++) {
-      add_v3_v3(mverts[i].co, sds->obj_shift_f);
-    }
-  }
-
-  BKE_mesh_calc_edges(result, false, false);
-  result->runtime.cd_dirty_vert |= CD_MASK_NORMAL;
-  return result;
-}
-
-static void smokeModifier_process(
-    SmokeModifierData *smd, Depsgraph *depsgraph, Scene *scene, Object *ob, Mesh *me)
-{
-  const int scene_framenr = (int)DEG_get_ctime(depsgraph);
-
-  if ((smd->type & MOD_SMOKE_TYPE_FLOW)) {
-    if (scene_framenr >= smd->time) {
-      smokeModifier_init(smd, ob, scene_framenr, me);
-    }
-
-    if (smd->flow->mesh) {
-      BKE_id_free(NULL, smd->flow->mesh);
-    }
-    smd->flow->mesh = BKE_mesh_copy_for_eval(me, false);
-
-    if (scene_framenr > smd->time) {
-      smd->time = scene_framenr;
-    }
-    else if (scene_framenr < smd->time) {
-      smd->time = scene_framenr;
-      smokeModifier_reset_ex(smd, false);
-    }
-  }
-  else if (smd->type & MOD_SMOKE_TYPE_COLL) {
-    if (scene_framenr >= smd->time) {
-      smokeModifier_init(smd, ob, scene_framenr, me);
-    }
-
-    if (smd->coll) {
-      if (smd->coll->mesh) {
-        BKE_id_free(NULL, smd->coll->mesh);
-      }
-
-      smd->coll->mesh = BKE_mesh_copy_for_eval(me, false);
-    }
-
-    smd->time = scene_framenr;
-    if (scene_framenr < smd->time) {
-      smokeModifier_reset_ex(smd, false);
-    }
-  }
-  else if (smd->type & MOD_SMOKE_TYPE_DOMAIN) {
-    SmokeDomainSettings *sds = smd->domain;
-    PointCache *cache = NULL;
-    PTCacheID pid;
-    int startframe, endframe, framenr;
-    float timescale;
-
-    framenr = scene_framenr;
-
-    cache = sds->point_cache[0];
-    BKE_ptcache_id_from_smoke(&pid, ob, smd);
-    BKE_ptcache_id_time(&pid, scene, framenr, &startframe, &endframe, &timescale);
-
-    if (!smd->domain->fluid || framenr == startframe) {
-      BKE_ptcache_id_reset(scene, &pid, PTCACHE_RESET_OUTDATED);
-      smokeModifier_reset_ex(smd, false);
-      BKE_ptcache_validate(cache, framenr);
-      cache->flag &= ~PTCACHE_REDO_NEEDED;
-    }
-
-    if (!smd->domain->fluid && (framenr != startframe) &&
-        (smd->domain->flags & MOD_SMOKE_FILE_LOAD) == 0 && (cache->flag & PTCACHE_BAKED) == 0) {
-      return;
-    }
-
-    smd->domain->flags &= ~MOD_SMOKE_FILE_LOAD;
-    CLAMP(framenr, startframe, endframe);
-
-    /* If already viewing a pre/after frame, no need to reload */
-    if ((smd->time == framenr) && (framenr != scene_framenr)) {
-      return;
-    }
-
-    if (smokeModifier_init(smd, ob, scene_framenr, me) == 0) {
-      printf("bad smokeModifier_init\n");
-      return;
-    }
-
-    /* only calculate something when we advanced a single frame */
-    /* don't simulate if viewing start frame, but scene frame is not real start frame */
-    bool can_simulate = (framenr == (int)smd->time + 1) && (framenr == scene_framenr);
-
-    /* try to read from cache */
-    if (BKE_ptcache_read(&pid, (float)framenr, can_simulate) == PTCACHE_READ_EXACT) {
-      BKE_ptcache_validate(cache, framenr);
-      smd->time = framenr;
-      return;
-    }
-
-    if (!can_simulate) {
-      return;
-    }
-
-#  ifdef DEBUG_TIME
-    double start = PIL_check_seconds_timer();
-#  endif
-
-    /* if on second frame, write cache for first frame */
-    if ((int)smd->time == startframe &&
-        (cache->flag & PTCACHE_OUTDATED || cache->last_exact == 0)) {
-      BKE_ptcache_write(&pid, startframe);
-    }
-
-    // set new time
-    smd->time = scene_framenr;
-
-    /* do simulation */
-
-    // simulate the actual smoke (c++ code in intern/smoke)
-    // DG: interesting commenting this line + deactivating loading of noise files
-    if (framenr != startframe) {
-      if (sds->flags & MOD_SMOKE_DISSOLVE) {
-        /* low res dissolve */
-        smoke_dissolve(sds->fluid, sds->diss_speed, sds->flags & MOD_SMOKE_DISSOLVE_LOG);
-        /* high res dissolve */
-        if (sds->wt) {
-          smoke_dissolve_wavelet(sds->wt, sds->diss_speed, sds->flags & MOD_SMOKE_DISSOLVE_LOG);
-        }
-      }
-
-      step(depsgraph, scene, ob, smd, me, scene->r.frs_sec / scene->r.frs_sec_base);
-    }
-
-    // create shadows before writing cache so they get stored
-    smoke_calc_transparency(sds, DEG_get_evaluated_view_layer(depsgraph));
-
-    if (sds->wt && sds->total_cells > 1) {
-      smoke_turbulence_step(sds->wt, sds->fluid);
-    }
-
-    BKE_ptcache_validate(cache, framenr);
-    if (framenr != startframe) {
-      BKE_ptcache_write(&pid, framenr);
-    }
-
-#  ifdef DEBUG_TIME
-    double end = PIL_check_seconds_timer();
-    printf("Frame: %d, Time: %f\n\n", (int)smd->time, (float)(end - start));
-#  endif
-  }
-}
-
-struct Mesh *smokeModifier_do(
-    SmokeModifierData *smd, Depsgraph *depsgraph, Scene *scene, Object *ob, Mesh *me)
-{
-  /* lock so preview render does not read smoke data while it gets modified */
-  if ((smd->type & MOD_SMOKE_TYPE_DOMAIN) && smd->domain) {
-    BLI_rw_mutex_lock(smd->domain->fluid_mutex, THREAD_LOCK_WRITE);
-  }
-
-  smokeModifier_process(smd, depsgraph, scene, ob, me);
-
-  if ((smd->type & MOD_SMOKE_TYPE_DOMAIN) && smd->domain) {
-    BLI_rw_mutex_unlock(smd->domain->fluid_mutex);
-  }
-
-  /* return generated geometry for adaptive domain */
-  Mesh *result;
-  if (smd->type & MOD_SMOKE_TYPE_DOMAIN && smd->domain &&
-      smd->domain->flags & MOD_SMOKE_ADAPTIVE_DOMAIN && smd->domain->base_res[0]) {
-    result = createDomainGeometry(smd->domain, ob);
-    BKE_mesh_copy_settings(result, me);
-  }
-  else {
-    result = BKE_mesh_copy_for_eval(me, false);
-  }
-
-  /* Smoke simulation needs a texture space relative to the adaptive domain bounds, not the
-   * original mesh. So recompute it at this point in the modifier stack. See T58492. */
-  BKE_mesh_texspace_calc(result);
-
-  return result;
-}
-
-static float calc_voxel_transp(
-    float *result, float *input, int res[3], int *pixel, float *tRay, float correct)
-{
-  const size_t index = smoke_get_index(pixel[0], res[0], pixel[1], res[1], pixel[2]);
-
-  // T_ray *= T_vox
-  *tRay *= expf(input[index] * correct);
-
-  if (result[index] < 0.0f) {
-    result[index] = *tRay;
-  }
-
-  return *tRay;
-}
-
-static void bresenham_linie_3D(int x1,
-                               int y1,
-                               int z1,
-                               int x2,
-                               int y2,
-                               int z2,
-                               float *tRay,
-                               bresenham_callback cb,
-                               float *result,
-                               float *input,
-                               int res[3],
-                               float correct)
-{
-  int dx, dy, dz, i, l, m, n, x_inc, y_inc, z_inc, err_1, err_2, dx2, dy2, dz2;
-  int pixel[3];
-
-  pixel[0] = x1;
-  pixel[1] = y1;
-  pixel[2] = z1;
-
-  dx = x2 - x1;
-  dy = y2 - y1;
-  dz = z2 - z1;
-
-  x_inc = (dx < 0) ? -1 : 1;
-  l = abs(dx);
-  y_inc = (dy < 0) ? -1 : 1;
-  m = abs(dy);
-  z_inc = (dz < 0) ? -1 : 1;
-  n = abs(dz);
-  dx2 = l << 1;
-  dy2 = m << 1;
-  dz2 = n << 1;
-
-  if ((l >= m) && (l >= n)) {
-    err_1 = dy2 - l;
-    err_2 = dz2 - l;
-    for (i = 0; i < l; i++) {
-      if (cb(result, input, res, pixel, tRay, correct) <= FLT_EPSILON) {
-        break;
-      }
-      if (err_1 > 0) {
-        pixel[1] += y_inc;
-        err_1 -= dx2;
-      }
-      if (err_2 > 0) {
-        pixel[2] += z_inc;
-        err_2 -= dx2;
-      }
-      err_1 += dy2;
-      err_2 += dz2;
-      pixel[0] += x_inc;
-    }
-  }
-  else if ((m >= l) && (m >= n)) {
-    err_1 = dx2 - m;
-    err_2 = dz2 - m;
-    for (i = 0; i < m; i++) {
-      if (cb(result, input, res, pixel, tRay, correct) <= FLT_EPSILON) {
-        break;
-      }
-      if (err_1 > 0) {
-        pixel[0] += x_inc;
-        err_1 -= dy2;
-      }
-      if (err_2 > 0) {
-        pixel[2] += z_inc;
-        err_2 -= dy2;
-      }
-      err_1 += dx2;
-      err_2 += dz2;
-      pixel[1] += y_inc;
-    }
-  }
-  else {
-    err_1 = dy2 - n;
-    err_2 = dx2 - n;
-    for (i = 0; i < n; i++) {
-      if (cb(result, input, res, pixel, tRay, correct) <= FLT_EPSILON) {
-        break;
-      }
-      if (err_1 > 0) {
-        pixel[1] += y_inc;
-        err_1 -= dz2;
-      }
-      if (err_2 > 0) {
-        pixel[0] += x_inc;
-        err_2 -= dz2;
-      }
-      err_1 += dy2;
-      err_2 += dx2;
-      pixel[2] += z_inc;
-    }
-  }
-  cb(result, input, res, pixel, tRay, correct);
-}
-
-static void smoke_calc_transparency(SmokeDomainSettings *sds, ViewLayer *view_layer)
-{
-  float bv[6] = {0};
-  float light[3];
-  int a, z, slabsize = sds->res[0] * sds->res[1], size = sds->res[0] * sds->res[1] * sds->res[2];
-  float *density = smoke_get_density(sds->fluid);
-  float correct = -7.0f * sds->dx;
-
-  if (!get_light(view_layer, light)) {
-    return;
-  }
-
-  /* convert light pos to sim cell space */
-  mul_m4_v3(sds->imat, light);
-  light[0] = (light[0] - sds->p0[0]) / sds->cell_size[0] - 0.5f - (float)sds->res_min[0];
-  light[1] = (light[1] - sds->p0[1]) / sds->cell_size[1] - 0.5f - (float)sds->res_min[1];
-  light[2] = (light[2] - sds->p0[2]) / sds->cell_size[2] - 0.5f - (float)sds->res_min[2];
-
-  for (a = 0; a < size; a++) {
-    sds->shadow[a] = -1.0f;
-  }
-
-  /* calculate domain bounds in sim cell space */
-  // 0,2,4 = 0.0f
-  bv[1] = (float)sds->res[0];  // x
-  bv[3] = (float)sds->res[1];  // y
-  bv[5] = (float)sds->res[2];  // z
-
-  for (z = 0; z < sds->res[2]; z++) {
-    size_t index = z * slabsize;
-    int x, y;
-
-    for (y = 0; y < sds->res[1]; y++) {
-      for (x = 0; x < sds->res[0]; x++, index++) {
-        float voxelCenter[3];
-        float pos[3];
-        int cell[3];
-        float tRay = 1.0;
-
-        if (sds->shadow[index] >= 0.0f) {
-          continue;
-        }
-        voxelCenter[0] = (float)x;
-        voxelCenter[1] = (float)y;
-        voxelCenter[2] = (float)z;
-
-        // get starting cell (light pos)
-        if (BLI_bvhtree_bb_raycast(bv, light, voxelCenter, pos) > FLT_EPSILON) {
-          // we're outside -> use point on side of domain
-          cell[0] = (int)floor(pos[0]);
-          cell[1] = (int)floor(pos[1]);
-          cell[2] = (int)floor(pos[2]);
-        }
-        else {
-          // we're inside -> use light itself
-          cell[0] = (int)floor(light[0]);
-          cell[1] = (int)floor(light[1]);
-          cell[2] = (int)floor(light[2]);
-        }
-        /* clamp within grid bounds */
-        CLAMP(cell[0], 0, sds->res[0] - 1);
-        CLAMP(cell[1], 0, sds->res[1] - 1);
-        CLAMP(cell[2], 0, sds->res[2] - 1);
-
-        bresenham_linie_3D(cell[0],
-                           cell[1],
-                           cell[2],
-                           x,
-                           y,
-                           z,
-                           &tRay,
-                           calc_voxel_transp,
-                           sds->shadow,
-                           density,
-                           sds->res,
-                           correct);
-
-        // convention -> from a RGBA float array, use G value for tRay
-        sds->shadow[index] = tRay;
-      }
-    }
-  }
-}
-
-/* get smoke velocity and density at given coordinates
- * returns fluid density or -1.0f if outside domain. */
-float BKE_smoke_get_velocity_at(struct Object *ob, float position[3], float velocity[3])
-{
-  SmokeModifierData *smd = (SmokeModifierData *)modifiers_findByType(ob, eModifierType_Smoke);
-  zero_v3(velocity);
-
-  if (smd && (smd->type & MOD_SMOKE_TYPE_DOMAIN) && smd->domain && smd->domain->fluid) {
-    SmokeDomainSettings *sds = smd->domain;
-    float time_mult = 25.f * DT_DEFAULT;
-    float vel_mag;
-    float *velX = smoke_get_velocity_x(sds->fluid);
-    float *velY = smoke_get_velocity_y(sds->fluid);
-    float *velZ = smoke_get_velocity_z(sds->fluid);
-    float density = 0.0f, fuel = 0.0f;
-    float pos[3];
-    copy_v3_v3(pos, position);
-    smoke_pos_to_cell(sds, pos);
-
-    /* check if point is outside domain max bounds */
-    if (pos[0] < sds->res_min[0] || pos[1] < sds->res_min[1] || pos[2] < sds->res_min[2]) {
-      return -1.0f;
-    }
-    if (pos[0] > sds->res_max[0] || pos[1] > sds->res_max[1] || pos[2] > sds->res_max[2]) {
-      return -1.0f;
-    }
-
-    /* map pos between 0.0 - 1.0 */
-    pos[0] = (pos[0] - sds->res_min[0]) / ((float)sds->res[0]);
-    pos[1] = (pos[1] - sds->res_min[1]) / ((float)sds->res[1]);
-    pos[2] = (pos[2] - sds->res_min[2]) / ((float)sds->res[2]);
-
-    /* check if point is outside active area */
-    if (smd->domain->flags & MOD_SMOKE_ADAPTIVE_DOMAIN) {
-      if (pos[0] < 0.0f || pos[1] < 0.0f || pos[2] < 0.0f) {
-        return 0.0f;
-      }
-      if (pos[0] > 1.0f || pos[1] > 1.0f || pos[2] > 1.0f) {
-        return 0.0f;
-      }
-    }
-
-    /* get interpolated velocity */
-    velocity[0] = BLI_voxel_sample_trilinear(velX, sds->res, pos) * sds->global_size[0] *
-                  time_mult;
-    velocity[1] = BLI_voxel_sample_trilinear(velY, sds->res, pos) * sds->global_size[1] *
-                  time_mult;
-    velocity[2] = BLI_voxel_sample_trilinear(velZ, sds->res, pos) * sds->global_size[2] *
-                  time_mult;
-
-    /* convert velocity direction to global space */
-    vel_mag = len_v3(velocity);
-    mul_mat3_m4_v3(sds->obmat, velocity);
-    normalize_v3(velocity);
-    mul_v3_fl(velocity, vel_mag);
-
-    /* use max value of fuel or smoke density */
-    density = BLI_voxel_sample_trilinear(smoke_get_density(sds->fluid), sds->res, pos);
-    if (smoke_has_fuel(sds->fluid)) {
-      fuel = BLI_voxel_sample_trilinear(smoke_get_fuel(sds->fluid), sds->res, pos);
-    }
-    return MAX2(density, fuel);
-  }
-  return -1.0f;
-}
-
-int BKE_smoke_get_data_flags(SmokeDomainSettings *sds)
-{
-  int flags = 0;
-
-  if (sds->fluid) {
-    if (smoke_has_heat(sds->fluid)) {
-      flags |= SM_ACTIVE_HEAT;
-    }
-    if (smoke_has_fuel(sds->fluid)) {
-      flags |= SM_ACTIVE_FIRE;
-    }
-    if (smoke_has_colors(sds->fluid)) {
-      flags |= SM_ACTIVE_COLORS;
-    }
-  }
-
-  return flags;
-}
-
-#endif /* WITH_SMOKE */
-
-bool BKE_smoke_show_highres(Scene *scene, SmokeDomainSettings *sds)
-{
-  if ((sds->viewsettings & MOD_SMOKE_VIEW_SHOW_HIGHRES) == 0) {
-    return false;
-  }
-  if (scene->r.mode & R_SIMPLIFY) {
-    return !scene->r.simplify_smoke_ignore_highres;
-  }
-  return true;
-}
index 2a51a57f887d3c26c9e099331f89793731c4de03..f8723b495f7b99bf2fcd8e5c8292fbc679d93d03 100644 (file)
@@ -83,7 +83,7 @@
 #include "DNA_sdna_types.h"
 #include "DNA_scene_types.h"
 #include "DNA_sequence_types.h"
-#include "DNA_smoke_types.h"
+#include "DNA_fluid_types.h"
 #include "DNA_speaker_types.h"
 #include "DNA_sound_types.h"
 #include "DNA_space_types.h"
 /* local prototypes */
 static void read_libraries(FileData *basefd, ListBase *mainlist);
 static void *read_struct(FileData *fd, BHead *bh, const char *blockname);
-static void direct_link_modifiers(FileData *fd, ListBase *lb);
+static void direct_link_modifiers(FileData *fd, ListBase *lb, const Object *ob);
 static BHead *find_bhead_from_code_name(FileData *fd, const short idcode, const char *name);
 static BHead *find_bhead_from_idname(FileData *fd, const char *idname);
 
@@ -4636,7 +4636,7 @@ static void lib_link_particlesettings(FileData *fd, Main *main)
 
       part->instance_object = newlibadr(fd, part->id.lib, part->instance_object);
       part->instance_collection = newlibadr_us(fd, part->id.lib, part->instance_collection);
-      part->eff_group = newlibadr(fd, part->id.lib, part->eff_group);
+      part->force_group = newlibadr(fd, part->id.lib, part->force_group);
       part->bb_ob = newlibadr(fd, part->id.lib, part->bb_ob);
       part->collision_group = newlibadr(fd, part->id.lib, part->collision_group);
 
@@ -4647,7 +4647,7 @@ static void lib_link_particlesettings(FileData *fd, Main *main)
         part->effector_weights->group = newlibadr(fd, part->id.lib, part->effector_weights->group);
       }
       else {
-        part->effector_weights = BKE_effector_add_weights(part->eff_group);
+        part->effector_weights = BKE_effector_add_weights(part->force_group);
       }
 
       if (part->instance_weights.first && part->instance_collection) {
@@ -4729,7 +4729,7 @@ static void direct_link_particlesettings(FileData *fd, ParticleSettings *part)
 
   part->effector_weights = newdataadr(fd, part->effector_weights);
   if (!part->effector_weights) {
-    part->effector_weights = BKE_effector_add_weights(part->eff_group);
+    part->effector_weights = BKE_effector_add_weights(part->force_group);
   }
 
   link_list(fd, &part->instance_weights);
@@ -5372,12 +5372,12 @@ static void lib_link_object(FileData *fd, Main *main)
       }
 
       {
-        SmokeModifierData *smd = (SmokeModifierData *)modifiers_findByType(ob,
-                                                                           eModifierType_Smoke);
+        FluidModifierData *mmd = (FluidModifierData *)modifiers_findByType(ob,
+                                                                           eModifierType_Fluid);
 
-        if (smd && (smd->type == MOD_SMOKE_TYPE_DOMAIN) && smd->domain) {
-          /* Flag for refreshing the simulation after loading. */
-          smd->domain->flags |= MOD_SMOKE_FILE_LOAD;
+        if (mmd && (mmd->type == MOD_FLUID_TYPE_DOMAIN) && mmd->domain) {
+          /* Flag for refreshing the simulation after loading */
+          mmd->domain->flags |= FLUID_DOMAIN_FILE_LOAD;
         }
       }
 
@@ -5485,7 +5485,7 @@ static void direct_link_pose(FileData *fd, bPose *pose)
   }
 }
 
-static void direct_link_modifiers(FileData *fd, ListBase *lb)
+static void direct_link_modifiers(FileData *fd, ListBase *lb, const Object *ob)
 {
   ModifierData *md;
 
@@ -5495,6 +5495,24 @@ static void direct_link_modifiers(FileData *fd, ListBase *lb)
     md->error = NULL;
     md->runtime = NULL;
 
+    if (md->type == eModifierType_Fluidsim) {
+      blo_reportf_wrap(
+          fd->reports,
+          RPT_WARNING,
+          TIP_(
+              "Possible data loss when saving this file! %s modifier is deprecated (Object: %s)."),
+          md->name,
+          ob->id.name + 2);
+    }
+    else if (md->type == eModifierType_Smoke) {
+      blo_reportf_wrap(
+          fd->reports,
+          RPT_WARNING,
+          TIP_(
+              "Possible data loss when saving this file! %s modifier is deprecated (Object: %s)."),
+          md->name,
+          ob->id.name + 2);
+    }
     /* if modifiers disappear, or for upward compatibility */
     if (NULL == modifierType_getInfo(md->type)) {
       md->type = eModifierType_None;
@@ -5537,91 +5555,83 @@ static void direct_link_modifiers(FileData *fd, ListBase *lb)
 
       clmd->solver_result = NULL;
     }
-    else if (md->type == eModifierType_Fluidsim) {
-      FluidsimModifierData *fluidmd = (FluidsimModifierData *)md;
+    else if (md->type == eModifierType_Fluid) {
 
-      fluidmd->fss = newdataadr(fd, fluidmd->fss);
-      if (fluidmd->fss) {
-        fluidmd->fss->fmd = fluidmd;
-        fluidmd->fss->meshVelocities = NULL;
-      }
-    }
-    else if (md->type == eModifierType_Smoke) {
-      SmokeModifierData *smd = (SmokeModifierData *)md;
-
-      if (smd->type == MOD_SMOKE_TYPE_DOMAIN) {
-        smd->flow = NULL;
-        smd->coll = NULL;
-        smd->domain = newdataadr(fd, smd->domain);
-        smd->domain->smd = smd;
-
-        smd->domain->fluid = NULL;
-        smd->domain->fluid_mutex = BLI_rw_mutex_alloc();
-        smd->domain->wt = NULL;
-        smd->domain->shadow = NULL;
-        smd->domain->tex = NULL;
-        smd->domain->tex_shadow = NULL;
-        smd->domain->tex_flame = NULL;
-        smd->domain->tex_flame_coba = NULL;
-        smd->domain->tex_coba = NULL;
-        smd->domain->tex_field = NULL;
-        smd->domain->tex_velocity_x = NULL;
-        smd->domain->tex_velocity_y = NULL;
-        smd->domain->tex_velocity_z = NULL;
-        smd->domain->tex_wt = NULL;
-        smd->domain->coba = newdataadr(fd, smd->domain->coba);
-
-        smd->domain->effector_weights = newdataadr(fd, smd->domain->effector_weights);
-        if (!smd->domain->effector_weights) {
-          smd->domain->effector_weights = BKE_effector_add_weights(NULL);
+      FluidModifierData *mmd = (FluidModifierData *)md;
+
+      if (mmd->type == MOD_FLUID_TYPE_DOMAIN) {
+        mmd->flow = NULL;
+        mmd->effector = NULL;
+        mmd->domain = newdataadr(fd, mmd->domain);
+        mmd->domain->mmd = mmd;
+
+        mmd->domain->fluid = NULL;
+        mmd->domain->fluid_mutex = BLI_rw_mutex_alloc();
+        mmd->domain->tex = NULL;
+        mmd->domain->tex_shadow = NULL;
+        mmd->domain->tex_flame = NULL;
+        mmd->domain->tex_flame_coba = NULL;
+        mmd->domain->tex_coba = NULL;
+        mmd->domain->tex_field = NULL;
+        mmd->domain->tex_velocity_x = NULL;
+        mmd->domain->tex_velocity_y = NULL;
+        mmd->domain->tex_velocity_z = NULL;
+        mmd->domain->tex_wt = NULL;
+        mmd->domain->mesh_velocities = NULL;
+        mmd->domain->coba = newdataadr(fd, mmd->domain->coba);
+
+        mmd->domain->effector_weights = newdataadr(fd, mmd->domain->effector_weights);
+        if (!mmd->domain->effector_weights) {
+          mmd->domain->effector_weights = BKE_effector_add_weights(NULL);
         }
 
         direct_link_pointcache_list(
-            fd, &(smd->domain->ptcaches[0]), &(smd->domain->point_cache[0]), 1);
+            fd, &(mmd->domain->ptcaches[0]), &(mmd->domain->point_cache[0]), 1);
 
-        /* Smoke uses only one cache from now on, so store pointer convert */
-        if (smd->domain->ptcaches[1].first || smd->domain->point_cache[1]) {
-          if (smd->domain->point_cache[1]) {
-            PointCache *cache = newdataadr(fd, smd->domain->point_cache[1]);
+        /* Manta sim uses only one cache from now on, so store pointer convert */
+        if (mmd->domain->ptcaches[1].first || mmd->domain->point_cache[1]) {
+          if (mmd->domain->point_cache[1]) {
+            PointCache *cache = newdataadr(fd, mmd->domain->point_cache[1]);
             if (cache->flag & PTCACHE_FAKE_SMOKE) {
-              /* Smoke was already saved in "new format" and this cache is a fake one. */
+              /* Mantasim / smoke was already saved in "new format" and this cache is a fake one.
+               */
             }
             else {
               printf(
-                  "High resolution smoke cache not available due to pointcache update. Please "
+                  "High resolution manta cache not available due to pointcache update. Please "
                   "reset the simulation.\n");
             }
             BKE_ptcache_free(cache);
           }
-          BLI_listbase_clear(&smd->domain->ptcaches[1]);
-          smd->domain->point_cache[1] = NULL;
-        }
-      }
-      else if (smd->type == MOD_SMOKE_TYPE_FLOW) {
-        smd->domain = NULL;
-        smd->coll = NULL;
-        smd->flow = newdataadr(fd, smd->flow);
-        smd->flow->smd = smd;
-        smd->flow->mesh = NULL;
-        smd->flow->verts_old = NULL;
-        smd->flow->numverts = 0;
-        smd->flow->psys = newdataadr(fd, smd->flow->psys);
-      }
-      else if (smd->type == MOD_SMOKE_TYPE_COLL) {
-        smd->flow = NULL;
-        smd->domain = NULL;
-        smd->coll = newdataadr(fd, smd->coll);
-        if (smd->coll) {
-          smd->coll->smd = smd;
-          smd->coll->verts_old = NULL;
-          smd->coll->numverts = 0;
-          smd->coll->mesh = NULL;
+          BLI_listbase_clear(&mmd->domain->ptcaches[1]);
+          mmd->domain->point_cache[1] = NULL;
+        }
+      }
+      else if (mmd->type == MOD_FLUID_TYPE_FLOW) {
+        mmd->domain = NULL;
+        mmd->effector = NULL;
+        mmd->flow = newdataadr(fd, mmd->flow);
+        mmd->flow->mmd = mmd;
+        mmd->flow->mesh = NULL;
+        mmd->flow->verts_old = NULL;
+        mmd->flow->numverts = 0;
+        mmd->flow->psys = newdataadr(fd, mmd->flow->psys);
+      }
+      else if (mmd->type == MOD_FLUID_TYPE_EFFEC) {
+        mmd->flow = NULL;
+        mmd->domain = NULL;
+        mmd->effector = newdataadr(fd, mmd->effector);
+        if (mmd->effector) {
+          mmd->effector->mmd = mmd;
+          mmd->effector->verts_old = NULL;
+          mmd->effector->numverts = 0;
+          mmd->effector->mesh = NULL;
         }
         else {
-          smd->type = 0;
-          smd->flow = NULL;
-          smd->domain = NULL;
-          smd->coll = NULL;
+          mmd->type = 0;
+          mmd->flow = NULL;
+          mmd->domain = NULL;
+          mmd->effector = NULL;
         }
       }
     }
@@ -5944,7 +5954,7 @@ static void direct_link_object(FileData *fd, Object *ob)
   ob->matbits = newdataadr(fd, ob->matbits);
 
   /* do it here, below old data gets converted */
-  direct_link_modifiers(fd, &ob->modifiers);
+  direct_link_modifiers(fd, &ob->modifiers, ob);
   direct_link_gpencil_modifiers(fd, &ob->greasepencil_modifiers);
   direct_link_shaderfxs(fd, &ob->shader_fx);
 
@@ -10383,7 +10393,7 @@ static void expand_particlesettings(FileData *fd, Main *mainvar, ParticleSetting
 
   expand_doit(fd, mainvar, part->instance_object);
   expand_doit(fd, mainvar, part->instance_collection);
-  expand_doit(fd, mainvar, part->eff_group);
+  expand_doit(fd, mainvar, part->force_group);
   expand_doit(fd, mainvar, part->bb_ob);
   expand_doit(fd, mainvar, part->collision_group);
 
index 3e7b158260366943ebf491388e21481e1c451a87..a5ab0c0acb74d18fee01686a43304a2ba743dfb9 100644 (file)
@@ -50,7 +50,7 @@
 #include "DNA_screen_types.h"
 #include "DNA_sdna_types.h"
 #include "DNA_sequence_types.h"
-#include "DNA_smoke_types.h"
+#include "DNA_fluid_types.h"
 #include "DNA_sound_types.h"
 #include "DNA_space_types.h"
 #include "DNA_world_types.h"
@@ -1789,19 +1789,19 @@ void blo_do_versions_250(FileData *fd, Library *lib, Main *bmain)
       ModifierData *md;
 
       for (md = ob->modifiers.first; md; md = md->next) {
-        if (md->type == eModifierType_Smoke) {
-          SmokeModifierData *smd = (SmokeModifierData *)md;
+        if (md->type == eModifierType_Fluid) {
+          FluidModifierData *mmd = (FluidModifierData *)md;
 
-          if ((smd->type & MOD_SMOKE_TYPE_DOMAIN) && smd->domain) {
-            smd->domain->vorticity = 2.0f;
-            smd->domain->time_scale = 1.0f;
+          if ((mmd->type & MOD_FLUID_TYPE_DOMAIN) && mmd->domain) {
+            mmd->domain->vorticity = 2.0f;
+            mmd->domain->time_scale = 1.0f;
 
-            if (!(smd->domain->flags & (1 << 4))) {
+            if (!(mmd->domain->flags & (1 << 4))) {
               continue;
             }
 
             /* delete old MOD_SMOKE_INITVELOCITY flag */
-            smd->domain->flags &= ~(1 << 4);
+            mmd->domain->flags &= ~(1 << 4);
 
             /* for now just add it to all flow objects in the scene */
             {
@@ -1809,19 +1809,19 @@ void blo_do_versions_250(FileData *fd, Library *lib, Main *bmain)
               for (ob2 = bmain->objects.first; ob2; ob2 = ob2->id.next) {
                 ModifierData *md2;
                 for (md2 = ob2->modifiers.first; md2; md2 = md2->next) {
-                  if (md2->type == eModifierType_Smoke) {
-                    SmokeModifierData *smd2 = (SmokeModifierData *)md2;
+                  if (md2->type == eModifierType_Fluid) {
+                    FluidModifierData *mmd2 = (FluidModifierData *)md2;
 
-                    if ((smd2->type & MOD_SMOKE_TYPE_FLOW) && smd2->flow) {
-                      smd2->flow->flags |= MOD_SMOKE_FLOW_INITVELOCITY;
+                    if ((mmd2->type & MOD_FLUID_TYPE_FLOW) && mmd2->flow) {
+                      mmd2->flow->flags |= FLUID_FLOW_INITVELOCITY;
                     }
                   }
                 }
               }
             }
           }
-          else if ((smd->type & MOD_SMOKE_TYPE_FLOW) && smd->flow) {
-            smd->flow->vel_multi = 1.0f;
+          else if ((mmd->type & MOD_FLUID_TYPE_FLOW) && mmd->flow) {
+            mmd->flow->vel_multi = 1.0f;
           }
         }
       }
index 40219a363236c47a08ddc11c15185a484dbf2992..f23e4b5e2a4874709b4c73e54a94961b4b465e12 100644 (file)
@@ -39,7 +39,7 @@
 #include "DNA_view3d_types.h"
 #include "DNA_screen_types.h"
 #include "DNA_sdna_types.h"
-#include "DNA_smoke_types.h"
+#include "DNA_fluid_types.h"
 #include "DNA_space_types.h"
 #include "DNA_world_types.h"
 #include "DNA_light_types.h"
@@ -1292,12 +1292,12 @@ void blo_do_versions_260(FileData *fd, Library *UNUSED(lib), Main *bmain)
     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
       ModifierData *md;
       for (md = ob->modifiers.first; md; md = md->next) {
-        if (md->type == eModifierType_Smoke) {
-          SmokeModifierData *smd = (SmokeModifierData *)md;
-          if ((smd->type & MOD_SMOKE_TYPE_DOMAIN) && smd->domain) {
-            int maxres = max_iii(smd->domain->res[0], smd->domain->res[1], smd->domain->res[2]);
-            smd->domain->scale = smd->domain->dx * maxres;
-            smd->domain->dx = 1.0f / smd->domain->scale;
+        if (md->type == eModifierType_Fluid) {
+          FluidModifierData *mmd = (FluidModifierData *)md;
+          if ((mmd->type & MOD_FLUID_TYPE_DOMAIN) && mmd->domain) {
+            int maxres = max_iii(mmd->domain->res[0], mmd->domain->res[1], mmd->domain->res[2]);
+            mmd->domain->scale = mmd->domain->dx * maxres;
+            mmd->domain->dx = 1.0f / mmd->domain->scale;
           }
         }
       }
@@ -1610,31 +1610,31 @@ void blo_do_versions_260(FileData *fd, Library *UNUSED(lib), Main *bmain)
       for (ob = bmain->objects.first; ob; ob = ob->id.next) {
         ModifierData *md;
         for (md = ob->modifiers.first; md; md = md->next) {
-          if (md->type == eModifierType_Smoke) {
-            SmokeModifierData *smd = (SmokeModifierData *)md;
-            if ((smd->type & MOD_SMOKE_TYPE_DOMAIN) && smd->domain) {
+          if (md->type == eModifierType_Fluid) {
+            FluidModifierData *mmd = (FluidModifierData *)md;
+            if ((mmd->type & MOD_FLUID_TYPE_DOMAIN) && mmd->domain) {
               /* keep branch saves if possible */
-              if (!smd->domain->flame_max_temp) {
-                smd->domain->burning_rate = 0.75f;
-                smd->domain->flame_smoke = 1.0f;
-                smd->domain->flame_vorticity = 0.5f;
-                smd->domain->flame_ignition = 1.25f;
-                smd->domain->flame_max_temp = 1.75f;
-                smd->domain->adapt_threshold = 0.02f;
-                smd->domain->adapt_margin = 4;
-                smd->domain->flame_smoke_color[0] = 0.7f;
-                smd->domain->flame_smoke_color[1] = 0.7f;
-                smd->domain->flame_smoke_color[2] = 0.7f;
+              if (!mmd->domain->flame_max_temp) {
+                mmd->domain->burning_rate = 0.75f;
+                mmd->domain->flame_smoke = 1.0f;
+                mmd->domain->flame_vorticity = 0.5f;
+                mmd->domain->flame_ignition = 1.25f;
+                mmd->domain->flame_max_temp = 1.75f;
+                mmd->domain->adapt_threshold = 0.02f;
+                mmd->domain->adapt_margin = 4;
+                mmd->domain->flame_smoke_color[0] = 0.7f;
+                mmd->domain->flame_smoke_color[1] = 0.7f;
+                mmd->domain->flame_smoke_color[2] = 0.7f;
               }
             }
-            else if ((smd->type & MOD_SMOKE_TYPE_FLOW) && smd->flow) {
-              if (!smd->flow->texture_size) {
-                smd->flow->fuel_amount = 1.0;
-                smd->flow->surface_distance = 1.5;
-                smd->flow->color[0] = 0.7f;
-                smd->flow->color[1] = 0.7f;
-                smd->flow->color[2] = 0.7f;
-                smd->flow->texture_size = 1.0f;
+            else if ((mmd->type & MOD_FLUID_TYPE_FLOW) && mmd->flow) {
+              if (!mmd->flow->texture_size) {
+                mmd->flow->fuel_amount = 1.0;
+                mmd->flow->surface_distance = 1.5;
+                mmd->flow->color[0] = 0.7f;
+                mmd->flow->color[1] = 0.7f;
+                mmd->flow->color[2] = 0.7f;
+                mmd->flow->texture_size = 1.0f;
               }
             }
           }
@@ -2140,14 +2140,14 @@ void blo_do_versions_260(FileData *fd, Library *UNUSED(lib), Main *bmain)
     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
       ModifierData *md;
       for (md = ob->modifiers.first; md; md = md->next) {
-        if (md->type == eModifierType_Smoke) {
-          SmokeModifierData *smd = (SmokeModifierData *)md;
-          if ((smd->type & MOD_SMOKE_TYPE_DOMAIN) && smd->domain) {
-            if (smd->domain->flags & MOD_SMOKE_HIGH_SMOOTH) {
-              smd->domain->highres_sampling = SM_HRES_LINEAR;
+        if (md->type == eModifierType_Fluid) {
+          FluidModifierData *mmd = (FluidModifierData *)md;
+          if ((mmd->type & MOD_FLUID_TYPE_DOMAIN) && mmd->domain) {
+            if (mmd->domain->flags & FLUID_DOMAIN_USE_HIGH_SMOOTH) {
+              mmd->domain->highres_sampling = SM_HRES_LINEAR;
             }
             else {
-              smd->domain->highres_sampling = SM_HRES_NEAREST;
+              mmd->domain->highres_sampling = SM_HRES_NEAREST;
             }
           }
         }
@@ -2207,11 +2207,11 @@ void blo_do_versions_260(FileData *fd, Library *UNUSED(lib), Main *bmain)
     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
       ModifierData *md;
       for (md = ob->modifiers.first; md; md = md->next) {
-        if (md->type == eModifierType_Smoke) {
-          SmokeModifierData *smd = (SmokeModifierData *)md;
-          if ((smd->type & MOD_SMOKE_TYPE_FLOW) && smd->flow) {
-            if (!smd->flow->particle_size) {
-              smd->flow->particle_size = 1.0f;
+        if (md->type == eModifierType_Fluid) {
+          FluidModifierData *mmd = (FluidModifierData *)md;
+          if ((mmd->type & MOD_FLUID_TYPE_FLOW) && mmd->flow) {
+            if (!mmd->flow->particle_size) {
+              mmd->flow->particle_size = 1.0f;
             }
           }
         }
index fb570b956b69868132581c81f2e68b83dfd0cb0e..f421f31814c9a23289668baf4f1ef48f39ee2231 100644 (file)
@@ -46,7 +46,7 @@
 #include "DNA_particle_types.h"
 #include "DNA_linestyle_types.h"
 #include "DNA_view3d_types.h"
-#include "DNA_smoke_types.h"
+#include "DNA_fluid_types.h"
 #include "DNA_rigidbody_types.h"
 #include "DNA_light_types.h"
 
@@ -1549,18 +1549,18 @@ void blo_do_versions_270(FileData *fd, Library *UNUSED(lib), Main *bmain)
       }
     }
 
-    if (!DNA_struct_elem_find(fd->filesdna, "SmokeModifierData", "float", "slice_per_voxel")) {
+    if (!DNA_struct_elem_find(fd->filesdna, "FluidModifierData", "float", "slice_per_voxel")) {
       Object *ob;
       ModifierData *md;
 
       for (ob = bmain->objects.first; ob; ob = ob->id.next) {
         for (md = ob->modifiers.first; md; md = md->next) {
-          if (md->type == eModifierType_Smoke) {
-            SmokeModifierData *smd = (SmokeModifierData *)md;
-            if (smd->domain) {
-              smd->domain->slice_per_voxel = 5.0f;
-              smd->domain->slice_depth = 0.5f;
-              smd->domain->display_thickness = 1.0f;
+          if (md->type == eModifierType_Fluid) {
+            FluidModifierData *mmd = (FluidModifierData *)md;
+            if (mmd->domain) {
+              mmd->domain->slice_per_voxel = 5.0f;
+              mmd->domain->slice_depth = 0.5f;
+              mmd->domain->display_thickness = 1.0f;
             }
           }
         }
@@ -1719,16 +1719,16 @@ void blo_do_versions_270(FileData *fd, Library *UNUSED(lib), Main *bmain)
   }
 
   if (!MAIN_VERSION_ATLEAST(bmain, 279, 3)) {
-    if (!DNA_struct_elem_find(fd->filesdna, "SmokeDomainSettings", "float", "clipping")) {
+    if (!DNA_struct_elem_find(fd->filesdna, "FluidDomainSettings", "float", "clipping")) {
       Object *ob;
       ModifierData *md;
 
       for (ob = bmain->objects.first; ob; ob = ob->id.next) {
         for (md = ob->modifiers.first; md; md = md->next) {
-          if (md->type == eModifierType_Smoke) {
-            SmokeModifierData *smd = (SmokeModifierData *)md;
-            if (smd->domain) {
-              smd->domain->clipping = 1e-3f;
+          if (md->type == eModifierType_Fluid) {
+            FluidModifierData *mmd = (FluidModifierData *)md;
+            if (mmd->domain) {
+              mmd->domain->clipping = 1e-3f;
             }
           }
         }
index 5d46f0735ebdbebe65d4806ae30eba6bb3fb399e..73cdd40c02c6b7445e93bdfc2b8b7d4e24945dce 100644 (file)
@@ -2292,7 +2292,7 @@ void blo_do_versions_pre250(FileData *fd, Library *lib, Main *bmain)
         part->omat = paf->mat[0];
         part->hair_step = paf->totkey;
 
-        part->eff_group = paf->group;
+        part->force_group = paf->group;
 
         /* old system didn't interpolate between keypoints at render time */
         part->draw_step = part->ren_step = 0;
index f8ac4e4062c558462353852a4af6ba54129474c8..30e7cf476fb2c5333a66520031c87e65edafeb86 100644 (file)
 #include "DNA_scene_types.h"
 #include "DNA_sdna_types.h"
 #include "DNA_sequence_types.h"
-#include "DNA_smoke_types.h"
+#include "DNA_fluid_types.h"
 #include "DNA_space_types.h"
 #include "DNA_screen_types.h"
 #include "DNA_speaker_types.h"
@@ -1628,38 +1628,38 @@ static void write_modifiers(WriteData *wd, ListBase *modbase)
       writestruct(wd, DATA, EffectorWeights, 1, clmd->sim_parms->effector_weights);
       write_pointcaches(wd, &clmd->ptcaches);
     }
-    else if (md->type == eModifierType_Smoke) {
-      SmokeModifierData *smd = (SmokeModifierData *)md;
+    else if (md->type == eModifierType_Fluid) {
+      FluidModifierData *mmd = (FluidModifierData *)md;
 
-      if (smd->type & MOD_SMOKE_TYPE_DOMAIN) {
-        writestruct(wd, DATA, SmokeDomainSettings, 1, smd->domain);
+      if (mmd->type & MOD_FLUID_TYPE_DOMAIN) {
+        writestruct(wd, DATA, FluidDomainSettings, 1, mmd->domain);
 
-        if (smd->domain) {
-          write_pointcaches(wd, &(smd->domain->ptcaches[0]));
+        if (mmd->domain) {
+          write_pointcaches(wd, &(mmd->domain->ptcaches[0]));
 
           /* create fake pointcache so that old blender versions can read it */
-          smd->domain->point_cache[1] = BKE_ptcache_add(&smd->domain->ptcaches[1]);
-          smd->domain->point_cache[1]->flag |= PTCACHE_DISK_CACHE | PTCACHE_FAKE_SMOKE;
-          smd->domain->point_cache[1]->step = 1;
+          mmd->domain->point_cache[1] = BKE_ptcache_add(&mmd->domain->ptcaches[1]);
+          mmd->domain->point_cache[1]->flag |= PTCACHE_DISK_CACHE | PTCACHE_FAKE_SMOKE;
+          mmd->domain->point_cache[1]->step = 1;
 
-          write_pointcaches(wd, &(smd->domain->ptcaches[1]));
+          write_pointcaches(wd, &(mmd->domain->ptcaches[1]));
 
-          if (smd->domain->coba) {
-            writestruct(wd, DATA, ColorBand, 1, smd->domain->coba);
+          if (mmd->domain->coba) {
+            writestruct(wd, DATA, ColorBand, 1, mmd->domain->coba);
           }
 
           /* cleanup the fake pointcache */
-          BKE_ptcache_free_list(&smd->domain->ptcaches[1]);
-          smd->domain->point_cache[1] = NULL;
+          BKE_ptcache_free_list(&mmd->domain->ptcaches[1]);
+          mmd->domain->point_cache[1] = NULL;
 
-          writestruct(wd, DATA, EffectorWeights, 1, smd->domain->effector_weights);
+          writestruct(wd, DATA, EffectorWeights, 1, mmd->domain->effector_weights);
         }
       }
-      else if (smd->type & MOD_SMOKE_TYPE_FLOW) {
-        writestruct(wd, DATA, SmokeFlowSettings, 1, smd->flow);
+      else if (mmd->type & MOD_FLUID_TYPE_FLOW) {
+        writestruct(wd, DATA, FluidFlowSettings, 1, mmd->flow);
       }
-      else if (smd->type & MOD_SMOKE_TYPE_COLL) {
-        writestruct(wd, DATA, SmokeCollSettings, 1, smd->coll);
+      else if (mmd->type & MOD_FLUID_TYPE_EFFEC) {
+        writestruct(wd, DATA, FluidEffectorSettings, 1, mmd->effector);
       }
     }
     else if (md->type == eModifierType_Fluidsim) {
index 3f81e49b1707d579df13c57522aeb30bdf87bd8f..f47081cd54e2846276b849fa8055f5b282bc7cc8 100644 (file)
@@ -54,7 +54,7 @@ static ePhysicsRelationType modifier_to_relation_type(unsigned int modifier_type
   switch (modifier_type) {
     case eModifierType_Collision:
       return DEG_PHYSICS_COLLISION;
-    case eModifierType_Smoke:
+    case eModifierType_Fluid:
       return DEG_PHYSICS_SMOKE_COLLISION;
     case eModifierType_DynamicPaint:
       return DEG_PHYSICS_DYNAMIC_BRUSH;
index 67fd441a0b187bbb74163e65ac4cf7464bc02d0a..2e0b5d36496f2b41dc6b7f7cc4a9b580e7fbb542 100644 (file)
 #include "BLI_string_utils.h"
 
 #include "DNA_object_force_types.h"
-#include "DNA_smoke_types.h"
+#include "DNA_fluid_types.h"
 #include "DNA_world_types.h"
 
 #include "BKE_modifier.h"
 #include "BKE_mesh.h"
-#include "BKE_smoke.h"
+#include "BKE_fluid.h"
 
 #include "ED_screen.h"
 
@@ -63,7 +63,7 @@ static struct {
   GPUTexture *dummy_scatter;
   GPUTexture *dummy_transmit;
 
-  /* List of all smoke domains rendered within this frame. */
+  /* List of all fluid simulation / smoke domains rendered within this frame. */
   ListBase smoke_domains;
 } e_data = {NULL}; /* Engine data */
 
@@ -430,41 +430,47 @@ void EEVEE_volumes_cache_object_add(EEVEE_ViewLayerData *sldata,
 
   /* Smoke Simulation */
   if (((ob->base_flag & BASE_FROM_DUPLI) == 0) &&
-      (md = modifiers_findByType(ob, eModifierType_Smoke)) &&
+      (md = modifiers_findByType(ob, eModifierType_Fluid)) &&
       (modifier_isEnabled(scene, md, eModifierMode_Realtime)) &&
-      ((SmokeModifierData *)md)->domain != NULL) {
-    SmokeModifierData *smd = (SmokeModifierData *)md;
-    SmokeDomainSettings *sds = smd->domain;
+      ((FluidModifierData *)md)->domain != NULL) {
+    FluidModifierData *mmd = (FluidModifierData *)md;
+    FluidDomainSettings *mds = mmd->domain;
+
+    /* Don't try to show liquid domains here. */
+    if (!mds->fluid || !(mds->type == FLUID_DOMAIN_TYPE_GAS)) {
+      return;
+    }
 
     /* Don't show smoke before simulation starts, this could be made an option in the future. */
-    const bool show_smoke = ((int)DEG_get_ctime(draw_ctx->depsgraph) >=
-                             sds->point_cache[0]->startframe);
+    /* (sebbas): Always show smoke for manta */
+    /* const bool show_smoke = ((int)DEG_get_ctime(draw_ctx->depsgraph) >=
+     * mds->point_cache[0]->startframe); */
 
-    if (sds->fluid && show_smoke) {
-      const bool show_highres = BKE_smoke_show_highres(scene, sds);
-      if (!sds->wt || !show_highres) {
-        GPU_create_smoke(smd, 0);
+    if (mds->fluid && (mds->type == FLUID_DOMAIN_TYPE_GAS) /* && show_smoke */) {
+      if (!(mds->flags & FLUID_DOMAIN_USE_NOISE)) {
+        GPU_create_smoke(mmd, 0);
       }
-      else if (sds->wt && show_highres) {
-        GPU_create_smoke(smd, 1);
+      else if (mds->flags & FLUID_DOMAIN_USE_NOISE) {
+        GPU_create_smoke(mmd, 1);
       }
-      BLI_addtail(&e_data.smoke_domains, BLI_genericNodeN(smd));
+      BLI_addtail(&e_data.smoke_domains, BLI_genericNodeN(mmd));
     }
 
     DRW_shgroup_uniform_texture_ref(
-        grp, "sampdensity", sds->tex ? &sds->tex : &e_data.dummy_density);
+        grp, "sampdensity", mds->tex ? &mds->tex : &e_data.dummy_density);
     DRW_shgroup_uniform_texture_ref(
-        grp, "sampflame", sds->tex_flame ? &sds->tex_flame : &e_data.dummy_flame);
+        grp, "sampflame", mds->tex_flame ? &mds->tex_flame : &e_data.dummy_flame);
 
     /* Constant Volume color. */
-    bool use_constant_color = ((sds->active_fields & SM_ACTIVE_COLORS) == 0 &&
-                               (sds->active_fields & SM_ACTIVE_COLOR_SET) != 0);
+    static float white[3] = {1.0f, 1.0f, 1.0f};
+    bool use_constant_color = ((mds->active_fields & FLUID_DOMAIN_ACTIVE_COLORS) == 0 &&
+                               (mds->active_fields & FLUID_DOMAIN_ACTIVE_COLOR_SET) != 0);
 
     DRW_shgroup_uniform_vec3(
-        grp, "volumeColor", (use_constant_color) ? sds->active_color : white, 1);
+        grp, "volumeColor", (use_constant_color) ? mds->active_color : white, 1);
 
     /* Output is such that 0..1 maps to 0..1000K */
-    DRW_shgroup_uniform_vec2(grp, "unftemperature", &sds->flame_ignition, 1);
+    DRW_shgroup_uniform_vec2(grp, "unftemperature", &mds->flame_ignition, 1);
   }
   else {
     DRW_shgroup_uniform_texture(grp, "sampdensity", e_data.dummy_density);
@@ -692,8 +698,8 @@ void EEVEE_volumes_free_smoke_textures(void)
 {
   /* Free Smoke Textures after rendering */
   for (LinkData *link = e_data.smoke_domains.first; link; link = link->next) {
-    SmokeModifierData *smd = (SmokeModifierData *)link->data;
-    GPU_free_smoke(smd);
+    FluidModifierData *mmd = (FluidModifierData *)link->data;
+    GPU_free_smoke(mmd);
   }
   BLI_freelistN(&e_data.smoke_domains);
 }
index f6e3ed4d4de4ad24340a7fddf489b0d76ae7d60a..90ddb9f7476f1675e6ca5c98b0342e815cbaad5f 100644 (file)
@@ -45,7 +45,7 @@
 #include "DNA_modifier_types.h"
 #include "DNA_object_force_types.h"
 #include "DNA_rigidbody_types.h"
-#include "DNA_smoke_types.h"
+#include "DNA_fluid_types.h"
 
 #include "DEG_depsgraph_query.h"
 
@@ -1410,22 +1410,22 @@ static void OVERLAY_volume_extra(OVERLAY_ExtraCallBuffers *cb,
                                  Scene *scene,
                                  float *color)
 {
-  SmokeModifierData *smd = (SmokeModifierData *)md;
-  SmokeDomainSettings *sds = smd->domain;
+  FluidModifierData *mmd = (FluidModifierData *)md;
+  FluidDomainSettings *mds = mmd->domain;
 
   /* Don't show smoke before simulation starts, this could be made an option in the future. */
-  const bool draw_velocity = (sds->draw_velocity && sds->fluid &&
-                              CFRA >= sds->point_cache[0]->startframe);
+  const bool draw_velocity = (mds->draw_velocity && mds->fluid &&
+                              CFRA >= mds->point_cache[0]->startframe);
 
   /* Small cube showing voxel size. */
   {
     float min[3];
-    madd_v3fl_v3fl_v3fl_v3i(min, sds->p0, sds->cell_size, sds->res_min);
+    madd_v3fl_v3fl_v3fl_v3i(min, mds->p0, mds->cell_size, mds->res_min);
     float voxel_cubemat[4][4] = {{0.0f}};
     /* scale small cube to voxel size */
-    voxel_cubemat[0][0] = 1.0f / (float)sds->base_res[0];
-    voxel_cubemat[1][1] = 1.0f / (float)sds->base_res[1];
-    voxel_cubemat[2][2] = 1.0f / (float)sds->base_res[2];
+    voxel_cubemat[0][0] = 1.0f / (float)mds->base_res[0];
+    voxel_cubemat[1][1] = 1.0f / (float)mds->base_res[1];
+    voxel_cubemat[2][2] = 1.0f / (float)mds->base_res[2];
     voxel_cubemat[3][3] = 1.0f;
     /* translate small cube to corner */
     copy_v3_v3(voxel_cubemat[3], min);
@@ -1437,38 +1437,38 @@ static void OVERLAY_volume_extra(OVERLAY_ExtraCallBuffers *cb,
   }
 
   if (draw_velocity) {
-    const bool use_needle = (sds->vector_draw_type == VECTOR_DRAW_NEEDLE);
+    const bool use_needle = (mds->vector_draw_type == VECTOR_DRAW_NEEDLE);
     int line_count = (use_needle) ? 6 : 1;
     int slice_axis = -1;
-    line_count *= sds->res[0] * sds->res[1] * sds->res[2];
+    line_count *= mds->res[0] * mds->res[1] * mds->res[2];
 
-    if (sds->slice_method == MOD_SMOKE_SLICE_AXIS_ALIGNED &&
-        sds->axis_slice_method == AXIS_SLICE_SINGLE) {
+    if (mds->slice_method == FLUID_DOMAIN_SLICE_AXIS_ALIGNED &&
+        mds->axis_slice_method == AXIS_SLICE_SINGLE) {
       float viewinv[4][4];
       DRW_view_viewmat_get(NULL, viewinv, true);
 
-      const int axis = (sds->slice_axis == SLICE_AXIS_AUTO) ? axis_dominant_v3_single(viewinv[2]) :
-                                                              sds->slice_axis - 1;
+      const int axis = (mds->slice_axis == SLICE_AXIS_AUTO) ? axis_dominant_v3_single(viewinv[2]) :
+                                                              mds->slice_axis - 1;
       slice_axis = axis;
-      line_count /= sds->res[axis];
+      line_count /= mds->res[axis];
     }
 
-    GPU_create_smoke_velocity(smd);
+    GPU_create_smoke_velocity(mmd);
 
     GPUShader *sh = OVERLAY_shader_volume_velocity(use_needle);
     DRWShadingGroup *grp = DRW_shgroup_create(sh, data->psl->extra_ps[0]);
-    DRW_shgroup_uniform_texture(grp, "velocityX", sds->tex_velocity_x);
-    DRW_shgroup_uniform_texture(grp, "velocityY", sds->tex_velocity_y);
-    DRW_shgroup_uniform_texture(grp, "velocityZ", sds->tex_velocity_z);
-    DRW_shgroup_uniform_float_copy(grp, "displaySize", sds->vector_scale);
-    DRW_shgroup_uniform_float_copy(grp, "slicePosition", sds->slice_depth);
-    DRW_shgroup_uniform_vec3_copy(grp, "cellSize", sds->cell_size);
-    DRW_shgroup_uniform_vec3_copy(grp, "domainOriginOffset", sds->p0);
-    DRW_shgroup_uniform_ivec3_copy(grp, "adaptiveCellOffset", sds->res_min);
+    DRW_shgroup_uniform_texture(grp, "velocityX", mds->tex_velocity_x);
+    DRW_shgroup_uniform_texture(grp, "velocityY", mds->tex_velocity_y);
+    DRW_shgroup_uniform_texture(grp, "velocityZ", mds->tex_velocity_z);
+    DRW_shgroup_uniform_float_copy(grp, "displaySize", mds->vector_scale);
+    DRW_shgroup_uniform_float_copy(grp, "slicePosition", mds->slice_depth);
+    DRW_shgroup_uniform_vec3_copy(grp, "cellSize", mds->cell_size);
+    DRW_shgroup_uniform_vec3_copy(grp, "domainOriginOffset", mds->p0);
+    DRW_shgroup_uniform_ivec3_copy(grp, "adaptiveCellOffset", mds->res_min);
     DRW_shgroup_uniform_int_copy(grp, "sliceAxis", slice_axis);
     DRW_shgroup_call_procedural_lines(grp, ob, line_count);
 
-    BLI_addtail(&data->stl->pd->smoke_domains, BLI_genericNodeN(smd));
+    BLI_addtail(&data->stl->pd->smoke_domains, BLI_genericNodeN(mmd));
   }
 }
 
@@ -1482,8 +1482,8 @@ static void OVERLAY_volume_free_smoke_textures(OVERLAY_Data *data)
    * all viewport in a redraw at least. */
   LinkData *link;
   while ((link = BLI_pophead(&data->stl->pd->smoke_domains))) {
-    SmokeModifierData *smd = (SmokeModifierData *)link->data;
-    GPU_free_smoke_velocity(smd);
+    FluidModifierData *mmd = (FluidModifierData *)link->data;
+    GPU_free_smoke_velocity(mmd);
     MEM_freeN(link);
   }
 }
@@ -1555,9 +1555,9 @@ void OVERLAY_extra_cache_populate(OVERLAY_Data *vedata, Object *ob)
   const bool draw_xform = draw_ctx->object_mode == OB_MODE_OBJECT &&
                           (scene->toolsettings->transform_flag & SCE_XFORM_DATA_ORIGIN) &&
                           (ob->base_flag & BASE_SELECTED) && !is_select_mode;
-  const bool draw_volume = !from_dupli && (md = modifiers_findByType(ob, eModifierType_Smoke)) &&
+  const bool draw_volume = !from_dupli && (md = modifiers_findByType(ob, eModifierType_Fluid)) &&
                            (modifier_isEnabled(scene, md, eModifierMode_Realtime)) &&
-                           (((SmokeModifierData *)md)->domain != NULL);
+                           (((FluidModifierData *)md)->domain != NULL);
 
   float *color;
   int theme_id = DRW_object_wire_theme_get(ob, view_layer, &color);
index 64f88bd74fa2d17abdc5eb41d4f06f1562a6c41d..752694301f738b58bb1531de884ab355f80858f8 100644 (file)
@@ -6,11 +6,11 @@ uniform float displaySize = 1.0;
 uniform float slicePosition;
 uniform int sliceAxis; /* -1 is no slice, 0 is X, 1 is Y, 2 is Z. */
 
-/* SmokeDomainSettings.cell_size */
+/* FluidDomainSettings.cell_size */
 uniform vec3 cellSize;
-/* SmokeDomainSettings.p0 */
+/* FluidDomainSettings.p0 */
 uniform vec3 domainOriginOffset;
-/* SmokeDomainSettings.res_min */
+/* FluidDomainSettings.res_min */
 uniform ivec3 adaptiveCellOffset;
 
 flat out vec4 finalColor;
index 8e61750da38b477b34caa51fa45dd4fe61a717e7..a536132a1cfd5273d87d184d956aa99317470f87 100644 (file)
@@ -34,6 +34,7 @@
 #include "BKE_particle.h"
 
 #include "DNA_image_types.h"
+#include "DNA_fluid_types.h"
 #include "DNA_mesh_types.h"
 #include "DNA_modifier_types.h"
 #include "DNA_node_types.h"
@@ -981,9 +982,10 @@ void workbench_deferred_solid_cache_populate(WORKBENCH_Data *vedata, Object *ob)
 
   ModifierData *md;
   if (((ob->base_flag & BASE_FROM_DUPLI) == 0) &&
-      (md = modifiers_findByType(ob, eModifierType_Smoke)) &&
+      (md = modifiers_findByType(ob, eModifierType_Fluid)) &&
       (modifier_isEnabled(scene, md, eModifierMode_Realtime)) &&
-      (((SmokeModifierData *)md)->domain != NULL)) {
+      (((FluidModifierData *)md)->domain != NULL) &&
+      (((FluidModifierData *)md)->domain->type == FLUID_DOMAIN_TYPE_GAS)) {
     workbench_volume_cache_populate(vedata, scene, ob, md);
     return; /* Do not draw solid in this case. */
   }
index dbd7ebfe0d1f294518cec77d1a474469e888e8b9..90f5d24fabd119f6b3088f6b1afbb00225f860d6 100644 (file)
@@ -33,6 +33,7 @@
 #include "BKE_particle.h"
 
 #include "DNA_image_types.h"
+#include "DNA_fluid_types.h"
 #include "DNA_mesh_types.h"
 #include "DNA_modifier_types.h"
 #include "DNA_node_types.h"
@@ -618,9 +619,10 @@ void workbench_forward_cache_populate(WORKBENCH_Data *vedata, Object *ob)
 
   ModifierData *md;
   if (((ob->base_flag & BASE_FROM_DUPLI) == 0) &&
-      (md = modifiers_findByType(ob, eModifierType_Smoke)) &&
+      (md = modifiers_findByType(ob, eModifierType_Fluid)) &&
       (modifier_isEnabled(scene, md, eModifierMode_Realtime)) &&
-      (((SmokeModifierData *)md)->domain != NULL)) {
+      (((FluidModifierData *)md)->domain != NULL) &&
+      (((FluidModifierData *)md)->domain->type == FLUID_DOMAIN_TYPE_GAS)) {
     workbench_volume_cache_populate(vedata, scene, ob, md);
     return; /* Do not draw solid in this case. */
   }
index 23f0898c13808aadb3d1b9b3110e4b69d6d1ad15..2f7296fb40f4dfd4a24ea2146fac02ef4946e871 100644 (file)
@@ -23,7 +23,7 @@
 #include "workbench_private.h"
 
 #include "BKE_object.h"
-#include "BKE_smoke.h"
+#include "BKE_fluid.h"
 
 #include "BLI_rand.h"
 #include "BLI_dynstr.h"
@@ -31,7 +31,7 @@
 
 #include "DNA_modifier_types.h"
 #include "DNA_object_force_types.h"
-#include "DNA_smoke_types.h"
+#include "DNA_fluid_types.h"
 
 #include "GPU_draw.h"
 
@@ -119,57 +119,56 @@ void workbench_volume_cache_init(WORKBENCH_Data *vedata)
 }
 
 void workbench_volume_cache_populate(WORKBENCH_Data *vedata,
-                                     Scene *scene,
+                                     Scene *UNUSED(scene),
                                      Object *ob,
                                      ModifierData *md)
 {
-  SmokeModifierData *smd = (SmokeModifierData *)md;
-  SmokeDomainSettings *sds = smd->domain;
+  FluidModifierData *mmd = (FluidModifierData *)md;
+  FluidDomainSettings *mds = mmd->domain;
   WORKBENCH_PrivateData *wpd = vedata->stl->g_data;
   WORKBENCH_EffectInfo *effect_info = vedata->stl->effects;
   DefaultTextureList *dtxl = DRW_viewport_texture_list_get();
   DRWShadingGroup *grp = NULL;
 
-  /* Don't show smoke before simulation starts, this could be made an option in the future. */
-  if (!sds->fluid || CFRA < sds->point_cache[0]->startframe) {
+  /* Don't try to show liquid domains here */
+  if (!mds->fluid || !(mds->type == FLUID_DOMAIN_TYPE_GAS)) {
     return;
   }
 
   wpd->volumes_do = true;
-  const bool show_highres = BKE_smoke_show_highres(scene, sds);
-  if (sds->use_coba) {
-    GPU_create_smoke_coba_field(smd);
+  if (mds->use_coba) {
+    GPU_create_smoke_coba_field(mmd);
   }
-  else if (!sds->wt || !show_highres) {
-    GPU_create_smoke(smd, 0);
+  else if (!(mds->flags & FLUID_DOMAIN_USE_NOISE)) {
+    GPU_create_smoke(mmd, 0);
   }
-  else if (sds->wt && show_highres) {
-    GPU_create_smoke(smd, 1);
+  else if (mds->flags & FLUID_DOMAIN_USE_NOISE) {
+    GPU_create_smoke(mmd, 1);
   }
 
-  if ((!sds->use_coba && sds->tex == NULL) || (sds->use_coba && sds->tex_field == NULL)) {
+  if ((!mds->use_coba && mds->tex == NULL) || (mds->use_coba && mds->tex_field == NULL)) {
     return;
   }
 
-  const bool use_slice = (sds->slice_method == MOD_SMOKE_SLICE_AXIS_ALIGNED &&
-                          sds->axis_slice_method == AXIS_SLICE_SINGLE);
-  const bool cubic_interp = (sds->interp_method == VOLUME_INTERP_CUBIC);
-  GPUShader *sh = volume_shader_get(use_slice, sds->use_coba, cubic_interp);
+  const bool use_slice = (mds->slice_method == FLUID_DOMAIN_SLICE_AXIS_ALIGNED &&
+                          mds->axis_slice_method == AXIS_SLICE_SINGLE);
+  const bool cubic_interp = (mds->interp_method == VOLUME_INTERP_CUBIC);
+  GPUShader *sh = volume_shader_get(use_slice, mds->use_coba, cubic_interp);
 
   if (use_slice) {
     float invviewmat[4][4];
     DRW_view_viewmat_get(NULL, invviewmat, true);
 
-    const int axis = (sds->slice_axis == SLICE_AXIS_AUTO) ?
+    const int axis = (mds->slice_axis == SLICE_AXIS_AUTO) ?
                          axis_dominant_v3_single(invviewmat[2]) :
-                         sds->slice_axis - 1;
+                         mds->slice_axis - 1;
     float dim[3];
     BKE_object_dimensions_get(ob, dim);
     /* 0.05f to achieve somewhat the same opacity as the full view.  */
     float step_length = max_ff(1e-16f, dim[axis] * 0.05f);
 
     grp = DRW_shgroup_create(sh, vedata->psl->volume_pass);
-    DRW_shgroup_uniform_float_copy(grp, "slicePosition", sds->slice_depth);
+    DRW_shgroup_uniform_float_copy(grp, "slicePosition", mds->slice_depth);
     DRW_shgroup_uniform_int_copy(grp, "sliceAxis", axis);
     DRW_shgroup_uniform_float_copy(grp, "stepLength", step_length);
     DRW_shgroup_state_disable(grp, DRW_STATE_CULL_FRONT);
@@ -178,8 +177,8 @@ void workbench_volume_cache_populate(WORKBENCH_Data *vedata,
     double noise_ofs;
     BLI_halton_1d(3, 0.0, effect_info->jitter_index, &noise_ofs);
     float dim[3], step_length, max_slice;
-    float slice_ct[3] = {sds->res[0], sds->res[1], sds->res[2]};
-    mul_v3_fl(slice_ct, max_ff(0.001f, sds->slice_per_voxel));
+    float slice_ct[3] = {mds->res[0], mds->res[1], mds->res[2]};
+    mul_v3_fl(slice_ct, max_ff(0.001f, mds->slice_per_voxel));
     max_slice = max_fff(slice_ct[0], slice_ct[1], slice_ct[2]);
     BKE_object_dimensions_get(ob, dim);
     invert_v3(slice_ct);
@@ -194,25 +193,25 @@ void workbench_volume_cache_populate(WORKBENCH_Data *vedata,
     DRW_shgroup_state_enable(grp, DRW_STATE_CULL_FRONT);
   }
 
-  if (sds->use_coba) {
-    DRW_shgroup_uniform_texture(grp, "densityTexture", sds->tex_field);
-    DRW_shgroup_uniform_texture(grp, "transferTexture", sds->tex_coba);
+  if (mds->use_coba) {
+    DRW_shgroup_uniform_texture(grp, "densityTexture", mds->tex_field);
+    DRW_shgroup_uniform_texture(grp, "transferTexture", mds->tex_coba);
   }
   else {
     static float white[3] = {1.0f, 1.0f, 1.0f};
-    bool use_constant_color = ((sds->active_fields & SM_ACTIVE_COLORS) == 0 &&
-                               (sds->active_fields & SM_ACTIVE_COLOR_SET) != 0);
-    DRW_shgroup_uniform_texture(grp, "densityTexture", sds->tex);
-    DRW_shgroup_uniform_texture(grp, "shadowTexture", sds->tex_shadow);
+    bool use_constant_color = ((mds->active_fields & FLUID_DOMAIN_ACTIVE_COLORS) == 0 &&
+                               (mds->active_fields & FLUID_DOMAIN_ACTIVE_COLOR_SET) != 0);
+    DRW_shgroup_uniform_texture(grp, "densityTexture", mds->tex);
+    DRW_shgroup_uniform_texture(grp, "shadowTexture", mds->tex_shadow);
     DRW_shgroup_uniform_texture(
-        grp, "flameTexture", (sds->tex_flame) ? sds->tex_flame : e_data.dummy_tex);
+        grp, "flameTexture", (mds->tex_flame) ? mds->tex_flame : e_data.dummy_tex);
     DRW_shgroup_uniform_texture(
-        grp, "flameColorTexture", (sds->tex_flame) ? sds->tex_flame_coba : e_data.dummy_coba_tex);
+        grp, "flameColorTexture", (mds->tex_flame) ? mds->tex_flame_coba : e_data.dummy_coba_tex);
     DRW_shgroup_uniform_vec3(
-        grp, "activeColor", (use_constant_color) ? sds->active_color : white, 1);
+        grp, "activeColor", (use_constant_color) ? mds->active_color : white, 1);
   }
   DRW_shgroup_uniform_texture_ref(grp, "depthBuffer", &dtxl->depth);
-  DRW_shgroup_uniform_float_copy(grp, "densityScale", 10.0f * sds->display_thickness);
+  DRW_shgroup_uniform_float_copy(grp, "densityScale", 10.0f * mds->display_thickness);
 
   if (use_slice) {
     DRW_shgroup_call(grp, DRW_cache_quad_get(), ob);
@@ -221,7 +220,7 @@ void workbench_volume_cache_populate(WORKBENCH_Data *vedata,
     DRW_shgroup_call(grp, DRW_cache_cube_get(), ob);
   }
 
-  BLI_addtail(&wpd->smoke_domains, BLI_genericNodeN(smd));
+  BLI_addtail(&wpd->smoke_domains, BLI_genericNodeN(mmd));
 }
 
 void workbench_volume_smoke_textures_free(WORKBENCH_PrivateData *wpd)
@@ -233,8 +232,8 @@ void workbench_volume_smoke_textures_free(WORKBENCH_PrivateData *wpd)
    * modifier is not used for display. We should share them for
    * all viewport in a redraw at least. */
   for (LinkData *link = wpd->smoke_domains.first; link; link = link->next) {
-    SmokeModifierData *smd = (SmokeModifierData *)link->data;
-    GPU_free_smoke(smd);
+    FluidModifierData *mmd = (FluidModifierData *)link->data;
+    GPU_free_smoke(mmd);
   }
   BLI_freelistN(&wpd->smoke_domains);
 }
index fd8fe103a2d05426775b4193cf6aa3d7fdfd54f9..4cc0c865093e1a66d98685df511ac9f64d9bd45b 100644 (file)
@@ -385,9 +385,8 @@ set(ICON_NAMES
   mod_mask
   mod_cloth
   mod_explode
-  mod_fluidsim
   mod_multires
-  mod_smoke
+  mod_fluid
   mod_solidify
   mod_screw
   mod_vertex_weight
index 2bf50d3b4b863400241b687eedb298c74f171f6a..44c734e264a1f442f9d2b6a86c75c374db0587d4 100644 (file)
@@ -560,7 +560,7 @@ DEF_ICON_MODIFIER(MOD_CLOTH)
 DEF_ICON_MODIFIER(MOD_EXPLODE)
 DEF_ICON_MODIFIER(MOD_FLUIDSIM)
 DEF_ICON_MODIFIER(MOD_MULTIRES)
-DEF_ICON_MODIFIER(MOD_SMOKE)
+DEF_ICON_MODIFIER(MOD_FLUID)
 DEF_ICON_MODIFIER(MOD_SOLIDIFY)
 DEF_ICON_MODIFIER(MOD_SCREW)
 DEF_ICON_MODIFIER(MOD_VERTEX_WEIGHT)
index 17247736d3b66eeec9a4fa6f394e1470ff299de4..de37219e00937af0c1a35617cb10dc1ba7e3ff97 100644 (file)
@@ -1819,11 +1819,16 @@ static int modifier_can_delete(ModifierData *md)
 {
   /* fluid particle modifier can't be deleted here */
   if (md->type == eModifierType_ParticleSystem) {
-    if (((ParticleSystemModifierData *)md)->psys->part->type == PART_FLUID) {
+    short particle_type = ((ParticleSystemModifierData *)md)->psys->part->type;
+    if (particle_type == PART_FLUID ||
+        particle_type == PART_FLUID_FLIP ||
+        particle_type == PART_FLUID_FOAM ||
+        particle_type == PART_FLUID_SPRAY ||
+        particle_type == PART_FLUID_BUBBLE ||
+        particle_type == PART_FLUID_BUBBLE) {
       return 0;
     }
   }
-
   return 1;
 }
 
@@ -1836,7 +1841,7 @@ static int modifier_is_simulation(ModifierData *md)
            eModifierType_Cloth,
            eModifierType_Collision,
            eModifierType_Fluidsim,
-           eModifierType_Smoke,
+           eModifierType_Fluid,
            eModifierType_Softbody,
            eModifierType_Surface,
            eModifierType_DynamicPaint)) {
@@ -2069,7 +2074,7 @@ static uiLayout *draw_modifier(uiLayout *layout,
                 eModifierType_Softbody,
                 eModifierType_ParticleSystem,
                 eModifierType_Cloth,
-                eModifierType_Smoke)) {
+                eModifierType_Fluid)) {
         uiItemO(row,
                 CTX_IFACE_(BLT_I18NCONTEXT_OPERATOR_DEFAULT, "Copy"),
                 ICON_NONE,
index 021c17a94c204da0becd7ab752d3dfdc62e09f22..ee8d345524ea9a0e803109a60b40fdc348495f7a 100644 (file)
@@ -27,6 +27,7 @@ set(INC
   ../../windowmanager
   ../../../../intern/glew-mx
   ../../../../intern/guardedalloc
+  ../../../../intern/mantaflow/extern
 )
 
 set(INC_SYS
@@ -56,18 +57,8 @@ set(LIB
 )
 
 if(WITH_MOD_FLUID)
-  list(APPEND INC
-    ../../../../intern/elbeem/extern
-  )
-  list(APPEND LIB
-    bf_intern_elbeem
-  )
-  add_definitions(-DWITH_MOD_FLUID)
-endif()
-
-if(WITH_MOD_SMOKE)
   list(APPEND LIB
-    bf_intern_smoke
+    bf_intern_mantaflow
   )
 endif()
 
index cfb3a400f471be80145bac1bcfb5b5492bd0bfef..4df74434c6a273a0529f90212b9f5d9f869d8442 100644 (file)
@@ -1065,7 +1065,7 @@ static void remove_particle_systems_from_object(Object *ob_to)
     if (ELEM(md->type,
              eModifierType_ParticleSystem,
              eModifierType_DynamicPaint,
-             eModifierType_Smoke)) {
+             eModifierType_Fluid)) {
       BLI_remlink(&ob_to->modifiers, md);
       modifier_free(md);
     }
index fc2f3d21bb618202366307b0d2ef56c340e9c3d9..1c091fc18da6825804c3589a6cbb65cb7e442b88 100644 (file)
@@ -103,7 +103,19 @@ void BOID_OT_state_move_up(struct wmOperatorType *ot);
 void BOID_OT_state_move_down(struct wmOperatorType *ot);
 
 /* physics_fluid.c */
-void FLUID_OT_bake(struct wmOperatorType *ot);
+void FLUID_OT_bake_all(struct wmOperatorType *ot);
+void FLUID_OT_free_all(struct wmOperatorType *ot);
+void FLUID_OT_bake_data(struct wmOperatorType *ot);
+void FLUID_OT_free_data(struct wmOperatorType *ot);
+void FLUID_OT_bake_noise(struct wmOperatorType *ot);
+void FLUID_OT_free_noise(struct wmOperatorType *ot);
+void FLUID_OT_bake_mesh(struct wmOperatorType *ot);
+void FLUID_OT_free_mesh(struct wmOperatorType *ot);
+void FLUID_OT_bake_particles(struct wmOperatorType *ot);
+void FLUID_OT_free_particles(struct wmOperatorType *ot);
+void FLUID_OT_bake_guiding(struct wmOperatorType *ot);
+void FLUID_OT_free_guiding(struct wmOperatorType *ot);
+void FLUID_OT_pause_bake(struct wmOperatorType *ot);
 
 /* dynamicpaint.c */
 void DPAINT_OT_bake(struct wmOperatorType *ot);
index b1b3927d05e1e4bed11cbba0e9f0a352cd9d0ef8..843c8f0a63b200a2f2cdb6ae5a8ef42273c48164 100644 (file)
@@ -126,7 +126,19 @@ static void operatortypes_boids(void)
 
 static void operatortypes_fluid(void)
 {
-  WM_operatortype_append(FLUID_OT_bake);
+  WM_operatortype_append(FLUID_OT_bake_all);
+  WM_operatortype_append(FLUID_OT_free_all);
+  WM_operatortype_append(FLUID_OT_bake_data);
+  WM_operatortype_append(FLUID_OT_free_data);
+  WM_operatortype_append(FLUID_OT_bake_noise);
+  WM_operatortype_append(FLUID_OT_free_noise);
+  WM_operatortype_append(FLUID_OT_bake_mesh);
+  WM_operatortype_append(FLUID_OT_free_mesh);
+  WM_operatortype_append(FLUID_OT_bake_particles);
+  WM_operatortype_append(FLUID_OT_free_particles);
+  WM_operatortype_append(FLUID_OT_bake_guiding);
+  WM_operatortype_append(FLUID_OT_free_guiding);
+  WM_operatortype_append(FLUID_OT_pause_bake);
 }
 
 /**************************** point cache **********************************/
index 8cb0a3f3c86a345a8c7b9eb25c523c372709dc38..ecd2b5a369791703603a04fc748f1926a47b46df 100644 (file)
@@ -770,7 +770,6 @@ const char *buttons_context_dir[] = {
     "cloth",
     "soft_body",
     "fluid",
-    "smoke",
     "collision",
     "brush",
     "dynamic_paint",
@@ -1018,24 +1017,14 @@ int buttons_context(const bContext *C, const char *member, bContextDataResult *r
       return 1;
     }
   }
-  else if (CTX_data_equals(member, "fluid")) {
-    PointerRNA *ptr = get_pointer_type(path, &RNA_Object);
 
-    if (ptr && ptr->data) {
-      Object *ob = ptr->data;
-      ModifierData *md = modifiers_findByType(ob, eModifierType_Fluidsim);
-      CTX_data_pointer_set(result, &ob->id, &RNA_FluidSimulationModifier, md);
-      return 1;
-    }
-  }
-
-  else if (CTX_data_equals(member, "smoke")) {
+  else if (CTX_data_equals(member, "fluid")) {
     PointerRNA *ptr = get_pointer_type(path, &RNA_Object);
 
     if (ptr && ptr->data) {
       Object *ob = ptr->data;
-      ModifierData *md = modifiers_findByType(ob, eModifierType_Smoke);
-      CTX_data_pointer_set(result, &ob->id, &RNA_SmokeModifier, md);
+      ModifierData *md = modifiers_findByType(ob, eModifierType_Fluid);
+      CTX_data_pointer_set(result, &ob->id, &RNA_FluidModifier, md);
       return 1;
     }
   }
index 486be952b2ff3acaed1c116afe9060344106c607..2c2989a284d27946901bd33e092057ddf0660cfe 100644 (file)
@@ -2125,14 +2125,14 @@ TreeElementIcon tree_element_get_icon(TreeStoreElem *tselem, TreeElement *te)
             case eModifierType_Surface:
               data.icon = ICON_MOD_PHYSICS;
               break;
-            case eModifierType_Fluidsim:
+            case eModifierType_Fluidsim: /* deprecated, old fluid modifier */
               data.icon = ICON_MOD_FLUIDSIM;
               break;
             case eModifierType_Multires:
               data.icon = ICON_MOD_MULTIRES;
               break;
-            case eModifierType_Smoke:
-              data.icon = ICON_MOD_SMOKE;
+            case eModifierType_Fluid:
+              data.icon = ICON_MOD_FLUID;
               break;
             case eModifierType_Solidify:
               data.icon = ICON_MOD_SOLIDIFY;
index 2feef9e0c9a7adc6ad2175e85907c147432b2a45..95d7f79f666cb878571145cc63478939dc556027 100644 (file)
@@ -32,7 +32,7 @@ set(INC
   ../../windowmanager
   ../../../../intern/glew-mx
   ../../../../intern/guardedalloc
-  ../../../../intern/smoke/extern
+  ../../../../intern/mantaflow/extern
 
   # dna_type_offsets.h
   ${CMAKE_CURRENT_BINARY_DIR}/../../makesdna/intern
@@ -95,8 +95,8 @@ if(WITH_FREESTYLE)
   add_definitions(-DWITH_FREESTYLE)
 endif()
 
-if(WITH_MOD_SMOKE)
-  add_definitions(-DWITH_SMOKE)
+if(WITH_MOD_FLUID)
+  add_definitions(-DWITH_FLUID)
 endif()
 
 blender_add_lib(bf_editor_space_view3d "${SRC}" "${INC}" "${INC_SYS}" "${LIB}")
index 44335f4da25f8ff1100b08686cd09fb7cc8092cf..87743911addeafc581799d5c89f6b84b26433388 100644 (file)
@@ -30,7 +30,6 @@ set(INC
   ../makesdna
   ../makesrna
   ../render/extern/include
-  ../../../intern/elbeem/extern
   ../../../intern/eigen
   ../../../intern/guardedalloc
 )
index bcdc1550fd2c702522de01c688f4f57293ab5be7..7b0845df21775b2715704cb4d19c40fbeb1eccf4 100644 (file)
@@ -44,7 +44,7 @@ set(INC
 
   ../../../intern/glew-mx
   ../../../intern/guardedalloc
-  ../../../intern/smoke/extern
+  ../../../intern/mantaflow/extern
 )
 
 set(INC_SYS
@@ -319,8 +319,8 @@ data_to_c_simple(shaders/gpu_shader_cfg_world_clip_lib.glsl SRC)
 data_to_c_simple(shaders/gpu_shader_common_obinfos_lib.glsl SRC)
 
 
-if(WITH_MOD_SMOKE)
-  add_definitions(-DWITH_SMOKE)
+if(WITH_MOD_FLUID)
+  add_definitions(-DWITH_FLUID)
 endif()
 
 add_definitions(${GL_DEFINITIONS})
index 7814c723fecca4176c04862cf54602083126f407..9ae6b0e75089fd6f93edf7f7343ce529699744ea 100644 (file)
@@ -32,7 +32,7 @@ struct ImBuf;
 struct Image;
 struct ImageUser;
 struct Main;
-struct SmokeModifierData;
+struct FluidModifierData;
 
 #include "DNA_object_enums.h"
 
@@ -84,11 +84,11 @@ void GPU_free_images_anim(struct Main *bmain);
 void GPU_free_images_old(struct Main *bmain);
 
 /* smoke drawing functions */
-void GPU_free_smoke(struct SmokeModifierData *smd);
-void GPU_free_smoke_velocity(struct SmokeModifierData *smd);
-void GPU_create_smoke(struct SmokeModifierData *smd, int highres);
-void GPU_create_smoke_coba_field(struct SmokeModifierData *smd);
-void GPU_create_smoke_velocity(struct SmokeModifierData *smd);
+void GPU_free_smoke(struct FluidModifierData *mmd);
+void GPU_free_smoke_velocity(struct FluidModifierData *mmd);
+void GPU_create_smoke(struct FluidModifierData *mmd, int highres);
+void GPU_create_smoke_coba_field(struct FluidModifierData *mmd);
+void GPU_create_smoke_velocity(struct FluidModifierData *mmd);
 
 /* Delayed free of OpenGL buffers by main thread */
 void GPU_free_unused_buffers(struct Main *bmain);
index d698db45b7aabb6f77bd8ea4f16c499b6921542c..2ac202b8ddf01dc74f8a0a086d002277829ccb13 100644 (file)
@@ -44,7 +44,7 @@
 #include "DNA_node_types.h"
 #include "DNA_object_types.h"
 #include "DNA_scene_types.h"
-#include "DNA_smoke_types.h"
+#include "DNA_fluid_types.h"
 #include "DNA_view3d_types.h"
 #include "DNA_particle_types.h"
 
@@ -71,9 +71,7 @@
 
 #include "PIL_time.h"
 
-#ifdef WITH_SMOKE
-#  include "smoke_API.h"
-#endif
+#include "manta_fluid_API.h"
 
 static void gpu_free_image_immediate(Image *ima);
 
@@ -949,7 +947,6 @@ enum {
 
 #define TFUNC_WIDTH 256
 
-#ifdef WITH_SMOKE
 static void create_flame_spectrum_texture(float *data)
 {
 #  define FIRE_THRESH 7
@@ -1026,71 +1023,71 @@ static void swizzle_texture_channel_rrrr(GPUTexture *tex)
   GPU_texture_unbind(tex);
 }
 
-static GPUTexture *create_field_texture(SmokeDomainSettings *sds)
+static GPUTexture *create_field_texture(FluidDomainSettings *mds)
 {
   float *field = NULL;
 
-  switch (sds->coba_field) {
-    case FLUID_FIELD_DENSITY:
-      field = smoke_get_density(sds->fluid);
+  switch (mds->coba_field) {
+    case FLUID_DOMAIN_FIELD_DENSITY:
+      field = manta_smoke_get_density(mds->fluid);
       break;
-    case FLUID_FIELD_HEAT:
-      field = smoke_get_heat(sds->fluid);
+    case FLUID_DOMAIN_FIELD_HEAT:
+      field = manta_smoke_get_heat(mds->fluid);
       break;
-    case FLUID_FIELD_FUEL:
-      field = smoke_get_fuel(sds->fluid);
+    case FLUID_DOMAIN_FIELD_FUEL:
+      field = manta_smoke_get_fuel(mds->fluid);
       break;
-    case FLUID_FIELD_REACT:
-      field = smoke_get_react(sds->fluid);
+    case FLUID_DOMAIN_FIELD_REACT:
+      field = manta_smoke_get_react(mds->fluid);
       break;
-    case FLUID_FIELD_FLAME:
-      field = smoke_get_flame(sds->fluid);
+    case FLUID_DOMAIN_FIELD_FLAME:
+      field = manta_smoke_get_flame(mds->fluid);
       break;
-    case FLUID_FIELD_VELOCITY_X:
-      field = smoke_get_velocity_x(sds->fluid);
+    case FLUID_DOMAIN_FIELD_VELOCITY_X:
+      field = manta_get_velocity_x(mds->fluid);
       break;
-    case FLUID_FIELD_VELOCITY_Y:
-      field = smoke_get_velocity_y(sds->fluid);
+    case FLUID_DOMAIN_FIELD_VELOCITY_Y:
+      field = manta_get_velocity_y(mds->fluid);
       break;
-    case FLUID_FIELD_VELOCITY_Z:
-      field = smoke_get_velocity_z(sds->fluid);
+    case FLUID_DOMAIN_FIELD_VELOCITY_Z:
+      field = manta_get_velocity_z(mds->fluid);
       break;
-    case FLUID_FIELD_COLOR_R:
-      field = smoke_get_color_r(sds->fluid);
+    case FLUID_DOMAIN_FIELD_COLOR_R:
+      field = manta_smoke_get_color_r(mds->fluid);
       break;
-    case FLUID_FIELD_COLOR_G:
-      field = smoke_get_color_g(sds->fluid);
+    case FLUID_DOMAIN_FIELD_COLOR_G:
+      field = manta_smoke_get_color_g(mds->fluid);
       break;
-    case FLUID_FIELD_COLOR_B:
-      field = smoke_get_color_b(sds->fluid);
+    case FLUID_DOMAIN_FIELD_COLOR_B:
+      field = manta_smoke_get_color_b(mds->fluid);
       break;
-    case FLUID_FIELD_FORCE_X:
-      field = smoke_get_force_x(sds->fluid);
+    case FLUID_DOMAIN_FIELD_FORCE_X:
+      field = manta_get_force_x(mds->fluid);
       break;
-    case FLUID_FIELD_FORCE_Y:
-      field = smoke_get_force_y(sds->fluid);
+    case FLUID_DOMAIN_FIELD_FORCE_Y:
+      field = manta_get_force_y(mds->fluid);
       break;
-    case FLUID_FIELD_FORCE_Z:
-      field = smoke_get_force_z(sds->fluid);
+    case FLUID_DOMAIN_FIELD_FORCE_Z:
+      field = manta_get_force_z(mds->fluid);
       break;
     default:
       return NULL;
   }
 
   GPUTexture *tex = GPU_texture_create_nD(
-      sds->res[0], sds->res[1], sds->res[2], 3, field, GPU_R8, GPU_DATA_FLOAT, 0, true, NULL);
+      mds->res[0], mds->res[1], mds->res[2], 3, field, GPU_R8, GPU_DATA_FLOAT, 0, true, NULL);
 
   swizzle_texture_channel_rrrr(tex);
   return tex;
 }
 
-static GPUTexture *create_density_texture(SmokeDomainSettings *sds, int highres)
+static GPUTexture *create_density_texture(FluidDomainSettings *mds, int highres)
 {
   float *data = NULL, *source;
-  int cell_count = (highres) ? smoke_turbulence_get_cells(sds->wt) : sds->total_cells;
-  const bool has_color = (highres) ? smoke_turbulence_has_colors(sds->wt) :
-                                     smoke_has_colors(sds->fluid);
-  int *dim = (highres) ? sds->res_wt : sds->res;
+  int cell_count = (highres) ? manta_smoke_turbulence_get_cells(mds->fluid) : mds->total_cells;
+  const bool has_color = (highres) ? manta_smoke_turbulence_has_colors(mds->fluid) :
+                                     manta_smoke_has_colors(mds->fluid);
+  int *dim = (highres) ? mds->res_noise : mds->res;
   eGPUTextureFormat format = (has_color) ? GPU_RGBA8 : GPU_R8;
 
   if (has_color) {
@@ -1099,18 +1096,18 @@ static GPUTexture *create_density_texture(SmokeDomainSettings *sds, int highres)
 
   if (highres) {
     if (has_color) {
-      smoke_turbulence_get_rgba(sds->wt, data, 0);
+      manta_smoke_turbulence_get_rgba(mds->fluid, data, 0);
     }
     else {
-      source = smoke_turbulence_get_density(sds->wt);
+      source = manta_smoke_turbulence_get_density(mds->fluid);
     }
   }
   else {
     if (has_color) {
-      smoke_get_rgba(sds->fluid, data, 0);
+      manta_smoke_get_rgba(mds->fluid, data, 0);
     }
     else {
-      source = smoke_get_density(sds->fluid);
+      source = manta_smoke_get_density(mds->fluid);
     }
   }
 
@@ -1137,22 +1134,22 @@ static GPUTexture *create_density_texture(SmokeDomainSettings *sds, int highres)
   return tex;
 }
 
-static GPUTexture *create_flame_texture(SmokeDomainSettings *sds, int highres)
+static GPUTexture *create_flame_texture(FluidDomainSettings *mds, int highres)
 {
   float *source = NULL;
-  const bool has_fuel = (highres) ? smoke_turbulence_has_fuel(sds->wt) :
-                                    smoke_has_fuel(sds->fluid);
-  int *dim = (highres) ? sds->res_wt : sds->res;
+  const bool has_fuel = (highres) ? manta_smoke_turbulence_has_fuel(mds->fluid) :
+                                    manta_smoke_has_fuel(mds->fluid);
+  int *dim = (highres) ? mds->res_noise : mds->res;
 
   if (!has_fuel) {
     return NULL;
   }
 
   if (highres) {
-    source = smoke_turbulence_get_flame(sds->wt);
+    source = manta_smoke_turbulence_get_flame(mds->fluid);
   }
   else {
-    source = smoke_get_flame(sds->fluid);
+    source = manta_smoke_get_flame(mds->fluid);
   }
 
   GPUTexture *tex = GPU_texture_create_nD(
@@ -1162,82 +1159,76 @@ static GPUTexture *create_flame_texture(SmokeDomainSettings *sds, int highres)
 
   return tex;
 }
-#endif /* WITH_SMOKE */
 
-void GPU_free_smoke(SmokeModifierData *smd)
+void GPU_free_smoke(FluidModifierData *mmd)
 {
-  if (smd->type & MOD_SMOKE_TYPE_DOMAIN && smd->domain) {
-    if (smd->domain->tex) {
-      GPU_texture_free(smd->domain->tex);
+  if (mmd->type & MOD_FLUID_TYPE_DOMAIN && mmd->domain) {
+    if (mmd->domain->tex) {
+      GPU_texture_free(mmd->domain->tex);
     }
-    smd->domain->tex = NULL;
+    mmd->domain->tex = NULL;
 
-    if (smd->domain->tex_shadow) {
-      GPU_texture_free(smd->domain->tex_shadow);
+    if (mmd->domain->tex_shadow) {
+      GPU_texture_free(mmd->domain->tex_shadow);
     }
-    smd->domain->tex_shadow = NULL;
+    mmd->domain->tex_shadow = NULL;
 
-    if (smd->domain->tex_flame) {
-      GPU_texture_free(smd->domain->tex_flame);
+    if (mmd->domain->tex_flame) {
+      GPU_texture_free(mmd->domain->tex_flame);
     }
-    smd->domain->tex_flame = NULL;
+    mmd->domain->tex_flame = NULL;
 
-    if (smd->domain->tex_flame_coba) {
-      GPU_texture_free(smd->domain->tex_flame_coba);
+    if (mmd->domain->tex_flame_coba) {
+      GPU_texture_free(mmd->domain->tex_flame_coba);
     }
-    smd->domain->tex_flame_coba = NULL;
+    mmd->domain->tex_flame_coba = NULL;
 
-    if (smd->domain->tex_coba) {
-      GPU_texture_free(smd->domain->tex_coba);
+    if (mmd->domain->tex_coba) {
+      GPU_texture_free(mmd->domain->tex_coba);
     }
-    smd->domain->tex_coba = NULL;
+    mmd->domain->tex_coba = NULL;
 
-    if (smd->domain->tex_field) {
-      GPU_texture_free(smd->domain->tex_field);
+    if (mmd->domain->tex_field) {
+      GPU_texture_free(mmd->domain->tex_field);
     }
-    smd->domain->tex_field = NULL;
+    mmd->domain->tex_field = NULL;
   }
 }
 
-void GPU_create_smoke_coba_field(SmokeModifierData *smd)
+void GPU_create_smoke_coba_field(FluidModifierData *mmd)
 {
-#ifdef WITH_SMOKE
-  if (smd->type & MOD_SMOKE_TYPE_DOMAIN) {
-    SmokeDomainSettings *sds = smd->domain;
+  if (mmd->type & MOD_FLUID_TYPE_DOMAIN) {
+    FluidDomainSettings *mds = mmd->domain;
 
-    if (!sds->tex_field) {
-      sds->tex_field = create_field_texture(sds);
+    if (!mds->tex_field) {
+      mds->tex_field = create_field_texture(mds);
     }
-    if (!sds->tex_coba) {
-      sds->tex_coba = create_transfer_function(TFUNC_COLOR_RAMP, sds->coba);
+    if (!mds->tex_coba) {
+      mds->tex_coba = create_transfer_function(TFUNC_COLOR_RAMP, mds->coba);
     }
   }
-#else   // WITH_SMOKE
-  smd->domain->tex_field = NULL;
-#endif  // WITH_SMOKE
 }
 
-void GPU_create_smoke(SmokeModifierData *smd, int highres)
+void GPU_create_smoke(FluidModifierData *mmd, int highres)
 {
-#ifdef WITH_SMOKE
-  if (smd->type & MOD_SMOKE_TYPE_DOMAIN) {
-    SmokeDomainSettings *sds = smd->domain;
+  if (mmd->type & MOD_FLUID_TYPE_DOMAIN) {
+    FluidDomainSettings *mds = mmd->domain;
 
-    if (!sds->tex) {
-      sds->tex = create_density_texture(sds, highres);
+    if (!mds->tex) {
+      mds->tex = create_density_texture(mds, highres);
     }
-    if (!sds->tex_flame) {
-      sds->tex_flame = create_flame_texture(sds, highres);
+    if (!mds->tex_flame) {
+      mds->tex_flame = create_flame_texture(mds, highres);
     }
-    if (!sds->tex_flame_coba && sds->tex_flame) {
-      sds->tex_flame_coba = create_transfer_function(TFUNC_FLAME_SPECTRUM, NULL);
+    if (!mds->tex_flame_coba && mds->tex_flame) {
+      mds->tex_flame_coba = create_transfer_function(TFUNC_FLAME_SPECTRUM, NULL);
     }
-    if (!sds->tex_shadow) {
-      sds->tex_shadow = GPU_texture_create_nD(sds->res[0],
-                                              sds->res[1],
-                                              sds->res[2],
+    if (!mds->tex_shadow) {
+      mds->tex_shadow = GPU_texture_create_nD(mds->res[0],
+                                              mds->res[1],
+                                              mds->res[2],
                                               3,
-                                              sds->shadow,
+                                              manta_smoke_get_shadow(mds->fluid),
                                               GPU_R8,
                                               GPU_DATA_FLOAT,
                                               0,
@@ -1245,64 +1236,51 @@ void GPU_create_smoke(SmokeModifierData *smd, int highres)
                                               NULL);
     }
   }
-#else   // WITH_SMOKE
-  (void)highres;
-  smd->domain->tex = NULL;
-  smd->domain->tex_flame = NULL;
-  smd->domain->tex_flame_coba = NULL;
-  smd->domain->tex_shadow = NULL;
-#endif  // WITH_SMOKE
 }
 
-void GPU_create_smoke_velocity(SmokeModifierData *smd)
+void GPU_create_smoke_velocity(FluidModifierData *mmd)
 {
-#ifdef WITH_SMOKE
-  if (smd->type & MOD_SMOKE_TYPE_DOMAIN) {
-    SmokeDomainSettings *sds = smd->domain;
+  if (mmd->type & MOD_FLUID_TYPE_DOMAIN) {
+    FluidDomainSettings *mds = mmd->domain;
 
-    const float *vel_x = smoke_get_velocity_x(sds->fluid);
-    const float *vel_y = smoke_get_velocity_y(sds->fluid);
-    const float *vel_z = smoke_get_velocity_z(sds->fluid);
+    const float *vel_x = manta_get_velocity_x(mds->fluid);
+    const float *vel_y = manta_get_velocity_y(mds->fluid);
+    const float *vel_z = manta_get_velocity_z(mds->fluid);
 
     if (ELEM(NULL, vel_x, vel_y, vel_z)) {
       return;
     }
 
-    if (!sds->tex_velocity_x) {
-      sds->tex_velocity_x = GPU_texture_create_3d(
-          sds->res[0], sds->res[1], sds->res[2], GPU_R16F, vel_x, NULL);
-      sds->tex_velocity_y = GPU_texture_create_3d(
-          sds->res[0], sds->res[1], sds->res[2], GPU_R16F, vel_y, NULL);
-      sds->tex_velocity_z = GPU_texture_create_3d(
-          sds->res[0], sds->res[1], sds->res[2], GPU_R16F, vel_z, NULL);
+    if (!mds->tex_velocity_x) {
+      mds->tex_velocity_x = GPU_texture_create_3d(
+          mds->res[0], mds->res[1], mds->res[2], GPU_R16F, vel_x, NULL);
+      mds->tex_velocity_y = GPU_texture_create_3d(
+          mds->res[0], mds->res[1], mds->res[2], GPU_R16F, vel_y, NULL);
+      mds->tex_velocity_z = GPU_texture_create_3d(
+          mds->res[0], mds->res[1], mds->res[2], GPU_R16F, vel_z, NULL);
     }
   }
-#else   // WITH_SMOKE
-  smd->domain->tex_velocity_x = NULL;
-  smd->domain->tex_velocity_y = NULL;
-  smd->domain->tex_velocity_z = NULL;
-#endif  // WITH_SMOKE
 }
 
 /* TODO Unify with the other GPU_free_smoke. */
-void GPU_free_smoke_velocity(SmokeModifierData *smd)
+void GPU_free_smoke_velocity(FluidModifierData *mmd)
 {
-  if (smd->type & MOD_SMOKE_TYPE_DOMAIN && smd->domain) {
-    if (smd->domain->tex_velocity_x) {
-      GPU_texture_free(smd->domain->tex_velocity_x);
+  if (mmd->type & MOD_FLUID_TYPE_DOMAIN && mmd->domain) {
+    if (mmd->domain->tex_velocity_x) {
+      GPU_texture_free(mmd->domain->tex_velocity_x);
     }
 
-    if (smd->domain->tex_velocity_y) {
-      GPU_texture_free(smd->domain->tex_velocity_y);
+    if (mmd->domain->tex_velocity_y) {
+      GPU_texture_free(mmd->domain->tex_velocity_y);
     }
 
-    if (smd->domain->tex_velocity_z) {
-      GPU_texture_free(smd->domain->tex_velocity_z);
+    if (mmd->domain->tex_velocity_z) {
+      GPU_texture_free(mmd->domain->tex_velocity_z);
     }
 
-    smd->domain->tex_velocity_x = NULL;
-    smd->domain->tex_velocity_y = NULL;
-    smd->domain->tex_velocity_z = NULL;
+    mmd->domain->tex_velocity_x = NULL;
+    mmd->domain->tex_velocity_y = NULL;
+    mmd->domain->tex_velocity_z = NULL;
   }
 }
 
index 0b61e312846a5289d3648e032cf9aecfc1f4cd06..020325b49f7e0c0c6a2e058e5467736f06c1a5e4 100644 (file)
@@ -87,6 +87,7 @@ typedef enum ModifierType {
   eModifierType_SurfaceDeform = 53,
   eModifierType_WeightedNormal = 54,
   eModifierType_Weld = 55,
+  eModifierType_Fluid = 56,
   NUM_MODIFIER_TYPES,
 } ModifierType;
 
@@ -451,24 +452,24 @@ enum {
   MOD_BEVEL_VMESH_CUTOFF,
 };
 
-typedef struct SmokeModifierData {
+typedef struct FluidModifierData {
   ModifierData modifier;
 
-  struct SmokeDomainSettings *domain;
+  struct FluidDomainSettings *domain;
   /** Inflow, outflow, smoke objects. */
-  struct SmokeFlowSettings *flow;
-  /** Collision objects. */
-  struct SmokeCollSettings *coll;
+  struct FluidFlowSettings *flow;
+  /** Effector objects (collision, guiding). */
+  struct FluidEffectorSettings *effector;
   float time;
   /** Domain, inflow, outflow, .... */
   int type;
-} SmokeModifierData;
+} FluidModifierData;
 
-/* Smoke modifier flags */
+/* Fluid modifier flags */
 enum {
-  MOD_SMOKE_TYPE_DOMAIN = (1 << 0),
-  MOD_SMOKE_TYPE_FLOW = (1 << 1),
-  MOD_SMOKE_TYPE_COLL = (1 << 2),
+  MOD_FLUID_TYPE_DOMAIN = (1 << 0),
+  MOD_FLUID_TYPE_FLOW = (1 << 1),
+  MOD_FLUID_TYPE_EFFEC = (1 << 2),
 };
 
 typedef struct DisplaceModifierData {
@@ -977,6 +978,7 @@ typedef enum {
   eMultiresModifierFlag_UseCrease = (1 << 2),
 } MultiresModifierFlag;
 
+/* DEPRECATED, only used for versioning. */
 typedef struct FluidsimModifierData {
   ModifierData modifier;
 
@@ -984,6