blender
/
blender
136
404
Fork 586
Code Issues 6.2k Pull Requests 761 Projects 19 Wiki Activity

Mantaflow [Part 6]: Updates in /blender/source 

A collection of smaller changes that are required in the /blender/source files. A lot of them are also due to variable renaming.

Reviewed By: sergey

Maniphest Tasks: T59995

Differential Revision: https://developer.blender.org/D3855
This commit is contained in:
Sebastián Barschkis 2019-12-16 15:50:14 +01:00
parent 7b87d3d34e
commit d27ccf990c
79 changed files with 1262 additions and 7989 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
extern/CMakeLists.txt vendored
View File

@ -105,3 +105,7 @@ if(WITH_QUADRIFLOW)
set(QUADRIFLOW_CMAKE_CFG ${CMAKE_CURRENT_SOURCE_DIR}/quadriflow/blender_config.cmake)
add_subdirectory(quadriflow)
endif()
if(WITH_MOD_FLUID)
add_subdirectory(mantaflow)
endif()

203
extern/mantaflow/CMakeLists.txt vendored Normal file
View File

@ -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}")

12
intern/CMakeLists.txt
View File

@ -40,14 +40,6 @@ if(WITH_MOD_REMESH)
add_subdirectory(dualcon)
endif()
if(WITH_MOD_FLUID)
add_subdirectory(elbeem)
endif()
if(WITH_MOD_SMOKE)
add_subdirectory(smoke)
endif()
if(WITH_IK_SOLVER)
add_subdirectory(iksolver)
endif()
@ -73,6 +65,10 @@ if(WIN32)
add_subdirectory(utfconv)
endif()
if(WITH_MOD_FLUID)
add_subdirectory(mantaflow)
endif()
if(WITH_OPENVDB)
add_subdirectory(openvdb)
endif()

21
intern/cycles/blender/blender_mesh.cpp
View File

@ -283,7 +283,7 @@ static void mikk_compute_tangents(
static void create_mesh_volume_attribute(
BL::Object &b_ob, Mesh *mesh, ImageManager *image_manager, AttributeStandard std, float frame)
{
BL::SmokeDomainSettings b_domain = object_smoke_domain_find(b_ob);
BL::FluidDomainSettings b_domain = object_fluid_domain_find(b_ob);
if (!b_domain)
return;
@ -930,13 +930,13 @@ static void sync_mesh_fluid_motion(BL::Object &b_ob, Scene *scene, Mesh *mesh)
if (scene->need_motion() == Scene::MOTION_NONE)
return;
BL::DomainFluidSettings b_fluid_domain = object_fluid_domain_find(b_ob);
BL::FluidDomainSettings b_fluid_domain = object_fluid_domain_find(b_ob);
if (!b_fluid_domain)
return;
/* If the mesh has modifiers following the fluid domain we can't export motion. */
if (b_fluid_domain.fluid_mesh_vertices.length() != mesh->verts.size())
if (b_fluid_domain.mesh_vertices.length() != mesh->verts.size())
return;
/* Find or add attribute */
@ -953,13 +953,12 @@ static void sync_mesh_fluid_motion(BL::Object &b_ob, Scene *scene, Mesh *mesh)
float relative_time = motion_times[step] * scene->motion_shutter_time() * 0.5f;
float3 *mP = attr_mP->data_float3() + step * mesh->verts.size();
BL::DomainFluidSettings::fluid_mesh_vertices_iterator fvi;
BL::FluidDomainSettings::mesh_vertices_iterator svi;
int i = 0;
for (b_fluid_domain.fluid_mesh_vertices.begin(fvi);
fvi != b_fluid_domain.fluid_mesh_vertices.end();
++fvi, ++i) {
mP[i] = P[i] + get_float3(fvi->velocity()) * relative_time;
for (b_fluid_domain.mesh_vertices.begin(svi); svi != b_fluid_domain.mesh_vertices.end();
++svi, ++i) {
mP[i] = P[i] + get_float3(svi->velocity()) * relative_time;
}
}
}
@ -1099,7 +1098,7 @@ Mesh *BlenderSync::sync_mesh(BL::Depsgraph &b_depsgraph,
}
mesh->geometry_flags = requested_geometry_flags;
/* fluid motion */
/* mesh fluid motion mantaflow */
sync_mesh_fluid_motion(b_ob, scene, mesh);
/* tag update */
@ -1148,8 +1147,8 @@ void BlenderSync::sync_mesh_motion(BL::Depsgraph &b_depsgraph,
* would need a more extensive check to see which objects are animated */
BL::Mesh b_mesh(PointerRNA_NULL);
/* fluid motion is exported immediate with mesh, skip here */
BL::DomainFluidSettings b_fluid_domain = object_fluid_domain_find(b_ob);
/* manta motion is exported immediate with mesh, skip here */
BL::FluidDomainSettings b_fluid_domain = object_fluid_domain_find(b_ob);
if (b_fluid_domain)
return;

32
intern/cycles/blender/blender_session.cpp
View File

@ -1158,7 +1158,7 @@ void BlenderSession::builtin_image_info(const string &builtin_name,
else if (b_id.is_a(&RNA_Object)) {
/* smoke volume data */
BL::Object b_ob(b_id);
BL::SmokeDomainSettings b_domain = object_smoke_domain_find(b_ob);
BL::FluidDomainSettings b_domain = object_fluid_domain_find(b_ob);
metadata.is_float = true;
metadata.depth = 1;
@ -1180,7 +1180,7 @@ void BlenderSession::builtin_image_info(const string &builtin_name,
return;
int3 resolution = get_int3(b_domain.domain_resolution());
int amplify = (b_domain.use_high_resolution()) ? b_domain.amplify() + 1 : 1;
int amplify = (b_domain.use_noise()) ? b_domain.noise_scale() : 1;
/* Velocity and heat data is always low-resolution. */
if (builtin_name == Attribute::standard_name(ATTR_STD_VOLUME_VELOCITY) ||
@ -1339,14 +1339,14 @@ bool BlenderSession::builtin_image_float_pixels(const string &builtin_name,
else if (b_id.is_a(&RNA_Object)) {
/* smoke volume data */
BL::Object b_ob(b_id);
BL::SmokeDomainSettings b_domain = object_smoke_domain_find(b_ob);
BL::FluidDomainSettings b_domain = object_fluid_domain_find(b_ob);
if (!b_domain) {
return false;
}
int3 resolution = get_int3(b_domain.domain_resolution());
int length, amplify = (b_domain.use_high_resolution()) ? b_domain.amplify() + 1 : 1;
int length, amplify = (b_domain.use_noise()) ? b_domain.noise_scale() : 1;
/* Velocity and heat data is always low-resolution. */
if (builtin_name == Attribute::standard_name(ATTR_STD_VOLUME_VELOCITY) ||
@ -1360,47 +1360,47 @@ bool BlenderSession::builtin_image_float_pixels(const string &builtin_name,
const size_t num_pixels = ((size_t)width) * height * depth;
if (builtin_name == Attribute::standard_name(ATTR_STD_VOLUME_DENSITY)) {
SmokeDomainSettings_density_grid_get_length(&b_domain.ptr, &length);
FluidDomainSettings_density_grid_get_length(&b_domain.ptr, &length);
if (length == num_pixels) {
SmokeDomainSettings_density_grid_get(&b_domain.ptr, pixels);
FluidDomainSettings_density_grid_get(&b_domain.ptr, pixels);
return true;
}
}
else if (builtin_name == Attribute::standard_name(ATTR_STD_VOLUME_FLAME)) {
/* this is in range 0..1, and interpreted by the OpenGL smoke viewer
* as 1500..3000 K with the first part faded to zero density */
SmokeDomainSettings_flame_grid_get_length(&b_domain.ptr, &length);
FluidDomainSettings_flame_grid_get_length(&b_domain.ptr, &length);
if (length == num_pixels) {
SmokeDomainSettings_flame_grid_get(&b_domain.ptr, pixels);
FluidDomainSettings_flame_grid_get(&b_domain.ptr, pixels);
return true;
}
}
else if (builtin_name == Attribute::standard_name(ATTR_STD_VOLUME_COLOR)) {
/* the RGB is "premultiplied" by density for better interpolation results */
SmokeDomainSettings_color_grid_get_length(&b_domain.ptr, &length);
FluidDomainSettings_color_grid_get_length(&b_domain.ptr, &length);
if (length == num_pixels * 4) {
SmokeDomainSettings_color_grid_get(&b_domain.ptr, pixels);
FluidDomainSettings_color_grid_get(&b_domain.ptr, pixels);
return true;
}
}
else if (builtin_name == Attribute::standard_name(ATTR_STD_VOLUME_VELOCITY)) {
SmokeDomainSettings_velocity_grid_get_length(&b_domain.ptr, &length);
FluidDomainSettings_velocity_grid_get_length(&b_domain.ptr, &length);
if (length == num_pixels * 3) {
SmokeDomainSettings_velocity_grid_get(&b_domain.ptr, pixels);
FluidDomainSettings_velocity_grid_get(&b_domain.ptr, pixels);
return true;
}
}
else if (builtin_name == Attribute::standard_name(ATTR_STD_VOLUME_HEAT)) {
SmokeDomainSettings_heat_grid_get_length(&b_domain.ptr, &length);
FluidDomainSettings_heat_grid_get_length(&b_domain.ptr, &length);
if (length == num_pixels) {
SmokeDomainSettings_heat_grid_get(&b_domain.ptr, pixels);
FluidDomainSettings_heat_grid_get(&b_domain.ptr, pixels);
return true;
}
}
else if (builtin_name == Attribute::standard_name(ATTR_STD_VOLUME_TEMPERATURE)) {
SmokeDomainSettings_temperature_grid_get_length(&b_domain.ptr, &length);
FluidDomainSettings_temperature_grid_get_length(&b_domain.ptr, &length);
if (length == num_pixels) {
SmokeDomainSettings_temperature_grid_get(&b_domain.ptr, pixels);
FluidDomainSettings_temperature_grid_get(&b_domain.ptr, pixels);
return true;
}
}

29
intern/cycles/blender/blender_util.h
View File

@ -537,37 +537,20 @@ static inline bool object_use_deform_motion(BL::Object &b_parent, BL::Object &b_
return use_deform_motion;
}
static inline BL::SmokeDomainSettings object_smoke_domain_find(BL::Object &b_ob)
static inline BL::FluidDomainSettings object_fluid_domain_find(BL::Object &b_ob)
{
BL::Object::modifiers_iterator b_mod;
for (b_ob.modifiers.begin(b_mod); b_mod != b_ob.modifiers.end(); ++b_mod) {
if (b_mod->is_a(&RNA_SmokeModifier)) {
BL::SmokeModifier b_smd(*b_mod);
if (b_mod->is_a(&RNA_FluidModifier)) {
BL::FluidModifier b_mmd(*b_mod);
if (b_smd.smoke_type() == BL::SmokeModifier::smoke_type_DOMAIN)
return b_smd.domain_settings();
if (b_mmd.fluid_type() == BL::FluidModifier::fluid_type_DOMAIN)
return b_mmd.domain_settings();
}
}
return BL::SmokeDomainSettings(PointerRNA_NULL);
}
static inline BL::DomainFluidSettings object_fluid_domain_find(BL::Object b_ob)
{
BL::Object::modifiers_iterator b_mod;
for (b_ob.modifiers.begin(b_mod); b_mod != b_ob.modifiers.end(); ++b_mod) {
if (b_mod->is_a(&RNA_FluidSimulationModifier)) {
BL::FluidSimulationModifier b_fmd(*b_mod);
BL::FluidSettings fss = b_fmd.settings();
if (fss.type() == BL::FluidSettings::type_DOMAIN)
return (BL::DomainFluidSettings)b_fmd.settings();
}
}
return BL::DomainFluidSettings(PointerRNA_NULL);
return BL::FluidDomainSettings(PointerRNA_NULL);
}
static inline Mesh::SubdivisionType object_subdivision_type(BL::Object &b_ob,

0
release/datafiles/blender_icons16/icon16_mod_smoke.dat → release/datafiles/blender_icons16/icon16_mod_fluid.dat
View File

0
release/datafiles/blender_icons32/icon32_mod_smoke.dat → release/datafiles/blender_icons32/icon32_mod_fluid.dat
View File

2
release/datafiles/locale

@ -1 +1 @@
Subproject commit b0b6396312e7ceb78826d423f8f152ddba01c039
Subproject commit 8a05b618f031582c006c6f62b9e60619ab3eef8b

2
source/blender/CMakeLists.txt
View File

@ -53,6 +53,7 @@ set(SRC_DNA_INC
${CMAKE_CURRENT_SOURCE_DIR}/makesdna/DNA_linestyle_types.h
${CMAKE_CURRENT_SOURCE_DIR}/makesdna/DNA_listBase.h
${CMAKE_CURRENT_SOURCE_DIR}/makesdna/DNA_mask_types.h
${CMAKE_CURRENT_SOURCE_DIR}/makesdna/DNA_fluid_types.h
${CMAKE_CURRENT_SOURCE_DIR}/makesdna/DNA_material_types.h
${CMAKE_CURRENT_SOURCE_DIR}/makesdna/DNA_mesh_types.h
${CMAKE_CURRENT_SOURCE_DIR}/makesdna/DNA_meshdata_types.h
@ -75,7 +76,6 @@ set(SRC_DNA_INC
${CMAKE_CURRENT_SOURCE_DIR}/makesdna/DNA_sdna_types.h
${CMAKE_CURRENT_SOURCE_DIR}/makesdna/DNA_sequence_types.h
${CMAKE_CURRENT_SOURCE_DIR}/makesdna/DNA_shader_fx_types.h
${CMAKE_CURRENT_SOURCE_DIR}/makesdna/DNA_smoke_types.h
${CMAKE_CURRENT_SOURCE_DIR}/makesdna/DNA_sound_types.h
${CMAKE_CURRENT_SOURCE_DIR}/makesdna/DNA_space_types.h
${CMAKE_CURRENT_SOURCE_DIR}/makesdna/DNA_speaker_types.h

13
source/blender/alembic/intern/abc_exporter.cc
View File

@ -42,6 +42,7 @@ extern "C" {
#include "DNA_object_types.h"
#include "DNA_scene_types.h"
#include "DNA_space_types.h" /* for FILE_MAX */
#include "DNA_fluid_types.h"
#include "BLI_string.h"
@ -105,11 +106,12 @@ ExportSettings::ExportSettings()
static bool object_is_smoke_sim(Object *ob)
{
ModifierData *md = modifiers_findByType(ob, eModifierType_Smoke);
ModifierData *md = modifiers_findByType(ob, eModifierType_Fluid);
if (md) {
SmokeModifierData *smd = reinterpret_cast<SmokeModifierData *>(md);
return (smd->type == MOD_SMOKE_TYPE_DOMAIN);
FluidModifierData *smd = reinterpret_cast<FluidModifierData *>(md);
return (smd->type == MOD_FLUID_TYPE_DOMAIN && smd->domain &&
smd->domain->type == FLUID_DOMAIN_TYPE_GAS);
}
return false;
@ -553,7 +555,10 @@ void AbcExporter::createParticleSystemsWriters(Object *ob, AbcTransformWriter *x
m_settings.export_child_hairs = true;
m_shapes.push_back(new AbcHairWriter(ob, xform, m_shape_sampling_index, m_settings, psys));
}
else if (m_settings.export_particles && psys->part->type == PART_EMITTER) {
else if (m_settings.export_particles &&
(psys->part->type & PART_EMITTER || psys->part->type & PART_FLUID_FLIP ||
psys->part->type & PART_FLUID_SPRAY || psys->part->type & PART_FLUID_BUBBLE ||
psys->part->type & PART_FLUID_FOAM || psys->part->type & PART_FLUID_TRACER)) {
m_shapes.push_back(new AbcPointsWriter(ob, xform, m_shape_sampling_index, m_settings, psys));
}
}

69
source/blender/blenkernel/BKE_fluid.h Normal file
View File

@ -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__ */

51
source/blender/blenkernel/BKE_fluidsim.h
View File

@ -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

4
source/blender/blenkernel/BKE_pointcache.h
View File

@ -83,7 +83,7 @@ struct ParticleSystem;
struct PointCache;
struct RigidBodyWorld;
struct Scene;
struct SmokeModifierData;
struct FluidModifierData;
struct SoftBody;
struct ViewLayer;
@ -286,7 +286,7 @@ void BKE_ptcache_make_particle_key(struct ParticleKey *key, int index, void **da
void BKE_ptcache_id_from_softbody(PTCacheID *pid, struct Object *ob, struct SoftBody *sb);
void BKE_ptcache_id_from_particles(PTCacheID *pid, struct Object *ob, struct ParticleSystem *psys);
void BKE_ptcache_id_from_cloth(PTCacheID *pid, struct Object *ob, struct ClothModifierData *clmd);
void BKE_ptcache_id_from_smoke(PTCacheID *pid, struct Object *ob, struct SmokeModifierData *smd);
void BKE_ptcache_id_from_smoke(PTCacheID *pid, struct Object *ob, struct FluidModifierData *mmd);
void BKE_ptcache_id_from_dynamicpaint(PTCacheID *pid,
struct Object *ob,
struct DynamicPaintSurface *surface);

62
source/blender/blenkernel/BKE_smoke.h
View File

@ -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__ */

22
source/blender/blenkernel/CMakeLists.txt
View File

@ -45,11 +45,11 @@ set(INC
../../../intern/atomic
../../../intern/clog
../../../intern/libmv
../../../intern/mantaflow/extern
../../../intern/memutil
../../../intern/mikktspace
../../../intern/opensubdiv
../../../extern/curve_fit_nd
../../../intern/smoke/extern
# dna_type_offsets.h
${CMAKE_CURRENT_BINARY_DIR}/../makesdna/intern
@ -114,7 +114,6 @@ set(SRC
intern/editmesh_tangent.c
intern/effect.c
intern/fcurve.c
intern/fluidsim.c
intern/fmodifier.c
intern/font.c
intern/freestyle.c
@ -144,6 +143,7 @@ set(SRC
intern/lightprobe.c
intern/linestyle.c
intern/main.c
intern/fluid.c
intern/mask.c
intern/mask_evaluate.c
intern/mask_rasterize.c
@ -198,7 +198,6 @@ set(SRC
intern/sequencer.c
intern/shader_fx.c
intern/shrinkwrap.c
intern/smoke.c
intern/softbody.c
intern/sound.c
intern/speaker.c
@ -281,7 +280,6 @@ set(SRC
BKE_editmesh_tangent.h
BKE_effect.h
BKE_fcurve.h
BKE_fluidsim.h
BKE_font.h
BKE_freestyle.h
BKE_global.h
@ -307,6 +305,7 @@ set(SRC
BKE_lightprobe.h
BKE_linestyle.h
BKE_main.h
BKE_fluid.h
BKE_mask.h
BKE_material.h
BKE_mball.h
@ -341,7 +340,6 @@ set(SRC
BKE_sequencer.h
BKE_shader_fx.h
BKE_shrinkwrap.h
BKE_smoke.h
BKE_softbody.h
BKE_sound.h
BKE_speaker.h
@ -526,20 +524,10 @@ if(WITH_PYTHON)
endif()
if(WITH_MOD_FLUID)
list(APPEND INC
../../../intern/elbeem/extern
)
list(APPEND LIB
bf_intern_elbeem
bf_intern_mantaflow
)
add_definitions(-DWITH_MOD_FLUID)
endif()
if(WITH_MOD_SMOKE)
list(APPEND LIB
bf_intern_smoke
)
add_definitions(-DWITH_SMOKE)
add_definitions(-DWITH_FLUID)
endif()
if(WITH_MOD_OCEANSIM)

10
source/blender/blenkernel/intern/bpath.c
View File

@ -59,7 +59,7 @@
#include "DNA_texture_types.h"
#include "DNA_vfont_types.h"
#include "DNA_scene_types.h"
#include "DNA_smoke_types.h"
#include "DNA_fluid_types.h"
#include "DNA_freestyle_types.h"
#include "BLI_blenlib.h"
@ -498,10 +498,10 @@ void BKE_bpath_traverse_id(
rewrite_path_fixed(fluidmd->fss->surfdataPath, visit_cb, absbase, bpath_user_data);
}
}
else if (md->type == eModifierType_Smoke) {
SmokeModifierData *smd = (SmokeModifierData *)md;
if (smd->type & MOD_SMOKE_TYPE_DOMAIN) {
BPATH_TRAVERSE_POINTCACHE(smd->domain->ptcaches[0]);
else if (md->type == eModifierType_Fluid) {
FluidModifierData *mmd = (FluidModifierData *)md;
if (mmd->type & MOD_FLUID_TYPE_DOMAIN && mmd->domain) {
rewrite_path_fixed(mmd->domain->cache_directory, visit_cb, absbase, bpath_user_data);
}
}
else if (md->type == eModifierType_Cloth) {

9
source/blender/blenkernel/intern/dynamicpaint.c
View File

@ -6278,7 +6278,14 @@ static int dynamicPaint_doStep(Depsgraph *depsgraph,
/* Apply brush on the surface depending on it's collision type */
if (brush->psys && brush->psys->part &&
ELEM(brush->psys->part->type, PART_EMITTER, PART_FLUID) &&
ELEM(brush->psys->part->type,
PART_EMITTER,
PART_FLUID,
PART_FLUID_FLIP,
PART_FLUID_SPRAY,
PART_FLUID_BUBBLE,
PART_FLUID_FOAM,
PART_FLUID_TRACER) &&
psys_check_enabled(brushObj, brush->psys, for_render)) {
/* Paint a particle system */
dynamicPaint_paintParticles(surface, brush->psys, brush, timescale);

11
source/blender/blenkernel/intern/effect.c
View File

@ -62,7 +62,7 @@
#include "BKE_object.h"
#include "BKE_particle.h"
#include "BKE_scene.h"
#include "BKE_smoke.h"
#include "BKE_fluid.h"
#include "DEG_depsgraph.h"
#include "DEG_depsgraph_physics.h"
@ -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;

90
source/blender/blenkernel/intern/fluidsim.c
View File

@ -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);
}

4
source/blender/blenkernel/intern/modifier.c
View File

@ -108,7 +108,9 @@ void BKE_modifier_init(void)
const ModifierTypeInfo *modifierType_getInfo(ModifierType type)
{
/* type unsigned, no need to check < 0 */
if (type < NUM_MODIFIER_TYPES && modifier_types[type]->name[0] != '\0') {
if (type < NUM_MODIFIER_TYPES && modifier_types[type] &&
modifier_types[type]->name[0] != '\0')
{
return modifier_types[type];
}
else {

24
source/blender/blenkernel/intern/object.c
View File

@ -39,6 +39,7 @@
#include "DNA_key_types.h"
#include "DNA_light_types.h"
#include "DNA_lattice_types.h"
#include "DNA_fluid_types.h"
#include "DNA_material_types.h"
#include "DNA_meta_types.h"
#include "DNA_mesh_types.h"
@ -48,7 +49,6 @@
#include "DNA_screen_types.h"
#include "DNA_sequence_types.h"
#include "DNA_shader_fx_types.h"
#include "DNA_smoke_types.h"
#include "DNA_space_types.h"
#include "DNA_view3d_types.h"
#include "DNA_world_types.h"
@ -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;
}
}

19
source/blender/blenkernel/intern/particle.c
View File

@ -34,7 +34,7 @@
#include "DNA_mesh_types.h"
#include "DNA_meshdata_types.h"
#include "DNA_particle_types.h"
#include "DNA_smoke_types.h"
#include "DNA_fluid_types.h"
#include "DNA_scene_types.h"
#include "DNA_dynamicpaint_types.h"
@ -360,6 +360,11 @@ bool psys_check_enabled(Object *ob, ParticleSystem *psys, const bool use_render_
}
psmd = psys_get_modifier(ob, psys);
if (!psmd) {
return 0;
}
if (use_render_params) {
if (!(psmd->modifier.mode & eModifierMode_Render)) {
return 0;
@ -3577,12 +3582,12 @@ void object_remove_particle_system(Main *bmain, Scene *UNUSED(scene), Object *ob
return;
}
/* clear all other appearances of this pointer (like on smoke flow modifier) */
if ((md = modifiers_findByType(ob, eModifierType_Smoke))) {
SmokeModifierData *smd = (SmokeModifierData *)md;
if ((smd->type == MOD_SMOKE_TYPE_FLOW) && smd->flow && smd->flow->psys) {
if (smd->flow->psys == psys) {
smd->flow->psys = NULL;
/* clear all other appearances of this pointer (like on manta flow modifier) */
if ((md = modifiers_findByType(ob, eModifierType_Fluid))) {
FluidModifierData *mmd = (FluidModifierData *)md;
if ((mmd->type == MOD_FLUID_TYPE_FLOW) && mmd->flow && mmd->flow->psys) {
if (mmd->flow->psys == psys) {
mmd->flow->psys = NULL;
}
}
}

486
source/blender/blenkernel/intern/pointcache.c
View File

@ -40,7 +40,7 @@
#include "DNA_particle_types.h"
#include "DNA_rigidbody_types.h"
#include "DNA_scene_types.h"
#include "DNA_smoke_types.h"
#include "DNA_fluid_types.h"
#include "BLI_blenlib.h"
#include "BLI_math.h"
@ -64,7 +64,7 @@
#include "BKE_particle.h"
#include "BKE_pointcache.h"
#include "BKE_scene.h"
#include "BKE_smoke.h"
#include "BKE_fluid.h"
#include "BKE_softbody.h"
#include "BIK_api.h"
@ -591,11 +591,11 @@ static void ptcache_cloth_error(void *cloth_v, const char *message)
/* Smoke functions */
static int ptcache_smoke_totpoint(void *smoke_v, int UNUSED(cfra))
{
SmokeModifierData *smd = (SmokeModifierData *)smoke_v;
SmokeDomainSettings *sds = smd->domain;
FluidModifierData *mmd = (FluidModifierData *)smoke_v;
FluidDomainSettings *mds = mmd->domain;
if (sds->fluid) {
return sds->base_res[0] * sds->base_res[1] * sds->base_res[2];
if (mds->fluid) {
return mds->base_res[0] * mds->base_res[1] * mds->base_res[2];
}
else {
return 0;
@ -604,28 +604,28 @@ static int ptcache_smoke_totpoint(void *smoke_v, int UNUSED(cfra))
static void ptcache_smoke_error(void *smoke_v, const char *message)
{
SmokeModifierData *smd = (SmokeModifierData *)smoke_v;
modifier_setError(&smd->modifier, "%s", message);
FluidModifierData *mmd = (FluidModifierData *)smoke_v;
modifier_setError(&mmd->modifier, "%s", message);
}
# define SMOKE_CACHE_VERSION "1.04"
static int ptcache_smoke_write(PTCacheFile *pf, void *smoke_v)
{
SmokeModifierData *smd = (SmokeModifierData *)smoke_v;
SmokeDomainSettings *sds = smd->domain;
FluidModifierData *mmd = (FluidModifierData *)smoke_v;
FluidDomainSettings *mds = mmd->domain;
int ret = 0;
int fluid_fields = BKE_smoke_get_data_flags(sds);
int fluid_fields = BKE_fluid_get_data_flags(mds);
/* version header */
ptcache_file_write(pf, SMOKE_CACHE_VERSION, 4, sizeof(char));
ptcache_file_write(pf, &fluid_fields, 1, sizeof(int));
ptcache_file_write(pf, &sds->active_fields, 1, sizeof(int));
ptcache_file_write(pf, &sds->res, 3, sizeof(int));
ptcache_file_write(pf, &sds->dx, 1, sizeof(float));
ptcache_file_write(pf, &mds->active_fields, 1, sizeof(int));
ptcache_file_write(pf, &mds->res, 3, sizeof(int));
ptcache_file_write(pf, &mds->dx, 1, sizeof(float));
if (sds->fluid) {
size_t res = sds->res[0] * sds->res[1] * sds->res[2];
if (mds->fluid) {
size_t res = mds->res[0] * mds->res[1] * mds->res[2];
float dt, dx, *dens, *react, *fuel, *flame, *heat, *heatold, *vx, *vy, *vz, *r, *g, *b;
unsigned char *obstacles;
unsigned int in_len = sizeof(float) * (unsigned int)res;
@ -633,11 +633,11 @@ static int ptcache_smoke_write(PTCacheFile *pf, void *smoke_v)
"pointcache_lzo_buffer");
// int mode = res >= 1000000 ? 2 : 1;
int mode = 1; // light
if (sds->cache_comp == SM_CACHE_HEAVY) {
if (mds->cache_comp == SM_CACHE_HEAVY) {
mode = 2; // heavy
}
smoke_export(sds->fluid,
smoke_export(mds->fluid,
&dt,
&dx,
&dens,
@ -652,20 +652,21 @@ static int ptcache_smoke_write(PTCacheFile *pf, void *smoke_v)
&r,
&g,
&b,
&obstacles);
&obstacles,
NULL);
ptcache_file_compressed_write(pf, (unsigned char *)sds->shadow, in_len, out, mode);
ptcache_file_compressed_write(pf, (unsigned char *)mds->shadow, in_len, out, mode);
ptcache_file_compressed_write(pf, (unsigned char *)dens, in_len, out, mode);
if (fluid_fields & SM_ACTIVE_HEAT) {
if (fluid_fields & FLUID_DOMAIN_ACTIVE_HEAT) {
ptcache_file_compressed_write(pf, (unsigned char *)heat, in_len, out, mode);
ptcache_file_compressed_write(pf, (unsigned char *)heatold, in_len, out, mode);
}
if (fluid_fields & SM_ACTIVE_FIRE) {
if (fluid_fields & FLUID_DOMAIN_ACTIVE_FIRE) {
ptcache_file_compressed_write(pf, (unsigned char *)flame, in_len, out, mode);
ptcache_file_compressed_write(pf, (unsigned char *)fuel, in_len, out, mode);
ptcache_file_compressed_write(pf, (unsigned char *)react, in_len, out, mode);
}
if (fluid_fields & SM_ACTIVE_COLORS) {
if (fluid_fields & FLUID_DOMAIN_ACTIVE_COLORS) {
ptcache_file_compressed_write(pf, (unsigned char *)r, in_len, out, mode);
ptcache_file_compressed_write(pf, (unsigned char *)g, in_len, out, mode);
ptcache_file_compressed_write(pf, (unsigned char *)b, in_len, out, mode);
@ -676,52 +677,52 @@ static int ptcache_smoke_write(PTCacheFile *pf, void *smoke_v)
ptcache_file_compressed_write(pf, (unsigned char *)obstacles, (unsigned int)res, out, mode);
ptcache_file_write(pf, &dt, 1, sizeof(float));
ptcache_file_write(pf, &dx, 1, sizeof(float));
ptcache_file_write(pf, &sds->p0, 3, sizeof(float));
ptcache_file_write(pf, &sds->p1, 3, sizeof(float));
ptcache_file_write(pf, &sds->dp0, 3, sizeof(float));
ptcache_file_write(pf, &sds->shift, 3, sizeof(int));
ptcache_file_write(pf, &sds->obj_shift_f, 3, sizeof(float));
ptcache_file_write(pf, &sds->obmat, 16, sizeof(float));
ptcache_file_write(pf, &sds->base_res, 3, sizeof(int));
ptcache_file_write(pf, &sds->res_min, 3, sizeof(int));
ptcache_file_write(pf, &sds->res_max, 3, sizeof(int));
ptcache_file_write(pf, &sds->active_color, 3, sizeof(float));
ptcache_file_write(pf, &mds->p0, 3, sizeof(float));
ptcache_file_write(pf, &mds->p1, 3, sizeof(float));
ptcache_file_write(pf, &mds->dp0, 3, sizeof(float));
ptcache_file_write(pf, &mds->shift, 3, sizeof(int));
ptcache_file_write(pf, &mds->obj_shift_f, 3, sizeof(float));
ptcache_file_write(pf, &mds->obmat, 16, sizeof(float));
ptcache_file_write(pf, &mds->base_res, 3, sizeof(int));
ptcache_file_write(pf, &mds->res_min, 3, sizeof(int));
ptcache_file_write(pf, &mds->res_max, 3, sizeof(int));
ptcache_file_write(pf, &mds->active_color, 3, sizeof(float));
MEM_freeN(out);
ret = 1;
}
if (sds->wt) {
if (mds->wt) {
int res_big_array[3];
int res_big;
int res = sds->res[0] * sds->res[1] * sds->res[2];
int res = mds->res[0] * mds->res[1] * mds->res[2];
float *dens, *react, *fuel, *flame, *tcu, *tcv, *tcw, *r, *g, *b;
unsigned int in_len = sizeof(float) * (unsigned int)res;
unsigned int in_len_big;
unsigned char *out;
int mode;
smoke_turbulence_get_res(sds->wt, res_big_array);
smoke_turbulence_get_res(mds->wt, res_big_array);
res_big = res_big_array[0] * res_big_array[1] * res_big_array[2];
// mode = res_big >= 1000000 ? 2 : 1;
mode = 1; // light
if (sds->cache_high_comp == SM_CACHE_HEAVY) {
if (mds->cache_high_comp == SM_CACHE_HEAVY) {
mode = 2; // heavy
}
in_len_big = sizeof(float) * (unsigned int)res_big;
smoke_turbulence_export(sds->wt, &dens, &react, &flame, &fuel, &r, &g, &b, &tcu, &tcv, &tcw);
smoke_turbulence_export(mds->wt, &dens, &react, &flame, &fuel, &r, &g, &b, &tcu, &tcv, &tcw);
out = (unsigned char *)MEM_callocN(LZO_OUT_LEN(in_len_big), "pointcache_lzo_buffer");
ptcache_file_compressed_write(pf, (unsigned char *)dens, in_len_big, out, mode);
if (fluid_fields & SM_ACTIVE_FIRE) {
if (fluid_fields & FLUID_DOMAIN_ACTIVE_FIRE) {
ptcache_file_compressed_write(pf, (unsigned char *)flame, in_len_big, out, mode);
ptcache_file_compressed_write(pf, (unsigned char *)fuel, in_len_big, out, mode);
ptcache_file_compressed_write(pf, (unsigned char *)react, in_len_big, out, mode);
}
if (fluid_fields & SM_ACTIVE_COLORS) {
if (fluid_fields & FLUID_DOMAIN_ACTIVE_COLORS) {
ptcache_file_compressed_write(pf, (unsigned char *)r, in_len_big, out, mode);
ptcache_file_compressed_write(pf, (unsigned char *)g, in_len_big, out, mode);
ptcache_file_compressed_write(pf, (unsigned char *)b, in_len_big, out, mode);
@ -743,24 +744,24 @@ static int ptcache_smoke_write(PTCacheFile *pf, void *smoke_v)
/* read old smoke cache from 2.64 */
static int ptcache_smoke_read_old(PTCacheFile *pf, void *smoke_v)
{
SmokeModifierData *smd = (SmokeModifierData *)smoke_v;
SmokeDomainSettings *sds = smd->domain;
FluidModifierData *mmd = (FluidModifierData *)smoke_v;
FluidDomainSettings *mds = mmd->domain;
if (sds->fluid) {
const size_t res = sds->res[0] * sds->res[1] * sds->res[2];
if (mds->fluid) {
const size_t res = mds->res[0] * mds->res[1] * mds->res[2];
const unsigned int out_len = (unsigned int)res * sizeof(float);
float dt, dx, *dens, *heat, *heatold, *vx, *vy, *vz;
unsigned char *obstacles;
float *tmp_array = MEM_callocN(out_len, "Smoke old cache tmp");
int fluid_fields = BKE_smoke_get_data_flags(sds);
int fluid_fields = BKE_fluid_get_data_flags(mds);
/* Part part of the new cache header */
sds->active_color[0] = 0.7f;
sds->active_color[1] = 0.7f;
sds->active_color[2] = 0.7f;
mds->active_color[0] = 0.7f;
mds->active_color[1] = 0.7f;
mds->active_color[2] = 0.7f;
smoke_export(sds->fluid,
smoke_export(mds->fluid,
&dt,
&dx,
&dens,
@ -775,13 +776,14 @@ static int ptcache_smoke_read_old(PTCacheFile *pf, void *smoke_v)
NULL,
NULL,
NULL,
&obstacles);
&obstacles,
NULL);
ptcache_file_compressed_read(pf, (unsigned char *)sds->shadow, out_len);
ptcache_file_compressed_read(pf, (unsigned char *)mds->shadow, out_len);
ptcache_file_compressed_read(pf, (unsigned char *)dens, out_len);
ptcache_file_compressed_read(pf, (unsigned char *)tmp_array, out_len);
if (fluid_fields & SM_ACTIVE_HEAT) {
if (fluid_fields & FLUID_DOMAIN_ACTIVE_HEAT) {
ptcache_file_compressed_read(pf, (unsigned char *)heat, out_len);
ptcache_file_compressed_read(pf, (unsigned char *)heatold, out_len);
}
@ -801,19 +803,19 @@ static int ptcache_smoke_read_old(PTCacheFile *pf, void *smoke_v)
MEM_freeN(tmp_array);
if (pf->data_types & (1 << BPHYS_DATA_SMOKE_HIGH) && sds->wt) {
if (pf->data_types & (1 << BPHYS_DATA_SMOKE_HIGH) && mds->wt) {
int res_big, res_big_array[3];
float *tcu, *tcv, *tcw;
unsigned int out_len_big;
unsigned char *tmp_array_big;
smoke_turbulence_get_res(sds->wt, res_big_array);
smoke_turbulence_get_res(mds->wt, res_big_array);
res_big = res_big_array[0] * res_big_array[1] * res_big_array[2];
out_len_big = sizeof(float) * (unsigned int)res_big;
tmp_array_big = MEM_callocN(out_len_big, "Smoke old cache tmp");
smoke_turbulence_export(
sds->wt, &dens, NULL, NULL, NULL, NULL, NULL, NULL, &tcu, &tcv, &tcw);
mds->wt, &dens, NULL, NULL, NULL, NULL, NULL, NULL, &tcu, &tcv, &tcw);
ptcache_file_compressed_read(pf, (unsigned char *)dens, out_len_big);
ptcache_file_compressed_read(pf, (unsigned char *)tmp_array_big, out_len_big);
@ -831,12 +833,12 @@ static int ptcache_smoke_read_old(PTCacheFile *pf, void *smoke_v)
static int ptcache_smoke_read(PTCacheFile *pf, void *smoke_v)
{
SmokeModifierData *smd = (SmokeModifierData *)smoke_v;
SmokeDomainSettings *sds = smd->domain;
FluidModifierData *mmd = (FluidModifierData *)smoke_v;
FluidDomainSettings *mds = mmd->domain;
char version[4];
int ch_res[3];
float ch_dx;
int fluid_fields = BKE_smoke_get_data_flags(sds);
int fluid_fields = BKE_fluid_get_data_flags(mds);
int cache_fields = 0;
int active_fields = 0;
int reallocate = 0;
@ -856,8 +858,8 @@ static int ptcache_smoke_read(PTCacheFile *pf, void *smoke_v)
ptcache_file_read(pf, &ch_dx, 1, sizeof(float));
/* check if resolution has changed */
if (sds->res[0] != ch_res[0] || sds->res[1] != ch_res[1] || sds->res[2] != ch_res[2]) {
if (sds->flags & MOD_SMOKE_ADAPTIVE_DOMAIN) {
if (mds->res[0] != ch_res[0] || mds->res[1] != ch_res[1] || mds->res[2] != ch_res[2]) {
if (mds->flags & FLUID_DOMAIN_USE_ADAPTIVE_DOMAIN) {
reallocate = 1;
}
else {
@ -865,29 +867,26 @@ static int ptcache_smoke_read(PTCacheFile *pf, void *smoke_v)
}
}
/* check if active fields have changed */
if (fluid_fields != cache_fields || active_fields != sds->active_fields) {
if (fluid_fields != cache_fields || active_fields != mds->active_fields) {
reallocate = 1;
}
/* reallocate fluid if needed*/
if (reallocate) {
sds->active_fields = active_fields | cache_fields;
BKE_smoke_reallocate_fluid(sds, ch_dx, ch_res, 1);
sds->dx = ch_dx;
copy_v3_v3_int(sds->res, ch_res);
sds->total_cells = ch_res[0] * ch_res[1] * ch_res[2];
if (sds->flags & MOD_SMOKE_HIGHRES) {
BKE_smoke_reallocate_highres_fluid(sds, ch_dx, ch_res, 1);
}
mds->active_fields = active_fields | cache_fields;
BKE_fluid_reallocate_fluid(mds, ch_res, 1);
mds->dx = ch_dx;
copy_v3_v3_int(mds->res, ch_res);
mds->total_cells = ch_res[0] * ch_res[1] * ch_res[2];
}
if (sds->fluid) {
size_t res = sds->res[0] * sds->res[1] * sds->res[2];
if (mds->fluid) {
size_t res = mds->res[0] * mds->res[1] * mds->res[2];
float dt, dx, *dens, *react, *fuel, *flame, *heat, *heatold, *vx, *vy, *vz, *r, *g, *b;
unsigned char *obstacles;
unsigned int out_len = (unsigned int)res * sizeof(float);
smoke_export(sds->fluid,
smoke_export(mds->fluid,
&dt,
&dx,
&dens,
@ -902,20 +901,21 @@ static int ptcache_smoke_read(PTCacheFile *pf, void *smoke_v)
&r,
&g,
&b,
&obstacles);
&obstacles,
NULL);
ptcache_file_compressed_read(pf, (unsigned char *)sds->shadow, out_len);
ptcache_file_compressed_read(pf, (unsigned char *)mds->shadow, out_len);
ptcache_file_compressed_read(pf, (unsigned char *)dens, out_len);
if (cache_fields & SM_ACTIVE_HEAT) {
if (cache_fields & FLUID_DOMAIN_ACTIVE_HEAT) {
ptcache_file_compressed_read(pf, (unsigned char *)heat, out_len);
ptcache_file_compressed_read(pf, (unsigned char *)heatold, out_len);
}
if (cache_fields & SM_ACTIVE_FIRE) {
if (cache_fields & FLUID_DOMAIN_ACTIVE_FIRE) {
ptcache_file_compressed_read(pf, (unsigned char *)flame, out_len);
ptcache_file_compressed_read(pf, (unsigned char *)fuel, out_len);
ptcache_file_compressed_read(pf, (unsigned char *)react, out_len);
}
if (cache_fields & SM_ACTIVE_COLORS) {
if (cache_fields & FLUID_DOMAIN_ACTIVE_COLORS) {
ptcache_file_compressed_read(pf, (unsigned char *)r, out_len);
ptcache_file_compressed_read(pf, (unsigned char *)g, out_len);
ptcache_file_compressed_read(pf, (unsigned char *)b, out_len);
@ -926,38 +926,38 @@ static int ptcache_smoke_read(PTCacheFile *pf, void *smoke_v)
ptcache_file_compressed_read(pf, (unsigned char *)obstacles, (unsigned int)res);
ptcache_file_read(pf, &dt, 1, sizeof(float));
ptcache_file_read(pf, &dx, 1, sizeof(float));
ptcache_file_read(pf, &sds->p0, 3, sizeof(float));
ptcache_file_read(pf, &sds->p1, 3, sizeof(float));
ptcache_file_read(pf, &sds->dp0, 3, sizeof(float));
ptcache_file_read(pf, &sds->shift, 3, sizeof(int));
ptcache_file_read(pf, &sds->obj_shift_f, 3, sizeof(float));
ptcache_file_read(pf, &sds->obmat, 16, sizeof(float));
ptcache_file_read(pf, &sds->base_res, 3, sizeof(int));
ptcache_file_read(pf, &sds->res_min, 3, sizeof(int));
ptcache_file_read(pf, &sds->res_max, 3, sizeof(int));
ptcache_file_read(pf, &sds->active_color, 3, sizeof(float));
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) && sds->wt) {
int res = sds->res[0] * sds->res[1] * sds->res[2];
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;
FluidModifierData *mmd = (FluidModifierData *)smoke_v;
FluidDomainSettings *mds = mmd->domain;
OpenVDBWriter_set_flags(writer, sds->openvdb_comp, (sds->data_depth == 16));
OpenVDBWriter_set_flags(writer, mds->openvdb_comp, (mds->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);
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_smoke_get_data_flags(sds);
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);
}
}

3654
source/blender/blenkernel/intern/smoke.c
View File

File diff suppressed because it is too large Load Diff

164
source/blender/blenloader/intern/readfile.c
View File

@ -83,7 +83,7 @@
#include "DNA_sdna_types.h"
#include "DNA_scene_types.h"
#include "DNA_sequence_types.h"
#include "DNA_smoke_types.h"
#include "DNA_fluid_types.h"
#include "DNA_speaker_types.h"
#include "DNA_sound_types.h"
#include "DNA_space_types.h"
@ -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;
FluidModifierData *mmd = (FluidModifierData *)md;
if (smd->type == MOD_SMOKE_TYPE_DOMAIN) {
smd->flow = NULL;
smd->coll = NULL;
smd->domain = newdataadr(fd, smd->domain);
smd->domain->smd = smd;
if (mmd->type == MOD_FLUID_TYPE_DOMAIN) {
mmd->flow = NULL;
mmd->effector = NULL;
mmd->domain = newdataadr(fd, mmd->domain);
mmd->domain->mmd = mmd;
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);
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);
smd->domain->effector_weights = newdataadr(fd, smd->domain->effector_weights);
if (!smd->domain->effector_weights) {
smd->domain->effector_weights = BKE_effector_add_weights(NULL);
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;
BLI_listbase_clear(&mmd->domain->ptcaches[1]);
mmd->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 (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 (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;
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);

28
source/blender/blenloader/intern/versioning_250.c
View File

@ -50,7 +50,7 @@
#include "DNA_screen_types.h"
#include "DNA_sdna_types.h"
#include "DNA_sequence_types.h"
#include "DNA_smoke_types.h"
#include "DNA_fluid_types.h"
#include "DNA_sound_types.h"
#include "DNA_space_types.h"
#include "DNA_world_types.h"
@ -1789,19 +1789,19 @@ void blo_do_versions_250(FileData *fd, Library *lib, Main *bmain)
ModifierData *md;
for (md = ob->modifiers.first; md; md = md->next) {
if (md->type == eModifierType_Smoke) {
SmokeModifierData *smd = (SmokeModifierData *)md;
if (md->type == eModifierType_Fluid) {
FluidModifierData *mmd = (FluidModifierData *)md;
if ((smd->type & MOD_SMOKE_TYPE_DOMAIN) && smd->domain) {
smd->domain->vorticity = 2.0f;
smd->domain->time_scale = 1.0f;
if ((mmd->type & MOD_FLUID_TYPE_DOMAIN) && mmd->domain) {
mmd->domain->vorticity = 2.0f;
mmd->domain->time_scale = 1.0f;
if (!(smd->domain->flags & (1 << 4))) {
if (!(mmd->domain->flags & (1 << 4))) {
continue;
}
/* delete old MOD_SMOKE_INITVELOCITY flag */
smd->domain->flags &= ~(1 << 4);
mmd->domain->flags &= ~(1 << 4);
/* for now just add it to all flow objects in the scene */
{
@ -1809,19 +1809,19 @@ void blo_do_versions_250(FileData *fd, Library *lib, Main *bmain)
for (ob2 = bmain->objects.first; ob2; ob2 = ob2->id.next) {
ModifierData *md2;
for (md2 = ob2->modifiers.first; md2; md2 = md2->next) {
if (md2->type == eModifierType_Smoke) {
SmokeModifierData *smd2 = (SmokeModifierData *)md2;
if (md2->type == eModifierType_Fluid) {
FluidModifierData *mmd2 = (FluidModifierData *)md2;
if ((smd2->type & MOD_SMOKE_TYPE_FLOW) && smd2->flow) {
smd2->flow->flags |= MOD_SMOKE_FLOW_INITVELOCITY;
if ((mmd2->type & MOD_FLUID_TYPE_FLOW) && mmd2->flow) {
mmd2->flow->flags |= FLUID_FLOW_INITVELOCITY;
}
}
}
}
}
}
else if ((smd->type & MOD_SMOKE_TYPE_FLOW) && smd->flow) {
smd->flow->vel_multi = 1.0f;
else if ((mmd->type & MOD_FLUID_TYPE_FLOW) && mmd->flow) {
mmd->flow->vel_multi = 1.0f;
}
}
}

80
source/blender/blenloader/intern/versioning_260.c
View File

@ -39,7 +39,7 @@
#include "DNA_view3d_types.h"
#include "DNA_screen_types.h"
#include "DNA_sdna_types.h"
#include "DNA_smoke_types.h"
#include "DNA_fluid_types.h"
#include "DNA_space_types.h"
#include "DNA_world_types.h"
#include "DNA_light_types.h"
@ -1292,12 +1292,12 @@ void blo_do_versions_260(FileData *fd, Library *UNUSED(lib), Main *bmain)
for (ob = bmain->objects.first; ob; ob = ob->id.next) {
ModifierData *md;
for (md = ob->modifiers.first; md; md = md->next) {
if (md->type == eModifierType_Smoke) {
SmokeModifierData *smd = (SmokeModifierData *)md;
if ((smd->type & MOD_SMOKE_TYPE_DOMAIN) && smd->domain) {
int maxres = max_iii(smd->domain->res[0], smd->domain->res[1], smd->domain->res[2]);
smd->domain->scale = smd->domain->dx * maxres;
smd->domain->dx = 1.0f / smd->domain->scale;
if (md->type == eModifierType_Fluid) {
FluidModifierData *mmd = (FluidModifierData *)md;
if ((mmd->type & MOD_FLUID_TYPE_DOMAIN) && mmd->domain) {
int maxres = max_iii(mmd->domain->res[0], mmd->domain->res[1], mmd->domain->res[2]);
mmd->domain->scale = mmd->domain->dx * maxres;
mmd->domain->dx = 1.0f / mmd->domain->scale;
}
}
}
@ -1610,31 +1610,31 @@ void blo_do_versions_260(FileData *fd, Library *UNUSED(lib), Main *bmain)
for (ob = bmain->objects.first; ob; ob = ob->id.next) {
ModifierData *md;
for (md = ob->modifiers.first; md; md = md->next) {
if (md->type == eModifierType_Smoke) {
SmokeModifierData *smd = (SmokeModifierData *)md;
if ((smd->type & MOD_SMOKE_TYPE_DOMAIN) && smd->domain) {
if (md->type == eModifierType_Fluid) {
FluidModifierData *mmd = (FluidModifierData *)md;
if ((mmd->type & MOD_FLUID_TYPE_DOMAIN) && mmd->domain) {
/* keep branch saves if possible */
if (!smd->domain->flame_max_temp) {
smd->domain->burning_rate = 0.75f;
smd->domain->flame_smoke = 1.0f;
smd->domain->flame_vorticity = 0.5f;
smd->domain->flame_ignition = 1.25f;
smd->domain->flame_max_temp = 1.75f;
smd->domain->adapt_threshold = 0.02f;
smd->domain->adapt_margin = 4;
smd->domain->flame_smoke_color[0] = 0.7f;
smd->domain->flame_smoke_color[1] = 0.7f;
smd->domain->flame_smoke_color[2] = 0.7f;
if (!mmd->domain->flame_max_temp) {
mmd->domain->burning_rate = 0.75f;
mmd->domain->flame_smoke = 1.0f;
mmd->domain->flame_vorticity = 0.5f;
mmd->domain->flame_ignition = 1.25f;
mmd->domain->flame_max_temp = 1.75f;
mmd->domain->adapt_threshold = 0.02f;
mmd->domain->adapt_margin = 4;
mmd->domain->flame_smoke_color[0] = 0.7f;
mmd->domain->flame_smoke_color[1] = 0.7f;
mmd->domain->flame_smoke_color[2] = 0.7f;
}
}
else if ((smd->type & MOD_SMOKE_TYPE_FLOW) && smd->flow) {
if (!smd->flow->texture_size) {
smd->flow->fuel_amount = 1.0;
smd->flow->surface_distance = 1.5;
smd->flow->color[0] = 0.7f;
smd->flow->color[1] = 0.7f;
smd->flow->color[2] = 0.7f;
smd->flow->texture_size = 1.0f;
else if ((mmd->type & MOD_FLUID_TYPE_FLOW) && mmd->flow) {
if (!mmd->flow->texture_size) {
mmd->flow->fuel_amount = 1.0;
mmd->flow->surface_distance = 1.5;
mmd->flow->color[0] = 0.7f;
mmd->flow->color[1] = 0.7f;
mmd->flow->color[2] = 0.7f;
mmd->flow->texture_size = 1.0f;
}
}
}
@ -2140,14 +2140,14 @@ void blo_do_versions_260(FileData *fd, Library *UNUSED(lib), Main *bmain)
for (ob = bmain->objects.first; ob; ob = ob->id.next) {
ModifierData *md;
for (md = ob->modifiers.first; md; md = md->next) {
if (md->type == eModifierType_Smoke) {
SmokeModifierData *smd = (SmokeModifierData *)md;
if ((smd->type & MOD_SMOKE_TYPE_DOMAIN) && smd->domain) {
if (smd->domain->flags & MOD_SMOKE_HIGH_SMOOTH) {
smd->domain->highres_sampling = SM_HRES_LINEAR;
if (md->type == eModifierType_Fluid) {
FluidModifierData *mmd = (FluidModifierData *)md;
if ((mmd->type & MOD_FLUID_TYPE_DOMAIN) && mmd->domain) {
if (mmd->domain->flags & FLUID_DOMAIN_USE_HIGH_SMOOTH) {
mmd->domain->highres_sampling = SM_HRES_LINEAR;
}
else {
smd->domain->highres_sampling = SM_HRES_NEAREST;
mmd->domain->highres_sampling = SM_HRES_NEAREST;
}
}
}
@ -2207,11 +2207,11 @@ void blo_do_versions_260(FileData *fd, Library *UNUSED(lib), Main *bmain)
for (ob = bmain->objects.first; ob; ob = ob->id.next) {
ModifierData *md;
for (md = ob->modifiers.first; md; md = md->next) {
if (md->type == eModifierType_Smoke) {
SmokeModifierData *smd = (SmokeModifierData *)md;
if ((smd->type & MOD_SMOKE_TYPE_FLOW) && smd->flow) {
if (!smd->flow->particle_size) {
smd->flow->particle_size = 1.0f;
if (md->type == eModifierType_Fluid) {
FluidModifierData *mmd = (FluidModifierData *)md;
if ((mmd->type & MOD_FLUID_TYPE_FLOW) && mmd->flow) {
if (!mmd->flow->particle_size) {
mmd->flow->particle_size = 1.0f;
}
}
}

26
source/blender/blenloader/intern/versioning_270.c
View File

@ -46,7 +46,7 @@
#include "DNA_particle_types.h"
#include "DNA_linestyle_types.h"
#include "DNA_view3d_types.h"
#include "DNA_smoke_types.h"
#include "DNA_fluid_types.h"
#include "DNA_rigidbody_types.h"
#include "DNA_light_types.h"
@ -1549,18 +1549,18 @@ void blo_do_versions_270(FileData *fd, Library *UNUSED(lib), Main *bmain)
}
}
if (!DNA_struct_elem_find(fd->filesdna, "SmokeModifierData", "float", "slice_per_voxel")) {
if (!DNA_struct_elem_find(fd->filesdna, "FluidModifierData", "float", "slice_per_voxel")) {
Object *ob;
ModifierData *md;
for (ob = bmain->objects.first; ob; ob = ob->id.next) {
for (md = ob->modifiers.first; md; md = md->next) {
if (md->type == eModifierType_Smoke) {
SmokeModifierData *smd = (SmokeModifierData *)md;
if (smd->domain) {
smd->domain->slice_per_voxel = 5.0f;
smd->domain->slice_depth = 0.5f;
smd->domain->display_thickness = 1.0f;
if (md->type == eModifierType_Fluid) {
FluidModifierData *mmd = (FluidModifierData *)md;
if (mmd->domain) {
mmd->domain->slice_per_voxel = 5.0f;
mmd->domain->slice_depth = 0.5f;
mmd->domain->display_thickness = 1.0f;
}
}
}
@ -1719,16 +1719,16 @@ void blo_do_versions_270(FileData *fd, Library *UNUSED(lib), Main *bmain)
}
if (!MAIN_VERSION_ATLEAST(bmain, 279, 3)) {
if (!DNA_struct_elem_find(fd->filesdna, "SmokeDomainSettings", "float", "clipping")) {
if (!DNA_struct_elem_find(fd->filesdna, "FluidDomainSettings", "float", "clipping")) {
Object *ob;
ModifierData *md;
for (ob = bmain->objects.first; ob; ob = ob->id.next) {
for (md = ob->modifiers.first; md; md = md->next) {
if (md->type == eModifierType_Smoke) {
SmokeModifierData *smd = (SmokeModifierData *)md;
if (smd->domain) {
smd->domain->clipping = 1e-3f;
if (md->type == eModifierType_Fluid) {
FluidModifierData *mmd = (FluidModifierData *)md;
if (mmd->domain) {
mmd->domain->clipping = 1e-3f;
}
}
}

2
source/blender/blenloader/intern/versioning_legacy.c
View File

@ -2292,7 +2292,7 @@ void blo_do_versions_pre250(FileData *fd, Library *lib, Main *bmain)
part->omat = paf->mat[0];
part->hair_step = paf->totkey;
part->eff_group = paf->group;
part->force_group = paf->group;
/* old system didn't interpolate between keypoints at render time */
part->draw_step = part->ren_step = 0;

40
source/blender/blenloader/intern/writefile.c
View File

@ -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) {

2
source/blender/depsgraph/intern/depsgraph_physics.cc
View File

@ -54,7 +54,7 @@ static ePhysicsRelationType modifier_to_relation_type(unsigned int modifier_type
switch (modifier_type) {
case eModifierType_Collision:
return DEG_PHYSICS_COLLISION;
case eModifierType_Smoke:
case eModifierType_Fluid:
return DEG_PHYSICS_SMOKE_COLLISION;
case eModifierType_DynamicPaint:
return DEG_PHYSICS_DYNAMIC_BRUSH;

54
source/blender/draw/engines/eevee/eevee_volumes.c
View File

@ -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);
}

60
source/blender/draw/engines/overlay/overlay_extra.c
View File

@ -45,7 +45,7 @@
#include "DNA_modifier_types.h"
#include "DNA_object_force_types.h"
#include "DNA_rigidbody_types.h"
#include "DNA_smoke_types.h"
#include "DNA_fluid_types.h"
#include "DEG_depsgraph_query.h"
@ -1410,22 +1410,22 @@ static void OVERLAY_volume_extra(OVERLAY_ExtraCallBuffers *cb,
Scene *scene,
float *color)
{
SmokeModifierData *smd = (SmokeModifierData *)md;
SmokeDomainSettings *sds = smd->domain;
FluidModifierData *mmd = (FluidModifierData *)md;
FluidDomainSettings *mds = mmd->domain;
/* Don't show smoke before simulation starts, this could be made an option in the future. */
const bool draw_velocity = (sds->draw_velocity && sds->fluid &&
CFRA >= sds->point_cache[0]->startframe);
const bool draw_velocity = (mds->draw_velocity && mds->fluid &&
CFRA >= mds->point_cache[0]->startframe);
/* Small cube showing voxel size. */
{
float min[3];
madd_v3fl_v3fl_v3fl_v3i(min, sds->p0, sds->cell_size, sds->res_min);
madd_v3fl_v3fl_v3fl_v3i(min, mds->p0, mds->cell_size, mds->res_min);
float voxel_cubemat[4][4] = {{0.0f}};
/* scale small cube to voxel size */
voxel_cubemat[0][0] = 1.0f / (float)sds->base_res[0];
voxel_cubemat[1][1] = 1.0f / (float)sds->base_res[1];
voxel_cubemat[2][2] = 1.0f / (float)sds->base_res[2];
voxel_cubemat[0][0] = 1.0f / (float)mds->base_res[0];
voxel_cubemat[1][1] = 1.0f / (float)mds->base_res[1];
voxel_cubemat[2][2] = 1.0f / (float)mds->base_res[2];
voxel_cubemat[3][3] = 1.0f;
/* translate small cube to corner */
copy_v3_v3(voxel_cubemat[3], min);
@ -1437,38 +1437,38 @@ static void OVERLAY_volume_extra(OVERLAY_ExtraCallBuffers *cb,
}
if (draw_velocity) {
const bool use_needle = (sds->vector_draw_type == VECTOR_DRAW_NEEDLE);
const bool use_needle = (mds->vector_draw_type == VECTOR_DRAW_NEEDLE);
int line_count = (use_needle) ? 6 : 1;
int slice_axis = -1;
line_count *= sds->res[0] * sds->res[1] * sds->res[2];
line_count *= mds->res[0] * mds->res[1] * mds->res[2];
if (sds->slice_method == MOD_SMOKE_SLICE_AXIS_ALIGNED &&
sds->axis_slice_method == AXIS_SLICE_SINGLE) {
if (mds->slice_method == FLUID_DOMAIN_SLICE_AXIS_ALIGNED &&
mds->axis_slice_method == AXIS_SLICE_SINGLE) {
float viewinv[4][4];
DRW_view_viewmat_get(NULL, viewinv, true);
const int axis = (sds->slice_axis == SLICE_AXIS_AUTO) ? axis_dominant_v3_single(viewinv[2]) :
sds->slice_axis - 1;
const int axis = (mds->slice_axis == SLICE_AXIS_AUTO) ? axis_dominant_v3_single(viewinv[2]) :
mds->slice_axis - 1;
slice_axis = axis;
line_count /= sds->res[axis];
line_count /= mds->res[axis];
}
GPU_create_smoke_velocity(smd);
GPU_create_smoke_velocity(mmd);
GPUShader *sh = OVERLAY_shader_volume_velocity(use_needle);
DRWShadingGroup *grp = DRW_shgroup_create(sh, data->psl->extra_ps[0]);
DRW_shgroup_uniform_texture(grp, "velocityX", sds->tex_velocity_x);
DRW_shgroup_uniform_texture(grp, "velocityY", sds->tex_velocity_y);
DRW_shgroup_uniform_texture(grp, "velocityZ", sds->tex_velocity_z);
DRW_shgroup_uniform_float_copy(grp, "displaySize", sds->vector_scale);
DRW_shgroup_uniform_float_copy(grp, "slicePosition", sds->slice_depth);
DRW_shgroup_uniform_vec3_copy(grp, "cellSize", sds->cell_size);
DRW_shgroup_uniform_vec3_copy(grp, "domainOriginOffset", sds->p0);
DRW_shgroup_uniform_ivec3_copy(grp, "adaptiveCellOffset", sds->res_min);
DRW_shgroup_uniform_texture(grp, "velocityX", mds->tex_velocity_x);
DRW_shgroup_uniform_texture(grp, "velocityY", mds->tex_velocity_y);
DRW_shgroup_uniform_texture(grp, "velocityZ", mds->tex_velocity_z);
DRW_shgroup_uniform_float_copy(grp, "displaySize", mds->vector_scale);
DRW_shgroup_uniform_float_copy(grp, "slicePosition", mds->slice_depth);
DRW_shgroup_uniform_vec3_copy(grp, "cellSize", mds->cell_size);
DRW_shgroup_uniform_vec3_copy(grp, "domainOriginOffset", mds->p0);
DRW_shgroup_uniform_ivec3_copy(grp, "adaptiveCellOffset", mds->res_min);
DRW_shgroup_uniform_int_copy(grp, "sliceAxis", slice_axis);
DRW_shgroup_call_procedural_lines(grp, ob, line_count);
BLI_addtail(&data->stl->pd->smoke_domains, BLI_genericNodeN(smd));
BLI_addtail(&data->stl->pd->smoke_domains, BLI_genericNodeN(mmd));
}
}
@ -1482,8 +1482,8 @@ static void OVERLAY_volume_free_smoke_textures(OVERLAY_Data *data)
* all viewport in a redraw at least. */
LinkData *link;
while ((link = BLI_pophead(&data->stl->pd->smoke_domains))) {
SmokeModifierData *smd = (SmokeModifierData *)link->data;
GPU_free_smoke_velocity(smd);
FluidModifierData *mmd = (FluidModifierData *)link->data;
GPU_free_smoke_velocity(mmd);
MEM_freeN(link);
}
}
@ -1555,9 +1555,9 @@ void OVERLAY_extra_cache_populate(OVERLAY_Data *vedata, Object *ob)
const bool draw_xform = draw_ctx->object_mode == OB_MODE_OBJECT &&
(scene->toolsettings->transform_flag & SCE_XFORM_DATA_ORIGIN) &&
(ob->base_flag & BASE_SELECTED) && !is_select_mode;
const bool draw_volume = !from_dupli && (md = modifiers_findByType(ob, eModifierType_Smoke)) &&
const bool draw_volume = !from_dupli && (md = modifiers_findByType(ob, eModifierType_Fluid)) &&
(modifier_isEnabled(scene, md, eModifierMode_Realtime)) &&
(((SmokeModifierData *)md)->domain != NULL);
(((FluidModifierData *)md)->domain != NULL);
float *color;
int theme_id = DRW_object_wire_theme_get(ob, view_layer, &color);

6
source/blender/draw/engines/overlay/shaders/volume_velocity_vert.glsl
View File

@ -6,11 +6,11 @@ uniform float displaySize = 1.0;
uniform float slicePosition;
uniform int sliceAxis; /* -1 is no slice, 0 is X, 1 is Y, 2 is Z. */
/* SmokeDomainSettings.cell_size */
/* FluidDomainSettings.cell_size */
uniform vec3 cellSize;
/* SmokeDomainSettings.p0 */
/* FluidDomainSettings.p0 */
uniform vec3 domainOriginOffset;
/* SmokeDomainSettings.res_min */
/* FluidDomainSettings.res_min */
uniform ivec3 adaptiveCellOffset;
flat out vec4 finalColor;

6
source/blender/draw/engines/workbench/workbench_deferred.c
View File

@ -34,6 +34,7 @@
#include "BKE_particle.h"
#include "DNA_image_types.h"
#include "DNA_fluid_types.h"
#include "DNA_mesh_types.h"
#include "DNA_modifier_types.h"
#include "DNA_node_types.h"
@ -981,9 +982,10 @@ void workbench_deferred_solid_cache_populate(WORKBENCH_Data *vedata, Object *ob)
ModifierData *md;
if (((ob->base_flag & BASE_FROM_DUPLI) == 0) &&
(md = modifiers_findByType(ob, eModifierType_Smoke)) &&
(md = modifiers_findByType(ob, eModifierType_Fluid)) &&
(modifier_isEnabled(scene, md, eModifierMode_Realtime)) &&
(((SmokeModifierData *)md)->domain != NULL)) {
(((FluidModifierData *)md)->domain != NULL) &&
(((FluidModifierData *)md)->domain->type == FLUID_DOMAIN_TYPE_GAS)) {
workbench_volume_cache_populate(vedata, scene, ob, md);
return; /* Do not draw solid in this case. */
}

6
source/blender/draw/engines/workbench/workbench_forward.c
View File

@ -33,6 +33,7 @@
#include "BKE_particle.h"
#include "DNA_image_types.h"
#include "DNA_fluid_types.h"
#include "DNA_mesh_types.h"
#include "DNA_modifier_types.h"
#include "DNA_node_types.h"
@ -618,9 +619,10 @@ void workbench_forward_cache_populate(WORKBENCH_Data *vedata, Object *ob)
ModifierData *md;
if (((ob->base_flag & BASE_FROM_DUPLI) == 0) &&
(md = modifiers_findByType(ob, eModifierType_Smoke)) &&
(md = modifiers_findByType(ob, eModifierType_Fluid)) &&
(modifier_isEnabled(scene, md, eModifierMode_Realtime)) &&
(((SmokeModifierData *)md)->domain != NULL)) {
(((FluidModifierData *)md)->domain != NULL) &&
(((FluidModifierData *)md)->domain->type == FLUID_DOMAIN_TYPE_GAS)) {
workbench_volume_cache_populate(vedata, scene, ob, md);
return; /* Do not draw solid in this case. */
}

75
source/blender/draw/engines/workbench/workbench_volume.c
View File

@ -23,7 +23,7 @@
#include "workbench_private.h"
#include "BKE_object.h"
#include "BKE_smoke.h"
#include "BKE_fluid.h"
#include "BLI_rand.h"
#include "BLI_dynstr.h"
@ -31,7 +31,7 @@
#include "DNA_modifier_types.h"
#include "DNA_object_force_types.h"
#include "DNA_smoke_types.h"
#include "DNA_fluid_types.h"
#include "GPU_draw.h"
@ -119,57 +119,56 @@ void workbench_volume_cache_init(WORKBENCH_Data *vedata)
}
void workbench_volume_cache_populate(WORKBENCH_Data *vedata,
Scene *scene,
Scene *UNUSED(scene),
Object *ob,
ModifierData *md)
{
SmokeModifierData *smd = (SmokeModifierData *)md;
SmokeDomainSettings *sds = smd->domain;
FluidModifierData *mmd = (FluidModifierData *)md;
FluidDomainSettings *mds = mmd->domain;
WORKBENCH_PrivateData *wpd = vedata->stl->g_data;
WORKBENCH_EffectInfo *effect_info = vedata->stl->effects;
DefaultTextureList *dtxl = DRW_viewport_texture_list_get();
DRWShadingGroup *grp = NULL;
/* Don't show smoke before simulation starts, this could be made an option in the future. */
if (!sds->fluid || CFRA < sds->point_cache[0]->startframe) {
/* Don't try to show liquid domains here */
if (!mds->fluid || !(mds->type == FLUID_DOMAIN_TYPE_GAS)) {
return;
}
wpd->volumes_do = true;
const bool show_highres = BKE_smoke_show_highres(scene, sds);
if (sds->use_coba) {
GPU_create_smoke_coba_field(smd);
if (mds->use_coba) {
GPU_create_smoke_coba_field(mmd);
}
else if (!sds->wt || !show_highres) {
GPU_create_smoke(smd, 0);
else if (!(mds->flags & FLUID_DOMAIN_USE_NOISE)) {
GPU_create_smoke(mmd, 0);
}
else if (sds->wt && show_highres) {
GPU_create_smoke(smd, 1);
else if (mds->flags & FLUID_DOMAIN_USE_NOISE) {
GPU_create_smoke(mmd, 1);
}
if ((!sds->use_coba && sds->tex == NULL) || (sds->use_coba && sds->tex_field == NULL)) {
if ((!mds->use_coba && mds->tex == NULL) || (mds->use_coba && mds->tex_field == NULL)) {
return;
}
const bool use_slice = (sds->slice_method == MOD_SMOKE_SLICE_AXIS_ALIGNED &&
sds->axis_slice_method == AXIS_SLICE_SINGLE);
const bool cubic_interp = (sds->interp_method == VOLUME_INTERP_CUBIC);
GPUShader *sh = volume_shader_get(use_slice, sds->use_coba, cubic_interp);
const bool use_slice = (mds->slice_method == FLUID_DOMAIN_SLICE_AXIS_ALIGNED &&
mds->axis_slice_method == AXIS_SLICE_SINGLE);
const bool cubic_interp = (mds->interp_method == VOLUME_INTERP_CUBIC);
GPUShader *sh = volume_shader_get(use_slice, mds->use_coba, cubic_interp);
if (use_slice) {
float invviewmat[4][4];
DRW_view_viewmat_get(NULL, invviewmat, true);
const int axis = (sds->slice_axis == SLICE_AXIS_AUTO) ?
const int axis = (mds->slice_axis == SLICE_AXIS_AUTO) ?
axis_dominant_v3_single(invviewmat[2]) :
sds->slice_axis - 1;
mds->slice_axis - 1;
float dim[3];
BKE_object_dimensions_get(ob, dim);
/* 0.05f to achieve somewhat the same opacity as the full view. */
float step_length = max_ff(1e-16f, dim[axis] * 0.05f);
grp = DRW_shgroup_create(sh, vedata->psl->volume_pass);
DRW_shgroup_uniform_float_copy(grp, "slicePosition", sds->slice_depth);
DRW_shgroup_uniform_float_copy(grp, "slicePosition", mds->slice_depth);
DRW_shgroup_uniform_int_copy(grp, "sliceAxis", axis);
DRW_shgroup_uniform_float_copy(grp, "stepLength", step_length);
DRW_shgroup_state_disable(grp, DRW_STATE_CULL_FRONT);
@ -178,8 +177,8 @@ void workbench_volume_cache_populate(WORKBENCH_Data *vedata,
double noise_ofs;
BLI_halton_1d(3, 0.0, effect_info->jitter_index, &noise_ofs);
float dim[3], step_length, max_slice;
float slice_ct[3] = {sds->res[0], sds->res[1], sds->res[2]};
mul_v3_fl(slice_ct, max_ff(0.001f, sds->slice_per_voxel));
float slice_ct[3] = {mds->res[0], mds->res[1], mds->res[2]};
mul_v3_fl(slice_ct, max_ff(0.001f, mds->slice_per_voxel));
max_slice = max_fff(slice_ct[0], slice_ct[1], slice_ct[2]);
BKE_object_dimensions_get(ob, dim);
invert_v3(slice_ct);
@ -194,25 +193,25 @@ void workbench_volume_cache_populate(WORKBENCH_Data *vedata,
DRW_shgroup_state_enable(grp, DRW_STATE_CULL_FRONT);
}
if (sds->use_coba) {
DRW_shgroup_uniform_texture(grp, "densityTexture", sds->tex_field);
DRW_shgroup_uniform_texture(grp, "transferTexture", sds->tex_coba);
if (mds->use_coba) {
DRW_shgroup_uniform_texture(grp, "densityTexture", mds->tex_field);
DRW_shgroup_uniform_texture(grp, "transferTexture", mds->tex_coba);
}
else {
static float white[3] = {1.0f, 1.0f, 1.0f};
bool use_constant_color = ((sds->active_fields & SM_ACTIVE_COLORS) == 0 &&
(sds->active_fields & SM_ACTIVE_COLOR_SET) != 0);
DRW_shgroup_uniform_texture(grp, "densityTexture", sds->tex);
DRW_shgroup_uniform_texture(grp, "shadowTexture", sds->tex_shadow);
bool use_constant_color = ((mds->active_fields & FLUID_DOMAIN_ACTIVE_COLORS) == 0 &&
(mds->active_fields & FLUID_DOMAIN_ACTIVE_COLOR_SET) != 0);
DRW_shgroup_uniform_texture(grp, "densityTexture", mds->tex);
DRW_shgroup_uniform_texture(grp, "shadowTexture", mds->tex_shadow);
DRW_shgroup_uniform_texture(
grp, "flameTexture", (sds->tex_flame) ? sds->tex_flame : e_data.dummy_tex);
grp, "flameTexture", (mds->tex_flame) ? mds->tex_flame : e_data.dummy_tex);
DRW_shgroup_uniform_texture(
grp, "flameColorTexture", (sds->tex_flame) ? sds->tex_flame_coba : e_data.dummy_coba_tex);
grp, "flameColorTexture", (mds->tex_flame) ? mds->tex_flame_coba : e_data.dummy_coba_tex);
DRW_shgroup_uniform_vec3(
grp, "activeColor", (use_constant_color) ? sds->active_color : white, 1);
grp, "activeColor", (use_constant_color) ? mds->active_color : white, 1);
}
DRW_shgroup_uniform_texture_ref(grp, "depthBuffer", &dtxl->depth);
DRW_shgroup_uniform_float_copy(grp, "densityScale", 10.0f * sds->display_thickness);
DRW_shgroup_uniform_float_copy(grp, "densityScale", 10.0f * mds->display_thickness);
if (use_slice) {
DRW_shgroup_call(grp, DRW_cache_quad_get(), ob);
@ -221,7 +220,7 @@ void workbench_volume_cache_populate(WORKBENCH_Data *vedata,
DRW_shgroup_call(grp, DRW_cache_cube_get(), ob);
}
BLI_addtail(&wpd->smoke_domains, BLI_genericNodeN(smd));
BLI_addtail(&wpd->smoke_domains, BLI_genericNodeN(mmd));
}
void workbench_volume_smoke_textures_free(WORKBENCH_PrivateData *wpd)
@ -233,8 +232,8 @@ void workbench_volume_smoke_textures_free(WORKBENCH_PrivateData *wpd)
* modifier is not used for display. We should share them for
* all viewport in a redraw at least. */
for (LinkData *link = wpd->smoke_domains.first; link; link = link->next) {
SmokeModifierData *smd = (SmokeModifierData *)link->data;
GPU_free_smoke(smd);
FluidModifierData *mmd = (FluidModifierData *)link->data;
GPU_free_smoke(mmd);
}
BLI_freelistN(&wpd->smoke_domains);
}

3
source/blender/editors/datafiles/CMakeLists.txt
View File

@ -385,9 +385,8 @@ set(ICON_NAMES
mod_mask
mod_cloth
mod_explode
mod_fluidsim
mod_multires
mod_smoke
mod_fluid
mod_solidify
mod_screw
mod_vertex_weight

2
source/blender/editors/include/UI_icons.h
View File

@ -560,7 +560,7 @@ DEF_ICON_MODIFIER(MOD_CLOTH)
DEF_ICON_MODIFIER(MOD_EXPLODE)
DEF_ICON_MODIFIER(MOD_FLUIDSIM)
DEF_ICON_MODIFIER(MOD_MULTIRES)
DEF_ICON_MODIFIER(MOD_SMOKE)
DEF_ICON_MODIFIER(MOD_FLUID)
DEF_ICON_MODIFIER(MOD_SOLIDIFY)
DEF_ICON_MODIFIER(MOD_SCREW)
DEF_ICON_MODIFIER(MOD_VERTEX_WEIGHT)

13
source/blender/editors/interface/interface_templates.c
View File

@ -1819,11 +1819,16 @@ static int modifier_can_delete(ModifierData *md)
{
/* fluid particle modifier can't be deleted here */
if (md->type == eModifierType_ParticleSystem) {
if (((ParticleSystemModifierData *)md)->psys->part->type == PART_FLUID) {
short particle_type = ((ParticleSystemModifierData *)md)->psys->part->type;
if (particle_type == PART_FLUID ||
particle_type == PART_FLUID_FLIP ||
particle_type == PART_FLUID_FOAM ||
particle_type == PART_FLUID_SPRAY ||
particle_type == PART_FLUID_BUBBLE ||
particle_type == PART_FLUID_BUBBLE) {
return 0;
}
}
return 1;
}
@ -1836,7 +1841,7 @@ static int modifier_is_simulation(ModifierData *md)
eModifierType_Cloth,
eModifierType_Collision,
eModifierType_Fluidsim,
eModifierType_Smoke,
eModifierType_Fluid,
eModifierType_Softbody,
eModifierType_Surface,
eModifierType_DynamicPaint)) {
@ -2069,7 +2074,7 @@ static uiLayout *draw_modifier(uiLayout *layout,
eModifierType_Softbody,
eModifierType_ParticleSystem,
eModifierType_Cloth,
eModifierType_Smoke)) {
eModifierType_Fluid)) {
uiItemO(row,
CTX_IFACE_(BLT_I18NCONTEXT_OPERATOR_DEFAULT, "Copy"),
ICON_NONE,

13
source/blender/editors/physics/CMakeLists.txt
View File

@ -27,6 +27,7 @@ set(INC
../../windowmanager
../../../../intern/glew-mx
../../../../intern/guardedalloc
../../../../intern/mantaflow/extern
)
set(INC_SYS
@ -56,18 +57,8 @@ set(LIB
)
if(WITH_MOD_FLUID)
list(APPEND INC
../../../../intern/elbeem/extern
)
list(APPEND LIB
bf_intern_elbeem
)
add_definitions(-DWITH_MOD_FLUID)
endif()
if(WITH_MOD_SMOKE)
list(APPEND LIB
bf_intern_smoke
bf_intern_mantaflow
)
endif()

2
source/blender/editors/physics/particle_object.c
View File

@ -1065,7 +1065,7 @@ static void remove_particle_systems_from_object(Object *ob_to)
if (ELEM(md->type,
eModifierType_ParticleSystem,
eModifierType_DynamicPaint,
eModifierType_Smoke)) {
eModifierType_Fluid)) {
BLI_remlink(&ob_to->modifiers, md);
modifier_free(md);
}

14
source/blender/editors/physics/physics_intern.h
View File

@ -103,7 +103,19 @@ void BOID_OT_state_move_up(struct wmOperatorType *ot);
void BOID_OT_state_move_down(struct wmOperatorType *ot);
/* physics_fluid.c */
void FLUID_OT_bake(struct wmOperatorType *ot);
void FLUID_OT_bake_all(struct wmOperatorType *ot);
void FLUID_OT_free_all(struct wmOperatorType *ot);
void FLUID_OT_bake_data(struct wmOperatorType *ot);
void FLUID_OT_free_data(struct wmOperatorType *ot);
void FLUID_OT_bake_noise(struct wmOperatorType *ot);
void FLUID_OT_free_noise(struct wmOperatorType *ot);
void FLUID_OT_bake_mesh(struct wmOperatorType *ot);
void FLUID_OT_free_mesh(struct wmOperatorType *ot);
void FLUID_OT_bake_particles(struct wmOperatorType *ot);
void FLUID_OT_free_particles(struct wmOperatorType *ot);
void FLUID_OT_bake_guiding(struct wmOperatorType *ot);
void FLUID_OT_free_guiding(struct wmOperatorType *ot);
void FLUID_OT_pause_bake(struct wmOperatorType *ot);
/* dynamicpaint.c */
void DPAINT_OT_bake(struct wmOperatorType *ot);

14
source/blender/editors/physics/physics_ops.c
View File

@ -126,7 +126,19 @@ static void operatortypes_boids(void)
static void operatortypes_fluid(void)
{
WM_operatortype_append(FLUID_OT_bake);
WM_operatortype_append(FLUID_OT_bake_all);
WM_operatortype_append(FLUID_OT_free_all);
WM_operatortype_append(FLUID_OT_bake_data);
WM_operatortype_append(FLUID_OT_free_data);
WM_operatortype_append(FLUID_OT_bake_noise);
WM_operatortype_append(FLUID_OT_free_noise);
WM_operatortype_append(FLUID_OT_bake_mesh);
WM_operatortype_append(FLUID_OT_free_mesh);
WM_operatortype_append(FLUID_OT_bake_particles);
WM_operatortype_append(FLUID_OT_free_particles);
WM_operatortype_append(FLUID_OT_bake_guiding);
WM_operatortype_append(FLUID_OT_free_guiding);
WM_operatortype_append(FLUID_OT_pause_bake);
}
/**************************** point cache **********************************/

17
source/blender/editors/space_buttons/buttons_context.c
View File

@ -770,7 +770,6 @@ const char *buttons_context_dir[] = {
"cloth",
"soft_body",
"fluid",
"smoke",
"collision",
"brush",
"dynamic_paint",
@ -1018,24 +1017,14 @@ int buttons_context(const bContext *C, const char *member, bContextDataResult *r
return 1;
}
}
else if (CTX_data_equals(member, "fluid")) {
PointerRNA *ptr = get_pointer_type(path, &RNA_Object);
if (ptr && ptr->data) {
Object *ob = ptr->data;
ModifierData *md = modifiers_findByType(ob, eModifierType_Fluidsim);
CTX_data_pointer_set(result, &ob->id, &RNA_FluidSimulationModifier, md);
return 1;
}
}
else if (CTX_data_equals(member, "smoke")) {
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;
}
}

6
source/blender/editors/space_outliner/outliner_draw.c
View File

@ -2125,14 +2125,14 @@ TreeElementIcon tree_element_get_icon(TreeStoreElem *tselem, TreeElement *te)
case eModifierType_Surface:
data.icon = ICON_MOD_PHYSICS;
break;
case eModifierType_Fluidsim:
case eModifierType_Fluidsim: /* deprecated, old fluid modifier */
data.icon = ICON_MOD_FLUIDSIM;
break;
case eModifierType_Multires:
data.icon = ICON_MOD_MULTIRES;
break;
case eModifierType_Smoke:
data.icon = ICON_MOD_SMOKE;
case eModifierType_Fluid:
data.icon = ICON_MOD_FLUID;
break;
case eModifierType_Solidify:
data.icon = ICON_MOD_SOLIDIFY;

6
source/blender/editors/space_view3d/CMakeLists.txt
View File

@ -32,7 +32,7 @@ set(INC
../../windowmanager
../../../../intern/glew-mx
../../../../intern/guardedalloc
../../../../intern/smoke/extern
../../../../intern/mantaflow/extern
# dna_type_offsets.h
${CMAKE_CURRENT_BINARY_DIR}/../../makesdna/intern
@ -95,8 +95,8 @@ if(WITH_FREESTYLE)
add_definitions(-DWITH_FREESTYLE)
endif()
if(WITH_MOD_SMOKE)
add_definitions(-DWITH_SMOKE)
if(WITH_MOD_FLUID)
add_definitions(-DWITH_FLUID)
endif()
blender_add_lib(bf_editor_space_view3d "${SRC}" "${INC}" "${INC_SYS}" "${LIB}")

1
source/blender/gpencil_modifiers/CMakeLists.txt
View File

@ -30,7 +30,6 @@ set(INC
../makesdna
../makesrna
../render/extern/include
../../../intern/elbeem/extern
../../../intern/eigen
../../../intern/guardedalloc
)

6
source/blender/gpu/CMakeLists.txt
View File

@ -44,7 +44,7 @@ set(INC
../../../intern/glew-mx
../../../intern/guardedalloc
../../../intern/smoke/extern
../../../intern/mantaflow/extern
)
set(INC_SYS
@ -319,8 +319,8 @@ data_to_c_simple(shaders/gpu_shader_cfg_world_clip_lib.glsl SRC)
data_to_c_simple(shaders/gpu_shader_common_obinfos_lib.glsl SRC)
if(WITH_MOD_SMOKE)
add_definitions(-DWITH_SMOKE)
if(WITH_MOD_FLUID)
add_definitions(-DWITH_FLUID)
endif()
add_definitions(${GL_DEFINITIONS})

12
source/blender/gpu/GPU_draw.h
View File

@ -32,7 +32,7 @@ struct ImBuf;
struct Image;
struct ImageUser;
struct Main;
struct SmokeModifierData;
struct FluidModifierData;
#include "DNA_object_enums.h"
@ -84,11 +84,11 @@ void GPU_free_images_anim(struct Main *bmain);
void GPU_free_images_old(struct Main *bmain);
/* smoke drawing functions */
void GPU_free_smoke(struct SmokeModifierData *smd);
void GPU_free_smoke_velocity(struct SmokeModifierData *smd);
void GPU_create_smoke(struct SmokeModifierData *smd, int highres);
void GPU_create_smoke_coba_field(struct SmokeModifierData *smd);
void GPU_create_smoke_velocity(struct SmokeModifierData *smd);
void GPU_free_smoke(struct FluidModifierData *mmd);
void GPU_free_smoke_velocity(struct FluidModifierData *mmd);
void GPU_create_smoke(struct FluidModifierData *mmd, int highres);
void GPU_create_smoke_coba_field(struct FluidModifierData *mmd);
void GPU_create_smoke_velocity(struct FluidModifierData *mmd);
/* Delayed free of OpenGL buffers by main thread */
void GPU_free_unused_buffers(struct Main *bmain);

248
source/blender/gpu/intern/gpu_draw.c
View File

@ -44,7 +44,7 @@
#include "DNA_node_types.h"
#include "DNA_object_types.h"
#include "DNA_scene_types.h"
#include "DNA_smoke_types.h"
#include "DNA_fluid_types.h"
#include "DNA_view3d_types.h"
#include "DNA_particle_types.h"
@ -71,9 +71,7 @@
#include "PIL_time.h"
#ifdef WITH_SMOKE
# include "smoke_API.h"
#endif
#include "manta_fluid_API.h"
static void gpu_free_image_immediate(Image *ima);
@ -949,7 +947,6 @@ enum {
#define TFUNC_WIDTH 256
#ifdef WITH_SMOKE
static void create_flame_spectrum_texture(float *data)
{
# define FIRE_THRESH 7
@ -1026,71 +1023,71 @@ static void swizzle_texture_channel_rrrr(GPUTexture *tex)
GPU_texture_unbind(tex);
}
static GPUTexture *create_field_texture(SmokeDomainSettings *sds)
static GPUTexture *create_field_texture(FluidDomainSettings *mds)
{
float *field = NULL;
switch (sds->coba_field) {
case FLUID_FIELD_DENSITY:
field = smoke_get_density(sds->fluid);
switch (mds->coba_field) {
case FLUID_DOMAIN_FIELD_DENSITY:
field = manta_smoke_get_density(mds->fluid);
break;
case FLUID_FIELD_HEAT:
field = smoke_get_heat(sds->fluid);
case FLUID_DOMAIN_FIELD_HEAT:
field = manta_smoke_get_heat(mds->fluid);
break;
case FLUID_FIELD_FUEL:
field = smoke_get_fuel(sds->fluid);
case FLUID_DOMAIN_FIELD_FUEL:
field = manta_smoke_get_fuel(mds->fluid);
break;
case FLUID_FIELD_REACT:
field = smoke_get_react(sds->fluid);
case FLUID_DOMAIN_FIELD_REACT:
field = manta_smoke_get_react(mds->fluid);
break;
case FLUID_FIELD_FLAME:
field = smoke_get_flame(sds->fluid);
case FLUID_DOMAIN_FIELD_FLAME:
field = manta_smoke_get_flame(mds->fluid);
break;
case FLUID_FIELD_VELOCITY_X:
field = smoke_get_velocity_x(sds->fluid);
case FLUID_DOMAIN_FIELD_VELOCITY_X:
field = manta_get_velocity_x(mds->fluid);
break;
case FLUID_FIELD_VELOCITY_Y:
field = smoke_get_velocity_y(sds->fluid);
case FLUID_DOMAIN_FIELD_VELOCITY_Y:
field = manta_get_velocity_y(mds->fluid);
break;
case FLUID_FIELD_VELOCITY_Z:
field = smoke_get_velocity_z(sds->fluid);
case FLUID_DOMAIN_FIELD_VELOCITY_Z:
field = manta_get_velocity_z(mds->fluid);
break;
case FLUID_FIELD_COLOR_R:
field = smoke_get_color_r(sds->fluid);
case FLUID_DOMAIN_FIELD_COLOR_R:
field = manta_smoke_get_color_r(mds->fluid);
break;
case FLUID_FIELD_COLOR_G:
field = smoke_get_color_g(sds->fluid);
case FLUID_DOMAIN_FIELD_COLOR_G:
field = manta_smoke_get_color_g(mds->fluid);
break;
case FLUID_FIELD_COLOR_B:
field = smoke_get_color_b(sds->fluid);
case FLUID_DOMAIN_FIELD_COLOR_B:
field = manta_smoke_get_color_b(mds->fluid);
break;
case FLUID_FIELD_FORCE_X:
field = smoke_get_force_x(sds->fluid);
case FLUID_DOMAIN_FIELD_FORCE_X:
field = manta_get_force_x(mds->fluid);
break;
case FLUID_FIELD_FORCE_Y:
field = smoke_get_force_y(sds->fluid);
case FLUID_DOMAIN_FIELD_FORCE_Y:
field = manta_get_force_y(mds->fluid);
break;
case FLUID_FIELD_FORCE_Z:
field = smoke_get_force_z(sds->fluid);
case FLUID_DOMAIN_FIELD_FORCE_Z:
field = manta_get_force_z(mds->fluid);
break;
default:
return NULL;
}
GPUTexture *tex = GPU_texture_create_nD(
sds->res[0], sds->res[1], sds->res[2], 3, field, GPU_R8, GPU_DATA_FLOAT, 0, true, NULL);
mds->res[0], mds->res[1], mds->res[2], 3, field, GPU_R8, GPU_DATA_FLOAT, 0, true, NULL);
swizzle_texture_channel_rrrr(tex);
return tex;
}
static GPUTexture *create_density_texture(SmokeDomainSettings *sds, int highres)
static GPUTexture *create_density_texture(FluidDomainSettings *mds, int highres)
{
float *data = NULL, *source;
int cell_count = (highres) ? smoke_turbulence_get_cells(sds->wt) : sds->total_cells;
const bool has_color = (highres) ? smoke_turbulence_has_colors(sds->wt) :
smoke_has_colors(sds->fluid);
int *dim = (highres) ? sds->res_wt : sds->res;
int cell_count = (highres) ? manta_smoke_turbulence_get_cells(mds->fluid) : mds->total_cells;
const bool has_color = (highres) ? manta_smoke_turbulence_has_colors(mds->fluid) :
manta_smoke_has_colors(mds->fluid);
int *dim = (highres) ? mds->res_noise : mds->res;
eGPUTextureFormat format = (has_color) ? GPU_RGBA8 : GPU_R8;
if (has_color) {
@ -1099,18 +1096,18 @@ static GPUTexture *create_density_texture(SmokeDomainSettings *sds, int highres)
if (highres) {
if (has_color) {
smoke_turbulence_get_rgba(sds->wt, data, 0);
manta_smoke_turbulence_get_rgba(mds->fluid, data, 0);
}
else {
source = smoke_turbulence_get_density(sds->wt);
source = manta_smoke_turbulence_get_density(mds->fluid);
}
}
else {
if (has_color) {
smoke_get_rgba(sds->fluid, data, 0);
manta_smoke_get_rgba(mds->fluid, data, 0);
}
else {
source = smoke_get_density(sds->fluid);
source = manta_smoke_get_density(mds->fluid);
}
}
@ -1137,22 +1134,22 @@ static GPUTexture *create_density_texture(SmokeDomainSettings *sds, int highres)
return tex;
}
static GPUTexture *create_flame_texture(SmokeDomainSettings *sds, int highres)
static GPUTexture *create_flame_texture(FluidDomainSettings *mds, int highres)
{
float *source = NULL;
const bool has_fuel = (highres) ? smoke_turbulence_has_fuel(sds->wt) :
smoke_has_fuel(sds->fluid);
int *dim = (highres) ? sds->res_wt : sds->res;
const bool has_fuel = (highres) ? manta_smoke_turbulence_has_fuel(mds->fluid) :
manta_smoke_has_fuel(mds->fluid);
int *dim = (highres) ? mds->res_noise : mds->res;
if (!has_fuel) {
return NULL;
}
if (highres) {
source = smoke_turbulence_get_flame(sds->wt);
source = manta_smoke_turbulence_get_flame(mds->fluid);
}
else {
source = smoke_get_flame(sds->fluid);
source = manta_smoke_get_flame(mds->fluid);
}
GPUTexture *tex = GPU_texture_create_nD(
@ -1162,82 +1159,76 @@ static GPUTexture *create_flame_texture(SmokeDomainSettings *sds, int highres)
return tex;
}
#endif /* WITH_SMOKE */
void GPU_free_smoke(SmokeModifierData *smd)
void GPU_free_smoke(FluidModifierData *mmd)
{
if (smd->type & MOD_SMOKE_TYPE_DOMAIN && smd->domain) {
if (smd->domain->tex) {
GPU_texture_free(smd->domain->tex);
if (mmd->type & MOD_FLUID_TYPE_DOMAIN && mmd->domain) {
if (mmd->domain->tex) {
GPU_texture_free(mmd->domain->tex);
}
smd->domain->tex = NULL;
mmd->domain->tex = NULL;
if (smd->domain->tex_shadow) {
GPU_texture_free(smd->domain->tex_shadow);
if (mmd->domain->tex_shadow) {
GPU_texture_free(mmd->domain->tex_shadow);
}
smd->domain->tex_shadow = NULL;
mmd->domain->tex_shadow = NULL;
if (smd->domain->tex_flame) {
GPU_texture_free(smd->domain->tex_flame);
if (mmd->domain->tex_flame) {
GPU_texture_free(mmd->domain->tex_flame);
}
smd->domain->tex_flame = NULL;
mmd->domain->tex_flame = NULL;
if (smd->domain->tex_flame_coba) {
GPU_texture_free(smd->domain->tex_flame_coba);
if (mmd->domain->tex_flame_coba) {
GPU_texture_free(mmd->domain->tex_flame_coba);
}
smd->domain->tex_flame_coba = NULL;
mmd->domain->tex_flame_coba = NULL;
if (smd->domain->tex_coba) {
GPU_texture_free(smd->domain->tex_coba);
if (mmd->domain->tex_coba) {
GPU_texture_free(mmd->domain->tex_coba);
}
smd->domain->tex_coba = NULL;
mmd->domain->tex_coba = NULL;
if (smd->domain->tex_field) {
GPU_texture_free(smd->domain->tex_field);
if (mmd->domain->tex_field) {
GPU_texture_free(mmd->domain->tex_field);
}
smd->domain->tex_field = NULL;
mmd->domain->tex_field = NULL;
}
}
void GPU_create_smoke_coba_field(SmokeModifierData *smd)
void GPU_create_smoke_coba_field(FluidModifierData *mmd)
{
#ifdef WITH_SMOKE
if (smd->type & MOD_SMOKE_TYPE_DOMAIN) {
SmokeDomainSettings *sds = smd->domain;
if (mmd->type & MOD_FLUID_TYPE_DOMAIN) {
FluidDomainSettings *mds = mmd->domain;
if (!sds->tex_field) {
sds->tex_field = create_field_texture(sds);
if (!mds->tex_field) {
mds->tex_field = create_field_texture(mds);
}
if (!sds->tex_coba) {
sds->tex_coba = create_transfer_function(TFUNC_COLOR_RAMP, sds->coba);
if (!mds->tex_coba) {
mds->tex_coba = create_transfer_function(TFUNC_COLOR_RAMP, mds->coba);
}
}
#else // WITH_SMOKE
smd->domain->tex_field = NULL;
#endif // WITH_SMOKE
}
void GPU_create_smoke(SmokeModifierData *smd, int highres)
void GPU_create_smoke(FluidModifierData *mmd, int highres)
{
#ifdef WITH_SMOKE
if (smd->type & MOD_SMOKE_TYPE_DOMAIN) {
SmokeDomainSettings *sds = smd->domain;
if (mmd->type & MOD_FLUID_TYPE_DOMAIN) {
FluidDomainSettings *mds = mmd->domain;
if (!sds->tex) {
sds->tex = create_density_texture(sds, highres);
if (!mds->tex) {
mds->tex = create_density_texture(mds, highres);
}
if (!sds->tex_flame) {
sds->tex_flame = create_flame_texture(sds, highres);
if (!mds->tex_flame) {
mds->tex_flame = create_flame_texture(mds, highres);
}
if (!sds->tex_flame_coba && sds->tex_flame) {
sds->tex_flame_coba = create_transfer_function(TFUNC_FLAME_SPECTRUM, NULL);
if (!mds->tex_flame_coba && mds->tex_flame) {
mds->tex_flame_coba = create_transfer_function(TFUNC_FLAME_SPECTRUM, NULL);
}
if (!sds->tex_shadow) {
sds->tex_shadow = GPU_texture_create_nD(sds->res[0],
sds->res[1],
sds->res[2],
if (!mds->tex_shadow) {
mds->tex_shadow = GPU_texture_create_nD(mds->res[0],
mds->res[1],
mds->res[2],
3,
sds->shadow,
manta_smoke_get_shadow(mds->fluid),
GPU_R8,
GPU_DATA_FLOAT,
0,
@ -1245,64 +1236,51 @@ void GPU_create_smoke(SmokeModifierData *smd, int highres)
NULL);
}
}
#else // WITH_SMOKE
(void)highres;
smd->domain->tex = NULL;
smd->domain->tex_flame = NULL;
smd->domain->tex_flame_coba = NULL;
smd->domain->tex_shadow = NULL;
#endif // WITH_SMOKE
}
void GPU_create_smoke_velocity(SmokeModifierData *smd)
void GPU_create_smoke_velocity(FluidModifierData *mmd)
{
#ifdef WITH_SMOKE
if (smd->type & MOD_SMOKE_TYPE_DOMAIN) {
SmokeDomainSettings *sds = smd->domain;
if (mmd->type & MOD_FLUID_TYPE_DOMAIN) {
FluidDomainSettings *mds = mmd->domain;
const float *vel_x = smoke_get_velocity_x(sds->fluid);
const float *vel_y = smoke_get_velocity_y(sds->fluid);
const float *vel_z = smoke_get_velocity_z(sds->fluid);
const float *vel_x = manta_get_velocity_x(mds->fluid);
const float *vel_y = manta_get_velocity_y(mds->fluid);
const float *vel_z = manta_get_velocity_z(mds->fluid);
if (ELEM(NULL, vel_x, vel_y, vel_z)) {
return;
}
if (!sds->tex_velocity_x) {
sds->tex_velocity_x = GPU_texture_create_3d(
sds->res[0], sds->res[1], sds->res[2], GPU_R16F, vel_x, NULL);
sds->tex_velocity_y = GPU_texture_create_3d(
sds->res[0], sds->res[1], sds->res[2], GPU_R16F, vel_y, NULL);
sds->tex_velocity_z = GPU_texture_create_3d(
sds->res[0], sds->res[1], sds->res[2], GPU_R16F, vel_z, NULL);
if (!mds->tex_velocity_x) {
mds->tex_velocity_x = GPU_texture_create_3d(
mds->res[0], mds->res[1], mds->res[2], GPU_R16F, vel_x, NULL);
mds->tex_velocity_y = GPU_texture_create_3d(
mds->res[0], mds->res[1], mds->res[2], GPU_R16F, vel_y, NULL);
mds->tex_velocity_z = GPU_texture_create_3d(
mds->res[0], mds->res[1], mds->res[2], GPU_R16F, vel_z, NULL);
}
}
#else // WITH_SMOKE
smd->domain->tex_velocity_x = NULL;
smd->domain->tex_velocity_y = NULL;
smd->domain->tex_velocity_z = NULL;
#endif // WITH_SMOKE
}
/* TODO Unify with the other GPU_free_smoke. */
void GPU_free_smoke_velocity(SmokeModifierData *smd)
void GPU_free_smoke_velocity(FluidModifierData *mmd)
{
if (smd->type & MOD_SMOKE_TYPE_DOMAIN && smd->domain) {
if (smd->domain->tex_velocity_x) {
GPU_texture_free(smd->domain->tex_velocity_x);
if (mmd->type & MOD_FLUID_TYPE_DOMAIN && mmd->domain) {
if (mmd->domain->tex_velocity_x) {
GPU_texture_free(mmd->domain->tex_velocity_x);
}
if (smd->domain->tex_velocity_y) {
GPU_texture_free(smd->domain->tex_velocity_y);
if (mmd->domain->tex_velocity_y) {
GPU_texture_free(mmd->domain->tex_velocity_y);
}
if (smd->domain->tex_velocity_z) {
GPU_texture_free(smd->domain->tex_velocity_z);
if (mmd->domain->tex_velocity_z) {
GPU_texture_free(mmd->domain->tex_velocity_z);
}
smd->domain->tex_velocity_x = NULL;
smd->domain->tex_velocity_y = NULL;
smd->domain->tex_velocity_z = NULL;
mmd->domain->tex_velocity_x = NULL;
mmd->domain->tex_velocity_y = NULL;
mmd->domain->tex_velocity_z = NULL;
}
}

27
source/blender/makesdna/DNA_modifier_types.h
View File

@ -87,6 +87,7 @@ typedef enum ModifierType {
eModifierType_SurfaceDeform = 53,
eModifierType_WeightedNormal = 54,
eModifierType_Weld = 55,
eModifierType_Fluid = 56,
NUM_MODIFIER_TYPES,
} ModifierType;
@ -451,24 +452,24 @@ enum {
MOD_BEVEL_VMESH_CUTOFF,
};
typedef struct SmokeModifierData {
typedef struct FluidModifierData {
ModifierData modifier;
struct SmokeDomainSettings *domain;
struct FluidDomainSettings *domain;
/** Inflow, outflow, smoke objects. */
struct SmokeFlowSettings *flow;
/** Collision objects. */
struct SmokeCollSettings *coll;
struct FluidFlowSettings *flow;
/** Effector objects (collision, guiding). */
struct FluidEffectorSettings *effector;
float time;
/** Domain, inflow, outflow, .... */
int type;
} SmokeModifierData;
} FluidModifierData;
/* Smoke modifier flags */
/* Fluid modifier flags */
enum {
MOD_SMOKE_TYPE_DOMAIN = (1 << 0),
MOD_SMOKE_TYPE_FLOW = (1 << 1),
MOD_SMOKE_TYPE_COLL = (1 << 2),
MOD_FLUID_TYPE_DOMAIN = (1 << 0),
MOD_FLUID_TYPE_FLOW = (1 << 1),
MOD_FLUID_TYPE_EFFEC = (1 << 2),
};
typedef struct DisplaceModifierData {
@ -977,6 +978,7 @@ typedef enum {
eMultiresModifierFlag_UseCrease = (1 << 2),
} MultiresModifierFlag;
/* DEPRECATED, only used for versioning. */
typedef struct FluidsimModifierData {
ModifierData modifier;
@ -984,6 +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;

3
source/blender/makesdna/DNA_object_types.h
View File

@ -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;

36
source/blender/makesdna/DNA_particle_types.h
View File

@ -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

346
source/blender/makesdna/DNA_smoke_types.h
View File

@ -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

4
source/blender/makesdna/intern/makesdna.c
View File

@ -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"

9
source/blender/makesrna/RNA_access.h
View File

@ -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;

13
source/blender/makesrna/intern/CMakeLists.txt
View File

@ -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(

3
source/blender/makesrna/intern/makesrna.c
View File

@ -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},

792
source/blender/makesrna/intern/rna_fluidsim.c
View File

@ -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

4
source/blender/makesrna/intern/rna_gpencil_modifier.c
View File

@ -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"

3
source/blender/makesrna/intern/rna_internal.h
View File

@ -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);

83
source/blender/makesrna/intern/rna_modifier.c
View File

@ -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);

8
source/blender/makesrna/intern/rna_object_force.c
View File

@ -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);

5
source/blender/makesrna/intern/rna_particle.c
View File

@ -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)

1218
source/blender/makesrna/intern/rna_smoke.c
View File

File diff suppressed because it is too large Load Diff

10
source/blender/modifiers/CMakeLists.txt
View File

@ -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()

2
source/blender/modifiers/MOD_modifiertypes.h
View File

@ -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;

113
source/blender/modifiers/intern/MOD_smoke.c → source/blender/modifiers/intern/MOD_fluid.c
View File

@ -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 (smd->domain->effector_weights) {
walk(userData, ob, (ID **)&smd->domain->effector_weights->group, IDWALK_CB_NOP);
if (mmd->domain->guiding_parent) {
walk(userData, ob, (ID **)&mmd->domain->guiding_parent, 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,

150
source/blender/modifiers/intern/MOD_fluidsim.c
View File

@ -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,
};

588
source/blender/modifiers/intern/MOD_fluidsim_util.c
View File

@ -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
}

39
source/blender/modifiers/intern/MOD_fluidsim_util.h
View File

@ -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

3
source/blender/modifiers/intern/MOD_util.c
View File

@ -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);

9
source/blender/python/intern/CMakeLists.txt
View File

@ -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)

21
source/blender/python/intern/bpy_app_build_options.c
View File

@ -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;

16
source/blender/python/intern/bpy_interface.c
View File

@ -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;

6
source/blender/render/CMakeLists.txt
View File

@ -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)

1
source/blender/shader_fx/CMakeLists.txt
View File

@ -30,7 +30,6 @@ set(INC
../makesdna
../makesrna
../render/extern/include
../../../intern/elbeem/extern
../../../intern/eigen
../../../intern/guardedalloc
)