diff options
79 files changed, 1272 insertions, 7999 deletions
diff --git a/extern/CMakeLists.txt b/extern/CMakeLists.txt index b985a39106b..e79aba0e988 100644 --- a/extern/CMakeLists.txt +++ b/extern/CMakeLists.txt @@ -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 index 00000000000..72ce920c621 --- /dev/null +++ b/extern/mantaflow/CMakeLists.txt @@ -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}") diff --git a/intern/CMakeLists.txt b/intern/CMakeLists.txt index e6b561c39b9..a5605e875a8 100644 --- a/intern/CMakeLists.txt +++ b/intern/CMakeLists.txt @@ -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() diff --git a/intern/cycles/blender/blender_mesh.cpp b/intern/cycles/blender/blender_mesh.cpp index 5c28404e745..b18f9a37948 100644 --- a/intern/cycles/blender/blender_mesh.cpp +++ b/intern/cycles/blender/blender_mesh.cpp @@ -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; diff --git a/intern/cycles/blender/blender_session.cpp b/intern/cycles/blender/blender_session.cpp index 78fb49db6c8..26b04babce2 100644 --- a/intern/cycles/blender/blender_session.cpp +++ b/intern/cycles/blender/blender_session.cpp @@ -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; } } diff --git a/intern/cycles/blender/blender_util.h b/intern/cycles/blender/blender_util.h index fa7646840c9..2c3e279a8d8 100644 --- a/intern/cycles/blender/blender_util.h +++ b/intern/cycles/blender/blender_util.h @@ -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, diff --git a/release/datafiles/blender_icons16/icon16_mod_smoke.dat b/release/datafiles/blender_icons16/icon16_mod_fluid.dat Binary files differindex 0524059740d..0524059740d 100644 --- a/release/datafiles/blender_icons16/icon16_mod_smoke.dat +++ b/release/datafiles/blender_icons16/icon16_mod_fluid.dat diff --git a/release/datafiles/blender_icons32/icon32_mod_smoke.dat b/release/datafiles/blender_icons32/icon32_mod_fluid.dat Binary files differindex e3390d5f2ce..e3390d5f2ce 100644 --- a/release/datafiles/blender_icons32/icon32_mod_smoke.dat +++ b/release/datafiles/blender_icons32/icon32_mod_fluid.dat diff --git a/release/datafiles/locale b/release/datafiles/locale -Subproject b0b6396312e7ceb78826d423f8f152ddba01c03 +Subproject 8a05b618f031582c006c6f62b9e60619ab3eef8 diff --git a/source/blender/CMakeLists.txt b/source/blender/CMakeLists.txt index 68d7b6d9b2d..f6536692add 100644 --- a/source/blender/CMakeLists.txt +++ b/source/blender/CMakeLists.txt @@ -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 diff --git a/source/blender/alembic/intern/abc_exporter.cc b/source/blender/alembic/intern/abc_exporter.cc index d422a3c023e..5d9f92432d1 100644 --- a/source/blender/alembic/intern/abc_exporter.cc +++ b/source/blender/alembic/intern/abc_exporter.cc @@ -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 index 00000000000..8ada379a293 --- /dev/null +++ b/source/blender/blenkernel/BKE_fluid.h @@ -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 index d44c88c30a9..00000000000 --- a/source/blender/blenkernel/BKE_fluidsim.h +++ /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 diff --git a/source/blender/blenkernel/BKE_pointcache.h b/source/blender/blenkernel/BKE_pointcache.h index 6ce60081f5b..2ebe485419a 100644 --- a/source/blender/blenkernel/BKE_pointcache.h +++ b/source/blender/blenkernel/BKE_pointcache.h @@ -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 index 10632d47203..00000000000 --- a/source/blender/blenkernel/BKE_smoke.h +++ /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__ */ diff --git a/source/blender/blenkernel/CMakeLists.txt b/source/blender/blenkernel/CMakeLists.txt index 88a3629ea3f..ad84a1b579c 100644 --- a/source/blender/blenkernel/CMakeLists.txt +++ b/source/blender/blenkernel/CMakeLists.txt @@ -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) diff --git a/source/blender/blenkernel/intern/bpath.c b/source/blender/blenkernel/intern/bpath.c index de7837cdd90..90b26f8c288 100644 --- a/source/blender/blenkernel/intern/bpath.c +++ b/source/blender/blenkernel/intern/bpath.c @@ -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) { diff --git a/source/blender/blenkernel/intern/dynamicpaint.c b/source/blender/blenkernel/intern/dynamicpaint.c index 91b169590ac..74a523bfbdc 100644 --- a/source/blender/blenkernel/intern/dynamicpaint.c +++ b/source/blender/blenkernel/intern/dynamicpaint.c @@ -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); diff --git a/source/blender/blenkernel/intern/effect.c b/source/blender/blenkernel/intern/effect.c index ffab82b75af..91f83110675 100644 --- a/source/blender/blenkernel/intern/effect.c +++ b/source/blender/blenkernel/intern/effect.c @@ -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" @@ -71,13 +71,6 @@ #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 index 994e00f227a..00000000000 --- a/source/blender/blenkernel/intern/fluidsim.c +++ /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); -} diff --git a/source/blender/blenkernel/intern/modifier.c b/source/blender/blenkernel/intern/modifier.c index fd7d2fd4a03..f51cf2bc2b4 100644 --- a/source/blender/blenkernel/intern/modifier.c +++ b/source/blender/blenkernel/intern/modifier.c @@ -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 { diff --git a/source/blender/blenkernel/intern/object.c b/source/blender/blenkernel/intern/object.c index 08890965ece..10553e73d8d 100644 --- a/source/blender/blenkernel/intern/object.c +++ b/source/blender/blenkernel/intern/object.c @@ -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" @@ -123,10 +123,6 @@ #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; } } diff --git a/source/blender/blenkernel/intern/particle.c b/source/blender/blenkernel/intern/particle.c index 096142b9889..ded38cf562f 100644 --- a/source/blender/blenkernel/intern/particle.c +++ b/source/blender/blenkernel/intern/particle.c @@ -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; } } } diff --git a/source/blender/blenkernel/intern/pointcache.c b/source/blender/blenkernel/intern/pointcache.c index 7ae5f91c615..5e1611cb3f9 100644 --- a/source/blender/blenkernel/intern/pointcache.c +++ b/source/blender/blenkernel/intern/pointcache.c @@ -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 index 4c3b7a619da..00000000000 --- a/source/blender/blenkernel/intern/smoke.c +++ /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, ×cale); - - 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; -} diff --git a/source/blender/blenloader/intern/readfile.c b/source/blender/blenloader/intern/readfile.c index 2a51a57f887..f8723b495f7 100644 --- a/source/blender/blenloader/intern/readfile.c +++ b/source/blender/blenloader/intern/readfile.c @@ -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" @@ -239,7 +239,7 @@ /* 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); diff --git a/source/blender/blenloader/intern/versioning_250.c b/source/blender/blenloader/intern/versioning_250.c index 3e7b1582603..a5ab0c0acb7 100644 --- a/source/blender/blenloader/intern/versioning_250.c +++ b/source/blender/blenloader/intern/versioning_250.c @@ -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; } } } diff --git a/source/blender/blenloader/intern/versioning_260.c b/source/blender/blenloader/intern/versioning_260.c index 40219a36323..f23e4b5e2a4 100644 --- a/source/blender/blenloader/intern/versioning_260.c +++ b/source/blender/blenloader/intern/versioning_260.c @@ -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; } } } diff --git a/source/blender/blenloader/intern/versioning_270.c b/source/blender/blenloader/intern/versioning_270.c index fb570b956b6..f421f31814c 100644 --- a/source/blender/blenloader/intern/versioning_270.c +++ b/source/blender/blenloader/intern/versioning_270.c @@ -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; } } } diff --git a/source/blender/blenloader/intern/versioning_legacy.c b/source/blender/blenloader/intern/versioning_legacy.c index 5d46f0735eb..73cdd40c02c 100644 --- a/source/blender/blenloader/intern/versioning_legacy.c +++ b/source/blender/blenloader/intern/versioning_legacy.c @@ -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; diff --git a/source/blender/blenloader/intern/writefile.c b/source/blender/blenloader/intern/writefile.c index f8ac4e4062c..30e7cf476fb 100644 --- a/source/blender/blenloader/intern/writefile.c +++ b/source/blender/blenloader/intern/writefile.c @@ -126,7 +126,7 @@ #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) { diff --git a/source/blender/depsgraph/intern/depsgraph_physics.cc b/source/blender/depsgraph/intern/depsgraph_physics.cc index 3f81e49b170..f47081cd54e 100644 --- a/source/blender/depsgraph/intern/depsgraph_physics.cc +++ b/source/blender/depsgraph/intern/depsgraph_physics.cc @@ -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; diff --git a/source/blender/draw/engines/eevee/eevee_volumes.c b/source/blender/draw/engines/eevee/eevee_volumes.c index 67fd441a0b1..2e0b5d36496 100644 --- a/source/blender/draw/engines/eevee/eevee_volumes.c +++ b/source/blender/draw/engines/eevee/eevee_volumes.c @@ -28,12 +28,12 @@ #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); } diff --git a/source/blender/draw/engines/overlay/overlay_extra.c b/source/blender/draw/engines/overlay/overlay_extra.c index f6e3ed4d4de..90ddb9f7476 100644 --- a/source/blender/draw/engines/overlay/overlay_extra.c +++ b/source/blender/draw/engines/overlay/overlay_extra.c @@ -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); diff --git a/source/blender/draw/engines/overlay/shaders/volume_velocity_vert.glsl b/source/blender/draw/engines/overlay/shaders/volume_velocity_vert.glsl index 64f88bd74fa..752694301f7 100644 --- a/source/blender/draw/engines/overlay/shaders/volume_velocity_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/volume_velocity_vert.glsl @@ -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; diff --git a/source/blender/draw/engines/workbench/workbench_deferred.c b/source/blender/draw/engines/workbench/workbench_deferred.c index 8e61750da38..a536132a1cf 100644 --- a/source/blender/draw/engines/workbench/workbench_deferred.c +++ b/source/blender/draw/engines/workbench/workbench_deferred.c @@ -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. */ } diff --git a/source/blender/draw/engines/workbench/workbench_forward.c b/source/blender/draw/engines/workbench/workbench_forward.c index dbd7ebfe0d1..90f5d24fabd 100644 --- a/source/blender/draw/engines/workbench/workbench_forward.c +++ b/source/blender/draw/engines/workbench/workbench_forward.c @@ -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. */ } diff --git a/source/blender/draw/engines/workbench/workbench_volume.c b/source/blender/draw/engines/workbench/workbench_volume.c index 23f0898c138..2f7296fb40f 100644 --- a/source/blender/draw/engines/workbench/workbench_volume.c +++ b/source/blender/draw/engines/workbench/workbench_volume.c @@ -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); } diff --git a/source/blender/editors/datafiles/CMakeLists.txt b/source/blender/editors/datafiles/CMakeLists.txt index fd8fe103a2d..4cc0c865093 100644 --- a/source/blender/editors/datafiles/CMakeLists.txt +++ b/source/blender/editors/datafiles/CMakeLists.txt @@ -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 diff --git a/source/blender/editors/include/UI_icons.h b/source/blender/editors/include/UI_icons.h index 2bf50d3b4b8..44c734e264a 100644 --- a/source/blender/editors/include/UI_icons.h +++ b/source/blender/editors/include/UI_icons.h @@ -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) diff --git a/source/blender/editors/interface/interface_templates.c b/source/blender/editors/interface/interface_templates.c index 17247736d3b..de37219e009 100644 --- a/source/blender/editors/interface/interface_templates.c +++ b/source/blender/editors/interface/interface_templates.c @@ -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, diff --git a/source/blender/editors/physics/CMakeLists.txt b/source/blender/editors/physics/CMakeLists.txt index 021c17a94c2..ee8d345524e 100644 --- a/source/blender/editors/physics/CMakeLists.txt +++ b/source/blender/editors/physics/CMakeLists.txt @@ -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() diff --git a/source/blender/editors/physics/particle_object.c b/source/blender/editors/physics/particle_object.c index cfb3a400f47..4df74434c6a 100644 --- a/source/blender/editors/physics/particle_object.c +++ b/source/blender/editors/physics/particle_object.c @@ -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); } diff --git a/source/blender/editors/physics/physics_intern.h b/source/blender/editors/physics/physics_intern.h index fc2f3d21bb6..1c091fc18da 100644 --- a/source/blender/editors/physics/physics_intern.h +++ b/source/blender/editors/physics/physics_intern.h @@ -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); diff --git a/source/blender/editors/physics/physics_ops.c b/source/blender/editors/physics/physics_ops.c index b1b3927d05e..843c8f0a63b 100644 --- a/source/blender/editors/physics/physics_ops.c +++ b/source/blender/editors/physics/physics_ops.c @@ -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 **********************************/ diff --git a/source/blender/editors/space_buttons/buttons_context.c b/source/blender/editors/space_buttons/buttons_context.c index 8cb0a3f3c86..ecd2b5a3697 100644 --- a/source/blender/editors/space_buttons/buttons_context.c +++ b/source/blender/editors/space_buttons/buttons_context.c @@ -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; } } diff --git a/source/blender/editors/space_outliner/outliner_draw.c b/source/blender/editors/space_outliner/outliner_draw.c index 486be952b2f..2c2989a284d 100644 --- a/source/blender/editors/space_outliner/outliner_draw.c +++ b/source/blender/editors/space_outliner/outliner_draw.c @@ -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; diff --git a/source/blender/editors/space_view3d/CMakeLists.txt b/source/blender/editors/space_view3d/CMakeLists.txt index 2feef9e0c9a..95d7f79f666 100644 --- a/source/blender/editors/space_view3d/CMakeLists.txt +++ b/source/blender/editors/space_view3d/CMakeLists.txt @@ -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}") diff --git a/source/blender/gpencil_modifiers/CMakeLists.txt b/source/blender/gpencil_modifiers/CMakeLists.txt index 44335f4da25..87743911add 100644 --- a/source/blender/gpencil_modifiers/CMakeLists.txt +++ b/source/blender/gpencil_modifiers/CMakeLists.txt @@ -30,7 +30,6 @@ set(INC ../makesdna ../makesrna ../render/extern/include - ../../../intern/elbeem/extern ../../../intern/eigen ../../../intern/guardedalloc ) diff --git a/source/blender/gpu/CMakeLists.txt b/source/blender/gpu/CMakeLists.txt index bcdc1550fd2..7b0845df217 100644 --- a/source/blender/gpu/CMakeLists.txt +++ b/source/blender/gpu/CMakeLists.txt @@ -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}) diff --git a/source/blender/gpu/GPU_draw.h b/source/blender/gpu/GPU_draw.h index 7814c723fec..9ae6b0e7508 100644 --- a/source/blender/gpu/GPU_draw.h +++ b/source/blender/gpu/GPU_draw.h @@ -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); diff --git a/source/blender/gpu/intern/gpu_draw.c b/source/blender/gpu/intern/gpu_draw.c index d698db45b7a..2ac202b8ddf 100644 --- a/source/blender/gpu/intern/gpu_draw.c +++ b/source/blender/gpu/intern/gpu_draw.c @@ -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; } } diff --git a/source/blender/makesdna/DNA_modifier_types.h b/source/blender/makesdna/DNA_modifier_types.h index 0b61e312846..020325b49f7 100644 --- a/source/blender/makesdna/DNA_modifier_types.h +++ b/source/blender/makesdna/DNA_modifier_types.h @@ -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 +986,11 @@ typedef struct FluidsimModifierData { struct FluidsimSettings *fss; } FluidsimModifierData; +/* DEPRECATED, only used for versioning. */ +typedef struct SmokeModifierData { + ModifierData modifier; +} SmokeModifierData; + typedef struct ShrinkwrapModifierData { ModifierData modifier; diff --git a/source/blender/makesdna/DNA_object_types.h b/source/blender/makesdna/DNA_object_types.h index a1ea51ab573..fbed0754046 100644 --- a/source/blender/makesdna/DNA_object_types.h +++ b/source/blender/makesdna/DNA_object_types.h @@ -371,7 +371,8 @@ typedef struct Object { struct Collection *instance_collection; /** If fluidsim enabled, store additional settings. */ - struct FluidsimSettings *fluidsimSettings; + struct FluidsimSettings *fluidsimSettings + DNA_DEPRECATED; // XXX deprecated... replaced by mantaflow, keep for readfile struct DerivedMesh *derivedDeform, *derivedFinal; diff --git a/source/blender/makesdna/DNA_particle_types.h b/source/blender/makesdna/DNA_particle_types.h index 4aaa1fe32f6..78f965c327b 100644 --- a/source/blender/makesdna/DNA_particle_types.h +++ b/source/blender/makesdna/DNA_particle_types.h @@ -273,7 +273,7 @@ typedef struct ParticleSettings { struct Collection *instance_collection; struct ListBase instance_weights; - struct Collection *eff_group DNA_DEPRECATED; // deprecated + struct Collection *force_group DNA_DEPRECATED; // deprecated struct Object *instance_object; struct Object *bb_ob; /** Old animation system, deprecated for 2.5. */ @@ -429,13 +429,33 @@ typedef enum eParticleDrawFlag { PART_DRAW_HAIR_GRID = (1 << 18), } eParticleDrawFlag; -/* part->type */ -/* hair is always baked static in object/geometry space */ -/* other types (normal particles) are in global space and not static baked */ -#define PART_EMITTER 0 -//#define PART_REACTOR 1 -#define PART_HAIR 2 -#define PART_FLUID 3 +/* part->type + * Hair is always baked static in object/geometry space. + * Other types (normal particles) are in global space and not static baked. */ +enum { + PART_EMITTER = (1 << 0), + /* REACTOR type currently unused */ + /* PART_REACTOR = (1 << 1), */ + PART_HAIR = (1 << 2), + PART_FLUID = (1 << 3), /* deprecated (belonged to elbeem) */ + PART_FLUID_FLIP = (1 << 4), + PART_FLUID_SPRAY = (1 << 5), + PART_FLUID_BUBBLE = (1 << 6), + PART_FLUID_FOAM = (1 << 7), + PART_FLUID_TRACER = (1 << 8), +}; + +/* Mirroring Mantaflow particle types from particle.h (Mantaflow header). */ +enum { + PARTICLE_TYPE_NONE = (0 << 0), + PARTICLE_TYPE_NEW = (1 << 0), + PARTICLE_TYPE_SPRAY = (1 << 1), + PARTICLE_TYPE_BUBBLE = (1 << 2), + PARTICLE_TYPE_FOAM = (1 << 3), + PARTICLE_TYPE_TRACER = (1 << 4), + PARTICLE_TYPE_DELETE = (1 << 10), + PARTICLE_TYPE_INVALID = (1 << 30), +}; /* part->flag */ #define PART_REACT_STA_END 1 diff --git a/source/blender/makesdna/DNA_smoke_types.h b/source/blender/makesdna/DNA_smoke_types.h deleted file mode 100644 index d795800df2f..00000000000 --- a/source/blender/makesdna/DNA_smoke_types.h +++ /dev/null @@ -1,346 +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) 2006 by NaN Holding BV. - * All rights reserved. - */ - -/** \file - * \ingroup DNA - */ - -#ifndef __DNA_SMOKE_TYPES_H__ -#define __DNA_SMOKE_TYPES_H__ - -/* flags */ -enum { - MOD_SMOKE_HIGHRES = (1 << 1), /* enable high resolution */ - MOD_SMOKE_DISSOLVE = (1 << 2), /* let smoke dissolve */ - MOD_SMOKE_DISSOLVE_LOG = (1 << 3), /* using 1/x for dissolve */ - -#ifdef DNA_DEPRECATED - MOD_SMOKE_HIGH_SMOOTH = (1 << 5), /* -- Deprecated -- */ -#endif - MOD_SMOKE_FILE_LOAD = (1 << 6), /* flag for file load */ - MOD_SMOKE_ADAPTIVE_DOMAIN = (1 << 7), -}; - -/* noise */ -#define MOD_SMOKE_NOISEWAVE (1 << 0) -#define MOD_SMOKE_NOISEFFT (1 << 1) -#define MOD_SMOKE_NOISECURL (1 << 2) -/* viewsettings */ -#define MOD_SMOKE_VIEW_SHOW_HIGHRES (1 << 0) - -/* slice method */ -enum { - MOD_SMOKE_SLICE_VIEW_ALIGNED = 0, - MOD_SMOKE_SLICE_AXIS_ALIGNED = 1, -}; - -/* axis aligned method */ -enum { - AXIS_SLICE_FULL = 0, - AXIS_SLICE_SINGLE = 1, -}; - -/* single slice direction */ -enum { - SLICE_AXIS_AUTO = 0, - SLICE_AXIS_X = 1, - SLICE_AXIS_Y = 2, - SLICE_AXIS_Z = 3, -}; - -/* axis aligned method */ -enum { - VOLUME_INTERP_LINEAR = 0, - VOLUME_INTERP_CUBIC = 1, -}; - -enum { - VECTOR_DRAW_NEEDLE = 0, - VECTOR_DRAW_STREAMLINE = 1, -}; - -enum { - FLUID_FIELD_DENSITY = 0, - FLUID_FIELD_HEAT = 1, - FLUID_FIELD_FUEL = 2, - FLUID_FIELD_REACT = 3, - FLUID_FIELD_FLAME = 4, - FLUID_FIELD_VELOCITY_X = 5, - FLUID_FIELD_VELOCITY_Y = 6, - FLUID_FIELD_VELOCITY_Z = 7, - FLUID_FIELD_COLOR_R = 8, - FLUID_FIELD_COLOR_G = 9, - FLUID_FIELD_COLOR_B = 10, - FLUID_FIELD_FORCE_X = 11, - FLUID_FIELD_FORCE_Y = 12, - FLUID_FIELD_FORCE_Z = 13, -}; - -/* cache compression */ -#define SM_CACHE_LIGHT 0 -#define SM_CACHE_HEAVY 1 - -/* domain border collision */ -#define SM_BORDER_OPEN 0 -#define SM_BORDER_VERTICAL 1 -#define SM_BORDER_CLOSED 2 - -/* collision types */ -#define SM_COLL_STATIC 0 -#define SM_COLL_RIGID 1 -#define SM_COLL_ANIMATED 2 - -/* high resolution sampling types */ -#define SM_HRES_NEAREST 0 -#define SM_HRES_LINEAR 1 -#define SM_HRES_FULLSAMPLE 2 - -/* smoke data fields (active_fields) */ -#define SM_ACTIVE_HEAT (1 << 0) -#define SM_ACTIVE_FIRE (1 << 1) -#define SM_ACTIVE_COLORS (1 << 2) -#define SM_ACTIVE_COLOR_SET (1 << 3) - -enum { - VDB_COMPRESSION_BLOSC = 0, - VDB_COMPRESSION_ZIP = 1, - VDB_COMPRESSION_NONE = 2, -}; - -typedef struct SmokeDomainSettings { - /** For fast RNA access. */ - struct SmokeModifierData *smd; - struct FLUID_3D *fluid; - void *fluid_mutex; - struct Collection *fluid_group; - struct Collection *eff_group; // UNUSED - struct Collection *coll_group; // collision objects group - struct WTURBULENCE *wt; // WTURBULENCE object, if active - struct GPUTexture *tex; - struct GPUTexture *tex_wt; - struct GPUTexture *tex_shadow; - struct GPUTexture *tex_flame; - struct GPUTexture *tex_flame_coba; - struct GPUTexture *tex_coba; - struct GPUTexture *tex_field; - struct GPUTexture *tex_velocity_x; - struct GPUTexture *tex_velocity_y; - struct GPUTexture *tex_velocity_z; - float *shadow; - - /* simulation data */ - /** Start point of BB in local space (includes sub-cell shift for adaptive domain.)*/ - float p0[3]; - /** End point of BB in local space. */ - float p1[3]; - /** Difference from object center to grid start point. */ - float dp0[3]; - /** Size of simulation cell in local space. */ - float cell_size[3]; - /** Global size of domain axises. */ - float global_size[3]; - float prev_loc[3]; - /** Current domain shift in simulation cells. */ - int shift[3]; - /** Exact domain shift. */ - float shift_f[3]; - /** - * How much object has shifted since previous smoke frame - * (used to "lock" domain while drawing). - */ - float obj_shift_f[3]; - /** Domain object imat. */ - float imat[4][4]; - /** Domain obmat. */ - float obmat[4][4]; - /** Low res fluid matrix. */ - float fluidmat[4][4]; - /** High res fluid matrix. */ - float fluidmat_wt[4][4]; - - /** Initial "non-adapted" resolution. */ - int base_res[3]; - /** Cell min. */ - int res_min[3]; - /** Cell max. */ - int res_max[3]; - /** Data resolution (res_max-res_min). */ - int res[3]; - int total_cells; - /** 1.0f / res. */ - float dx; - /** Largest domain size. */ - float scale; - - /* user settings */ - int adapt_margin; - int adapt_res; - float adapt_threshold; - - float alpha; - float beta; - /** Wavelet amplification. */ - int amplify; - /** Longest axis on the BB gets this resolution assigned. */ - int maxres; - /** Show up-res or low res, etc. */ - int flags; - int viewsettings; - /** Noise type: wave, curl, anisotropic. */ - short noise; - short diss_percent; - /** In frames. */ - int diss_speed; - float strength; - int res_wt[3]; - float dx_wt; - /* point cache options */ - int cache_comp; - int cache_high_comp; - /* OpenVDB cache options */ - int openvdb_comp; - char cache_file_format; - char data_depth; - char _pad[2]; - - /* Smoke uses only one cache from now on (index [0]), - * but keeping the array for now for reading old files. */ - /** Definition is in DNA_object_force_types.h. */ - struct PointCache *point_cache[2]; - struct ListBase ptcaches[2]; - struct EffectorWeights *effector_weights; - /** How domain border collisions are handled. */ - int border_collisions; - float time_scale; - float vorticity; - int active_fields; - /** Monitor color situation of simulation. */ - float active_color[3]; - int highres_sampling; - - /* flame parameters */ - float burning_rate, flame_smoke, flame_vorticity; - float flame_ignition, flame_max_temp; - float flame_smoke_color[3]; - - /* Display settings */ - char slice_method, axis_slice_method; - char slice_axis, draw_velocity; - float slice_per_voxel; - float slice_depth; - float display_thickness; - - struct ColorBand *coba; - float vector_scale; - char vector_draw_type; - char use_coba; - /** Simulation field used for the color mapping. */ - char coba_field; - char interp_method; - - float clipping; - char _pad3[4]; -} SmokeDomainSettings; - -/* inflow / outflow */ - -/* type */ -#define MOD_SMOKE_FLOW_TYPE_SMOKE 0 -#define MOD_SMOKE_FLOW_TYPE_FIRE 1 -#define MOD_SMOKE_FLOW_TYPE_OUTFLOW 2 -#define MOD_SMOKE_FLOW_TYPE_SMOKEFIRE 3 - -/* flow source */ -#define MOD_SMOKE_FLOW_SOURCE_PARTICLES 0 -#define MOD_SMOKE_FLOW_SOURCE_MESH 1 - -/* flow texture type */ -#define MOD_SMOKE_FLOW_TEXTURE_MAP_AUTO 0 -#define MOD_SMOKE_FLOW_TEXTURE_MAP_UV 1 - -/* flags */ -enum { - /** Old style emission. */ - MOD_SMOKE_FLOW_ABSOLUTE = (1 << 1), - /** Passes particles speed to the smoke. */ - MOD_SMOKE_FLOW_INITVELOCITY = (1 << 2), - /** Use texture to control emission speed. */ - MOD_SMOKE_FLOW_TEXTUREEMIT = (1 << 3), - /** Use specific size for particles instead of closest cell. */ - MOD_SMOKE_FLOW_USE_PART_SIZE = (1 << 4), -}; - -typedef struct SmokeFlowSettings { - /** For fast RNA access. */ - struct SmokeModifierData *smd; - struct Mesh *mesh; - struct ParticleSystem *psys; - struct Tex *noise_texture; - - /* initial velocity */ - /** Previous vertex positions in domain space. */ - float *verts_old; - int numverts; - float vel_multi; // Multiplier for inherited velocity - float vel_normal; - float vel_random; - /* emission */ - float density; - float color[3]; - float fuel_amount; - /** Delta temperature (temp - ambient temp). */ - float temp; - /** Density emitted within mesh volume. */ - float volume_density; - /** Maximum emission distance from mesh surface. */ - float surface_distance; - float particle_size; - int subframes; - /* texture control */ - float texture_size; - float texture_offset; - char _pad[4]; - /** MAX_CUSTOMDATA_LAYER_NAME. */ - char uvlayer_name[64]; - short vgroup_density; - - /** Smoke, flames, both, outflow. */ - short type; - short source; - short texture_type; - /** Absolute emission et.c*/ - int flags; -} SmokeFlowSettings; - -// struct BVHTreeFromMesh *bvh; -// float mat[4][4]; -// float mat_old[4][4]; - -/* collision objects (filled with smoke) */ -typedef struct SmokeCollSettings { - /** For fast RNA access. */ - struct SmokeModifierData *smd; - struct Mesh *mesh; - float *verts_old; - int numverts; - short type; // static = 0, rigid = 1, dynamic = 2 - char _pad[2]; -} SmokeCollSettings; - -#endif diff --git a/source/blender/makesdna/intern/makesdna.c b/source/blender/makesdna/intern/makesdna.c index f4bc79b786a..9a5b2290e10 100644 --- a/source/blender/makesdna/intern/makesdna.c +++ b/source/blender/makesdna/intern/makesdna.c @@ -118,7 +118,7 @@ static const char *includefiles[] = { "DNA_windowmanager_types.h", "DNA_anim_types.h", "DNA_boid_types.h", - "DNA_smoke_types.h", + "DNA_fluid_types.h", "DNA_speaker_types.h", "DNA_movieclip_types.h", "DNA_tracking_types.h", @@ -1579,7 +1579,7 @@ int main(int argc, char **argv) #include "DNA_windowmanager_types.h" #include "DNA_anim_types.h" #include "DNA_boid_types.h" -#include "DNA_smoke_types.h" +#include "DNA_fluid_types.h" #include "DNA_speaker_types.h" #include "DNA_movieclip_types.h" #include "DNA_tracking_types.h" diff --git a/source/blender/makesrna/RNA_access.h b/source/blender/makesrna/RNA_access.h index 696503539a2..4066458ad45 100644 --- a/source/blender/makesrna/RNA_access.h +++ b/source/blender/makesrna/RNA_access.h @@ -262,7 +262,6 @@ extern StructRNA RNA_FloatProperty; extern StructRNA RNA_FloorConstraint; extern StructRNA RNA_FluidFluidSettings; extern StructRNA RNA_FluidSettings; -extern StructRNA RNA_FluidSimulationModifier; extern StructRNA RNA_FollowPathConstraint; extern StructRNA RNA_FreestyleLineSet; extern StructRNA RNA_FreestyleLineStyle; @@ -596,10 +595,10 @@ extern StructRNA RNA_ShrinkwrapModifier; extern StructRNA RNA_SimpleDeformModifier; extern StructRNA RNA_SimplifyGpencilModifier; extern StructRNA RNA_SkinModifier; -extern StructRNA RNA_SmokeCollSettings; -extern StructRNA RNA_SmokeDomainSettings; -extern StructRNA RNA_SmokeFlowSettings; -extern StructRNA RNA_SmokeModifier; +extern StructRNA RNA_FluidEffectorSettings; +extern StructRNA RNA_FluidDomainSettings; +extern StructRNA RNA_FluidFlowSettings; +extern StructRNA RNA_FluidModifier; extern StructRNA RNA_SmoothGpencilModifier; extern StructRNA RNA_SmoothModifier; extern StructRNA RNA_SoftBodyModifier; diff --git a/source/blender/makesrna/intern/CMakeLists.txt b/source/blender/makesrna/intern/CMakeLists.txt index f3ade54d5ec..5e1d94a9a1a 100644 --- a/source/blender/makesrna/intern/CMakeLists.txt +++ b/source/blender/makesrna/intern/CMakeLists.txt @@ -44,7 +44,6 @@ set(DEFSRC rna_depsgraph.c rna_dynamicpaint.c rna_fcurve.c - rna_fluidsim.c rna_gpencil.c rna_gpencil_modifier.c rna_image.c @@ -55,6 +54,7 @@ set(DEFSRC rna_lightprobe.c rna_linestyle.c rna_main.c + rna_fluid.c rna_mask.c rna_material.c rna_mesh.c @@ -77,7 +77,6 @@ set(DEFSRC rna_sculpt_paint.c rna_sequencer.c rna_shader_fx.c - rna_smoke.c rna_sound.c rna_space.c rna_speaker.c @@ -241,16 +240,12 @@ if(WITH_CODEC_FFMPEG) add_definitions(-DWITH_FFMPEG) endif() -if(WITH_MOD_FLUID) - add_definitions(-DWITH_MOD_FLUID) -endif() - if(WITH_FFTW3) add_definitions(-DWITH_FFTW3) endif() -if(WITH_MOD_SMOKE) - add_definitions(-DWITH_SMOKE) +if(WITH_MOD_FLUID) + add_definitions(-DWITH_FLUID) endif() if(WITH_MOD_OCEANSIM) @@ -348,7 +343,7 @@ blender_include_dirs( ../../../../intern/glew-mx ../../../../intern/guardedalloc ../../../../intern/memutil - ../../../../intern/smoke/extern + ../../../../intern/mantaflow/extern ) blender_include_dirs_sys( diff --git a/source/blender/makesrna/intern/makesrna.c b/source/blender/makesrna/intern/makesrna.c index 009a723551e..9b38ca8009c 100644 --- a/source/blender/makesrna/intern/makesrna.c +++ b/source/blender/makesrna/intern/makesrna.c @@ -4231,7 +4231,6 @@ static RNAProcessItem PROCESS_ITEMS[] = { {"rna_curve.c", "rna_curve_api.c", RNA_def_curve}, {"rna_dynamicpaint.c", NULL, RNA_def_dynamic_paint}, {"rna_fcurve.c", "rna_fcurve_api.c", RNA_def_fcurve}, - {"rna_fluidsim.c", NULL, RNA_def_fluidsim}, {"rna_gpencil.c", NULL, RNA_def_gpencil}, {"rna_image.c", "rna_image_api.c", RNA_def_image}, {"rna_key.c", NULL, RNA_def_key}, @@ -4240,6 +4239,7 @@ static RNAProcessItem PROCESS_ITEMS[] = { {"rna_layer.c", NULL, RNA_def_view_layer}, {"rna_linestyle.c", NULL, RNA_def_linestyle}, {"rna_main.c", "rna_main_api.c", RNA_def_main}, + {"rna_fluid.c", NULL, RNA_def_fluid}, {"rna_material.c", "rna_material_api.c", RNA_def_material}, {"rna_mesh.c", "rna_mesh_api.c", RNA_def_mesh}, {"rna_meta.c", "rna_meta_api.c", RNA_def_meta}, @@ -4263,7 +4263,6 @@ static RNAProcessItem PROCESS_ITEMS[] = { {"rna_screen.c", NULL, RNA_def_screen}, {"rna_sculpt_paint.c", NULL, RNA_def_sculpt_paint}, {"rna_sequencer.c", "rna_sequencer_api.c", RNA_def_sequencer}, - {"rna_smoke.c", NULL, RNA_def_smoke}, {"rna_space.c", "rna_space_api.c", RNA_def_space}, {"rna_speaker.c", NULL, RNA_def_speaker}, {"rna_test.c", NULL, RNA_def_test}, diff --git a/source/blender/makesrna/intern/rna_fluidsim.c b/source/blender/makesrna/intern/rna_fluidsim.c deleted file mode 100644 index 2f09b90a81e..00000000000 --- a/source/blender/makesrna/intern/rna_fluidsim.c +++ /dev/null @@ -1,792 +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. - */ - -/** \file - * \ingroup RNA - */ - -#include <stdlib.h> - -#include "DNA_object_fluidsim_types.h" - -#include "BLI_threads.h" -#include "BLI_utildefines.h" -#include "BLI_path_util.h" - -#include "RNA_define.h" - -#include "rna_internal.h" - -#include "WM_api.h" -#include "WM_types.h" - -#ifdef RNA_RUNTIME - -# include "MEM_guardedalloc.h" - -# include "DNA_scene_types.h" -# include "DNA_particle_types.h" - -# include "BKE_fluidsim.h" -# include "BKE_global.h" -# include "BKE_main.h" -# include "BKE_modifier.h" -# include "BKE_particle.h" -# include "BKE_pointcache.h" - -# include "DEG_depsgraph.h" - -static StructRNA *rna_FluidSettings_refine(struct PointerRNA *ptr) -{ - FluidsimSettings *fss = (FluidsimSettings *)ptr->data; - - switch (fss->type) { - case OB_FLUIDSIM_DOMAIN: - return &RNA_DomainFluidSettings; - case OB_FLUIDSIM_FLUID: - return &RNA_FluidFluidSettings; - case OB_FLUIDSIM_OBSTACLE: - return &RNA_ObstacleFluidSettings; - case OB_FLUIDSIM_INFLOW: - return &RNA_InflowFluidSettings; - case OB_FLUIDSIM_OUTFLOW: - return &RNA_OutflowFluidSettings; - case OB_FLUIDSIM_PARTICLE: - return &RNA_ParticleFluidSettings; - case OB_FLUIDSIM_CONTROL: - return &RNA_ControlFluidSettings; - default: - return &RNA_FluidSettings; - } -} - -static void rna_fluid_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr) -{ - Object *ob = (Object *)ptr->owner_id; - - DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY); - WM_main_add_notifier(NC_OBJECT | ND_MODIFIER, ob); -} - -static int fluidsim_find_lastframe(Main *bmain, Object *ob, FluidsimSettings *fss) -{ - char targetFileTest[FILE_MAX]; - char targetFile[FILE_MAX]; - int curFrame = 1; - - BLI_join_dirfile( - targetFile, sizeof(targetFile), fss->surfdataPath, OB_FLUIDSIM_SURF_FINAL_OBJ_FNAME); - BLI_path_abs(targetFile, modifier_path_relbase(bmain, ob)); - - do { - BLI_strncpy(targetFileTest, targetFile, sizeof(targetFileTest)); - BLI_path_frame(targetFileTest, curFrame++, 0); - } while (BLI_exists(targetFileTest)); - - return curFrame - 1; -} - -static void rna_fluid_find_enframe(Main *bmain, Scene *scene, PointerRNA *ptr) -{ - Object *ob = (Object *)ptr->owner_id; - FluidsimModifierData *fluidmd = (FluidsimModifierData *)modifiers_findByType( - ob, eModifierType_Fluidsim); - - if (fluidmd->fss->flag & OB_FLUIDSIM_REVERSE) { - fluidmd->fss->lastgoodframe = fluidsim_find_lastframe(bmain, ob, fluidmd->fss); - } - else { - fluidmd->fss->lastgoodframe = -1; - } - rna_fluid_update(bmain, scene, ptr); -} - -static void rna_FluidSettings_update_type(Main *bmain, Scene *scene, PointerRNA *ptr) -{ - Object *ob = (Object *)ptr->owner_id; - FluidsimModifierData *fluidmd; - ParticleSystemModifierData *psmd; - ParticleSystem *psys, *next_psys; - ParticleSettings *part; - - fluidmd = (FluidsimModifierData *)modifiers_findByType(ob, eModifierType_Fluidsim); - fluidmd->fss->flag &= ~OB_FLUIDSIM_REVERSE; /* clear flag */ - - /* remove fluidsim particle system */ - if (fluidmd->fss->type & OB_FLUIDSIM_PARTICLE) { - for (psys = ob->particlesystem.first; psys; psys = psys->next) { - if (psys->part->type == PART_FLUID) { - break; - } - } - - if (ob->type == OB_MESH && !psys) { - /* add particle system */ - part = BKE_particlesettings_add(bmain, "ParticleSettings"); - psys = MEM_callocN(sizeof(ParticleSystem), "particle_system"); - - part->type = PART_FLUID; - psys->part = part; - psys->pointcache = BKE_ptcache_add(&psys->ptcaches); - BLI_strncpy(psys->name, "FluidParticles", sizeof(psys->name)); - BLI_addtail(&ob->particlesystem, psys); - - /* add modifier */ - psmd = (ParticleSystemModifierData *)modifier_new(eModifierType_ParticleSystem); - BLI_strncpy(psmd->modifier.name, "FluidParticleSystem", sizeof(psmd->modifier.name)); - psmd->psys = psys; - BLI_addtail(&ob->modifiers, psmd); - modifier_unique_name(&ob->modifiers, (ModifierData *)psmd); - } - } - else { - for (psys = ob->particlesystem.first; psys; psys = next_psys) { - next_psys = psys->next; - if (psys->part->type == PART_FLUID) { - /* clear modifier */ - psmd = psys_get_modifier(ob, psys); - BLI_remlink(&ob->modifiers, psmd); - modifier_free((ModifierData *)psmd); - - /* clear particle system */ - BLI_remlink(&ob->particlesystem, psys); - psys_free(ob, psys); - } - } - } - - rna_fluid_update(bmain, scene, ptr); -} - -static void rna_DomainFluidSettings_memory_estimate_get(PointerRNA *ptr, char *value) -{ -# ifndef WITH_MOD_FLUID - (void)ptr; - value[0] = '\0'; -# else - Object *ob = (Object *)ptr->owner_id; - FluidsimSettings *fss = (FluidsimSettings *)ptr->data; - - fluid_estimate_memory(ob, fss, value); -# endif -} - -static int rna_DomainFluidSettings_memory_estimate_length(PointerRNA *ptr) -{ -# ifndef WITH_MOD_FLUID - UNUSED_VARS(ptr); - return 0; -# else - char value[32]; - - rna_DomainFluidSettings_memory_estimate_get(ptr, value); - return strlen(value); -# endif -} - -static char *rna_FluidSettings_path(PointerRNA *ptr) -{ - FluidsimSettings *fss = (FluidsimSettings *)ptr->data; - ModifierData *md = (ModifierData *)fss->fmd; - char name_esc[sizeof(md->name) * 2]; - - BLI_strescape(name_esc, md->name, sizeof(name_esc)); - return BLI_sprintfN("modifiers[\"%s\"].settings", name_esc); -} - -#else - -static void rna_def_fluidsim_slip(StructRNA *srna) -{ - PropertyRNA *prop; - - static const EnumPropertyItem slip_items[] = { - {OB_FSBND_NOSLIP, - "NOSLIP", - 0, - "No Slip", - "Obstacle causes zero normal and tangential velocity (=sticky), default for all " - "(only option for moving objects)"}, - {OB_FSBND_PARTSLIP, - "PARTIALSLIP", - 0, - "Partial Slip", - "Mix between no-slip and free-slip (non moving objects only!)"}, - {OB_FSBND_FREESLIP, - "FREESLIP", - 0, - "Free Slip", - "Obstacle only causes zero normal velocity (=not sticky, non moving objects only!)"}, - {0, NULL, 0, NULL, NULL}, - }; - - prop = RNA_def_property(srna, "slip_type", PROP_ENUM, PROP_NONE); - RNA_def_property_enum_bitflag_sdna(prop, NULL, "typeFlags"); - RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); - RNA_def_property_enum_items(prop, slip_items); - RNA_def_property_ui_text(prop, "Slip Type", ""); - - prop = RNA_def_property(srna, "partial_slip_factor", PROP_FLOAT, PROP_FACTOR); - RNA_def_property_float_sdna(prop, NULL, "partSlipValue"); - RNA_def_property_range(prop, 0.0f, 1.0f); - RNA_def_property_ui_text( - prop, - "Partial Slip Amount", - "Amount of mixing between no- and free-slip, 0 is no slip and 1 is free slip"); -} - -static void rna_def_fluid_mesh_vertices(BlenderRNA *brna) -{ - StructRNA *srna; - PropertyRNA *prop; - - srna = RNA_def_struct(brna, "FluidVertexVelocity", NULL); - RNA_def_struct_ui_text(srna, "Fluid Mesh Velocity", "Velocity of a simulated fluid mesh"); - RNA_def_struct_ui_icon(srna, ICON_VERTEXSEL); - - prop = RNA_def_property(srna, "velocity", PROP_FLOAT, PROP_VELOCITY); - RNA_def_property_array(prop, 3); - RNA_def_property_float_sdna(prop, NULL, "vel"); - RNA_def_property_ui_text(prop, "Velocity", ""); - RNA_def_property_clear_flag(prop, PROP_EDITABLE); -} - -static void rna_def_fluidsim_domain(BlenderRNA *brna) -{ - StructRNA *srna; - PropertyRNA *prop; - - static const EnumPropertyItem quality_items[] = { - {OB_FSDOM_GEOM, "GEOMETRY", 0, "Geometry", "Display geometry"}, - {OB_FSDOM_PREVIEW, "PREVIEW", 0, "Preview", "Display preview quality results"}, - {OB_FSDOM_FINAL, "FINAL", 0, "Final", "Display final quality results"}, - {0, NULL, 0, NULL, NULL}, - }; - - srna = RNA_def_struct(brna, "DomainFluidSettings", "FluidSettings"); - RNA_def_struct_sdna(srna, "FluidsimSettings"); - RNA_def_struct_ui_text(srna, - "Domain Fluid Simulation Settings", - "Fluid simulation settings for the domain of a fluid simulation"); - - /* standard settings */ - - prop = RNA_def_property(srna, "threads", PROP_INT, PROP_NONE); - RNA_def_property_int_sdna(prop, NULL, "threads"); - RNA_def_property_range(prop, 0, BLENDER_MAX_THREADS); - RNA_def_property_ui_text( - prop, "Simulation Threads", "Override number of threads for the simulation, 0 is automatic"); - - prop = RNA_def_property(srna, "resolution", PROP_INT, PROP_NONE); - RNA_def_property_int_sdna(prop, NULL, "resolutionxyz"); - RNA_def_property_range(prop, 1, 1024); - RNA_def_property_ui_text(prop, "Resolution", "Domain resolution in X,Y and Z direction"); - RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); - - prop = RNA_def_property(srna, "preview_resolution", PROP_INT, PROP_NONE); - RNA_def_property_int_sdna(prop, NULL, "previewresxyz"); - RNA_def_property_range(prop, 1, 100); - RNA_def_property_ui_text( - prop, "Preview Resolution", "Preview resolution in X,Y and Z direction"); - RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); - - prop = RNA_def_property(srna, "viewport_display_mode", PROP_ENUM, PROP_NONE); - RNA_def_property_enum_sdna(prop, NULL, "guiDisplayMode"); - RNA_def_property_enum_items(prop, quality_items); - RNA_def_property_ui_text( - prop, "Viewport Display Mode", "How to display the mesh in the viewport"); - RNA_def_property_update(prop, 0, "rna_fluid_update"); - - prop = RNA_def_property(srna, "render_display_mode", PROP_ENUM, PROP_NONE); - RNA_def_property_enum_sdna(prop, NULL, "renderDisplayMode"); - RNA_def_property_enum_items(prop, quality_items); - RNA_def_property_ui_text(prop, "Render Display Mode", "How to display the mesh for rendering"); - - prop = RNA_def_property(srna, "use_reverse_frames", PROP_BOOLEAN, PROP_NONE); - RNA_def_property_boolean_sdna(prop, NULL, "flag", OB_FLUIDSIM_REVERSE); - RNA_def_property_ui_text(prop, "Reverse Frames", "Reverse fluid frames"); - RNA_def_property_update(prop, 0, "rna_fluid_find_enframe"); - - prop = RNA_def_property(srna, "filepath", PROP_STRING, PROP_FILEPATH); - RNA_def_property_string_maxlength(prop, FILE_MAX); - RNA_def_property_string_sdna(prop, NULL, "surfdataPath"); - RNA_def_property_ui_text( - prop, "Path", "Directory (and/or filename prefix) to store baked fluid simulation files in"); - RNA_def_property_update(prop, 0, "rna_fluid_update"); - - prop = RNA_def_property(srna, "memory_estimate", PROP_STRING, PROP_NONE); - RNA_def_property_clear_flag(prop, PROP_EDITABLE); - RNA_def_property_string_funcs(prop, - "rna_DomainFluidSettings_memory_estimate_get", - "rna_DomainFluidSettings_memory_estimate_length", - NULL); - RNA_def_property_ui_text( - prop, "Memory Estimate", "Estimated amount of memory needed for baking the domain"); - - /* advanced settings */ - prop = RNA_def_property(srna, "gravity", PROP_FLOAT, PROP_ACCELERATION); - RNA_def_property_float_sdna(prop, NULL, "grav"); - RNA_def_property_array(prop, 3); - RNA_def_property_range(prop, -1000.1, 1000.1); - RNA_def_property_ui_text(prop, "Gravity", "Gravity in X, Y and Z direction"); - - prop = RNA_def_property(srna, "use_time_override", PROP_BOOLEAN, PROP_NONE); - RNA_def_property_boolean_sdna(prop, NULL, "flag", OB_FLUIDSIM_OVERRIDE_TIME); - RNA_def_property_ui_text( - prop, - "Override Time", - "Use a custom start and end time (in seconds) instead of the scene's timeline"); - - prop = RNA_def_property(srna, "start_time", PROP_FLOAT, PROP_TIME); - RNA_def_property_float_sdna(prop, NULL, "animStart"); - RNA_def_property_range(prop, 0, FLT_MAX); - RNA_def_property_ui_text( - prop, "Start Time", "Simulation time of the first blender frame (in seconds)"); - - prop = RNA_def_property(srna, "end_time", PROP_FLOAT, PROP_TIME); - RNA_def_property_float_sdna(prop, NULL, "animEnd"); - RNA_def_property_range(prop, 0, FLT_MAX); - RNA_def_property_ui_text( - prop, "End Time", "Simulation time of the last blender frame (in seconds)"); - - prop = RNA_def_property(srna, "frame_offset", PROP_INT, PROP_NONE); - RNA_def_property_int_sdna(prop, NULL, "frameOffset"); - RNA_def_property_ui_text(prop, "Cache Offset", "Offset when reading baked cache"); - RNA_def_property_update(prop, NC_OBJECT, "rna_fluid_update"); - - prop = RNA_def_property(srna, "simulation_scale", PROP_FLOAT, PROP_NONE); - RNA_def_property_float_sdna(prop, NULL, "realsize"); - RNA_def_property_range(prop, 0.001, 10); - RNA_def_property_ui_text(prop, "Real World Size", "Size of the simulation domain in meters"); - - prop = RNA_def_property(srna, "simulation_rate", PROP_FLOAT, PROP_NONE); - RNA_def_property_float_sdna(prop, NULL, "animRate"); - RNA_def_property_range(prop, 0.0, 100.0); - RNA_def_property_ui_text( - prop, "Simulation Speed", "Fluid motion rate (0 = stationary, 1 = normal speed)"); - - prop = RNA_def_property(srna, "viscosity_base", PROP_FLOAT, PROP_NONE); - RNA_def_property_float_sdna(prop, NULL, "viscosityValue"); - RNA_def_property_range(prop, 0, 10); - RNA_def_property_ui_text( - prop, - "Viscosity Base", - "Viscosity setting: value that is multiplied by 10 to the power of (exponent*-1)"); - - prop = RNA_def_property(srna, "viscosity_exponent", PROP_INT, PROP_NONE); - RNA_def_property_int_sdna(prop, NULL, "viscosityExponent"); - RNA_def_property_range(prop, 0, 10); - RNA_def_property_ui_text( - prop, - "Viscosity Exponent", - "Negative exponent for the viscosity value (to simplify entering small values " - "e.g. 5*10^-6)"); - - prop = RNA_def_property(srna, "grid_levels", PROP_INT, PROP_NONE); - RNA_def_property_int_sdna(prop, NULL, "maxRefine"); - RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); - RNA_def_property_range(prop, -1, 4); - RNA_def_property_ui_text( - prop, "Grid Levels", "Number of coarsened grids to use (-1 for automatic)"); - - prop = RNA_def_property(srna, "compressibility", PROP_FLOAT, PROP_NONE); - RNA_def_property_float_sdna(prop, NULL, "gstar"); - RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); - RNA_def_property_range(prop, 0.001, 0.1); - RNA_def_property_ui_text(prop, - "Compressibility", - "Allowed compressibility due to gravitational force for standing fluid " - "(directly affects simulation step size)"); - - /* domain boundary settings */ - - rna_def_fluidsim_slip(srna); - - prop = RNA_def_property(srna, "surface_smooth", PROP_FLOAT, PROP_NONE); - RNA_def_property_float_sdna(prop, NULL, "surfaceSmoothing"); - RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); - RNA_def_property_range(prop, 0.0, 5.0); - RNA_def_property_ui_text( - prop, - "Surface Smoothing", - "Amount of surface smoothing (a value of 0 is off, 1 is normal smoothing and " - "more than 1 is extra smoothing)"); - - prop = RNA_def_property(srna, "surface_subdivisions", PROP_INT, PROP_NONE); - RNA_def_property_int_sdna(prop, NULL, "surfaceSubdivs"); - RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); - RNA_def_property_range(prop, 0, 5); - RNA_def_property_ui_text( - prop, - "Surface Subdivisions", - "Number of isosurface subdivisions (this is necessary for the inclusion of particles " - "into the surface generation - WARNING: can lead to longer computation times !)"); - - prop = RNA_def_property(srna, "use_speed_vectors", PROP_BOOLEAN, PROP_NONE); - RNA_def_property_boolean_negative_sdna(prop, NULL, "domainNovecgen", 0); - RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); - RNA_def_property_ui_text( - prop, "Generate Speed Vectors", "Generate speed vectors for vector blur"); - - /* no collision object surface */ - prop = RNA_def_property(srna, "use_surface_noobs", PROP_BOOLEAN, PROP_NONE); - RNA_def_property_boolean_sdna(prop, NULL, "typeFlags", OB_FSSG_NOOBS); - RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); - RNA_def_property_ui_text( - prop, - "Remove Air Bubbles", - "Removes the air gap between fluid surface and obstacles - WARNING: Can result " - "in a dissolving surface in other areas"); - - /* particles */ - - prop = RNA_def_property(srna, "tracer_particles", PROP_INT, PROP_NONE); - RNA_def_property_int_sdna(prop, NULL, "generateTracers"); - RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); - RNA_def_property_range(prop, 0, 10000); - RNA_def_property_ui_text(prop, "Tracer Particles", "Number of tracer particles to generate"); - - prop = RNA_def_property(srna, "generate_particles", PROP_FLOAT, PROP_NONE); - RNA_def_property_float_sdna(prop, NULL, "generateParticles"); - RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); - RNA_def_property_range(prop, 0.0, 10.0); - RNA_def_property_ui_text( - prop, "Generate Particles", "Amount of particles to generate (0=off, 1=normal, >1=more)"); - - /* simulated fluid mesh data */ - prop = RNA_def_property(srna, "fluid_mesh_vertices", PROP_COLLECTION, PROP_NONE); - RNA_def_property_collection_sdna(prop, NULL, "meshVelocities", "totvert"); - RNA_def_property_struct_type(prop, "FluidVertexVelocity"); - RNA_def_property_ui_text( - prop, "Fluid Mesh Vertices", "Vertices of the fluid mesh generated by simulation"); - - rna_def_fluid_mesh_vertices(brna); -} - -static void rna_def_fluidsim_volume(StructRNA *srna) -{ - PropertyRNA *prop; - - static const EnumPropertyItem volume_type_items[] = { - {1, "VOLUME", 0, "Volume", "Use only the inner volume of the mesh"}, - {2, "SHELL", 0, "Shell", "Use only the outer shell of the mesh"}, - {3, "BOTH", 0, "Both", "Use both the inner volume and the outer shell of the mesh"}, - {0, NULL, 0, NULL, NULL}, - }; - - prop = RNA_def_property(srna, "volume_initialization", PROP_ENUM, PROP_NONE); - RNA_def_property_enum_bitflag_sdna(prop, NULL, "volumeInitType"); - RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); - RNA_def_property_enum_items(prop, volume_type_items); - RNA_def_property_ui_text( - prop, - "Volume Initialization", - "Volume initialization type " - "(WARNING: complex volumes might require too much memory and break simulation)"); - - prop = RNA_def_property(srna, "use_animated_mesh", PROP_BOOLEAN, PROP_NONE); - RNA_def_property_boolean_sdna(prop, NULL, "domainNovecgen", 0); - RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); - RNA_def_property_ui_text( - prop, - "Export Animated Mesh", - "Export this mesh as an animated one (slower and enforces No Slip, only use if really " - "necessary [e.g. armatures or parented objects], animated pos/rot/scale F-Curves " - "do not require it)"); -} - -static void rna_def_fluidsim_active(StructRNA *srna) -{ - PropertyRNA *prop; - - prop = RNA_def_property(srna, "use", PROP_BOOLEAN, PROP_NONE); - RNA_def_property_boolean_sdna(prop, NULL, "flag", OB_FLUIDSIM_ACTIVE); - RNA_def_property_ui_text(prop, "Enabled", "Object contributes to the fluid simulation"); -} - -static void rna_def_fluidsim_fluid(BlenderRNA *brna) -{ - StructRNA *srna; - PropertyRNA *prop; - - srna = RNA_def_struct(brna, "FluidFluidSettings", "FluidSettings"); - RNA_def_struct_sdna(srna, "FluidsimSettings"); - RNA_def_struct_ui_text(srna, - "Fluid Fluid Simulation Settings", - "Fluid simulation settings for the fluid in the simulation"); - - rna_def_fluidsim_active(srna); - rna_def_fluidsim_volume(srna); - - prop = RNA_def_property(srna, "initial_velocity", PROP_FLOAT, PROP_VELOCITY); - RNA_def_property_float_sdna(prop, NULL, "iniVelx"); - RNA_def_property_array(prop, 3); - RNA_def_property_range(prop, -1000.1, 1000.1); - RNA_def_property_ui_text(prop, "Initial Velocity", "Initial velocity of fluid"); -} - -static void rna_def_fluidsim_obstacle(BlenderRNA *brna) -{ - StructRNA *srna; - PropertyRNA *prop; - - srna = RNA_def_struct(brna, "ObstacleFluidSettings", "FluidSettings"); - RNA_def_struct_sdna(srna, "FluidsimSettings"); - RNA_def_struct_ui_text(srna, - "Obstacle Fluid Simulation Settings", - "Fluid simulation settings for obstacles in the simulation"); - - rna_def_fluidsim_active(srna); - rna_def_fluidsim_volume(srna); - rna_def_fluidsim_slip(srna); - - prop = RNA_def_property(srna, "impact_factor", PROP_FLOAT, PROP_NONE); - RNA_def_property_float_sdna(prop, NULL, "surfaceSmoothing"); - RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); - RNA_def_property_range(prop, -2.0, 10.0); - RNA_def_property_ui_text( - prop, - "Impact Factor", - "This is an unphysical value for moving objects - it controls the impact an obstacle " - "has on the fluid, =0 behaves a bit like outflow (deleting fluid), =1 is default, " - "while >1 results in high forces (can be used to tweak total mass)"); -} - -static void rna_def_fluidsim_inflow(BlenderRNA *brna) -{ - StructRNA *srna; - PropertyRNA *prop; - - srna = RNA_def_struct(brna, "InflowFluidSettings", "FluidSettings"); - RNA_def_struct_sdna(srna, "FluidsimSettings"); - RNA_def_struct_ui_text(srna, - "Inflow Fluid Simulation Settings", - "Fluid simulation settings for objects adding fluids in the simulation"); - - rna_def_fluidsim_active(srna); - rna_def_fluidsim_volume(srna); - - prop = RNA_def_property(srna, "inflow_velocity", PROP_FLOAT, PROP_VELOCITY); - RNA_def_property_float_sdna(prop, NULL, "iniVelx"); - RNA_def_property_array(prop, 3); - RNA_def_property_range(prop, -1000.1, 1000.1); - RNA_def_property_ui_text(prop, "Inflow Velocity", "Initial velocity of fluid"); - - prop = RNA_def_property(srna, "use_local_coords", PROP_BOOLEAN, PROP_NONE); - RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); - RNA_def_property_boolean_sdna(prop, NULL, "typeFlags", OB_FSINFLOW_LOCALCOORD); - RNA_def_property_ui_text( - prop, "Local Coordinates", "Use local coordinates for inflow (e.g. for rotating objects)"); -} - -static void rna_def_fluidsim_outflow(BlenderRNA *brna) -{ - StructRNA *srna; - - srna = RNA_def_struct(brna, "OutflowFluidSettings", "FluidSettings"); - RNA_def_struct_sdna(srna, "FluidsimSettings"); - RNA_def_struct_ui_text( - srna, - "Outflow Fluid Simulation Settings", - "Fluid simulation settings for objects removing fluids from the simulation"); - - rna_def_fluidsim_active(srna); - rna_def_fluidsim_volume(srna); -} - -static void rna_def_fluidsim_particle(BlenderRNA *brna) -{ - StructRNA *srna; - PropertyRNA *prop; - - srna = RNA_def_struct(brna, "ParticleFluidSettings", "FluidSettings"); - RNA_def_struct_sdna(srna, "FluidsimSettings"); - RNA_def_struct_ui_text(srna, - "Particle Fluid Simulation Settings", - "Fluid simulation settings for objects storing fluid particles generated" - " by the simulation"); - - prop = RNA_def_property(srna, "use_drops", PROP_BOOLEAN, PROP_NONE); - RNA_def_property_boolean_sdna(prop, NULL, "typeFlags", OB_FSPART_DROP); - RNA_def_property_ui_text(prop, "Drops", "Show drop particles"); - - prop = RNA_def_property(srna, "use_floats", PROP_BOOLEAN, PROP_NONE); - RNA_def_property_boolean_sdna(prop, NULL, "typeFlags", OB_FSPART_FLOAT); - RNA_def_property_ui_text(prop, "Floats", "Show floating foam particles"); - - prop = RNA_def_property(srna, "show_tracer", PROP_BOOLEAN, PROP_NONE); - RNA_def_property_boolean_sdna(prop, NULL, "typeFlags", OB_FSPART_TRACER); - RNA_def_property_ui_text(prop, "Tracer", "Show tracer particles"); - - prop = RNA_def_property(srna, "particle_influence", PROP_FLOAT, PROP_NONE); - RNA_def_property_float_sdna(prop, NULL, "particleInfSize"); - RNA_def_property_range(prop, 0.0, 2.0); - RNA_def_property_ui_text( - prop, - "Particle Influence", - "Amount of particle size scaling: 0=off (all same size), 1=full (range 0.2-2.0), " - ">1=stronger"); - - prop = RNA_def_property(srna, "alpha_influence", PROP_FLOAT, PROP_NONE); - RNA_def_property_float_sdna(prop, NULL, "particleInfAlpha"); - RNA_def_property_range(prop, 0.0, 2.0); - RNA_def_property_ui_text( - prop, - "Alpha Influence", - "Amount of particle alpha change, inverse of size influence: 0=off (all same alpha), " - "1=full (larger particles get lower alphas, smaller ones higher values)"); - - prop = RNA_def_property(srna, "filepath", PROP_STRING, PROP_FILEPATH); - RNA_def_property_string_maxlength(prop, FILE_MAX); - RNA_def_property_string_sdna(prop, NULL, "surfdataPath"); - RNA_def_property_ui_text( - prop, "Path", "Directory (and/or filename prefix) to store and load particles from"); - RNA_def_property_update(prop, 0, "rna_fluid_update"); -} - -static void rna_def_fluidsim_control(BlenderRNA *brna) -{ - StructRNA *srna; - PropertyRNA *prop; - - srna = RNA_def_struct(brna, "ControlFluidSettings", "FluidSettings"); - RNA_def_struct_sdna(srna, "FluidsimSettings"); - RNA_def_struct_ui_text( - srna, - "Control Fluid Simulation Settings", - "Fluid simulation settings for objects controlling the motion of fluid in the simulation"); - - rna_def_fluidsim_active(srna); - - prop = RNA_def_property(srna, "start_time", PROP_FLOAT, PROP_TIME); - RNA_def_property_float_sdna(prop, NULL, "cpsTimeStart"); - RNA_def_property_range(prop, 0.0, FLT_MAX); - RNA_def_property_ui_text(prop, "Start Time", "Time when the control particles are activated"); - - prop = RNA_def_property(srna, "end_time", PROP_FLOAT, PROP_TIME); - RNA_def_property_float_sdna(prop, NULL, "cpsTimeEnd"); - RNA_def_property_range(prop, 0.0, FLT_MAX); - RNA_def_property_ui_text(prop, "End Time", "Time when the control particles are deactivated"); - - prop = RNA_def_property(srna, "attraction_strength", PROP_FLOAT, PROP_NONE); - RNA_def_property_float_sdna(prop, NULL, "attractforceStrength"); - RNA_def_property_range(prop, -10.0, 10.0); - RNA_def_property_ui_text(prop, - "Attraction Strength", - "Force strength for directional attraction towards the control object"); - - prop = RNA_def_property(srna, "attraction_radius", PROP_FLOAT, PROP_NONE); - RNA_def_property_float_sdna(prop, NULL, "attractforceRadius"); - RNA_def_property_range(prop, 0.0, 10.0); - RNA_def_property_ui_text( - prop, "Attraction Radius", "Force field radius around the control object"); - - prop = RNA_def_property(srna, "velocity_strength", PROP_FLOAT, PROP_NONE); - RNA_def_property_float_sdna(prop, NULL, "velocityforceStrength"); - RNA_def_property_range(prop, 0.0, 10.0); - RNA_def_property_ui_text( - prop, - "Velocity Strength", - "Force strength of how much of the control object's velocity is influencing the " - "fluid velocity"); - - prop = RNA_def_property(srna, "velocity_radius", PROP_FLOAT, PROP_NONE); - RNA_def_property_float_sdna(prop, NULL, "velocityforceRadius"); - RNA_def_property_range(prop, 0.0, 10.0); - RNA_def_property_ui_text( - prop, "Velocity Radius", "Force field radius around the control object"); - - prop = RNA_def_property(srna, "quality", PROP_FLOAT, PROP_NONE); - RNA_def_property_float_sdna(prop, NULL, "cpsQuality"); - RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); - RNA_def_property_range(prop, 5.0, 100.0); - RNA_def_property_ui_text( - prop, "Quality", "Quality which is used for object sampling (higher = better but slower)"); - - prop = RNA_def_property(srna, "use_reverse_frames", PROP_BOOLEAN, PROP_NONE); - RNA_def_property_boolean_sdna(prop, NULL, "flag", OB_FLUIDSIM_REVERSE); - RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); - RNA_def_property_ui_text(prop, "Reverse Frames", "Reverse control object movement"); - RNA_def_property_update(prop, 0, "rna_fluid_find_enframe"); -} - -void RNA_def_fluidsim(BlenderRNA *brna) -{ - StructRNA *srna; - PropertyRNA *prop; - - static const EnumPropertyItem prop_fluid_type_items[] = { - {OB_FLUIDSIM_ENABLE, "NONE", 0, "None", ""}, - {OB_FLUIDSIM_DOMAIN, - "DOMAIN", - 0, - "Domain", - "Bounding box of this object represents the computational domain of the " - "fluid simulation"}, - {OB_FLUIDSIM_FLUID, - "FLUID", - 0, - "Fluid", - "Object represents a volume of fluid in the simulation"}, - {OB_FLUIDSIM_OBSTACLE, "OBSTACLE", 0, "Obstacle", "Object is a fixed obstacle"}, - {OB_FLUIDSIM_INFLOW, "INFLOW", 0, "Inflow", "Object adds fluid to the simulation"}, - {OB_FLUIDSIM_OUTFLOW, "OUTFLOW", 0, "Outflow", "Object removes fluid from the simulation"}, - {OB_FLUIDSIM_PARTICLE, - "PARTICLE", - 0, - "Particle", - "Object is made a particle system to display particles generated by a " - "fluidsim domain object"}, - {OB_FLUIDSIM_CONTROL, - "CONTROL", - 0, - "Control", - "Object is made a fluid control mesh, which influences the fluid"}, - {0, NULL, 0, NULL, NULL}, - }; - - srna = RNA_def_struct(brna, "FluidSettings", NULL); - RNA_def_struct_sdna(srna, "FluidsimSettings"); - RNA_def_struct_refine_func(srna, "rna_FluidSettings_refine"); - RNA_def_struct_path_func(srna, "rna_FluidSettings_path"); - RNA_def_struct_ui_text(srna, - "Fluid Simulation Settings", - "Fluid simulation settings for an object taking part in the simulation"); - - prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE); - RNA_def_property_enum_bitflag_sdna(prop, NULL, "type"); - RNA_def_property_enum_items(prop, prop_fluid_type_items); - RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); - RNA_def_property_ui_text(prop, "Type", "Type of participation in the fluid simulation"); - RNA_def_property_update(prop, 0, "rna_FluidSettings_update_type"); - -# if 0 - prop = RNA_def_property(srna, "ipo", PROP_POINTER, PROP_NONE); - RNA_def_property_ui_text(prop, "IPO Curves", "IPO curves used by fluid simulation settings"); -# endif - - /* types */ - - rna_def_fluidsim_domain(brna); - rna_def_fluidsim_fluid(brna); - rna_def_fluidsim_obstacle(brna); - rna_def_fluidsim_inflow(brna); - rna_def_fluidsim_outflow(brna); - rna_def_fluidsim_particle(brna); - rna_def_fluidsim_control(brna); -} - -#endif diff --git a/source/blender/makesrna/intern/rna_gpencil_modifier.c b/source/blender/makesrna/intern/rna_gpencil_modifier.c index 7aa3ee60c5a..59baf7e4cbf 100644 --- a/source/blender/makesrna/intern/rna_gpencil_modifier.c +++ b/source/blender/makesrna/intern/rna_gpencil_modifier.c @@ -43,7 +43,7 @@ #include "BKE_mesh_mapping.h" #include "BKE_mesh_remap.h" #include "BKE_multires.h" -#include "BKE_smoke.h" /* For smokeModifier_free & smokeModifier_createType */ +#include "BKE_fluid.h" /* For fluidModifier_free & fluidModifier_createType */ #include "RNA_access.h" #include "RNA_define.h" @@ -174,7 +174,7 @@ static const EnumPropertyItem rna_enum_time_mode_items[] = { # include "DNA_particle_types.h" # include "DNA_curve_types.h" -# include "DNA_smoke_types.h" +# include "DNA_fluid_types.h" # include "BKE_cachefile.h" # include "BKE_context.h" diff --git a/source/blender/makesrna/intern/rna_internal.h b/source/blender/makesrna/intern/rna_internal.h index 94394a4826b..46455a43b2e 100644 --- a/source/blender/makesrna/intern/rna_internal.h +++ b/source/blender/makesrna/intern/rna_internal.h @@ -155,7 +155,6 @@ void RNA_def_controller(struct BlenderRNA *brna); void RNA_def_curve(struct BlenderRNA *brna); void RNA_def_depsgraph(struct BlenderRNA *brna); void RNA_def_dynamic_paint(struct BlenderRNA *brna); -void RNA_def_fluidsim(struct BlenderRNA *brna); void RNA_def_fcurve(struct BlenderRNA *brna); void RNA_def_gpencil(struct BlenderRNA *brna); void RNA_def_greasepencil_modifier(struct BlenderRNA *brna); @@ -188,7 +187,7 @@ void RNA_def_view_layer(struct BlenderRNA *brna); void RNA_def_screen(struct BlenderRNA *brna); void RNA_def_sculpt_paint(struct BlenderRNA *brna); void RNA_def_sequencer(struct BlenderRNA *brna); -void RNA_def_smoke(struct BlenderRNA *brna); +void RNA_def_fluid(struct BlenderRNA *brna); void RNA_def_space(struct BlenderRNA *brna); void RNA_def_speaker(struct BlenderRNA *brna); void RNA_def_test(struct BlenderRNA *brna); diff --git a/source/blender/makesrna/intern/rna_modifier.c b/source/blender/makesrna/intern/rna_modifier.c index 3759b721152..6e5e38ab52e 100644 --- a/source/blender/makesrna/intern/rna_modifier.c +++ b/source/blender/makesrna/intern/rna_modifier.c @@ -45,7 +45,7 @@ #include "BKE_mesh_remap.h" #include "BKE_multires.h" #include "BKE_ocean.h" -#include "BKE_smoke.h" /* For smokeModifier_free & smokeModifier_createType */ +#include "BKE_fluid.h" /* For fluidModifier_free & fluidModifier_createType */ #include "RNA_access.h" #include "RNA_define.h" @@ -275,7 +275,6 @@ const EnumPropertyItem rna_enum_object_modifier_type_items[] = { ICON_MOD_EXPLODE, "Explode", "Break apart the mesh faces and let them follow particles"}, - {eModifierType_Fluidsim, "FLUID_SIMULATION", ICON_MOD_FLUIDSIM, "Fluid Simulation", ""}, {eModifierType_Ocean, "OCEAN", ICON_MOD_OCEAN, "Ocean", "Generate a moving ocean surface"}, {eModifierType_ParticleInstance, "PARTICLE_INSTANCE", @@ -287,7 +286,7 @@ const EnumPropertyItem rna_enum_object_modifier_type_items[] = { ICON_MOD_PARTICLES, "Particle System", "Spawn particles from the shape"}, - {eModifierType_Smoke, "SMOKE", ICON_MOD_SMOKE, "Smoke", ""}, + {eModifierType_Fluid, "FLUID", ICON_MOD_FLUIDSIM, "Fluid Simulation", ""}, {eModifierType_Softbody, "SOFT_BODY", ICON_MOD_SOFT, "Soft Body", ""}, {eModifierType_Surface, "SURFACE", ICON_MODIFIER, "Surface", ""}, {0, NULL, 0, NULL, NULL}, @@ -580,7 +579,7 @@ const EnumPropertyItem rna_enum_axis_flag_xyz_items[] = { #ifdef RNA_RUNTIME # include "DNA_particle_types.h" # include "DNA_curve_types.h" -# include "DNA_smoke_types.h" +# include "DNA_fluid_types.h" # include "BKE_cachefile.h" # include "BKE_context.h" @@ -661,8 +660,6 @@ static StructRNA *rna_Modifier_refine(struct PointerRNA *ptr) return &RNA_BevelModifier; case eModifierType_Shrinkwrap: return &RNA_ShrinkwrapModifier; - case eModifierType_Fluidsim: - return &RNA_FluidSimulationModifier; case eModifierType_Mask: return &RNA_MaskModifier; case eModifierType_SimpleDeform: @@ -671,8 +668,8 @@ static StructRNA *rna_Modifier_refine(struct PointerRNA *ptr) return &RNA_MultiresModifier; case eModifierType_Surface: return &RNA_SurfaceModifier; - case eModifierType_Smoke: - return &RNA_SmokeModifier; + case eModifierType_Fluid: + return &RNA_FluidModifier; case eModifierType_Solidify: return &RNA_SolidifyModifier; case eModifierType_Screw: @@ -720,6 +717,8 @@ static StructRNA *rna_Modifier_refine(struct PointerRNA *ptr) case eModifierType_WeightedNormal: return &RNA_WeightedNormalModifier; /* Default */ + case eModifierType_Fluidsim: /* deprecated */ + case eModifierType_Smoke: case eModifierType_None: case eModifierType_ShapeKey: case NUM_MODIFIER_TYPES: @@ -1029,25 +1028,25 @@ static void rna_UVProjector_object_set(PointerRNA *ptr, /* Other rna callbacks */ -static void rna_Smoke_set_type(Main *bmain, Scene *scene, PointerRNA *ptr) +static void rna_fluid_set_type(Main *bmain, Scene *scene, PointerRNA *ptr) { - SmokeModifierData *smd = (SmokeModifierData *)ptr->data; + FluidModifierData *mmd = (FluidModifierData *)ptr->data; Object *ob = (Object *)ptr->owner_id; /* nothing changed */ - if ((smd->type & MOD_SMOKE_TYPE_DOMAIN) && smd->domain) { + if ((mmd->type & MOD_FLUID_TYPE_DOMAIN) && mmd->domain) { return; } - smokeModifier_free(smd); /* XXX TODO: completely free all 3 pointers */ - smokeModifier_createType(smd); /* create regarding of selected type */ + fluidModifier_free(mmd); /* XXX TODO: completely free all 3 pointers */ + fluidModifier_createType(mmd); /* create regarding of selected type */ - switch (smd->type) { - case MOD_SMOKE_TYPE_DOMAIN: + switch (mmd->type) { + case MOD_FLUID_TYPE_DOMAIN: ob->dt = OB_WIRE; break; - case MOD_SMOKE_TYPE_FLOW: - case MOD_SMOKE_TYPE_COLL: + case MOD_FLUID_TYPE_FLOW: + case MOD_FLUID_TYPE_EFFEC: case 0: default: break; @@ -3607,23 +3606,23 @@ static void rna_def_modifier_cloth(BlenderRNA *brna) RNA_def_property_ui_text(prop, "Hair Grid Resolution", ""); } -static void rna_def_modifier_smoke(BlenderRNA *brna) +static void rna_def_modifier_fluid(BlenderRNA *brna) { StructRNA *srna; PropertyRNA *prop; - static const EnumPropertyItem prop_smoke_type_items[] = { + static const EnumPropertyItem prop_fluid_type_items[] = { {0, "NONE", 0, "None", ""}, - {MOD_SMOKE_TYPE_DOMAIN, "DOMAIN", 0, "Domain", ""}, - {MOD_SMOKE_TYPE_FLOW, "FLOW", 0, "Flow", "Inflow/Outflow"}, - {MOD_SMOKE_TYPE_COLL, "COLLISION", 0, "Collision", ""}, + {MOD_FLUID_TYPE_DOMAIN, "DOMAIN", 0, "Domain", ""}, + {MOD_FLUID_TYPE_FLOW, "FLOW", 0, "Flow", "Inflow/Outflow"}, + {MOD_FLUID_TYPE_EFFEC, "EFFECTOR", 0, "Effector", ""}, {0, NULL, 0, NULL, NULL}, }; - srna = RNA_def_struct(brna, "SmokeModifier", "Modifier"); - RNA_def_struct_ui_text(srna, "Smoke Modifier", "Smoke simulation modifier"); - RNA_def_struct_sdna(srna, "SmokeModifierData"); - RNA_def_struct_ui_icon(srna, ICON_MOD_SMOKE); + srna = RNA_def_struct(brna, "FluidModifier", "Modifier"); + RNA_def_struct_ui_text(srna, "Fluid Modifier", "Fluid simulation modifier"); + RNA_def_struct_sdna(srna, "FluidModifierData"); + RNA_def_struct_ui_icon(srna, ICON_MOD_FLUIDSIM); prop = RNA_def_property(srna, "domain_settings", PROP_POINTER, PROP_NONE); RNA_def_property_pointer_sdna(prop, NULL, "domain"); @@ -3633,16 +3632,16 @@ static void rna_def_modifier_smoke(BlenderRNA *brna) RNA_def_property_pointer_sdna(prop, NULL, "flow"); RNA_def_property_ui_text(prop, "Flow Settings", ""); - prop = RNA_def_property(srna, "coll_settings", PROP_POINTER, PROP_NONE); - RNA_def_property_pointer_sdna(prop, NULL, "coll"); - RNA_def_property_ui_text(prop, "Collision Settings", ""); + prop = RNA_def_property(srna, "effec_settings", PROP_POINTER, PROP_NONE); + RNA_def_property_pointer_sdna(prop, NULL, "effector"); + RNA_def_property_ui_text(prop, "Effector Settings", ""); - prop = RNA_def_property(srna, "smoke_type", PROP_ENUM, PROP_NONE); + prop = RNA_def_property(srna, "fluid_type", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "type"); - RNA_def_property_enum_items(prop, prop_smoke_type_items); + RNA_def_property_enum_items(prop, prop_fluid_type_items); RNA_def_property_ui_text(prop, "Type", ""); RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); - RNA_def_property_update(prop, 0, "rna_Smoke_set_type"); + RNA_def_property_update(prop, 0, "rna_fluid_set_type"); } static void rna_def_modifier_dynamic_paint(BlenderRNA *brna) @@ -4069,23 +4068,6 @@ static void rna_def_modifier_shrinkwrap(BlenderRNA *brna) RNA_def_property_update(prop, 0, "rna_Modifier_update"); } -static void rna_def_modifier_fluidsim(BlenderRNA *brna) -{ - StructRNA *srna; - PropertyRNA *prop; - - srna = RNA_def_struct(brna, "FluidSimulationModifier", "Modifier"); - RNA_def_struct_ui_text(srna, "Fluid Simulation Modifier", "Fluid simulation modifier"); - RNA_def_struct_sdna(srna, "FluidsimModifierData"); - RNA_def_struct_ui_icon(srna, ICON_MOD_FLUIDSIM); - - prop = RNA_def_property(srna, "settings", PROP_POINTER, PROP_NONE); - RNA_def_property_flag(prop, PROP_NEVER_NULL); - RNA_def_property_pointer_sdna(prop, NULL, "fss"); - RNA_def_property_ui_text( - prop, "Settings", "Settings for how this object is used in the fluid simulation"); -} - static void rna_def_modifier_mask(BlenderRNA *brna) { StructRNA *srna; @@ -6388,13 +6370,12 @@ void RNA_def_modifier(BlenderRNA *brna) rna_def_modifier_collision(brna); rna_def_modifier_bevel(brna); rna_def_modifier_shrinkwrap(brna); - rna_def_modifier_fluidsim(brna); rna_def_modifier_mask(brna); rna_def_modifier_simpledeform(brna); rna_def_modifier_warp(brna); rna_def_modifier_multires(brna); rna_def_modifier_surface(brna); - rna_def_modifier_smoke(brna); + rna_def_modifier_fluid(brna); rna_def_modifier_solidify(brna); rna_def_modifier_screw(brna); rna_def_modifier_uvwarp(brna); diff --git a/source/blender/makesrna/intern/rna_object_force.c b/source/blender/makesrna/intern/rna_object_force.c index 16d70e21ec2..559b8ca4cc1 100644 --- a/source/blender/makesrna/intern/rna_object_force.c +++ b/source/blender/makesrna/intern/rna_object_force.c @@ -25,7 +25,7 @@ #include "DNA_object_force_types.h" #include "DNA_particle_types.h" #include "DNA_scene_types.h" -#include "DNA_smoke_types.h" +#include "DNA_fluid_types.h" #include "RNA_define.h" #include "RNA_enum_types.h" @@ -738,10 +738,10 @@ static char *rna_EffectorWeight_path(PointerRNA *ptr) } /* check smoke modifier */ - md = (ModifierData *)modifiers_findByType(ob, eModifierType_Smoke); + md = (ModifierData *)modifiers_findByType(ob, eModifierType_Fluid); if (md) { - SmokeModifierData *smd = (SmokeModifierData *)md; - if (smd->domain->effector_weights == ew) { + FluidModifierData *mmd = (FluidModifierData *)md; + if (mmd->domain->effector_weights == ew) { char name_esc[sizeof(md->name) * 2]; BLI_strescape(name_esc, md->name, sizeof(name_esc)); return BLI_sprintfN("modifiers[\"%s\"].settings.effector_weights", name_esc); diff --git a/source/blender/makesrna/intern/rna_particle.c b/source/blender/makesrna/intern/rna_particle.c index 211d9e19ab4..51df843947d 100644 --- a/source/blender/makesrna/intern/rna_particle.c +++ b/source/blender/makesrna/intern/rna_particle.c @@ -950,11 +950,12 @@ static float rna_PartSetting_linelenhead_get(struct PointerRNA *ptr) return settings->draw_line[1]; } -static bool rna_PartSettings_is_fluid_get(PointerRNA *ptr) +static int rna_PartSettings_is_fluid_get(PointerRNA *ptr) { ParticleSettings *part = (ParticleSettings *)ptr->data; - return part->type == PART_FLUID; + return (part->type & (PART_FLUID_FLIP | PART_FLUID_SPRAY | PART_FLUID_BUBBLE | PART_FLUID_FOAM | + PART_FLUID_TRACER)); } static void rna_ParticleSettings_use_clump_curve_update(Main *bmain, Scene *scene, PointerRNA *ptr) diff --git a/source/blender/makesrna/intern/rna_smoke.c b/source/blender/makesrna/intern/rna_smoke.c deleted file mode 100644 index c00cc789eff..00000000000 --- a/source/blender/makesrna/intern/rna_smoke.c +++ /dev/null @@ -1,1218 +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. - */ - -/** \file - * \ingroup RNA - */ - -#include <stdlib.h> -#include <limits.h> - -#include "BLI_sys_types.h" - -#include "RNA_define.h" -#include "RNA_enum_types.h" - -#include "rna_internal.h" - -#include "BKE_modifier.h" -#include "BKE_smoke.h" -#include "BKE_pointcache.h" - -#include "DNA_modifier_types.h" -#include "DNA_object_force_types.h" -#include "DNA_object_types.h" -#include "DNA_scene_types.h" -#include "DNA_smoke_types.h" - -#include "WM_types.h" - -#ifdef RNA_RUNTIME - -# include "BLI_threads.h" - -# include "BKE_colorband.h" -# include "BKE_context.h" -# include "BKE_particle.h" - -# include "DEG_depsgraph.h" -# include "DEG_depsgraph_build.h" - -# include "smoke_API.h" - -static void rna_Smoke_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr) -{ - DEG_id_tag_update(ptr->owner_id, ID_RECALC_GEOMETRY); -} - -static void rna_Smoke_dependency_update(Main *bmain, Scene *scene, PointerRNA *ptr) -{ - rna_Smoke_update(bmain, scene, ptr); - DEG_relations_tag_update(bmain); -} - -static void rna_Smoke_resetCache(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr) -{ - SmokeDomainSettings *settings = (SmokeDomainSettings *)ptr->data; - if (settings->smd && settings->smd->domain) { - settings->point_cache[0]->flag |= PTCACHE_OUTDATED; - } - DEG_id_tag_update(ptr->owner_id, ID_RECALC_GEOMETRY); -} - -static void rna_Smoke_cachetype_set(struct PointerRNA *ptr, int value) -{ - SmokeDomainSettings *settings = (SmokeDomainSettings *)ptr->data; - Object *ob = (Object *)ptr->owner_id; - - if (value != settings->cache_file_format) { - /* Clear old caches. */ - PTCacheID id; - BKE_ptcache_id_from_smoke(&id, ob, settings->smd); - BKE_ptcache_id_clear(&id, PTCACHE_CLEAR_ALL, 0); - - settings->cache_file_format = value; - } -} - -static void rna_Smoke_reset(Main *bmain, Scene *scene, PointerRNA *ptr) -{ - SmokeDomainSettings *settings = (SmokeDomainSettings *)ptr->data; - - smokeModifier_reset(settings->smd); - rna_Smoke_resetCache(bmain, scene, ptr); - - rna_Smoke_update(bmain, scene, ptr); -} - -static void rna_Smoke_reset_dependency(Main *bmain, Scene *scene, PointerRNA *ptr) -{ - SmokeDomainSettings *settings = (SmokeDomainSettings *)ptr->data; - - smokeModifier_reset(settings->smd); - - if (settings->smd && settings->smd->domain) { - settings->smd->domain->point_cache[0]->flag |= PTCACHE_OUTDATED; - } - - rna_Smoke_dependency_update(bmain, scene, ptr); -} - -static char *rna_SmokeDomainSettings_path(PointerRNA *ptr) -{ - SmokeDomainSettings *settings = (SmokeDomainSettings *)ptr->data; - ModifierData *md = (ModifierData *)settings->smd; - char name_esc[sizeof(md->name) * 2]; - - BLI_strescape(name_esc, md->name, sizeof(name_esc)); - return BLI_sprintfN("modifiers[\"%s\"].domain_settings", name_esc); -} - -static char *rna_SmokeFlowSettings_path(PointerRNA *ptr) -{ - SmokeFlowSettings *settings = (SmokeFlowSettings *)ptr->data; - ModifierData *md = (ModifierData *)settings->smd; - char name_esc[sizeof(md->name) * 2]; - - BLI_strescape(name_esc, md->name, sizeof(name_esc)); - return BLI_sprintfN("modifiers[\"%s\"].flow_settings", name_esc); -} - -static char *rna_SmokeCollSettings_path(PointerRNA *ptr) -{ - SmokeCollSettings *settings = (SmokeCollSettings *)ptr->data; - ModifierData *md = (ModifierData *)settings->smd; - char name_esc[sizeof(md->name) * 2]; - - BLI_strescape(name_esc, md->name, sizeof(name_esc)); - return BLI_sprintfN("modifiers[\"%s\"].coll_settings", name_esc); -} - -static int rna_SmokeModifier_grid_get_length(PointerRNA *ptr, int length[RNA_MAX_ARRAY_DIMENSION]) -{ -# ifdef WITH_SMOKE - SmokeDomainSettings *sds = (SmokeDomainSettings *)ptr->data; - float *density = NULL; - int size = 0; - - if (sds->flags & MOD_SMOKE_HIGHRES && sds->wt) { - /* high resolution smoke */ - int res[3]; - - smoke_turbulence_get_res(sds->wt, res); - size = res[0] * res[1] * res[2]; - - density = smoke_turbulence_get_density(sds->wt); - } - else if (sds->fluid) { - /* regular resolution */ - size = sds->res[0] * sds->res[1] * sds->res[2]; - density = smoke_get_density(sds->fluid); - } - - length[0] = (density) ? size : 0; -# else - (void)ptr; - length[0] = 0; -# endif - return length[0]; -} - -static int rna_SmokeModifier_color_grid_get_length(PointerRNA *ptr, - int length[RNA_MAX_ARRAY_DIMENSION]) -{ - rna_SmokeModifier_grid_get_length(ptr, length); - - length[0] *= 4; - return length[0]; -} - -static int rna_SmokeModifier_velocity_grid_get_length(PointerRNA *ptr, - int length[RNA_MAX_ARRAY_DIMENSION]) -{ -# ifdef WITH_SMOKE - SmokeDomainSettings *sds = (SmokeDomainSettings *)ptr->data; - float *vx = NULL; - float *vy = NULL; - float *vz = NULL; - int size = 0; - - /* Velocity data is always low-resolution. */ - if (sds->fluid) { - size = 3 * sds->res[0] * sds->res[1] * sds->res[2]; - vx = smoke_get_velocity_x(sds->fluid); - vy = smoke_get_velocity_y(sds->fluid); - vz = smoke_get_velocity_z(sds->fluid); - } - - length[0] = (vx && vy && vz) ? size : 0; -# else - (void)ptr; - length[0] = 0; -# endif - return length[0]; -} - -static int rna_SmokeModifier_heat_grid_get_length(PointerRNA *ptr, - int length[RNA_MAX_ARRAY_DIMENSION]) -{ -# ifdef WITH_SMOKE - SmokeDomainSettings *sds = (SmokeDomainSettings *)ptr->data; - float *heat = NULL; - int size = 0; - - /* Heat data is always low-resolution. */ - if (sds->fluid) { - size = sds->res[0] * sds->res[1] * sds->res[2]; - heat = smoke_get_heat(sds->fluid); - } - - length[0] = (heat) ? size : 0; -# else - (void)ptr; - length[0] = 0; -# endif - return length[0]; -} - -static void rna_SmokeModifier_density_grid_get(PointerRNA *ptr, float *values) -{ -# ifdef WITH_SMOKE - SmokeDomainSettings *sds = (SmokeDomainSettings *)ptr->data; - int length[RNA_MAX_ARRAY_DIMENSION]; - int size = rna_SmokeModifier_grid_get_length(ptr, length); - float *density; - - BLI_rw_mutex_lock(sds->fluid_mutex, THREAD_LOCK_READ); - - if (sds->flags & MOD_SMOKE_HIGHRES && sds->wt) { - density = smoke_turbulence_get_density(sds->wt); - } - else { - density = smoke_get_density(sds->fluid); - } - - memcpy(values, density, size * sizeof(float)); - - BLI_rw_mutex_unlock(sds->fluid_mutex); -# else - UNUSED_VARS(ptr, values); -# endif -} - -static void rna_SmokeModifier_velocity_grid_get(PointerRNA *ptr, float *values) -{ -# ifdef WITH_SMOKE - SmokeDomainSettings *sds = (SmokeDomainSettings *)ptr->data; - int length[RNA_MAX_ARRAY_DIMENSION]; - int size = rna_SmokeModifier_velocity_grid_get_length(ptr, length); - float *vx, *vy, *vz; - int i; - - BLI_rw_mutex_lock(sds->fluid_mutex, THREAD_LOCK_READ); - - vx = smoke_get_velocity_x(sds->fluid); - vy = smoke_get_velocity_y(sds->fluid); - vz = smoke_get_velocity_z(sds->fluid); - - for (i = 0; i < size; i += 3) { - *(values++) = *(vx++); - *(values++) = *(vy++); - *(values++) = *(vz++); - } - - BLI_rw_mutex_unlock(sds->fluid_mutex); -# else - UNUSED_VARS(ptr, values); -# endif -} - -static void rna_SmokeModifier_color_grid_get(PointerRNA *ptr, float *values) -{ -# ifdef WITH_SMOKE - SmokeDomainSettings *sds = (SmokeDomainSettings *)ptr->data; - int length[RNA_MAX_ARRAY_DIMENSION]; - int size = rna_SmokeModifier_grid_get_length(ptr, length); - - BLI_rw_mutex_lock(sds->fluid_mutex, THREAD_LOCK_READ); - - if (!sds->fluid) { - memset(values, 0, size * sizeof(float)); - } - else { - if (sds->flags & MOD_SMOKE_HIGHRES) { - if (smoke_turbulence_has_colors(sds->wt)) { - smoke_turbulence_get_rgba(sds->wt, values, 0); - } - else { - smoke_turbulence_get_rgba_from_density(sds->wt, sds->active_color, values, 0); - } - } - else { - if (smoke_has_colors(sds->fluid)) { - smoke_get_rgba(sds->fluid, values, 0); - } - else { - smoke_get_rgba_from_density(sds->fluid, sds->active_color, values, 0); - } - } - } - - BLI_rw_mutex_unlock(sds->fluid_mutex); -# else - UNUSED_VARS(ptr, values); -# endif -} - -static void rna_SmokeModifier_flame_grid_get(PointerRNA *ptr, float *values) -{ -# ifdef WITH_SMOKE - SmokeDomainSettings *sds = (SmokeDomainSettings *)ptr->data; - int length[RNA_MAX_ARRAY_DIMENSION]; - int size = rna_SmokeModifier_grid_get_length(ptr, length); - float *flame; - - BLI_rw_mutex_lock(sds->fluid_mutex, THREAD_LOCK_READ); - - if (sds->flags & MOD_SMOKE_HIGHRES && sds->wt) { - flame = smoke_turbulence_get_flame(sds->wt); - } - else { - flame = smoke_get_flame(sds->fluid); - } - - if (flame) { - memcpy(values, flame, size * sizeof(float)); - } - else { - memset(values, 0, size * sizeof(float)); - } - - BLI_rw_mutex_unlock(sds->fluid_mutex); -# else - UNUSED_VARS(ptr, values); -# endif -} - -static void rna_SmokeModifier_heat_grid_get(PointerRNA *ptr, float *values) -{ -# ifdef WITH_SMOKE - SmokeDomainSettings *sds = (SmokeDomainSettings *)ptr->data; - int length[RNA_MAX_ARRAY_DIMENSION]; - int size = rna_SmokeModifier_heat_grid_get_length(ptr, length); - float *heat; - - BLI_rw_mutex_lock(sds->fluid_mutex, THREAD_LOCK_READ); - - heat = smoke_get_heat(sds->fluid); - - if (heat != NULL) { - /* scale heat values from -2.0-2.0 to -1.0-1.0. */ - for (int i = 0; i < size; i++) { - values[i] = heat[i] * 0.5f; - } - } - else { - memset(values, 0, size * sizeof(float)); - } - - BLI_rw_mutex_unlock(sds->fluid_mutex); -# else - UNUSED_VARS(ptr, values); -# endif -} - -static void rna_SmokeModifier_temperature_grid_get(PointerRNA *ptr, float *values) -{ -# ifdef WITH_SMOKE - SmokeDomainSettings *sds = (SmokeDomainSettings *)ptr->data; - int length[RNA_MAX_ARRAY_DIMENSION]; - int size = rna_SmokeModifier_grid_get_length(ptr, length); - float *flame; - - BLI_rw_mutex_lock(sds->fluid_mutex, THREAD_LOCK_READ); - - if (sds->flags & MOD_SMOKE_HIGHRES && sds->wt) { - flame = smoke_turbulence_get_flame(sds->wt); - } - else { - flame = smoke_get_flame(sds->fluid); - } - - if (flame) { - /* Output is such that 0..1 maps to 0..1000K */ - float offset = sds->flame_ignition; - float scale = sds->flame_max_temp - sds->flame_ignition; - - for (int i = 0; i < size; i++) { - values[i] = (flame[i] > 0.01f) ? offset + flame[i] * scale : 0.0f; - } - } - else { - memset(values, 0, size * sizeof(float)); - } - - BLI_rw_mutex_unlock(sds->fluid_mutex); -# else - UNUSED_VARS(ptr, values); -# endif -} - -static void rna_SmokeFlow_density_vgroup_get(PointerRNA *ptr, char *value) -{ - SmokeFlowSettings *flow = (SmokeFlowSettings *)ptr->data; - rna_object_vgroup_name_index_get(ptr, value, flow->vgroup_density); -} - -static int rna_SmokeFlow_density_vgroup_length(PointerRNA *ptr) -{ - SmokeFlowSettings *flow = (SmokeFlowSettings *)ptr->data; - return rna_object_vgroup_name_index_length(ptr, flow->vgroup_density); -} - -static void rna_SmokeFlow_density_vgroup_set(PointerRNA *ptr, const char *value) -{ - SmokeFlowSettings *flow = (SmokeFlowSettings *)ptr->data; - rna_object_vgroup_name_index_set(ptr, value, &flow->vgroup_density); -} - -static void rna_SmokeFlow_uvlayer_set(PointerRNA *ptr, const char *value) -{ - SmokeFlowSettings *flow = (SmokeFlowSettings *)ptr->data; - rna_object_uvlayer_name_set(ptr, value, flow->uvlayer_name, sizeof(flow->uvlayer_name)); -} - -static void rna_Smoke_use_color_ramp_set(PointerRNA *ptr, bool value) -{ - SmokeDomainSettings *sds = (SmokeDomainSettings *)ptr->data; - - sds->use_coba = value; - - if (value && sds->coba == NULL) { - sds->coba = BKE_colorband_add(false); - } -} - -#else - -static void rna_def_smoke_domain_settings(BlenderRNA *brna) -{ - StructRNA *srna; - PropertyRNA *prop; - - static const EnumPropertyItem prop_noise_type_items[] = { - {MOD_SMOKE_NOISEWAVE, "NOISEWAVE", 0, "Wavelet", ""}, -# ifdef WITH_FFTW3 - {MOD_SMOKE_NOISEFFT, "NOISEFFT", 0, "FFT", ""}, -# endif - /* {MOD_SMOKE_NOISECURL, "NOISECURL", 0, "Curl", ""}, */ - {0, NULL, 0, NULL, NULL}, - }; - - static const EnumPropertyItem prop_compression_items[] = { - {VDB_COMPRESSION_ZIP, "ZIP", 0, "Zip", "Effective but slow compression"}, -# ifdef WITH_OPENVDB_BLOSC - {VDB_COMPRESSION_BLOSC, - "BLOSC", - 0, - "Blosc", - "Multithreaded compression, similar in size and quality as 'Zip'"}, -# endif - {VDB_COMPRESSION_NONE, "NONE", 0, "None", "Do not use any compression"}, - {0, NULL, 0, NULL, NULL}}; - - static const EnumPropertyItem smoke_cache_comp_items[] = { - {SM_CACHE_LIGHT, "CACHELIGHT", 0, "Lite", "Fast but not so effective compression"}, - {SM_CACHE_HEAVY, "CACHEHEAVY", 0, "Heavy", "Effective but slow compression"}, - {0, NULL, 0, NULL, NULL}, - }; - - static const EnumPropertyItem smoke_highres_sampling_items[] = { - {SM_HRES_FULLSAMPLE, "FULLSAMPLE", 0, "Full Sample", ""}, - {SM_HRES_LINEAR, "LINEAR", 0, "Linear", ""}, - {SM_HRES_NEAREST, "NEAREST", 0, "Nearest", ""}, - {0, NULL, 0, NULL, NULL}, - }; - - static const EnumPropertyItem smoke_data_depth_items[] = { - {16, "16", 0, "Float (Half)", "Half float (16 bit data)"}, - {0, "32", 0, "Float (Full)", "Full float (32 bit data)"}, /* default */ - {0, NULL, 0, NULL, NULL}, - }; - - static const EnumPropertyItem smoke_domain_colli_items[] = { - {SM_BORDER_OPEN, "BORDEROPEN", 0, "Open", "Smoke doesn't collide with any border"}, - {SM_BORDER_VERTICAL, - "BORDERVERTICAL", - 0, - "Vertically Open", - "Smoke doesn't collide with top and bottom sides"}, - {SM_BORDER_CLOSED, "BORDERCLOSED", 0, "Collide All", "Smoke collides with every side"}, - {0, NULL, 0, NULL, NULL}, - }; - - static const EnumPropertyItem cache_file_type_items[] = { - {PTCACHE_FILE_PTCACHE, - "POINTCACHE", - 0, - "Point Cache", - "Blender specific point cache file format"}, -# ifdef WITH_OPENVDB - {PTCACHE_FILE_OPENVDB, "OPENVDB", 0, "OpenVDB", "OpenVDB file format"}, -# endif - {0, NULL, 0, NULL, NULL}, - }; - - static const EnumPropertyItem smoke_view_items[] = { - {MOD_SMOKE_SLICE_VIEW_ALIGNED, - "VIEW_ALIGNED", - 0, - "View", - "Slice volume parallel to the view plane"}, - {MOD_SMOKE_SLICE_AXIS_ALIGNED, - "AXIS_ALIGNED", - 0, - "Axis", - "Slice volume parallel to the major axis"}, - {0, NULL, 0, NULL, NULL}, - }; - - static const EnumPropertyItem axis_slice_method_items[] = { - {AXIS_SLICE_FULL, "FULL", 0, "Full", "Slice the whole domain object"}, - {AXIS_SLICE_SINGLE, "SINGLE", 0, "Single", "Perform a single slice of the domain object"}, - {0, NULL, 0, NULL, NULL}, - }; - - static const EnumPropertyItem interp_method_item[] = { - {VOLUME_INTERP_LINEAR, "LINEAR", 0, "Linear", "Good smoothness and speed"}, - {VOLUME_INTERP_CUBIC, - "CUBIC", - 0, - "Cubic", - "Smoothed high quality interpolation, but slower"}, - {0, NULL, 0, NULL, NULL}, - }; - - static const EnumPropertyItem axis_slice_position_items[] = { - {SLICE_AXIS_AUTO, - "AUTO", - 0, - "Auto", - "Adjust slice direction according to the view direction"}, - {SLICE_AXIS_X, "X", 0, "X", "Slice along the X axis"}, - {SLICE_AXIS_Y, "Y", 0, "Y", "Slice along the Y axis"}, - {SLICE_AXIS_Z, "Z", 0, "Z", "Slice along the Z axis"}, - {0, NULL, 0, NULL, NULL}, - }; - - static const EnumPropertyItem vector_draw_items[] = { - {VECTOR_DRAW_NEEDLE, "NEEDLE", 0, "Needle", "Display vectors as needles"}, - {VECTOR_DRAW_STREAMLINE, "STREAMLINE", 0, "Streamlines", "Display vectors as streamlines"}, - {0, NULL, 0, NULL, NULL}, - }; - - srna = RNA_def_struct(brna, "SmokeDomainSettings", NULL); - RNA_def_struct_ui_text(srna, "Domain Settings", "Smoke domain settings"); - RNA_def_struct_sdna(srna, "SmokeDomainSettings"); - RNA_def_struct_path_func(srna, "rna_SmokeDomainSettings_path"); - - prop = RNA_def_property(srna, "resolution_max", PROP_INT, PROP_NONE); - RNA_def_property_int_sdna(prop, NULL, "maxres"); - RNA_def_property_range(prop, 6, 512); - RNA_def_property_ui_range(prop, 24, 512, 2, -1); - RNA_def_property_ui_text(prop, "Max Res", "Maximal resolution used in the fluid domain"); - RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_reset"); - - prop = RNA_def_property(srna, "amplify", PROP_INT, PROP_NONE); - RNA_def_property_int_sdna(prop, NULL, "amplify"); - RNA_def_property_range(prop, 1, 10); - RNA_def_property_ui_range(prop, 1, 10, 1, -1); - RNA_def_property_ui_text( - prop, "Amplification", "Enhance the resolution of smoke by this factor using noise"); - RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_reset"); - - prop = RNA_def_property(srna, "use_high_resolution", PROP_BOOLEAN, PROP_NONE); - RNA_def_property_boolean_sdna(prop, NULL, "flags", MOD_SMOKE_HIGHRES); - RNA_def_property_ui_text(prop, "High Res", "Enable high resolution (using amplification)"); - RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_reset"); - - prop = RNA_def_property(srna, "show_high_resolution", PROP_BOOLEAN, PROP_NONE); - RNA_def_property_boolean_sdna(prop, NULL, "viewsettings", MOD_SMOKE_VIEW_SHOW_HIGHRES); - RNA_def_property_ui_text( - prop, "Show High Resolution", "Show high resolution (using amplification)"); - RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL); - - prop = RNA_def_property(srna, "noise_type", PROP_ENUM, PROP_NONE); - RNA_def_property_enum_sdna(prop, NULL, "noise"); - RNA_def_property_enum_items(prop, prop_noise_type_items); - RNA_def_property_ui_text( - prop, "Noise Method", "Noise method which is used for creating the high resolution"); - RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_reset"); - - prop = RNA_def_property(srna, "alpha", PROP_FLOAT, PROP_NONE); - RNA_def_property_float_sdna(prop, NULL, "alpha"); - RNA_def_property_range(prop, -5.0, 5.0); - RNA_def_property_ui_range(prop, -5.0, 5.0, 0.02, 5); - RNA_def_property_ui_text( - prop, - "Density", - "How much density affects smoke motion (higher value results in faster rising smoke)"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_resetCache"); - - prop = RNA_def_property(srna, "beta", PROP_FLOAT, PROP_NONE); - RNA_def_property_float_sdna(prop, NULL, "beta"); - RNA_def_property_range(prop, -5.0, 5.0); - RNA_def_property_ui_range(prop, -5.0, 5.0, 0.02, 5); - RNA_def_property_ui_text( - prop, - "Heat", - "How much heat affects smoke motion (higher value results in faster rising smoke)"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_resetCache"); - - prop = RNA_def_property(srna, "collision_collection", PROP_POINTER, PROP_NONE); - RNA_def_property_pointer_sdna(prop, NULL, "coll_group"); - RNA_def_property_struct_type(prop, "Collection"); - RNA_def_property_flag(prop, PROP_EDITABLE); - RNA_def_property_ui_text(prop, "Collision Collection", "Limit collisions to this collection"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_reset_dependency"); - - prop = RNA_def_property(srna, "fluid_collection", PROP_POINTER, PROP_NONE); - RNA_def_property_pointer_sdna(prop, NULL, "fluid_group"); - RNA_def_property_struct_type(prop, "Collection"); - RNA_def_property_flag(prop, PROP_EDITABLE); - RNA_def_property_ui_text(prop, "Fluid Collection", "Limit fluid objects to this collection"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_reset_dependency"); - - prop = RNA_def_property(srna, "effector_collection", PROP_POINTER, PROP_NONE); - RNA_def_property_pointer_sdna(prop, NULL, "eff_group"); - RNA_def_property_struct_type(prop, "Collection"); - RNA_def_property_flag(prop, PROP_EDITABLE); - RNA_def_property_ui_text(prop, "Effector Collection", "Limit effectors to this collection"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_reset_dependency"); - - prop = RNA_def_property(srna, "strength", PROP_FLOAT, PROP_NONE); - RNA_def_property_float_sdna(prop, NULL, "strength"); - RNA_def_property_range(prop, 0.0, 10.0); - RNA_def_property_ui_range(prop, 0.0, 10.0, 1, 2); - RNA_def_property_ui_text(prop, "Strength", "Strength of noise"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_resetCache"); - - prop = RNA_def_property(srna, "dissolve_speed", PROP_INT, PROP_TIME); - RNA_def_property_int_sdna(prop, NULL, "diss_speed"); - RNA_def_property_range(prop, 1.0, 10000.0); - RNA_def_property_ui_range(prop, 1.0, 10000.0, 1, -1); - RNA_def_property_ui_text(prop, "Dissolve Speed", "Dissolve Speed"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_resetCache"); - - prop = RNA_def_property(srna, "use_dissolve_smoke", PROP_BOOLEAN, PROP_NONE); - RNA_def_property_boolean_sdna(prop, NULL, "flags", MOD_SMOKE_DISSOLVE); - RNA_def_property_ui_text(prop, "Dissolve Smoke", "Enable smoke to disappear over time"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_resetCache"); - - prop = RNA_def_property(srna, "use_dissolve_smoke_log", PROP_BOOLEAN, PROP_NONE); - RNA_def_property_boolean_sdna(prop, NULL, "flags", MOD_SMOKE_DISSOLVE_LOG); - RNA_def_property_ui_text(prop, "Logarithmic Dissolve", "Using 1/x "); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_resetCache"); - - prop = RNA_def_property(srna, "point_cache", PROP_POINTER, PROP_NONE); - RNA_def_property_flag(prop, PROP_NEVER_NULL); - RNA_def_property_pointer_sdna(prop, NULL, "point_cache[0]"); - RNA_def_property_struct_type(prop, "PointCache"); - RNA_def_property_ui_text(prop, "Point Cache", ""); - - prop = RNA_def_property(srna, "point_cache_compress_type", PROP_ENUM, PROP_NONE); - RNA_def_property_enum_sdna(prop, NULL, "cache_comp"); - RNA_def_property_enum_items(prop, smoke_cache_comp_items); - RNA_def_property_ui_text(prop, "Cache Compression", "Compression method to be used"); - - prop = RNA_def_property(srna, "openvdb_cache_compress_type", PROP_ENUM, PROP_NONE); - RNA_def_property_enum_sdna(prop, NULL, "openvdb_comp"); - RNA_def_property_enum_items(prop, prop_compression_items); - RNA_def_property_ui_text(prop, "Compression", "Compression method to be used"); - - prop = RNA_def_property(srna, "data_depth", PROP_ENUM, PROP_NONE); - RNA_def_property_enum_bitflag_sdna(prop, NULL, "data_depth"); - RNA_def_property_enum_items(prop, smoke_data_depth_items); - RNA_def_property_ui_text(prop, - "Data Depth", - "Bit depth for writing all scalar (including vector) " - "lower values reduce file size"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, NULL); - - prop = RNA_def_property(srna, "collision_extents", PROP_ENUM, PROP_NONE); - RNA_def_property_enum_sdna(prop, NULL, "border_collisions"); - RNA_def_property_enum_items(prop, smoke_domain_colli_items); - RNA_def_property_ui_text( - prop, "Border Collisions", "Select which domain border will be treated as collision object"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_reset"); - - prop = RNA_def_property(srna, "effector_weights", PROP_POINTER, PROP_NONE); - RNA_def_property_struct_type(prop, "EffectorWeights"); - RNA_def_property_clear_flag(prop, PROP_EDITABLE); - RNA_def_property_ui_text(prop, "Effector Weights", ""); - - prop = RNA_def_property(srna, "highres_sampling", PROP_ENUM, PROP_NONE); - RNA_def_property_enum_items(prop, smoke_highres_sampling_items); - RNA_def_property_ui_text(prop, "Emitter", "Method for sampling the high resolution flow"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_resetCache"); - - prop = RNA_def_property(srna, "time_scale", PROP_FLOAT, PROP_NONE); - RNA_def_property_float_sdna(prop, NULL, "time_scale"); - RNA_def_property_range(prop, 0.2, 1.5); - RNA_def_property_ui_range(prop, 0.2, 1.5, 0.02, 5); - RNA_def_property_ui_text(prop, "Time Scale", "Adjust simulation speed"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_resetCache"); - - prop = RNA_def_property(srna, "vorticity", PROP_FLOAT, PROP_NONE); - RNA_def_property_float_sdna(prop, NULL, "vorticity"); - RNA_def_property_range(prop, 0.01, 4.0); - RNA_def_property_ui_range(prop, 0.01, 4.0, 0.02, 5); - RNA_def_property_ui_text(prop, "Vorticity", "Amount of turbulence/rotation in fluid"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_resetCache"); - - prop = RNA_def_property(srna, "density_grid", PROP_FLOAT, PROP_NONE); - RNA_def_property_array(prop, 32); - RNA_def_property_flag(prop, PROP_DYNAMIC); - RNA_def_property_clear_flag(prop, PROP_EDITABLE); - RNA_def_property_dynamic_array_funcs(prop, "rna_SmokeModifier_grid_get_length"); - RNA_def_property_float_funcs(prop, "rna_SmokeModifier_density_grid_get", NULL, NULL); - RNA_def_property_ui_text(prop, "Density Grid", "Smoke density grid"); - - prop = RNA_def_property(srna, "velocity_grid", PROP_FLOAT, PROP_NONE); - RNA_def_property_array(prop, 32); - RNA_def_property_flag(prop, PROP_DYNAMIC); - RNA_def_property_clear_flag(prop, PROP_EDITABLE); - RNA_def_property_dynamic_array_funcs(prop, "rna_SmokeModifier_velocity_grid_get_length"); - RNA_def_property_float_funcs(prop, "rna_SmokeModifier_velocity_grid_get", NULL, NULL); - RNA_def_property_ui_text(prop, "Velocity Grid", "Smoke velocity grid"); - - prop = RNA_def_property(srna, "flame_grid", PROP_FLOAT, PROP_NONE); - RNA_def_property_array(prop, 32); - RNA_def_property_flag(prop, PROP_DYNAMIC); - RNA_def_property_clear_flag(prop, PROP_EDITABLE); - RNA_def_property_dynamic_array_funcs(prop, "rna_SmokeModifier_grid_get_length"); - RNA_def_property_float_funcs(prop, "rna_SmokeModifier_flame_grid_get", NULL, NULL); - RNA_def_property_ui_text(prop, "Flame Grid", "Smoke flame grid"); - - prop = RNA_def_property(srna, "color_grid", PROP_FLOAT, PROP_NONE); - RNA_def_property_array(prop, 32); - RNA_def_property_flag(prop, PROP_DYNAMIC); - RNA_def_property_clear_flag(prop, PROP_EDITABLE); - RNA_def_property_dynamic_array_funcs(prop, "rna_SmokeModifier_color_grid_get_length"); - RNA_def_property_float_funcs(prop, "rna_SmokeModifier_color_grid_get", NULL, NULL); - RNA_def_property_ui_text(prop, "Color Grid", "Smoke color grid"); - - prop = RNA_def_property(srna, "heat_grid", PROP_FLOAT, PROP_NONE); - RNA_def_property_array(prop, 32); - RNA_def_property_flag(prop, PROP_DYNAMIC); - RNA_def_property_clear_flag(prop, PROP_EDITABLE); - RNA_def_property_dynamic_array_funcs(prop, "rna_SmokeModifier_heat_grid_get_length"); - RNA_def_property_float_funcs(prop, "rna_SmokeModifier_heat_grid_get", NULL, NULL); - RNA_def_property_ui_text(prop, "Heat Grid", "Smoke heat grid"); - - prop = RNA_def_property(srna, "temperature_grid", PROP_FLOAT, PROP_NONE); - RNA_def_property_array(prop, 32); - RNA_def_property_flag(prop, PROP_DYNAMIC); - RNA_def_property_clear_flag(prop, PROP_EDITABLE); - RNA_def_property_dynamic_array_funcs(prop, "rna_SmokeModifier_grid_get_length"); - RNA_def_property_float_funcs(prop, "rna_SmokeModifier_temperature_grid_get", NULL, NULL); - RNA_def_property_ui_text( - prop, "Temperature Grid", "Smoke temperature grid, range 0..1 represents 0..1000K"); - - prop = RNA_def_property(srna, - "cell_size", - PROP_FLOAT, - PROP_XYZ); /* can change each frame when using adaptive domain */ - RNA_def_property_clear_flag(prop, PROP_EDITABLE); - RNA_def_property_ui_text(prop, "cell_size", "Cell Size"); - - prop = RNA_def_property(srna, - "start_point", - PROP_FLOAT, - PROP_XYZ); /* can change each frame when using adaptive domain */ - RNA_def_property_float_sdna(prop, NULL, "p0"); - RNA_def_property_clear_flag(prop, PROP_EDITABLE); - RNA_def_property_ui_text(prop, "p0", "Start point"); - - prop = RNA_def_property(srna, - "domain_resolution", - PROP_INT, - PROP_XYZ); /* can change each frame when using adaptive domain */ - RNA_def_property_int_sdna(prop, NULL, "res"); - RNA_def_property_clear_flag(prop, PROP_EDITABLE); - RNA_def_property_ui_text(prop, "res", "Smoke Grid Resolution"); - - prop = RNA_def_property(srna, "burning_rate", PROP_FLOAT, PROP_NONE); - RNA_def_property_range(prop, 0.01, 4.0); - RNA_def_property_ui_range(prop, 0.01, 2.0, 1.0, 5); - RNA_def_property_ui_text( - prop, "Speed", "Speed of the burning reaction (use larger values for smaller flame)"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_resetCache"); - - prop = RNA_def_property(srna, "flame_smoke", PROP_FLOAT, PROP_NONE); - RNA_def_property_range(prop, 0.0, 8.0); - RNA_def_property_ui_range(prop, 0.0, 4.0, 1.0, 5); - RNA_def_property_ui_text(prop, "Smoke", "Amount of smoke created by burning fuel"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_resetCache"); - - prop = RNA_def_property(srna, "flame_vorticity", PROP_FLOAT, PROP_FACTOR); - RNA_def_property_range(prop, 0.0, 2.0); - RNA_def_property_ui_range(prop, 0.0, 1.0, 1.0, 5); - RNA_def_property_ui_text(prop, "Vorticity", "Additional vorticity for the flames"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_resetCache"); - - prop = RNA_def_property(srna, "flame_ignition", PROP_FLOAT, PROP_NONE); - RNA_def_property_range(prop, 0.5, 5.0); - RNA_def_property_ui_range(prop, 0.5, 2.5, 1.0, 5); - RNA_def_property_ui_text(prop, "Ignition", "Minimum temperature of flames"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_resetCache"); - - prop = RNA_def_property(srna, "flame_max_temp", PROP_FLOAT, PROP_NONE); - RNA_def_property_range(prop, 1.0, 10.0); - RNA_def_property_ui_range(prop, 1.0, 5.0, 1.0, 5); - RNA_def_property_ui_text(prop, "Maximum", "Maximum temperature of flames"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_resetCache"); - - prop = RNA_def_property(srna, "flame_smoke_color", PROP_FLOAT, PROP_COLOR_GAMMA); - RNA_def_property_array(prop, 3); - RNA_def_property_ui_text(prop, "Smoke Color", "Color of smoke emitted from burning fuel"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_resetCache"); - - prop = RNA_def_property(srna, "use_adaptive_domain", PROP_BOOLEAN, PROP_NONE); - RNA_def_property_boolean_sdna(prop, NULL, "flags", MOD_SMOKE_ADAPTIVE_DOMAIN); - RNA_def_property_ui_text( - prop, "Adaptive Domain", "Adapt simulation resolution and size to fluid"); - RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_reset"); - - prop = RNA_def_property(srna, "additional_res", PROP_INT, PROP_NONE); - RNA_def_property_int_sdna(prop, NULL, "adapt_res"); - RNA_def_property_range(prop, 0, 512); - RNA_def_property_ui_range(prop, 0, 512, 2, -1); - RNA_def_property_ui_text(prop, "Additional", "Maximum number of additional cells"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_resetCache"); - - prop = RNA_def_property(srna, "adapt_margin", PROP_INT, PROP_NONE); - RNA_def_property_int_sdna(prop, NULL, "adapt_margin"); - RNA_def_property_range(prop, 2, 24); - RNA_def_property_ui_range(prop, 2, 24, 2, -1); - RNA_def_property_ui_text( - prop, "Margin", "Margin added around fluid to minimize boundary interference"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_resetCache"); - - prop = RNA_def_property(srna, "adapt_threshold", PROP_FLOAT, PROP_NONE); - RNA_def_property_range(prop, 0.01, 0.5); - RNA_def_property_ui_range(prop, 0.01, 0.5, 1.0, 5); - RNA_def_property_ui_text( - prop, "Threshold", "Maximum amount of fluid cell can contain before it is considered empty"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_resetCache"); - - prop = RNA_def_property(srna, "cache_file_format", PROP_ENUM, PROP_NONE); - RNA_def_property_enum_sdna(prop, NULL, "cache_file_format"); - RNA_def_property_enum_items(prop, cache_file_type_items); - RNA_def_property_enum_funcs(prop, NULL, "rna_Smoke_cachetype_set", NULL); - RNA_def_property_ui_text(prop, "File Format", "Select the file format to be used for caching"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_resetCache"); - - /* display settings */ - - prop = RNA_def_property(srna, "slice_method", PROP_ENUM, PROP_NONE); - RNA_def_property_enum_sdna(prop, NULL, "slice_method"); - RNA_def_property_enum_items(prop, smoke_view_items); - RNA_def_property_ui_text(prop, "View Method", "How to slice the volume for viewport rendering"); - RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL); - - prop = RNA_def_property(srna, "axis_slice_method", PROP_ENUM, PROP_NONE); - RNA_def_property_enum_sdna(prop, NULL, "axis_slice_method"); - RNA_def_property_enum_items(prop, axis_slice_method_items); - RNA_def_property_ui_text(prop, "Method", ""); - RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL); - - prop = RNA_def_property(srna, "slice_axis", PROP_ENUM, PROP_NONE); - RNA_def_property_enum_sdna(prop, NULL, "slice_axis"); - RNA_def_property_enum_items(prop, axis_slice_position_items); - RNA_def_property_ui_text(prop, "Axis", ""); - RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL); - - prop = RNA_def_property(srna, "slice_per_voxel", PROP_FLOAT, PROP_NONE); - RNA_def_property_float_sdna(prop, NULL, "slice_per_voxel"); - RNA_def_property_range(prop, 0.0, 100.0); - RNA_def_property_ui_range(prop, 0.0, 5.0, 0.1, 1); - RNA_def_property_ui_text( - prop, "Slice Per Voxel", "How many slices per voxel should be generated"); - RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL); - - prop = RNA_def_property(srna, "slice_depth", PROP_FLOAT, PROP_FACTOR); - RNA_def_property_float_sdna(prop, NULL, "slice_depth"); - RNA_def_property_range(prop, 0.0, 1.0); - RNA_def_property_ui_range(prop, 0.0, 1.0, 0.1, 3); - RNA_def_property_ui_text(prop, "Position", "Position of the slice"); - RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL); - - prop = RNA_def_property(srna, "display_thickness", PROP_FLOAT, PROP_NONE); - RNA_def_property_float_sdna(prop, NULL, "display_thickness"); - RNA_def_property_range(prop, 0.001, 1000.0); - RNA_def_property_ui_range(prop, 0.1, 100.0, 0.1, 3); - RNA_def_property_ui_text(prop, "Thickness", "Thickness of smoke drawing in the viewport"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, NULL); - - prop = RNA_def_property(srna, "display_interpolation", PROP_ENUM, PROP_NONE); - RNA_def_property_enum_sdna(prop, NULL, "interp_method"); - RNA_def_property_enum_items(prop, interp_method_item); - RNA_def_property_ui_text( - prop, "Interpolation", "Interpolation method to use for smoke/fire volumes in solid mode"); - RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL); - - prop = RNA_def_property(srna, "show_velocity", PROP_BOOLEAN, PROP_NONE); - RNA_def_property_boolean_sdna(prop, NULL, "draw_velocity", 0); - RNA_def_property_ui_text( - prop, "Display Velocity", "Toggle visualization of the velocity field as needles"); - RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL); - - prop = RNA_def_property(srna, "vector_display_type", PROP_ENUM, PROP_NONE); - RNA_def_property_enum_sdna(prop, NULL, "vector_draw_type"); - RNA_def_property_enum_items(prop, vector_draw_items); - RNA_def_property_ui_text(prop, "Display Type", ""); - RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL); - - prop = RNA_def_property(srna, "vector_scale", PROP_FLOAT, PROP_NONE); - RNA_def_property_float_sdna(prop, NULL, "vector_scale"); - RNA_def_property_range(prop, 0.0, 1000.0); - RNA_def_property_ui_range(prop, 0.0, 100.0, 0.1, 3); - RNA_def_property_ui_text(prop, "Scale", "Multiplier for scaling the vectors"); - RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL); - - /* --------- Color mapping. --------- */ - - prop = RNA_def_property(srna, "use_color_ramp", PROP_BOOLEAN, PROP_NONE); - RNA_def_property_boolean_sdna(prop, NULL, "use_coba", 0); - RNA_def_property_boolean_funcs(prop, NULL, "rna_Smoke_use_color_ramp_set"); - RNA_def_property_ui_text( - prop, - "Use Color Ramp", - "Render a simulation field while mapping its voxels values to the colors of a ramp"); - RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL); - - static const EnumPropertyItem coba_field_items[] = { - {FLUID_FIELD_COLOR_R, "COLOR_R", 0, "Red", "Red component of the color field"}, - {FLUID_FIELD_COLOR_G, "COLOR_G", 0, "Green", "Green component of the color field"}, - {FLUID_FIELD_COLOR_B, "COLOR_B", 0, "Blue", "Blue component of the color field"}, - {FLUID_FIELD_DENSITY, "DENSITY", 0, "Density", "Quantity of soot in the fluid"}, - {FLUID_FIELD_FLAME, "FLAME", 0, "Flame", "Flame field"}, - {FLUID_FIELD_FUEL, "FUEL", 0, "Fuel", "Fuel field"}, - {FLUID_FIELD_HEAT, "HEAT", 0, "Heat", "Temperature of the fluid"}, - {FLUID_FIELD_VELOCITY_X, "VELOCITY_X", 0, "X Velocity", "X component of the velocity field"}, - {FLUID_FIELD_VELOCITY_Y, "VELOCITY_Y", 0, "Y Velocity", "Y component of the velocity field"}, - {FLUID_FIELD_VELOCITY_Z, "VELOCITY_Z", 0, "Z Velocity", "Z component of the velocity field"}, - {0, NULL, 0, NULL, NULL}, - }; - - prop = RNA_def_property(srna, "coba_field", PROP_ENUM, PROP_NONE); - RNA_def_property_enum_sdna(prop, NULL, "coba_field"); - RNA_def_property_enum_items(prop, coba_field_items); - RNA_def_property_ui_text(prop, "Field", "Simulation field to color map"); - RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL); - - prop = RNA_def_property(srna, "color_ramp", PROP_POINTER, PROP_NEVER_NULL); - RNA_def_property_pointer_sdna(prop, NULL, "coba"); - RNA_def_property_struct_type(prop, "ColorRamp"); - RNA_def_property_ui_text(prop, "Color Ramp", ""); - RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL); - - prop = RNA_def_property(srna, "clipping", PROP_FLOAT, PROP_NONE); - RNA_def_property_float_sdna(prop, NULL, "clipping"); - RNA_def_property_range(prop, 0.0, 1.0); - RNA_def_property_ui_range(prop, 0.0, 1.0, 0.1, 3); - RNA_def_property_ui_text( - prop, - "Clipping", - "Value under which voxels are considered empty space to optimize caching and rendering"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, NULL); -} - -static void rna_def_smoke_flow_settings(BlenderRNA *brna) -{ - StructRNA *srna; - PropertyRNA *prop; - - static const EnumPropertyItem smoke_flow_types[] = { - {MOD_SMOKE_FLOW_TYPE_OUTFLOW, "OUTFLOW", 0, "Outflow", "Delete smoke from simulation"}, - {MOD_SMOKE_FLOW_TYPE_SMOKE, "SMOKE", 0, "Smoke", "Add smoke"}, - {MOD_SMOKE_FLOW_TYPE_SMOKEFIRE, "BOTH", 0, "Fire + Smoke", "Add fire and smoke"}, - {MOD_SMOKE_FLOW_TYPE_FIRE, "FIRE", 0, "Fire", "Add fire"}, - {0, NULL, 0, NULL, NULL}, - }; - - static const EnumPropertyItem smoke_flow_sources[] = { - {MOD_SMOKE_FLOW_SOURCE_PARTICLES, - "PARTICLES", - ICON_PARTICLES, - "Particle System", - "Emit smoke from particles"}, - {MOD_SMOKE_FLOW_SOURCE_MESH, - "MESH", - ICON_META_CUBE, - "Mesh", - "Emit smoke from mesh surface or volume"}, - {0, NULL, 0, NULL, NULL}, - }; - - static const EnumPropertyItem smoke_flow_texture_types[] = { - {MOD_SMOKE_FLOW_TEXTURE_MAP_AUTO, - "AUTO", - 0, - "Generated", - "Generated coordinates centered to flow object"}, - {MOD_SMOKE_FLOW_TEXTURE_MAP_UV, "UV", 0, "UV", "Use UV layer for texture coordinates"}, - {0, NULL, 0, NULL, NULL}, - }; - - srna = RNA_def_struct(brna, "SmokeFlowSettings", NULL); - RNA_def_struct_ui_text(srna, "Flow Settings", "Smoke flow settings"); - RNA_def_struct_sdna(srna, "SmokeFlowSettings"); - RNA_def_struct_path_func(srna, "rna_SmokeFlowSettings_path"); - - prop = RNA_def_property(srna, "density", PROP_FLOAT, PROP_FACTOR); - RNA_def_property_float_sdna(prop, NULL, "density"); - RNA_def_property_range(prop, 0.0, 1); - RNA_def_property_ui_range(prop, 0.0, 1.0, 1.0, 4); - RNA_def_property_ui_text(prop, "Density", ""); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_reset"); - - prop = RNA_def_property(srna, "smoke_color", PROP_FLOAT, PROP_COLOR_GAMMA); - RNA_def_property_float_sdna(prop, NULL, "color"); - RNA_def_property_array(prop, 3); - RNA_def_property_ui_text(prop, "Smoke Color", "Color of smoke"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_reset"); - - prop = RNA_def_property(srna, "fuel_amount", PROP_FLOAT, PROP_NONE); - RNA_def_property_range(prop, 0.0, 10); - RNA_def_property_ui_range(prop, 0.0, 5.0, 1.0, 4); - RNA_def_property_ui_text(prop, "Flame Rate", ""); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_reset"); - - prop = RNA_def_property(srna, "temperature", PROP_FLOAT, PROP_NONE); - RNA_def_property_float_sdna(prop, NULL, "temp"); - RNA_def_property_range(prop, -10, 10); - RNA_def_property_ui_range(prop, -10, 10, 1, 1); - RNA_def_property_ui_text(prop, "Temp. Diff.", "Temperature difference to ambient temperature"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_reset"); - - prop = RNA_def_property(srna, "particle_system", PROP_POINTER, PROP_NONE); - RNA_def_property_pointer_sdna(prop, NULL, "psys"); - RNA_def_property_struct_type(prop, "ParticleSystem"); - RNA_def_property_flag(prop, PROP_EDITABLE); - RNA_def_property_ui_text(prop, "Particle Systems", "Particle systems emitted from the object"); - RNA_def_property_update(prop, 0, "rna_Smoke_reset_dependency"); - - prop = RNA_def_property(srna, "smoke_flow_type", PROP_ENUM, PROP_NONE); - RNA_def_property_enum_sdna(prop, NULL, "type"); - RNA_def_property_enum_items(prop, smoke_flow_types); - RNA_def_property_ui_text(prop, "Flow Type", "Change how flow affects the simulation"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_reset"); - - prop = RNA_def_property(srna, "smoke_flow_source", PROP_ENUM, PROP_NONE); - RNA_def_property_enum_sdna(prop, NULL, "source"); - RNA_def_property_enum_items(prop, smoke_flow_sources); - RNA_def_property_ui_text(prop, "Source", "Change how smoke is emitted"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_reset"); - - prop = RNA_def_property(srna, "use_absolute", PROP_BOOLEAN, PROP_NONE); - RNA_def_property_boolean_sdna(prop, NULL, "flags", MOD_SMOKE_FLOW_ABSOLUTE); - RNA_def_property_ui_text( - prop, "Absolute Density", "Only allow given density value in emitter area"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_reset"); - - prop = RNA_def_property(srna, "use_initial_velocity", PROP_BOOLEAN, PROP_NONE); - RNA_def_property_boolean_sdna(prop, NULL, "flags", MOD_SMOKE_FLOW_INITVELOCITY); - RNA_def_property_ui_text( - prop, "Initial Velocity", "Smoke has some initial velocity when it is emitted"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_reset"); - - prop = RNA_def_property(srna, "velocity_factor", PROP_FLOAT, PROP_NONE); - RNA_def_property_float_sdna(prop, NULL, "vel_multi"); - RNA_def_property_range(prop, -100.0, 100.0); - RNA_def_property_ui_range(prop, -2.0, 2.0, 0.05, 5); - RNA_def_property_ui_text(prop, "Source", "Multiplier of source velocity passed to smoke"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_reset"); - - prop = RNA_def_property(srna, "velocity_normal", PROP_FLOAT, PROP_NONE); - RNA_def_property_float_sdna(prop, NULL, "vel_normal"); - RNA_def_property_range(prop, -100.0, 100.0); - RNA_def_property_ui_range(prop, -2.0, 2.0, 0.05, 5); - RNA_def_property_ui_text(prop, "Normal", "Amount of normal directional velocity"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_reset"); - - prop = RNA_def_property(srna, "velocity_random", PROP_FLOAT, PROP_NONE); - RNA_def_property_float_sdna(prop, NULL, "vel_random"); - RNA_def_property_range(prop, 0.0, 10.0); - RNA_def_property_ui_range(prop, 0.0, 2.0, 0.05, 5); - RNA_def_property_ui_text(prop, "Random", "Amount of random velocity"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_reset"); - - prop = RNA_def_property(srna, "volume_density", PROP_FLOAT, PROP_FACTOR); - RNA_def_property_range(prop, 0.0, 1.0); - RNA_def_property_ui_range(prop, 0.0, 1.0, 0.05, 5); - RNA_def_property_ui_text(prop, "Volume", "Factor for smoke emitted from inside the mesh volume"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_reset"); - - prop = RNA_def_property(srna, "surface_distance", PROP_FLOAT, PROP_DISTANCE); - RNA_def_property_range(prop, 0.0, 10.0); - RNA_def_property_ui_range(prop, 0.5, 5.0, 0.05, 5); - RNA_def_property_ui_text(prop, "Surface", "Maximum distance from mesh surface to emit smoke"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_reset"); - - prop = RNA_def_property(srna, "particle_size", PROP_FLOAT, PROP_NONE); - RNA_def_property_range(prop, 0.1, 20.0); - RNA_def_property_ui_range(prop, 0.5, 5.0, 0.05, 5); - RNA_def_property_ui_text(prop, "Size", "Particle size in simulation cells"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_reset"); - - prop = RNA_def_property(srna, "use_particle_size", PROP_BOOLEAN, PROP_NONE); - RNA_def_property_boolean_sdna(prop, NULL, "flags", MOD_SMOKE_FLOW_USE_PART_SIZE); - RNA_def_property_ui_text( - prop, "Set Size", "Set particle size in simulation cells or use nearest cell"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_reset"); - - prop = RNA_def_property(srna, "subframes", PROP_INT, PROP_NONE); - RNA_def_property_range(prop, 0, 50); - RNA_def_property_ui_range(prop, 0, 10, 1, -1); - RNA_def_property_ui_text(prop, - "Subframes", - "Number of additional samples to take between frames to improve " - "quality of fast moving flows"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_reset"); - - prop = RNA_def_property(srna, "density_vertex_group", PROP_STRING, PROP_NONE); - RNA_def_property_string_funcs(prop, - "rna_SmokeFlow_density_vgroup_get", - "rna_SmokeFlow_density_vgroup_length", - "rna_SmokeFlow_density_vgroup_set"); - RNA_def_property_ui_text( - prop, "Vertex Group", "Name of vertex group which determines surface emission rate"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_reset"); - - prop = RNA_def_property(srna, "use_texture", PROP_BOOLEAN, PROP_NONE); - RNA_def_property_boolean_sdna(prop, NULL, "flags", MOD_SMOKE_FLOW_TEXTUREEMIT); - RNA_def_property_ui_text(prop, "Use Texture", "Use a texture to control emission strength"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_reset"); - - prop = RNA_def_property(srna, "texture_map_type", PROP_ENUM, PROP_NONE); - RNA_def_property_enum_sdna(prop, NULL, "texture_type"); - RNA_def_property_enum_items(prop, smoke_flow_texture_types); - RNA_def_property_ui_text(prop, "Mapping", "Texture mapping type"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_reset"); - - prop = RNA_def_property(srna, "uv_layer", PROP_STRING, PROP_NONE); - RNA_def_property_string_sdna(prop, NULL, "uvlayer_name"); - RNA_def_property_ui_text(prop, "UV Map", "UV map name"); - RNA_def_property_string_funcs(prop, NULL, NULL, "rna_SmokeFlow_uvlayer_set"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_reset"); - - prop = RNA_def_property(srna, "noise_texture", PROP_POINTER, PROP_NONE); - RNA_def_property_flag(prop, PROP_EDITABLE); - RNA_def_property_ui_text(prop, "Texture", "Texture that controls emission strength"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_reset"); - - prop = RNA_def_property(srna, "texture_size", PROP_FLOAT, PROP_NONE); - RNA_def_property_range(prop, 0.01, 10.0); - RNA_def_property_ui_range(prop, 0.1, 5.0, 0.05, 5); - RNA_def_property_ui_text(prop, "Size", "Size of texture mapping"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_reset"); - - prop = RNA_def_property(srna, "texture_offset", PROP_FLOAT, PROP_NONE); - RNA_def_property_range(prop, 0.0, 200.0); - RNA_def_property_ui_range(prop, 0.0, 100.0, 0.05, 5); - RNA_def_property_ui_text(prop, "Offset", "Z-offset of texture mapping"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_reset"); -} - -static void rna_def_smoke_coll_settings(BlenderRNA *brna) -{ - static const EnumPropertyItem smoke_coll_type_items[] = { - {SM_COLL_STATIC, "COLLSTATIC", 0, "Static", "Non moving obstacle"}, - {SM_COLL_RIGID, "COLLRIGID", 0, "Rigid", "Rigid obstacle"}, - {SM_COLL_ANIMATED, "COLLANIMATED", 0, "Animated", "Animated obstacle"}, - {0, NULL, 0, NULL, NULL}, - }; - - StructRNA *srna; - PropertyRNA *prop; - - srna = RNA_def_struct(brna, "SmokeCollSettings", NULL); - RNA_def_struct_ui_text(srna, "Collision Settings", "Smoke collision settings"); - RNA_def_struct_sdna(srna, "SmokeCollSettings"); - RNA_def_struct_path_func(srna, "rna_SmokeCollSettings_path"); - - prop = RNA_def_property(srna, "collision_type", PROP_ENUM, PROP_NONE); - RNA_def_property_enum_sdna(prop, NULL, "type"); - RNA_def_property_enum_items(prop, smoke_coll_type_items); - RNA_def_property_ui_text(prop, "Collision Type", "Collision type"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_reset"); -} - -void RNA_def_smoke(BlenderRNA *brna) -{ - rna_def_smoke_domain_settings(brna); - rna_def_smoke_flow_settings(brna); - rna_def_smoke_coll_settings(brna); -} - -#endif diff --git a/source/blender/modifiers/CMakeLists.txt b/source/blender/modifiers/CMakeLists.txt index 11c27ad9066..dfa50696d6c 100644 --- a/source/blender/modifiers/CMakeLists.txt +++ b/source/blender/modifiers/CMakeLists.txt @@ -29,7 +29,6 @@ set(INC ../makesdna ../makesrna ../render/extern/include - ../../../intern/elbeem/extern ../../../intern/eigen ../../../intern/guardedalloc ) @@ -55,12 +54,11 @@ set(SRC intern/MOD_dynamicpaint.c intern/MOD_edgesplit.c intern/MOD_explode.c - intern/MOD_fluidsim.c - intern/MOD_fluidsim_util.c intern/MOD_hook.c intern/MOD_laplaciandeform.c intern/MOD_laplaciansmooth.c intern/MOD_lattice.c + intern/MOD_fluid.c intern/MOD_mask.c intern/MOD_meshcache.c intern/MOD_meshcache_mdd.c @@ -81,7 +79,6 @@ set(SRC intern/MOD_shrinkwrap.c intern/MOD_simpledeform.c intern/MOD_skin.c - intern/MOD_smoke.c intern/MOD_smooth.c intern/MOD_softbody.c intern/MOD_solidify.c @@ -105,7 +102,6 @@ set(SRC intern/MOD_wireframe.c MOD_modifiertypes.h - intern/MOD_fluidsim_util.h intern/MOD_meshcache_util.h intern/MOD_solidify_util.h intern/MOD_util.h @@ -137,10 +133,6 @@ if(WITH_MOD_REMESH) add_definitions(-DWITH_MOD_REMESH) endif() -if(WITH_MOD_FLUID) - add_definitions(-DWITH_MOD_FLUID) -endif() - if(WITH_MOD_OCEANSIM) add_definitions(-DWITH_OCEANSIM) endif() diff --git a/source/blender/modifiers/MOD_modifiertypes.h b/source/blender/modifiers/MOD_modifiertypes.h index d678c6b84fa..7dd1ce830aa 100644 --- a/source/blender/modifiers/MOD_modifiertypes.h +++ b/source/blender/modifiers/MOD_modifiertypes.h @@ -56,7 +56,7 @@ extern ModifierTypeInfo modifierType_Mask; extern ModifierTypeInfo modifierType_SimpleDeform; extern ModifierTypeInfo modifierType_Multires; extern ModifierTypeInfo modifierType_Surface; -extern ModifierTypeInfo modifierType_Smoke; +extern ModifierTypeInfo modifierType_Fluid; extern ModifierTypeInfo modifierType_ShapeKey; extern ModifierTypeInfo modifierType_Solidify; extern ModifierTypeInfo modifierType_Screw; diff --git a/source/blender/modifiers/intern/MOD_smoke.c b/source/blender/modifiers/intern/MOD_fluid.c index 34275d91ee6..aba9e352162 100644 --- a/source/blender/modifiers/intern/MOD_smoke.c +++ b/source/blender/modifiers/intern/MOD_fluid.c @@ -30,7 +30,7 @@ #include "DNA_collection_types.h" #include "DNA_object_types.h" #include "DNA_scene_types.h" -#include "DNA_smoke_types.h" +#include "DNA_fluid_types.h" #include "DNA_object_force_types.h" #include "DNA_mesh_types.h" @@ -38,7 +38,7 @@ #include "BKE_layer.h" #include "BKE_library_query.h" #include "BKE_modifier.h" -#include "BKE_smoke.h" +#include "BKE_fluid.h" #include "DEG_depsgraph.h" #include "DEG_depsgraph_build.h" @@ -49,45 +49,45 @@ static void initData(ModifierData *md) { - SmokeModifierData *smd = (SmokeModifierData *)md; + FluidModifierData *mmd = (FluidModifierData *)md; - smd->domain = NULL; - smd->flow = NULL; - smd->coll = NULL; - smd->type = 0; - smd->time = -1; + mmd->domain = NULL; + mmd->flow = NULL; + mmd->effector = NULL; + mmd->type = 0; + mmd->time = -1; } static void copyData(const ModifierData *md, ModifierData *target, const int flag) { - const SmokeModifierData *smd = (const SmokeModifierData *)md; - SmokeModifierData *tsmd = (SmokeModifierData *)target; + const FluidModifierData *mmd = (const FluidModifierData *)md; + FluidModifierData *tmmd = (FluidModifierData *)target; - smokeModifier_free(tsmd); - smokeModifier_copy(smd, tsmd, flag); + fluidModifier_free(tmmd); + fluidModifier_copy(mmd, tmmd, flag); } static void freeData(ModifierData *md) { - SmokeModifierData *smd = (SmokeModifierData *)md; + FluidModifierData *mmd = (FluidModifierData *)md; - smokeModifier_free(smd); + fluidModifier_free(mmd); } static void requiredDataMask(Object *UNUSED(ob), ModifierData *md, CustomData_MeshMasks *r_cddata_masks) { - SmokeModifierData *smd = (SmokeModifierData *)md; + FluidModifierData *mmd = (FluidModifierData *)md; - if (smd && (smd->type & MOD_SMOKE_TYPE_FLOW) && smd->flow) { - if (smd->flow->source == MOD_SMOKE_FLOW_SOURCE_MESH) { + if (mmd && (mmd->type & MOD_FLUID_TYPE_FLOW) && mmd->flow) { + if (mmd->flow->source == FLUID_FLOW_SOURCE_MESH) { /* vertex groups */ - if (smd->flow->vgroup_density) { + if (mmd->flow->vgroup_density) { r_cddata_masks->vmask |= CD_MASK_MDEFORMVERT; } /* uv layer */ - if (smd->flow->texture_type == MOD_SMOKE_FLOW_TEXTURE_MAP_UV) { + if (mmd->flow->texture_type == FLUID_FLOW_TEXTURE_MAP_UV) { r_cddata_masks->fmask |= CD_MASK_MTFACE; } } @@ -96,14 +96,17 @@ static void requiredDataMask(Object *UNUSED(ob), static Mesh *applyModifier(ModifierData *md, const ModifierEvalContext *ctx, Mesh *me) { - SmokeModifierData *smd = (SmokeModifierData *)md; + FluidModifierData *mmd = (FluidModifierData *)md; + Mesh *result = NULL; if (ctx->flag & MOD_APPLY_ORCO) { return me; } Scene *scene = DEG_get_evaluated_scene(ctx->depsgraph); - return smokeModifier_do(smd, ctx->depsgraph, scene, ctx->object, me); + + result = fluidModifier_do(mmd, ctx->depsgraph, scene, ctx->object, me); + return result ? result : me; } static bool dependsOnTime(ModifierData *UNUSED(md)) @@ -113,68 +116,78 @@ static bool dependsOnTime(ModifierData *UNUSED(md)) static bool is_flow_cb(Object *UNUSED(ob), ModifierData *md) { - SmokeModifierData *smd = (SmokeModifierData *)md; - return (smd->type & MOD_SMOKE_TYPE_FLOW) && smd->flow; + FluidModifierData *mmd = (FluidModifierData *)md; + return (mmd->type & MOD_FLUID_TYPE_FLOW) && mmd->flow; } static bool is_coll_cb(Object *UNUSED(ob), ModifierData *md) { - SmokeModifierData *smd = (SmokeModifierData *)md; - return (smd->type & MOD_SMOKE_TYPE_COLL) && smd->coll; + FluidModifierData *mmd = (FluidModifierData *)md; + return (mmd->type & MOD_FLUID_TYPE_EFFEC) && mmd->effector; } static void updateDepsgraph(ModifierData *md, const ModifierUpdateDepsgraphContext *ctx) { - SmokeModifierData *smd = (SmokeModifierData *)md; + FluidModifierData *mmd = (FluidModifierData *)md; - if (smd && (smd->type & MOD_SMOKE_TYPE_DOMAIN) && smd->domain) { + if (mmd && (mmd->type & MOD_FLUID_TYPE_DOMAIN) && mmd->domain) { DEG_add_collision_relations(ctx->node, ctx->object, - smd->domain->fluid_group, - eModifierType_Smoke, + mmd->domain->fluid_group, + eModifierType_Fluid, is_flow_cb, - "Smoke Flow"); + "Fluid Flow"); DEG_add_collision_relations(ctx->node, ctx->object, - smd->domain->coll_group, - eModifierType_Smoke, + mmd->domain->effector_group, + eModifierType_Fluid, is_coll_cb, - "Smoke Coll"); + "Fluid Effector"); DEG_add_forcefield_relations(ctx->node, ctx->object, - smd->domain->effector_weights, + mmd->domain->effector_weights, true, PFIELD_SMOKEFLOW, - "Smoke Force Field"); + "Fluid Force Field"); + + if (mmd->domain->guiding_parent != NULL) { + DEG_add_object_relation( + ctx->node, mmd->domain->guiding_parent, DEG_OB_COMP_TRANSFORM, "Fluid Guiding Object"); + DEG_add_object_relation( + ctx->node, mmd->domain->guiding_parent, DEG_OB_COMP_GEOMETRY, "Fluid Guiding Object"); + } } } static void foreachIDLink(ModifierData *md, Object *ob, IDWalkFunc walk, void *userData) { - SmokeModifierData *smd = (SmokeModifierData *)md; + FluidModifierData *mmd = (FluidModifierData *)md; - if (smd->type == MOD_SMOKE_TYPE_DOMAIN && smd->domain) { - walk(userData, ob, (ID **)&smd->domain->coll_group, IDWALK_CB_NOP); - walk(userData, ob, (ID **)&smd->domain->fluid_group, IDWALK_CB_NOP); - walk(userData, ob, (ID **)&smd->domain->eff_group, IDWALK_CB_NOP); + if (mmd->type == MOD_FLUID_TYPE_DOMAIN && mmd->domain) { + walk(userData, ob, (ID **)&mmd->domain->effector_group, IDWALK_CB_NOP); + walk(userData, ob, (ID **)&mmd->domain->fluid_group, IDWALK_CB_NOP); + walk(userData, ob, (ID **)&mmd->domain->force_group, IDWALK_CB_NOP); + + if (mmd->domain->guiding_parent) { + walk(userData, ob, (ID **)&mmd->domain->guiding_parent, IDWALK_CB_NOP); + } - if (smd->domain->effector_weights) { - walk(userData, ob, (ID **)&smd->domain->effector_weights->group, IDWALK_CB_NOP); + if (mmd->domain->effector_weights) { + walk(userData, ob, (ID **)&mmd->domain->effector_weights->group, IDWALK_CB_NOP); } } - if (smd->type == MOD_SMOKE_TYPE_FLOW && smd->flow) { - walk(userData, ob, (ID **)&smd->flow->noise_texture, IDWALK_CB_USER); + if (mmd->type == MOD_FLUID_TYPE_FLOW && mmd->flow) { + walk(userData, ob, (ID **)&mmd->flow->noise_texture, IDWALK_CB_USER); } } -ModifierTypeInfo modifierType_Smoke = { - /* name */ "Smoke", - /* structName */ "SmokeModifierData", - /* structSize */ sizeof(SmokeModifierData), +ModifierTypeInfo modifierType_Fluid = { + /* name */ "Fluid", + /* structName */ "FluidModifierData", + /* structSize */ sizeof(FluidModifierData), /* type */ eModifierTypeType_Constructive, - /* flags */ eModifierTypeFlag_AcceptsMesh | eModifierTypeFlag_UsesPointCache | - eModifierTypeFlag_Single, + /* flags */ eModifierTypeFlag_AcceptsMesh | eModifierTypeFlag_Single, /* copyData */ copyData, diff --git a/source/blender/modifiers/intern/MOD_fluidsim.c b/source/blender/modifiers/intern/MOD_fluidsim.c deleted file mode 100644 index 620b21f3e0c..00000000000 --- a/source/blender/modifiers/intern/MOD_fluidsim.c +++ /dev/null @@ -1,150 +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) 2005 by the Blender Foundation. - * All rights reserved. - */ - -/** \file - * \ingroup modifiers - */ - -#include "BLI_utildefines.h" - -#include "DNA_mesh_types.h" -#include "DNA_scene_types.h" -#include "DNA_object_fluidsim_types.h" -#include "DNA_object_types.h" - -#include "BKE_layer.h" -#include "BKE_modifier.h" - -#include "DEG_depsgraph_build.h" - -#include "MOD_fluidsim_util.h" -#include "MOD_modifiertypes.h" - -#include "MEM_guardedalloc.h" - -/* Fluidsim */ -static void initData(ModifierData *md) -{ - FluidsimModifierData *fluidmd = (FluidsimModifierData *)md; - - fluidsim_init(fluidmd); -} -static void freeData(ModifierData *md) -{ - FluidsimModifierData *fluidmd = (FluidsimModifierData *)md; - - fluidsim_free(fluidmd); -} - -static void copyData(const ModifierData *md, ModifierData *target, const int UNUSED(flag)) -{ - const FluidsimModifierData *fluidmd = (const FluidsimModifierData *)md; - FluidsimModifierData *tfluidmd = (FluidsimModifierData *)target; - - /* Free any FSS that was allocated in initData() */ - if (tfluidmd->fss) { - MEM_SAFE_FREE(tfluidmd->fss->meshVelocities); - MEM_freeN(tfluidmd->fss); - } - - if (fluidmd->fss == NULL) { - tfluidmd->fss = NULL; - return; - } - - tfluidmd->fss = MEM_dupallocN(fluidmd->fss); - if (tfluidmd->fss->meshVelocities != NULL) { - tfluidmd->fss->meshVelocities = MEM_dupallocN(tfluidmd->fss->meshVelocities); - } -} - -static Mesh *applyModifier(ModifierData *md, const ModifierEvalContext *ctx, Mesh *mesh) -{ - FluidsimModifierData *fluidmd = (FluidsimModifierData *)md; - Mesh *result = NULL; - - /* check for alloc failing */ - if (!fluidmd->fss) { - initData(md); - - if (!fluidmd->fss) { - return mesh; - } - } - - result = fluidsimModifier_do(fluidmd, ctx, mesh); - - return result ? result : mesh; -} - -static void updateDepsgraph(ModifierData *md, const ModifierUpdateDepsgraphContext *ctx) -{ - FluidsimModifierData *fluidmd = (FluidsimModifierData *)md; - if (fluidmd && fluidmd->fss) { - if (fluidmd->fss->type == OB_FLUIDSIM_DOMAIN) { - FOREACH_SCENE_OBJECT_BEGIN (ctx->scene, ob1) { - if (ob1 != ctx->object) { - FluidsimModifierData *fluidmdtmp = (FluidsimModifierData *)modifiers_findByType( - ob1, eModifierType_Fluidsim); - - /* Only put dependencies from NON-DOMAIN fluids in here. */ - if (fluidmdtmp && fluidmdtmp->fss && (fluidmdtmp->fss->type != OB_FLUIDSIM_DOMAIN)) { - DEG_add_object_relation(ctx->node, ob1, DEG_OB_COMP_TRANSFORM, "Fluidsim Object"); - } - } - } - FOREACH_SCENE_OBJECT_END; - } - } -} - -static bool dependsOnTime(ModifierData *UNUSED(md)) -{ - return true; -} - -ModifierTypeInfo modifierType_Fluidsim = { - /* name */ "Fluidsim", - /* structName */ "FluidsimModifierData", - /* structSize */ sizeof(FluidsimModifierData), - /* type */ eModifierTypeType_Nonconstructive, - - /* flags */ eModifierTypeFlag_AcceptsMesh | eModifierTypeFlag_RequiresOriginalData | - eModifierTypeFlag_Single, - - /* copyData */ copyData, - - /* deformVerts */ NULL, - /* deformMatrices */ NULL, - /* deformVertsEM */ NULL, - /* deformMatricesEM */ NULL, - /* applyModifier */ applyModifier, - - /* initData */ initData, - /* requiredDataMask */ NULL, - /* freeData */ freeData, - /* isDisabled */ NULL, - /* updateDepsgraph */ updateDepsgraph, - /* dependsOnTime */ dependsOnTime, - /* dependsOnNormals */ NULL, - /* foreachObjectLink */ NULL, - /* foreachIDLink */ NULL, - /* foreachTexLink */ NULL, - /* freeRuntimeData */ NULL, -}; diff --git a/source/blender/modifiers/intern/MOD_fluidsim_util.c b/source/blender/modifiers/intern/MOD_fluidsim_util.c deleted file mode 100644 index 748bf4db4e2..00000000000 --- a/source/blender/modifiers/intern/MOD_fluidsim_util.c +++ /dev/null @@ -1,588 +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) 2005 by the Blender Foundation. - * All rights reserved. - */ - -/** \file - * \ingroup modifiers - */ - -#include <stddef.h> -#include <zlib.h> - -#include "BLI_utildefines.h" - -#ifdef WITH_MOD_FLUID -# include "BLI_blenlib.h" -# include "BLI_math.h" -#endif - -#include "DNA_object_types.h" -#include "DNA_scene_types.h" -#include "DNA_mesh_types.h" -#include "DNA_meshdata_types.h" -#include "DNA_object_fluidsim_types.h" - -#include "BKE_fluidsim.h" /* ensure definitions here match */ -#include "BKE_mesh.h" -#ifdef WITH_MOD_FLUID -# include "BKE_global.h" -# include "BKE_library.h" -#endif - -#include "DEG_depsgraph.h" -#include "DEG_depsgraph_query.h" - -#include "MOD_fluidsim_util.h" -#include "MOD_modifiertypes.h" - -#include "MEM_guardedalloc.h" - -// headers for fluidsim bobj meshes -#include "LBM_fluidsim.h" - -void fluidsim_init(FluidsimModifierData *fluidmd) -{ -#ifdef WITH_MOD_FLUID - if (fluidmd) { - FluidsimSettings *fss = MEM_callocN(sizeof(FluidsimSettings), "fluidsimsettings"); - - fluidmd->fss = fss; - - if (!fss) { - return; - } - - fss->fmd = fluidmd; - fss->type = OB_FLUIDSIM_ENABLE; - fss->threads = 0; - fss->show_advancedoptions = 0; - - fss->resolutionxyz = 65; - fss->previewresxyz = 45; - fss->realsize = 0.5; - fss->guiDisplayMode = OB_FSDOM_PREVIEW; - fss->renderDisplayMode = OB_FSDOM_FINAL; - - fss->viscosityValue = 1.0; - fss->viscosityExponent = 6; - - fss->grav[0] = 0.0; - fss->grav[1] = 0.0; - fss->grav[2] = -9.81; - - fss->animStart = 0.0; - fss->animEnd = 4.0; - fss->animRate = 1.0; - fss->gstar = 0.005; // used as normgstar - fss->maxRefine = -1; - /* maxRefine is set according to resolutionxyz during bake */ - - /* fluid/inflow settings - * fss->iniVel --> automatically set to 0 */ - - modifier_path_init(fss->surfdataPath, sizeof(fss->surfdataPath), OB_FLUIDSIM_SURF_DIR_DEFAULT); - - /* first init of bounding box */ - /* no bounding box needed */ - - /* todo - reuse default init from elbeem! */ - fss->typeFlags = OB_FSBND_PARTSLIP | OB_FSSG_NOOBS; - fss->domainNovecgen = 0; - fss->volumeInitType = 1; /* volume */ - fss->partSlipValue = 0.2; - - fss->generateTracers = 0; - fss->generateParticles = 0.0; - fss->surfaceSmoothing = 1.0; - fss->surfaceSubdivs = 0.0; - fss->particleInfSize = 0.0; - fss->particleInfAlpha = 0.0; - - /* init fluid control settings */ - fss->attractforceStrength = 0.2; - fss->attractforceRadius = 0.75; - fss->velocityforceStrength = 0.2; - fss->velocityforceRadius = 0.75; - fss->cpsTimeStart = fss->animStart; - fss->cpsTimeEnd = fss->animEnd; - fss->cpsQuality = 10.0; // 1.0 / 10.0 => means 0.1 width - - /* - * BAD TODO: this is done in buttons_object.c in the moment - * Mesh *mesh = ob->data; - * // calculate bounding box - * fluid_get_bb(mesh->mvert, mesh->totvert, ob->obmat, fss->bbStart, fss->bbSize); - */ - - fss->meshVelocities = NULL; - - fss->lastgoodframe = -1; - - fss->flag |= OB_FLUIDSIM_ACTIVE; - } -#else - (void)fluidmd; /* unused */ -#endif - return; -} - -void fluidsim_free(FluidsimModifierData *fluidmd) -{ - if (fluidmd && fluidmd->fss) { - if (fluidmd->fss->meshVelocities) { - MEM_freeN(fluidmd->fss->meshVelocities); - } - MEM_SAFE_FREE(fluidmd->fss); - } - - return; -} - -#ifdef WITH_MOD_FLUID -/* read .bobj.gz file into a fluidsimMesh struct */ -static Mesh *fluidsim_read_obj(const char *filename, const MPoly *mp_example) -{ - int wri = 0, i; - int gotBytes; - gzFile gzf; - int numverts = 0, numfaces = 0; - Mesh *mesh = NULL; - MPoly *mp; - MLoop *ml; - MVert *mv; - short *normals, *no_s; - float no[3]; - - const short mp_mat_nr = mp_example->mat_nr; - const char mp_flag = mp_example->flag; - - /* ------------------------------------------------ - * get numverts + numfaces first - * ------------------------------------------------ */ - gzf = BLI_gzopen(filename, "rb"); - if (!gzf) { - return NULL; - } - - /* read numverts */ - gotBytes = gzread(gzf, &wri, sizeof(wri)); - numverts = wri; - - /* skip verts */ - gotBytes = gzseek(gzf, numverts * 3 * sizeof(float), SEEK_CUR) != -1; - - /* read number of normals */ - if (gotBytes) { - gotBytes = gzread(gzf, &wri, sizeof(wri)); - } - - /* skip normals */ - gotBytes = gzseek(gzf, numverts * 3 * sizeof(float), SEEK_CUR) != -1; - - /* get no. of triangles */ - if (gotBytes) { - gotBytes = gzread(gzf, &wri, sizeof(wri)); - } - numfaces = wri; - - gzclose(gzf); - /* ------------------------------------------------ */ - - if (!numfaces || !numverts || !gotBytes) { - return NULL; - } - - gzf = BLI_gzopen(filename, "rb"); - if (!gzf) { - return NULL; - } - - mesh = BKE_mesh_new_nomain(numverts, 0, 0, numfaces * 3, numfaces); - - if (!mesh) { - gzclose(gzf); - return NULL; - } - - /* read numverts */ - gotBytes = gzread(gzf, &wri, sizeof(wri)); - - /* read vertex position from file */ - mv = mesh->mvert; - - for (i = 0; i < numverts; i++, mv++) { - gotBytes = gzread(gzf, mv->co, sizeof(float) * 3); - } - - /* should be the same as numverts */ - gotBytes = gzread(gzf, &wri, sizeof(wri)); - if (wri != numverts) { - if (mesh) { - BKE_id_free(NULL, mesh); - } - gzclose(gzf); - return NULL; - } - - normals = MEM_calloc_arrayN(numverts, 3 * sizeof(short), "fluid_tmp_normals"); - if (!normals) { - if (mesh) { - BKE_id_free(NULL, mesh); - } - gzclose(gzf); - return NULL; - } - - /* read normals from file (but don't save them yet) */ - for (i = numverts, no_s = normals; i > 0; i--, no_s += 3) { - gotBytes = gzread(gzf, no, sizeof(float) * 3); - normal_float_to_short_v3(no_s, no); - } - - /* read no. of triangles */ - gotBytes = gzread(gzf, &wri, sizeof(wri)); - - if (wri != numfaces) { - printf("Fluidsim: error in reading data from file.\n"); - if (mesh) { - BKE_id_free(NULL, mesh); - } - gzclose(gzf); - MEM_freeN(normals); - return NULL; - } - - /* read triangles from file */ - mp = mesh->mpoly; - ml = mesh->mloop; - for (i = 0; i < numfaces; i++, mp++, ml += 3) { - int face[3]; - - gotBytes = gzread(gzf, face, sizeof(int) * 3); - - /* initialize from existing face */ - mp->mat_nr = mp_mat_nr; - mp->flag = mp_flag; - - mp->loopstart = i * 3; - mp->totloop = 3; - - ml[0].v = face[0]; - ml[1].v = face[1]; - ml[2].v = face[2]; - } - - gzclose(gzf); - - BKE_mesh_calc_edges(mesh, false, false); - BKE_mesh_vert_normals_apply(mesh, (short(*)[3])normals); - MEM_freeN(normals); - - // CDDM_calc_normals(result); - return mesh; -} - -void fluid_get_bb(MVert *mvert, - int totvert, - float obmat[4][4], - /*RET*/ float start[3], - /*RET*/ float size[3]) -{ - float bbsx = 0.0, bbsy = 0.0, bbsz = 0.0; - float bbex = 1.0, bbey = 1.0, bbez = 1.0; - int i; - float vec[3]; - - if (totvert == 0) { - zero_v3(start); - zero_v3(size); - return; - } - - copy_v3_v3(vec, mvert[0].co); - mul_m4_v3(obmat, vec); - bbsx = vec[0]; - bbsy = vec[1]; - bbsz = vec[2]; - bbex = vec[0]; - bbey = vec[1]; - bbez = vec[2]; - - for (i = 1; i < totvert; i++) { - copy_v3_v3(vec, mvert[i].co); - mul_m4_v3(obmat, vec); - - if (vec[0] < bbsx) { - bbsx = vec[0]; - } - if (vec[1] < bbsy) { - bbsy = vec[1]; - } - if (vec[2] < bbsz) { - bbsz = vec[2]; - } - if (vec[0] > bbex) { - bbex = vec[0]; - } - if (vec[1] > bbey) { - bbey = vec[1]; - } - if (vec[2] > bbez) { - bbez = vec[2]; - } - } - - /* return values... */ - if (start) { - start[0] = bbsx; - start[1] = bbsy; - start[2] = bbsz; - } - if (size) { - size[0] = bbex - bbsx; - size[1] = bbey - bbsy; - size[2] = bbez - bbsz; - } -} - -//------------------------------------------------------------------------------- -// old interface -//------------------------------------------------------------------------------- - -void fluid_estimate_memory(Object *ob, FluidsimSettings *fss, char *value) -{ - Mesh *mesh; - - value[0] = '\0'; - - if (ob->type == OB_MESH) { - /* use mesh bounding box and object scaling */ - mesh = ob->data; - - fluid_get_bb(mesh->mvert, mesh->totvert, ob->obmat, fss->bbStart, fss->bbSize); - elbeemEstimateMemreq( - fss->resolutionxyz, fss->bbSize[0], fss->bbSize[1], fss->bbSize[2], fss->maxRefine, value); - } -} - -/* read zipped fluidsim velocities into the co's of the fluidsimsettings normals struct */ -static void fluidsim_read_vel_cache(FluidsimModifierData *fluidmd, Mesh *mesh, char *filename) -{ - int wri, i, j; - float wrf; - gzFile gzf; - FluidsimSettings *fss = fluidmd->fss; - int len = strlen(filename); - int totvert = mesh->totvert; - FluidVertexVelocity *velarray = NULL; - - /* mesh and vverts have to be valid from loading... */ - - if (fss->meshVelocities) { - MEM_freeN(fss->meshVelocities); - } - - if (len < 7) { - return; - } - - if (fss->domainNovecgen > 0) { - return; - } - - fss->meshVelocities = MEM_calloc_arrayN( - mesh->totvert, sizeof(FluidVertexVelocity), "Fluidsim_velocities"); - fss->totvert = totvert; - - velarray = fss->meshVelocities; - - /* .bobj.gz, correct filename - * 87654321 */ - filename[len - 6] = 'v'; - filename[len - 5] = 'e'; - filename[len - 4] = 'l'; - - gzf = BLI_gzopen(filename, "rb"); - if (!gzf) { - MEM_freeN(fss->meshVelocities); - fss->meshVelocities = NULL; - return; - } - - gzread(gzf, &wri, sizeof(wri)); - if (wri != totvert) { - MEM_freeN(fss->meshVelocities); - fss->meshVelocities = NULL; - return; - } - - for (i = 0; i < totvert; i++) { - for (j = 0; j < 3; j++) { - gzread(gzf, &wrf, sizeof(wrf)); - velarray[i].vel[j] = wrf; - } - } - - gzclose(gzf); -} - -static Mesh *fluidsim_read_cache( - Object *ob, Mesh *orgmesh, FluidsimModifierData *fluidmd, int framenr, int useRenderParams) -{ - int curFrame = framenr /* - 1 */ /*scene->r.sfra*/; /* start with 0 at start frame */ - /* why start with 0 as start frame?? Animations + time are frozen for frame 0 anyway. - * (See physics_fluid.c for that. - DG) */ - /* If we start with frame 0, we need to remap all animation channels, too, - * because they will all be 1 frame late if using frame-1! - DG */ - - char targetFile[FILE_MAX]; - FluidsimSettings *fss = fluidmd->fss; - Mesh *newmesh = NULL; - MPoly *mpoly; - MPoly mp_example = {0}; - - const int displaymode = useRenderParams ? fss->renderDisplayMode : fss->guiDisplayMode; - - switch (displaymode) { - case OB_FSDOM_GEOM: - /* just display original object */ - return NULL; - case OB_FSDOM_PREVIEW: - /* use preview mesh */ - BLI_join_dirfile( - targetFile, sizeof(targetFile), fss->surfdataPath, OB_FLUIDSIM_SURF_PREVIEW_OBJ_FNAME); - break; - case OB_FSDOM_FINAL: - /* use final mesh */ - BLI_join_dirfile( - targetFile, sizeof(targetFile), fss->surfdataPath, OB_FLUIDSIM_SURF_FINAL_OBJ_FNAME); - break; - default: - BLI_assert(!"Wrong fluidsim display type"); - return NULL; - } - - /* offset baked frame */ - curFrame += fss->frameOffset; - - BLI_path_abs(targetFile, modifier_path_relbase_from_global(ob)); - BLI_path_frame(targetFile, curFrame, 0); // fixed #frame-no - - /* assign material + flags to new mesh. - * if there's no faces in original mesh, keep materials and flags unchanged */ - mpoly = orgmesh->mpoly; - if (mpoly) { - mp_example = *mpoly; - } - /* else leave NULL'd */ - - newmesh = fluidsim_read_obj(targetFile, &mp_example); - - if (!newmesh) { - /* switch, abort background rendering when fluidsim mesh is missing */ - const char *strEnvName2 = "BLENDER_ELBEEMBOBJABORT"; // from blendercall.cpp - - if (G.background == 1) { - if (BLI_getenv(strEnvName2)) { - int elevel = atoi(BLI_getenv(strEnvName2)); - if (elevel > 0) { - printf("Env. var %s set, fluid sim mesh '%s' not found, aborting render...\n", - strEnvName2, - targetFile); - exit(1); - } - } - } - - /* display org. object upon failure which is in new mesh */ - return NULL; - } - - BKE_mesh_copy_settings(newmesh, orgmesh); - - /* Fluid simulation has a texture space that based on the bounds of the fluid mesh. - * This does not seem particularly useful, but it's backwards compatible. */ - BKE_mesh_texspace_calc(newmesh); - - /* load vertex velocities, if they exist... - * TODO? use generate flag as loading flag as well? - * warning, needs original .bobj.gz mesh loading filename */ - if (displaymode == OB_FSDOM_FINAL) { - fluidsim_read_vel_cache(fluidmd, newmesh, targetFile); - } - else { - if (fss->meshVelocities) { - MEM_freeN(fss->meshVelocities); - } - - fss->meshVelocities = NULL; - } - - return newmesh; -} -#endif // WITH_MOD_FLUID - -Mesh *fluidsimModifier_do(FluidsimModifierData *fluidmd, - const ModifierEvalContext *ctx, - Mesh *mesh) -{ -#ifdef WITH_MOD_FLUID - Object *ob = ctx->object; - Depsgraph *depsgraph = ctx->depsgraph; - const bool useRenderParams = (ctx->flag & MOD_APPLY_RENDER) != 0; - // const bool isFinalCalc = (ctx->flag & MOD_APPLY_USECACHE) != 0; - Mesh *result = NULL; - int framenr; - FluidsimSettings *fss = NULL; - - framenr = (int)DEG_get_ctime(depsgraph); - - /* only handle fluidsim domains */ - if (fluidmd && fluidmd->fss && (fluidmd->fss->type != OB_FLUIDSIM_DOMAIN)) { - return mesh; - } - - /* sanity check */ - if (!fluidmd || !fluidmd->fss) { - return mesh; - } - - fss = fluidmd->fss; - - /* timescale not supported yet - * clmd->sim_parms->timescale = timescale; */ - - /* support reversing of baked fluid frames here */ - if ((fss->flag & OB_FLUIDSIM_REVERSE) && (fss->lastgoodframe >= 0)) { - framenr = fss->lastgoodframe - framenr + 1; - CLAMP(framenr, 1, fss->lastgoodframe); - } - - /* try to read from cache */ - /* if the frame is there, fine, otherwise don't do anything */ - if ((result = fluidsim_read_cache(ob, mesh, fluidmd, framenr, useRenderParams))) { - return result; - } - - return mesh; -#else - /* unused */ - UNUSED_VARS(fluidmd, ctx, mesh); - return NULL; -#endif -} diff --git a/source/blender/modifiers/intern/MOD_fluidsim_util.h b/source/blender/modifiers/intern/MOD_fluidsim_util.h deleted file mode 100644 index da70568353e..00000000000 --- a/source/blender/modifiers/intern/MOD_fluidsim_util.h +++ /dev/null @@ -1,39 +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 modifiers - */ - -#ifndef __MOD_FLUIDSIM_UTIL_H__ -#define __MOD_FLUIDSIM_UTIL_H__ - -struct FluidsimModifierData; -struct Mesh; -struct ModifierEvalContext; - -/* new fluid-modifier interface */ -void fluidsim_init(struct FluidsimModifierData *fluidmd); -void fluidsim_free(struct FluidsimModifierData *fluidmd); - -struct Mesh *fluidsimModifier_do(struct FluidsimModifierData *fluidmd, - const struct ModifierEvalContext *ctx, - struct Mesh *me); - -#endif diff --git a/source/blender/modifiers/intern/MOD_util.c b/source/blender/modifiers/intern/MOD_util.c index 05bd8b5e01a..0b72c31ad7b 100644 --- a/source/blender/modifiers/intern/MOD_util.c +++ b/source/blender/modifiers/intern/MOD_util.c @@ -279,12 +279,11 @@ void modifier_type_init(ModifierTypeInfo *types[]) INIT_TYPE(ParticleInstance); INIT_TYPE(Explode); INIT_TYPE(Shrinkwrap); - INIT_TYPE(Fluidsim); INIT_TYPE(Mask); INIT_TYPE(SimpleDeform); INIT_TYPE(Multires); INIT_TYPE(Surface); - INIT_TYPE(Smoke); + INIT_TYPE(Fluid); INIT_TYPE(ShapeKey); INIT_TYPE(Solidify); INIT_TYPE(Screw); diff --git a/source/blender/python/intern/CMakeLists.txt b/source/blender/python/intern/CMakeLists.txt index d5f0e2fb863..012492fe9a7 100644 --- a/source/blender/python/intern/CMakeLists.txt +++ b/source/blender/python/intern/CMakeLists.txt @@ -33,6 +33,7 @@ set(INC ../../windowmanager ../../../../intern/clog ../../../../intern/guardedalloc + ../../../../intern/mantaflow/extern ../../../../intern/opencolorio ) @@ -257,10 +258,6 @@ if(WITH_LIBMV) add_definitions(-DWITH_LIBMV) endif() -if(WITH_MOD_FLUID) - add_definitions(-DWITH_MOD_FLUID) -endif() - if(WITH_MOD_OCEANSIM) add_definitions(-DWITH_OCEANSIM) endif() @@ -269,8 +266,8 @@ if(WITH_MOD_REMESH) add_definitions(-DWITH_MOD_REMESH) endif() -if(WITH_MOD_SMOKE) - add_definitions(-DWITH_SMOKE) +if(WITH_MOD_FLUID) + add_definitions(-DWITH_FLUID) endif() if(WITH_OPENCOLLADA) diff --git a/source/blender/python/intern/bpy_app_build_options.c b/source/blender/python/intern/bpy_app_build_options.c index ee6a3fd41d8..7d2645e7776 100644 --- a/source/blender/python/intern/bpy_app_build_options.c +++ b/source/blender/python/intern/bpy_app_build_options.c @@ -51,16 +51,15 @@ static PyStructSequence_Field app_builtopts_info_fields[] = { {(char *)"sdl_dynload", NULL}, {(char *)"jack", NULL}, {(char *)"libmv", NULL}, - {(char *)"mod_fluid", NULL}, {(char *)"mod_oceansim", NULL}, {(char *)"mod_remesh", NULL}, - {(char *)"mod_smoke", NULL}, {(char *)"collada", NULL}, {(char *)"opencolorio", NULL}, {(char *)"openmp", NULL}, {(char *)"openvdb", NULL}, {(char *)"alembic", NULL}, {(char *)"usd", NULL}, + {(char *)"fluid", NULL}, {NULL}, }; @@ -222,12 +221,6 @@ static PyObject *make_builtopts_info(void) SetObjIncref(Py_False); #endif -#ifdef WITH_MOD_FLUID - SetObjIncref(Py_True); -#else - SetObjIncref(Py_False); -#endif - #ifdef WITH_OCEANSIM SetObjIncref(Py_True); #else @@ -240,12 +233,6 @@ static PyObject *make_builtopts_info(void) SetObjIncref(Py_False); #endif -#ifdef WITH_SMOKE - SetObjIncref(Py_True); -#else - SetObjIncref(Py_False); -#endif - #ifdef WITH_COLLADA SetObjIncref(Py_True); #else @@ -282,6 +269,12 @@ static PyObject *make_builtopts_info(void) SetObjIncref(Py_False); #endif +#ifdef WITH_FLUID + SetObjIncref(Py_True); +#else + SetObjIncref(Py_False); +#endif + #undef SetObjIncref return builtopts_info; diff --git a/source/blender/python/intern/bpy_interface.c b/source/blender/python/intern/bpy_interface.c index 2b9556e998a..bbf9b03cdd7 100644 --- a/source/blender/python/intern/bpy_interface.c +++ b/source/blender/python/intern/bpy_interface.c @@ -197,8 +197,15 @@ void BPY_context_set(bContext *C) BPy_SetContext(C); } +#ifdef WITH_FLUID +/* defined in manta module */ +extern PyObject *Manta_initPython(void); +#endif + +#ifdef WITH_AUDASPACE /* defined in AUD_C-API.cpp */ extern PyObject *AUD_initPython(void); +#endif #ifdef WITH_CYCLES /* defined in cycles module */ @@ -225,6 +232,9 @@ static struct _inittab bpy_internal_modules[] = { {"bmesh.utils", BPyInit_bmesh_utils}, {"bmesh.utils", BPyInit_bmesh_geometry}, #endif +#ifdef WITH_FLUID + {"manta", Manta_initPython}, +#endif #ifdef WITH_AUDASPACE {"aud", AUD_initPython}, #endif @@ -285,6 +295,12 @@ void BPY_python_start(int argc, const char **argv) /* Initialize thread support (also acquires lock) */ PyEval_InitThreads(); + + /* (sebbas): Required to prevent assertion error */ + /* see: + * https://stackoverflow.com/questions/27844676/assertionerror-3-x-only-when-calling-py-finalize-with-threads + */ + Py_DECREF(PyImport_ImportModule("threading")); #else (void)argc; (void)argv; diff --git a/source/blender/render/CMakeLists.txt b/source/blender/render/CMakeLists.txt index e265197646c..a92be8509d5 100644 --- a/source/blender/render/CMakeLists.txt +++ b/source/blender/render/CMakeLists.txt @@ -36,7 +36,7 @@ set(INC ../../../intern/atomic ../../../intern/guardedalloc ../../../intern/mikktspace - ../../../intern/smoke/extern + ../../../intern/mantaflow/extern ) set(INC_SYS @@ -86,8 +86,8 @@ if(WITH_IMAGE_OPENEXR) add_definitions(-DWITH_OPENEXR) endif() -if(WITH_MOD_SMOKE) - add_definitions(-DWITH_SMOKE) +if(WITH_MOD_FLUID) + add_definitions(-DWITH_FLUID) endif() if(WITH_FREESTYLE) diff --git a/source/blender/shader_fx/CMakeLists.txt b/source/blender/shader_fx/CMakeLists.txt index 57c7345076e..6d918763996 100644 --- a/source/blender/shader_fx/CMakeLists.txt +++ b/source/blender/shader_fx/CMakeLists.txt @@ -30,7 +30,6 @@ set(INC ../makesdna ../makesrna ../render/extern/include - ../../../intern/elbeem/extern ../../../intern/eigen ../../../intern/guardedalloc ) |