From 5cae44ef6d49253c9019fdaa84c9b76ecf98f141 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebasti=C3=A1n=20Barschkis?= Date: Wed, 15 Apr 2020 13:49:41 +0200 Subject: Fluid: Minor UI fix for diffusion panel Was missing active option. --- release/scripts/startup/bl_ui/properties_physics_fluid.py | 1 + 1 file changed, 1 insertion(+) diff --git a/release/scripts/startup/bl_ui/properties_physics_fluid.py b/release/scripts/startup/bl_ui/properties_physics_fluid.py index 390b5de7d37..960d2dff101 100644 --- a/release/scripts/startup/bl_ui/properties_physics_fluid.py +++ b/release/scripts/startup/bl_ui/properties_physics_fluid.py @@ -988,6 +988,7 @@ class PHYSICS_PT_diffusion(PhysicButtonsPanel, Panel): layout.use_property_split = True domain = context.fluid.domain_settings + layout.active = domain.use_diffusion is_baking_any = domain.is_cache_baking_any has_baked_any = domain.has_cache_baked_any -- cgit v1.2.3 From 06e3df4ce45ffe093f01bdb8eff2c7b1cf26f26b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebasti=C3=A1n=20Barschkis?= Date: Wed, 15 Apr 2020 13:56:47 +0200 Subject: Fix T75681: Mantaflow crash when trying to bake a cupcake: The CG solver diverged, residual norm > 1e30 Ensures that there are no enclosed holes between an obstacle and the domain walls. --- intern/mantaflow/intern/strings/liquid_script.h | 4 ++-- intern/mantaflow/intern/strings/smoke_script.h | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/intern/mantaflow/intern/strings/liquid_script.h b/intern/mantaflow/intern/strings/liquid_script.h index b0bf6f85914..34994f115d7 100644 --- a/intern/mantaflow/intern/strings/liquid_script.h +++ b/intern/mantaflow/intern/strings/liquid_script.h @@ -173,14 +173,14 @@ def liquid_adaptive_step_$ID$(framenr):\n\ if using_obstacle_s$ID$:\n\ mantaMsg('Initializing obstacle levelset')\n\ phiObsIn_s$ID$.join(phiObsSIn_s$ID$) # Join static obstacle map\n\ - phiObsIn_s$ID$.fillHoles(maxDepth=int(res_s$ID$), boundaryWidth=2)\n\ + phiObsIn_s$ID$.fillHoles(maxDepth=int(res_s$ID$), boundaryWidth=1)\n\ extrapolateLsSimple(phi=phiObsIn_s$ID$, distance=6, inside=True)\n\ extrapolateLsSimple(phi=phiObsIn_s$ID$, distance=3, inside=False)\n\ phiObs_s$ID$.join(phiObsIn_s$ID$)\n\ \n\ # Using boundaryWidth=2 to not search beginning from walls (just a performance optimization)\n\ # Additional sanity check: fill holes in phiObs which can result after joining with phiObsIn\n\ - phiObs_s$ID$.fillHoles(maxDepth=int(res_s$ID$), boundaryWidth=2)\n\ + phiObs_s$ID$.fillHoles(maxDepth=int(res_s$ID$), boundaryWidth=2 if using_fractions_s$ID$ else 1)\n\ extrapolateLsSimple(phi=phiObs_s$ID$, distance=6, inside=True)\n\ extrapolateLsSimple(phi=phiObs_s$ID$, distance=3)\n\ \n\ diff --git a/intern/mantaflow/intern/strings/smoke_script.h b/intern/mantaflow/intern/strings/smoke_script.h index 7a855ff2cb8..cb651eb40b3 100644 --- a/intern/mantaflow/intern/strings/smoke_script.h +++ b/intern/mantaflow/intern/strings/smoke_script.h @@ -279,14 +279,14 @@ def smoke_adaptive_step_$ID$(framenr):\n\ if using_obstacle_s$ID$:\n\ mantaMsg('Initializing obstacle levelset')\n\ phiObsIn_s$ID$.join(phiObsSIn_s$ID$) # Join static obstacle map\n\ - phiObsIn_s$ID$.fillHoles(maxDepth=int(res_s$ID$), boundaryWidth=2)\n\ + phiObsIn_s$ID$.fillHoles(maxDepth=int(res_s$ID$), boundaryWidth=1)\n\ extrapolateLsSimple(phi=phiObsIn_s$ID$, distance=6, inside=True)\n\ extrapolateLsSimple(phi=phiObsIn_s$ID$, distance=3, inside=False)\n\ phiObs_s$ID$.join(phiObsIn_s$ID$)\n\ \n\ # Using boundaryWidth=2 to not search beginning from walls (just a performance optimization)\n\ # Additional sanity check: fill holes in phiObs which can result after joining with phiObsIn\n\ - phiObs_s$ID$.fillHoles(maxDepth=int(res_s$ID$), boundaryWidth=2)\n\ + phiObs_s$ID$.fillHoles(maxDepth=int(res_s$ID$), boundaryWidth=1)\n\ extrapolateLsSimple(phi=phiObs_s$ID$, distance=6, inside=True)\n\ extrapolateLsSimple(phi=phiObs_s$ID$, distance=3, inside=False)\n\ \n\ -- cgit v1.2.3 From 40e9dc638b7f6a70d702cd06e244001b4ccb94a9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebasti=C3=A1n=20Barschkis?= Date: Wed, 15 Apr 2020 13:59:05 +0200 Subject: Fluid: Remove noise bake call from Python Saving noise cache files is handled in fluid.c. --- intern/mantaflow/intern/strings/fluid_script.h | 1 - 1 file changed, 1 deletion(-) diff --git a/intern/mantaflow/intern/strings/fluid_script.h b/intern/mantaflow/intern/strings/fluid_script.h index 0aad0546aea..e81a44109ef 100644 --- a/intern/mantaflow/intern/strings/fluid_script.h +++ b/intern/mantaflow/intern/strings/fluid_script.h @@ -527,7 +527,6 @@ def bake_noise_process_$ID$(framenr, format_data, format_noise, path_data, path_ sn$ID$.timestep = frameLength_s$ID$ # no adaptive timestep for noise\n\ \n\ smoke_step_noise_$ID$(framenr)\n\ - smoke_save_noise_$ID$(path_noise, framenr, format_noise, resumable)\n\ \n\ def bake_noise_$ID$(path_data, path_noise, framenr, format_data, format_noise, resumable):\n\ if not withMPBake or isWindows:\n\ -- cgit v1.2.3 From abdd4117b1e35d7df8755c7188be521e0bfb8756 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebasti=C3=A1n=20Barschkis?= Date: Wed, 15 Apr 2020 14:03:22 +0200 Subject: Fluid: Cleanup in MANTA main class More concise return types for cache import functions and general cleanup. --- intern/mantaflow/intern/MANTA_main.cpp | 40 +++++++++++++++------------------- 1 file changed, 18 insertions(+), 22 deletions(-) diff --git a/intern/mantaflow/intern/MANTA_main.cpp b/intern/mantaflow/intern/MANTA_main.cpp index 79c8625ec48..539e3080c54 100644 --- a/intern/mantaflow/intern/MANTA_main.cpp +++ b/intern/mantaflow/intern/MANTA_main.cpp @@ -61,28 +61,29 @@ int MANTA::with_debug(0); MANTA::MANTA(int *res, FluidModifierData *mmd) : mCurrentID(++solverID) { if (with_debug) - std::cout << "MANTA: " << mCurrentID << " with res(" << res[0] << ", " << res[1] << ", " + std::cout << "FLUID: " << mCurrentID << " with res(" << res[0] << ", " << res[1] << ", " << res[2] << ")" << std::endl; mmd->domain->fluid = this; mUsingLiquid = (mmd->domain->type == FLUID_DOMAIN_TYPE_LIQUID); mUsingSmoke = (mmd->domain->type == FLUID_DOMAIN_TYPE_GAS); - mUsingHeat = (mmd->domain->active_fields & FLUID_DOMAIN_ACTIVE_HEAT) && mUsingSmoke; - mUsingFire = (mmd->domain->active_fields & FLUID_DOMAIN_ACTIVE_FIRE) && mUsingSmoke; - mUsingColors = (mmd->domain->active_fields & FLUID_DOMAIN_ACTIVE_COLORS) && mUsingSmoke; mUsingNoise = (mmd->domain->flags & FLUID_DOMAIN_USE_NOISE) && mUsingSmoke; mUsingFractions = (mmd->domain->flags & FLUID_DOMAIN_USE_FRACTIONS) && mUsingLiquid; + mUsingMesh = (mmd->domain->flags & FLUID_DOMAIN_USE_MESH) && mUsingLiquid; + mUsingMVel = (mmd->domain->flags & FLUID_DOMAIN_USE_SPEED_VECTORS) && mUsingLiquid; + mUsingGuiding = (mmd->domain->flags & FLUID_DOMAIN_USE_GUIDE); mUsingDrops = (mmd->domain->particle_type & FLUID_DOMAIN_PARTICLE_SPRAY) && mUsingLiquid; mUsingBubbles = (mmd->domain->particle_type & FLUID_DOMAIN_PARTICLE_BUBBLE) && mUsingLiquid; mUsingFloats = (mmd->domain->particle_type & FLUID_DOMAIN_PARTICLE_FOAM) && mUsingLiquid; mUsingTracers = (mmd->domain->particle_type & FLUID_DOMAIN_PARTICLE_TRACER) && mUsingLiquid; - mUsingMesh = (mmd->domain->flags & FLUID_DOMAIN_USE_MESH) && mUsingLiquid; - mUsingMVel = (mmd->domain->flags & FLUID_DOMAIN_USE_SPEED_VECTORS) && mUsingLiquid; + + mUsingHeat = (mmd->domain->active_fields & FLUID_DOMAIN_ACTIVE_HEAT) && mUsingSmoke; + mUsingFire = (mmd->domain->active_fields & FLUID_DOMAIN_ACTIVE_FIRE) && mUsingSmoke; + mUsingColors = (mmd->domain->active_fields & FLUID_DOMAIN_ACTIVE_COLORS) && mUsingSmoke; mUsingObstacle = (mmd->domain->active_fields & FLUID_DOMAIN_ACTIVE_OBSTACLE); mUsingInvel = (mmd->domain->active_fields & FLUID_DOMAIN_ACTIVE_INVEL); mUsingOutflow = (mmd->domain->active_fields & FLUID_DOMAIN_ACTIVE_OUTFLOW); - mUsingGuiding = (mmd->domain->flags & FLUID_DOMAIN_USE_GUIDE); // Simulation constants mTempAmb = 0; // TODO: Maybe use this later for buoyancy calculation @@ -566,7 +567,7 @@ bool MANTA::runPythonString(std::vector commands) void MANTA::initializeMantaflow() { if (with_debug) - std::cout << "Fluid: Initializing Mantaflow framework." << std::endl; + std::cout << "Fluid: Initializing Mantaflow framework" << std::endl; std::string filename = "manta_scene_" + std::to_string(mCurrentID) + ".py"; std::vector fill = std::vector(); @@ -581,7 +582,7 @@ void MANTA::initializeMantaflow() void MANTA::terminateMantaflow() { if (with_debug) - std::cout << "Fluid: Releasing Mantaflow framework." << std::endl; + std::cout << "Fluid: Releasing Mantaflow framework" << std::endl; PyGILState_STATE gilstate = PyGILState_Ensure(); Pb::finalize(); // Namespace from Mantaflow (registry) @@ -1078,8 +1079,7 @@ bool MANTA::updateFlipStructures(FluidModifierData *mmd, int framenr) assert(result == expected); } - mFlipFromFile = true; - return (result == expected); + return mFlipFromFile = (result == expected); } bool MANTA::updateMeshStructures(FluidModifierData *mmd, int framenr) @@ -1126,8 +1126,7 @@ bool MANTA::updateMeshStructures(FluidModifierData *mmd, int framenr) } } - mMeshFromFile = true; - return (result == expected); + return mMeshFromFile = (result == expected); } bool MANTA::updateParticleStructures(FluidModifierData *mmd, int framenr) @@ -1177,8 +1176,7 @@ bool MANTA::updateParticleStructures(FluidModifierData *mmd, int framenr) assert(result == expected); } - mParticlesFromFile = true; - return (result == expected); + return mParticlesFromFile = (result == expected); } bool MANTA::updateSmokeStructures(FluidModifierData *mmd, int framenr) @@ -1268,8 +1266,7 @@ bool MANTA::updateSmokeStructures(FluidModifierData *mmd, int framenr) } } - mSmokeFromFile = true; - return (result == expected); + return mSmokeFromFile = (result == expected); } bool MANTA::updateNoiseStructures(FluidModifierData *mmd, int framenr) @@ -1351,8 +1348,7 @@ bool MANTA::updateNoiseStructures(FluidModifierData *mmd, int framenr) } } - mNoiseFromFile = true; - return (result == expected); + return mNoiseFromFile = (result == expected); } /* Dirty hack: Needed to format paths from python code that is run via PyRun_SimpleString */ @@ -2748,10 +2744,10 @@ bool MANTA::updateParticlesFromUni(std::string filename, bool isSecondarySys, bo return false; } if (!ibuffer[0]) { // Any particles present? - std::cerr << "Fluid Error -- updateParticlesFromUni(): No particles present in file: " - << filename << std::endl; + if (with_debug) + std::cout << "Fluid: No particles present in file: " << filename << std::endl; gzclose(gzf); - return false; + return true; // return true since having no particles in a cache file is valid } numParticles = ibuffer[0]; -- cgit v1.2.3 From 650f9cfe938f5e65e45a90223ce03c6b232a6217 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebasti=C3=A1n=20Barschkis?= Date: Wed, 15 Apr 2020 14:16:13 +0200 Subject: Fluid: Improved cache 'Replay' option When using the 'Replay' cache mode the cache needs to be invalidated whenever simulation variables have been changed. The invalidation will always only affect the according subcaches, e.g. when changing a mesh paramter only the mesh cache will be invalidated, the base cache will remain intact. Before this change Blender always invalidated the entire cache. --- source/blender/blenkernel/BKE_fluid.h | 1 + source/blender/blenkernel/intern/fluid.c | 237 ++++++++++++-------- source/blender/makesdna/DNA_fluid_types.h | 4 + source/blender/makesrna/intern/rna_fluid.c | 341 +++++++++++++++++------------ 4 files changed, 351 insertions(+), 232 deletions(-) diff --git a/source/blender/blenkernel/BKE_fluid.h b/source/blender/blenkernel/BKE_fluid.h index e8b4c819c62..e06a1a9fb92 100644 --- a/source/blender/blenkernel/BKE_fluid.h +++ b/source/blender/blenkernel/BKE_fluid.h @@ -61,6 +61,7 @@ void BKE_fluid_reallocate_copy_fluid(struct FluidDomainSettings *mds, int o_max[3], int o_shift[3], int n_shift[3]); +void BKE_fluid_cache_free_all(struct FluidDomainSettings *mds, struct Object *ob); void BKE_fluid_cache_free(struct FluidDomainSettings *mds, struct Object *ob, int cache_map); void BKE_fluid_cache_new_name_for_current_session(int maxlen, char *r_name); diff --git a/source/blender/blenkernel/intern/fluid.c b/source/blender/blenkernel/intern/fluid.c index 8697cd03827..578a6a13bb7 100644 --- a/source/blender/blenkernel/intern/fluid.c +++ b/source/blender/blenkernel/intern/fluid.c @@ -334,6 +334,14 @@ void BKE_fluid_reallocate_copy_fluid(FluidDomainSettings *mds, manta_free(fluid_old); } +void BKE_fluid_cache_free_all(FluidDomainSettings *mds, Object *ob) +{ + int cache_map = (FLUID_DOMAIN_OUTDATED_DATA | FLUID_DOMAIN_OUTDATED_NOISE | + FLUID_DOMAIN_OUTDATED_MESH | FLUID_DOMAIN_OUTDATED_PARTICLES | + FLUID_DOMAIN_OUTDATED_GUIDE); + BKE_fluid_cache_free(mds, ob, cache_map); +} + void BKE_fluid_cache_free(FluidDomainSettings *mds, Object *ob, int cache_map) { char temp_dir[FILE_MAX]; @@ -1130,7 +1138,18 @@ static void obstacles_from_mesh(Object *coll_ob, } } +static void ensure_obstaclefields(FluidDomainSettings *mds) +{ + if (mds->active_fields & FLUID_DOMAIN_ACTIVE_OBSTACLE) { + manta_ensure_obstacle(mds->fluid, mds->mmd); + } + if (mds->active_fields & FLUID_DOMAIN_ACTIVE_GUIDE) { + manta_ensure_guiding(mds->fluid, mds->mmd); + } +} + static void update_obstacleflags(FluidDomainSettings *mds, + Object *domain, Object **coll_ob_array, int coll_ob_array_len) { @@ -1157,6 +1176,11 @@ static void update_obstacleflags(FluidDomainSettings *mds, if (!mes) { break; } + if (mes->flags & FLUID_EFFECTOR_NEEDS_UPDATE) { + mes->flags &= ~FLUID_EFFECTOR_NEEDS_UPDATE; + BKE_fluid_cache_free_all(mds, domain); + mds->cache_flag |= FLUID_DOMAIN_OUTDATED_DATA; + } if (mes->type == FLUID_EFFECTOR_TYPE_COLLISION) { active_fields |= FLUID_DOMAIN_ACTIVE_OBSTACLE; } @@ -1165,13 +1189,6 @@ static void update_obstacleflags(FluidDomainSettings *mds, } } } - /* Finally, initialize new data fields if any */ - if (active_fields & FLUID_DOMAIN_ACTIVE_OBSTACLE) { - manta_ensure_obstacle(mds->fluid, mds->mmd); - } - if (active_fields & FLUID_DOMAIN_ACTIVE_GUIDE) { - manta_ensure_guiding(mds->fluid, mds->mmd); - } mds->active_fields = active_fields; } @@ -1193,7 +1210,8 @@ static void update_obstacles(Depsgraph *depsgraph, depsgraph, ob, mds->effector_group, &numeffecobjs, eModifierType_Fluid); /* Update all effector related flags and ensure that corresponding grids get initialized. */ - update_obstacleflags(mds, effecobjs, numeffecobjs); + update_obstacleflags(mds, ob, effecobjs, numeffecobjs); + ensure_obstaclefields(mds); /* Initialize effector maps for each flow. */ bb_maps = MEM_callocN(sizeof(struct FluidObjectBB) * numeffecobjs, "fluid_effector_bb_maps"); @@ -2573,21 +2591,49 @@ BLI_INLINE void apply_inflow_fields(FluidFlowSettings *mfs, } } -static void update_flowsflags(FluidDomainSettings *mds, Object **flowobjs, int numflowobj) +static void ensure_flowsfields(FluidDomainSettings *mds) +{ + if (mds->active_fields & FLUID_DOMAIN_ACTIVE_INVEL) { + manta_ensure_invelocity(mds->fluid, mds->mmd); + } + if (mds->active_fields & FLUID_DOMAIN_ACTIVE_OUTFLOW) { + manta_ensure_outflow(mds->fluid, mds->mmd); + } + if (mds->active_fields & FLUID_DOMAIN_ACTIVE_HEAT) { + manta_smoke_ensure_heat(mds->fluid, mds->mmd); + } + if (mds->active_fields & FLUID_DOMAIN_ACTIVE_FIRE) { + manta_smoke_ensure_fire(mds->fluid, mds->mmd); + } + if (mds->active_fields & FLUID_DOMAIN_ACTIVE_COLORS) { + /* initialize all smoke with "active_color" */ + manta_smoke_ensure_colors(mds->fluid, mds->mmd); + } + if (mds->type == FLUID_DOMAIN_TYPE_LIQUID && + (mds->particle_type & FLUID_DOMAIN_PARTICLE_SPRAY || + mds->particle_type & FLUID_DOMAIN_PARTICLE_FOAM || + mds->particle_type & FLUID_DOMAIN_PARTICLE_TRACER)) { + manta_liquid_ensure_sndparts(mds->fluid, mds->mmd); + } +} + +static void update_flowsflags(FluidDomainSettings *mds, + Object *domain, + Object **flowobjs, + int numflowobj) { int active_fields = mds->active_fields; uint flow_index; /* First, remove all flags that we want to update. */ int prev_flags = (FLUID_DOMAIN_ACTIVE_INVEL | FLUID_DOMAIN_ACTIVE_OUTFLOW | - FLUID_DOMAIN_ACTIVE_HEAT | FLUID_DOMAIN_ACTIVE_FIRE | - FLUID_DOMAIN_ACTIVE_COLOR_SET | FLUID_DOMAIN_ACTIVE_COLORS); + FLUID_DOMAIN_ACTIVE_HEAT | FLUID_DOMAIN_ACTIVE_FIRE); active_fields &= ~prev_flags; /* Monitor active fields based on flow settings */ for (flow_index = 0; flow_index < numflowobj; flow_index++) { - Object *coll_ob = flowobjs[flow_index]; - FluidModifierData *mmd2 = (FluidModifierData *)modifiers_findByType(coll_ob, + Object *flow_ob = flowobjs[flow_index]; + FluidModifierData *mmd2 = (FluidModifierData *)modifiers_findByType(flow_ob, eModifierType_Fluid); /* Sanity check. */ @@ -2600,6 +2646,11 @@ static void update_flowsflags(FluidDomainSettings *mds, Object **flowobjs, int n if (!mfs) { break; } + if (mfs->flags & FLUID_FLOW_NEEDS_UPDATE) { + mfs->flags &= ~FLUID_FLOW_NEEDS_UPDATE; + BKE_fluid_cache_free_all(mds, domain); + mds->cache_flag |= FLUID_DOMAIN_OUTDATED_DATA; + } if (mfs->flags & FLUID_FLOW_INITVELOCITY) { active_fields |= FLUID_DOMAIN_ACTIVE_INVEL; } @@ -2648,29 +2699,6 @@ static void update_flowsflags(FluidDomainSettings *mds, Object **flowobjs, int n active_fields |= FLUID_DOMAIN_ACTIVE_COLORS; } } - /* Finally, initialize new data fields if any */ - if (active_fields & FLUID_DOMAIN_ACTIVE_INVEL) { - manta_ensure_invelocity(mds->fluid, mds->mmd); - } - if (active_fields & FLUID_DOMAIN_ACTIVE_OUTFLOW) { - manta_ensure_outflow(mds->fluid, mds->mmd); - } - if (active_fields & FLUID_DOMAIN_ACTIVE_HEAT) { - manta_smoke_ensure_heat(mds->fluid, mds->mmd); - } - if (active_fields & FLUID_DOMAIN_ACTIVE_FIRE) { - manta_smoke_ensure_fire(mds->fluid, mds->mmd); - } - if (active_fields & FLUID_DOMAIN_ACTIVE_COLORS) { - /* initialize all smoke with "active_color" */ - manta_smoke_ensure_colors(mds->fluid, mds->mmd); - } - if (mds->type == FLUID_DOMAIN_TYPE_LIQUID && - (mds->particle_type & FLUID_DOMAIN_PARTICLE_SPRAY || - mds->particle_type & FLUID_DOMAIN_PARTICLE_FOAM || - mds->particle_type & FLUID_DOMAIN_PARTICLE_TRACER)) { - manta_liquid_ensure_sndparts(mds->fluid, mds->mmd); - } mds->active_fields = active_fields; } @@ -2692,7 +2720,8 @@ static void update_flowsfluids(struct Depsgraph *depsgraph, depsgraph, ob, mds->fluid_group, &numflowobj, eModifierType_Fluid); /* Update all flow related flags and ensure that corresponding grids get initialized. */ - update_flowsflags(mds, flowobjs, numflowobj); + update_flowsflags(mds, ob, flowobjs, numflowobj); + ensure_flowsfields(mds); /* Initialize emission maps for each flow. */ bb_maps = MEM_callocN(sizeof(struct FluidObjectBB) * numflowobj, "fluid_flow_bb_maps"); @@ -3566,6 +3595,7 @@ static int manta_step( break; } + /* Only bake if the domain is bigger than one cell (important for adaptive domain). */ if (mds->total_cells > 1) { update_effectors(depsgraph, scene, ob, mds, dt); manta_bake_data(mds->fluid, mmd, frame); @@ -3585,7 +3615,7 @@ static int manta_step( } } - if (mds->type == FLUID_DOMAIN_TYPE_GAS) { + if (mds->type == FLUID_DOMAIN_TYPE_GAS && result) { manta_smoke_calc_transparency(mds, DEG_get_evaluated_view_layer(depsgraph)); } BLI_mutex_unlock(&object_update_lock); @@ -3684,8 +3714,35 @@ static void BKE_fluid_modifier_processDomain(FluidModifierData *mmd, return; } + bool bake_outdated = mds->cache_flag & + (FLUID_DOMAIN_OUTDATED_DATA | FLUID_DOMAIN_OUTDATED_NOISE | + FLUID_DOMAIN_OUTDATED_MESH | FLUID_DOMAIN_OUTDATED_PARTICLES | + FLUID_DOMAIN_OUTDATED_GUIDE); + + /* Exit early if cache is outdated. */ + if (bake_outdated) { + return; + } + + /* Ensure cache directory is not relative. */ + const char *relbase = modifier_path_relbase_from_global(ob); + BLI_path_abs(mds->cache_directory, relbase); + + objs = BKE_collision_objects_create( + depsgraph, ob, mds->fluid_group, &numobj, eModifierType_Fluid); + update_flowsflags(mds, ob, objs, numobj); + if (objs) { + MEM_freeN(objs); + } + objs = BKE_collision_objects_create( + depsgraph, ob, mds->effector_group, &numobj, eModifierType_Fluid); + update_obstacleflags(mds, ob, objs, numobj); + if (objs) { + MEM_freeN(objs); + } + /* Reset fluid if no fluid present. */ - if (!mds->fluid) { + if (!mds->fluid || mds->cache_flag & FLUID_DOMAIN_OUTDATED_DATA) { BKE_fluid_modifier_reset_ex(mmd, false); /* Fluid domain init must not fail in order to continue modifier evaluation. */ @@ -3712,23 +3769,10 @@ static void BKE_fluid_modifier_processDomain(FluidModifierData *mmd, /* Get distance between cache start and current frame for total time. */ mds->time_total = abs(scene_framenr - mds->cache_frame_start) * mds->frame_length; - objs = BKE_collision_objects_create( - depsgraph, ob, mds->fluid_group, &numobj, eModifierType_Fluid); - update_flowsflags(mds, objs, numobj); - if (objs) { - MEM_freeN(objs); - } - - objs = BKE_collision_objects_create( - depsgraph, ob, mds->effector_group, &numobj, eModifierType_Fluid); - update_obstacleflags(mds, objs, numobj); - if (objs) { - MEM_freeN(objs); - } - - /* Ensure cache directory is not relative. */ - const char *relbase = modifier_path_relbase_from_global(ob); - BLI_path_abs(mds->cache_directory, relbase); + int next_frame = scene_framenr + 1; + int prev_frame = scene_framenr - 1; + /* Ensure positivity of previous frame. */ + CLAMP(prev_frame, mds->cache_frame_start, prev_frame); int data_frame = scene_framenr, noise_frame = scene_framenr; int mesh_frame = scene_framenr, particles_frame = scene_framenr, guide_frame = scene_framenr; @@ -3751,17 +3795,18 @@ static void BKE_fluid_modifier_processDomain(FluidModifierData *mmd, with_particles = drops || bubble || floater; bool has_data, has_noise, has_mesh, has_particles, has_guide; - has_data = has_noise = has_mesh = has_particles = has_guide = false; + has_data = manta_has_data(mds->fluid, mmd, scene_framenr); + has_noise = manta_has_noise(mds->fluid, mmd, scene_framenr); + has_mesh = manta_has_mesh(mds->fluid, mmd, scene_framenr); + has_particles = manta_has_particles(mds->fluid, mmd, scene_framenr); + has_guide = manta_has_guiding(mds->fluid, mmd, scene_framenr, guide_parent); - bool baking_data, baking_noise, baking_mesh, baking_particles, baking_guide, bake_outdated; + bool baking_data, baking_noise, baking_mesh, baking_particles, baking_guide; baking_data = mds->cache_flag & FLUID_DOMAIN_BAKING_DATA; baking_noise = mds->cache_flag & FLUID_DOMAIN_BAKING_NOISE; baking_mesh = mds->cache_flag & FLUID_DOMAIN_BAKING_MESH; baking_particles = mds->cache_flag & FLUID_DOMAIN_BAKING_PARTICLES; baking_guide = mds->cache_flag & FLUID_DOMAIN_BAKING_GUIDE; - bake_outdated = mds->cache_flag & (FLUID_DOMAIN_OUTDATED_DATA | FLUID_DOMAIN_OUTDATED_NOISE | - FLUID_DOMAIN_OUTDATED_MESH | FLUID_DOMAIN_OUTDATED_PARTICLES | - FLUID_DOMAIN_OUTDATED_GUIDE); bool resume_data, resume_noise, resume_mesh, resume_particles, resume_guide; resume_data = (!is_startframe) && (mds->cache_frame_pause_data == scene_framenr); @@ -3775,35 +3820,27 @@ static void BKE_fluid_modifier_processDomain(FluidModifierData *mmd, bake_cache = baking_data || baking_noise || baking_mesh || baking_particles || baking_guide; bool next_data, next_noise, next_mesh, next_particles, next_guide; - next_data = manta_has_data(mds->fluid, mmd, scene_framenr + 1); - next_noise = manta_has_noise(mds->fluid, mmd, scene_framenr + 1); - next_mesh = manta_has_mesh(mds->fluid, mmd, scene_framenr + 1); - next_particles = manta_has_particles(mds->fluid, mmd, scene_framenr + 1); - next_guide = manta_has_guiding(mds->fluid, mmd, scene_framenr + 1, guide_parent); + next_data = manta_has_data(mds->fluid, mmd, next_frame); + next_noise = manta_has_noise(mds->fluid, mmd, next_frame); + next_mesh = manta_has_mesh(mds->fluid, mmd, next_frame); + next_particles = manta_has_particles(mds->fluid, mmd, next_frame); + next_guide = manta_has_guiding(mds->fluid, mmd, next_frame, guide_parent); bool prev_data, prev_noise, prev_mesh, prev_particles, prev_guide; - prev_data = manta_has_data(mds->fluid, mmd, scene_framenr - 1); - prev_noise = manta_has_noise(mds->fluid, mmd, scene_framenr - 1); - prev_mesh = manta_has_mesh(mds->fluid, mmd, scene_framenr - 1); - prev_particles = manta_has_particles(mds->fluid, mmd, scene_framenr - 1); - prev_guide = manta_has_guiding(mds->fluid, mmd, scene_framenr - 1, guide_parent); - - /* Unused for now, but needed for proper caching. */ - UNUSED_VARS(prev_guide); - UNUSED_VARS(next_noise); - UNUSED_VARS(next_mesh); - UNUSED_VARS(next_particles); - UNUSED_VARS(next_guide); + prev_data = manta_has_data(mds->fluid, mmd, prev_frame); + prev_noise = manta_has_noise(mds->fluid, mmd, prev_frame); + prev_mesh = manta_has_mesh(mds->fluid, mmd, prev_frame); + prev_particles = manta_has_particles(mds->fluid, mmd, prev_frame); + prev_guide = manta_has_guiding(mds->fluid, mmd, prev_frame, guide_parent); + + /* Unused for now. */ + UNUSED_VARS(prev_guide, next_mesh, next_guide); bool with_gdomain; with_gdomain = (mds->guide_source == FLUID_DOMAIN_GUIDE_SRC_DOMAIN); int o_res[3], o_min[3], o_max[3], o_shift[3]; int mode = mds->cache_type; - int prev_frame = scene_framenr - 1; - - /* Ensure positivity of previous frame. */ - CLAMP(prev_frame, 1, prev_frame); /* Cache mode specific settings. */ switch (mode) { @@ -3851,21 +3888,23 @@ static void BKE_fluid_modifier_processDomain(FluidModifierData *mmd, break; case FLUID_DOMAIN_CACHE_REPLAY: default: + baking_data = !has_data && (is_startframe || prev_data); + if (with_smoke && with_noise) { + baking_noise = !has_noise && (is_startframe || prev_noise); + } + if (with_liquid && with_mesh) { + baking_mesh = !has_mesh && (is_startframe || prev_mesh); + } + if (with_liquid && with_particles) { + baking_particles = !has_particles && (is_startframe || prev_particles); + } + /* Always trying to read the cache in replay mode. */ read_cache = true; bake_cache = false; break; } - /* Cache outdated? If so reset, don't read, and then just rebake. - * Note: Only do this in replay mode! */ - bool mode_replay = (mode == FLUID_DOMAIN_CACHE_REPLAY); - if (bake_outdated && mode_replay) { - read_cache = false; - bake_cache = true; - BKE_fluid_cache_free(mds, ob, mds->cache_flag); - } - /* Try to read from cache and keep track of read success. */ if (read_cache) { @@ -3877,7 +3916,7 @@ static void BKE_fluid_modifier_processDomain(FluidModifierData *mmd, /* Read particles cache. */ if (with_liquid && with_particles) { - if (!baking_data && !baking_particles && !mode_replay) { + if (!baking_data && !baking_particles && next_particles) { /* Update particle data from file is faster than via Python (manta_read_particles()). */ has_particles = manta_update_particle_structures(mds->fluid, mmd, particles_frame); } @@ -3901,8 +3940,8 @@ static void BKE_fluid_modifier_processDomain(FluidModifierData *mmd, manta_needs_realloc(mds->fluid, mmd)) { BKE_fluid_reallocate_fluid(mds, mds->res, 1); } - if (!baking_data && !baking_noise && !mode_replay) { - has_data = manta_update_noise_structures(mds->fluid, mmd, noise_frame); + if (!baking_data && !baking_noise && next_noise) { + has_noise = manta_update_noise_structures(mds->fluid, mmd, noise_frame); } else { has_noise = manta_read_noise(mds->fluid, mmd, noise_frame); @@ -3921,8 +3960,9 @@ static void BKE_fluid_modifier_processDomain(FluidModifierData *mmd, mds, o_res, mds->res, o_min, mds->res_min, o_max, o_shift, mds->shift); } } - if (!baking_data && !baking_noise && !mode_replay) { - /* TODO (sebbas): Confirm if this read call is really needed or not. */ + if (!baking_data && !baking_noise && next_data && next_noise) { + /* TODO (sebbas): Confirm if this read call is really needed or not. + * Currently only important to load the shadow grid. */ has_data = manta_update_smoke_structures(mds->fluid, mmd, data_frame); } else { @@ -3946,7 +3986,7 @@ static void BKE_fluid_modifier_processDomain(FluidModifierData *mmd, } } if (with_liquid) { - if (!baking_data && !baking_particles && !baking_mesh && !mode_replay) { + if (!baking_data && !baking_particles && !baking_mesh && next_data) { has_data = manta_update_liquid_structures(mds->fluid, mmd, data_frame); } else { @@ -3960,6 +4000,9 @@ static void BKE_fluid_modifier_processDomain(FluidModifierData *mmd, switch (mode) { case FLUID_DOMAIN_CACHE_FINAL: case FLUID_DOMAIN_CACHE_MODULAR: + if (!baking_data && !baking_noise && !baking_mesh && !baking_particles && !baking_guide) { + bake_cache = false; + } break; case FLUID_DOMAIN_CACHE_REPLAY: default: diff --git a/source/blender/makesdna/DNA_fluid_types.h b/source/blender/makesdna/DNA_fluid_types.h index bb85d8304ec..166b3c22932 100644 --- a/source/blender/makesdna/DNA_fluid_types.h +++ b/source/blender/makesdna/DNA_fluid_types.h @@ -541,6 +541,8 @@ enum { FLUID_FLOW_USE_INFLOW = (1 << 5), /* Control how to initialize flow objects. */ FLUID_FLOW_USE_PLANE_INIT = (1 << 6), + /* Notify domain objects about state change (invalidate cache). */ + FLUID_FLOW_NEEDS_UPDATE = (1 << 7), }; typedef struct FluidFlowSettings { @@ -614,6 +616,8 @@ enum { FLUID_EFFECTOR_USE_EFFEC = (1 << 1), /* Control how to initialize flow objects. */ FLUID_EFFECTOR_USE_PLANE_INIT = (1 << 2), + /* Notify domain objects about state change (invalidate cache). */ + FLUID_EFFECTOR_NEEDS_UPDATE = (1 << 3), }; /* Collision objects (filled with smoke). */ diff --git a/source/blender/makesrna/intern/rna_fluid.c b/source/blender/makesrna/intern/rna_fluid.c index e087056e850..8992e7d38bd 100644 --- a/source/blender/makesrna/intern/rna_fluid.c +++ b/source/blender/makesrna/intern/rna_fluid.c @@ -73,29 +73,102 @@ static void rna_Fluid_dependency_update(Main *bmain, Scene *scene, PointerRNA *p DEG_relations_tag_update(bmain); } -static void rna_Fluid_resetCache(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr) +static void rna_Fluid_datacache_reset(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr) { +# ifdef WITH_FLUID FluidDomainSettings *settings = (FluidDomainSettings *)ptr->data; if (settings->mmd && settings->mmd->domain) { - settings->mmd->domain->cache_flag |= (FLUID_DOMAIN_OUTDATED_DATA | - FLUID_DOMAIN_OUTDATED_NOISE | - FLUID_DOMAIN_OUTDATED_MESH | - FLUID_DOMAIN_OUTDATED_PARTICLES); + Object *ob = (Object *)ptr->owner_id; + int cache_map = (FLUID_DOMAIN_OUTDATED_DATA | FLUID_DOMAIN_OUTDATED_NOISE | + FLUID_DOMAIN_OUTDATED_MESH | FLUID_DOMAIN_OUTDATED_PARTICLES); + BKE_fluid_cache_free(settings, ob, cache_map); } +# endif DEG_id_tag_update(ptr->owner_id, ID_RECALC_GEOMETRY); } -static void rna_Fluid_reset(Main *bmain, Scene *scene, PointerRNA *ptr) +static void rna_Fluid_noisecache_reset(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr) +{ +# ifdef WITH_FLUID + FluidDomainSettings *settings = (FluidDomainSettings *)ptr->data; + if (settings->mmd && settings->mmd->domain) { + Object *ob = (Object *)ptr->owner_id; + int cache_map = FLUID_DOMAIN_OUTDATED_NOISE; + BKE_fluid_cache_free(settings, ob, cache_map); + } +# endif + DEG_id_tag_update(ptr->owner_id, ID_RECALC_GEOMETRY); +} +static void rna_Fluid_meshcache_reset(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr) { - # ifdef WITH_FLUID - { - FluidDomainSettings *settings = (FluidDomainSettings *)ptr->data; - BKE_fluid_modifier_reset(settings->mmd); + FluidDomainSettings *settings = (FluidDomainSettings *)ptr->data; + if (settings->mmd && settings->mmd->domain) { + Object *ob = (Object *)ptr->owner_id; + int cache_map = FLUID_DOMAIN_OUTDATED_MESH; + BKE_fluid_cache_free(settings, ob, cache_map); } # endif + DEG_id_tag_update(ptr->owner_id, ID_RECALC_GEOMETRY); +} +static void rna_Fluid_particlescache_reset(Main *UNUSED(bmain), + Scene *UNUSED(scene), + PointerRNA *ptr) +{ +# ifdef WITH_FLUID + FluidDomainSettings *settings = (FluidDomainSettings *)ptr->data; + if (settings->mmd && settings->mmd->domain) { + Object *ob = (Object *)ptr->owner_id; + int cache_map = FLUID_DOMAIN_OUTDATED_PARTICLES; + BKE_fluid_cache_free(settings, ob, cache_map); + } +# endif + DEG_id_tag_update(ptr->owner_id, ID_RECALC_GEOMETRY); +} +static void rna_Fluid_guidingcache_reset(Main *UNUSED(bmain), + Scene *UNUSED(scene), + PointerRNA *ptr) +{ +# ifdef WITH_FLUID + FluidDomainSettings *settings = (FluidDomainSettings *)ptr->data; + if (settings->mmd && settings->mmd->domain) { + Object *ob = (Object *)ptr->owner_id; + int cache_map = (FLUID_DOMAIN_OUTDATED_DATA | FLUID_DOMAIN_OUTDATED_NOISE | + FLUID_DOMAIN_OUTDATED_MESH | FLUID_DOMAIN_OUTDATED_PARTICLES | + FLUID_DOMAIN_OUTDATED_GUIDE); + BKE_fluid_cache_free(settings, ob, cache_map); + } +# endif + DEG_id_tag_update(ptr->owner_id, ID_RECALC_GEOMETRY); +} - rna_Fluid_resetCache(bmain, scene, ptr); +static void rna_Fluid_effector_reset(Main *bmain, Scene *scene, PointerRNA *ptr) +{ +# ifdef WITH_FLUID + FluidEffectorSettings *settings = (FluidEffectorSettings *)ptr->data; + settings->flags |= FLUID_EFFECTOR_NEEDS_UPDATE; +# endif + + rna_Fluid_update(bmain, scene, ptr); +} + +static void rna_Fluid_flow_reset(Main *bmain, Scene *scene, PointerRNA *ptr) +{ +# ifdef WITH_FLUID + FluidFlowSettings *settings = (FluidFlowSettings *)ptr->data; + settings->flags |= FLUID_FLOW_NEEDS_UPDATE; +# endif + + rna_Fluid_update(bmain, scene, ptr); +} +static void rna_Fluid_domain_reset(Main *bmain, Scene *scene, PointerRNA *ptr) +{ +# ifdef WITH_FLUID + FluidDomainSettings *settings = (FluidDomainSettings *)ptr->data; + BKE_fluid_modifier_reset(settings->mmd); +# endif + + rna_Fluid_datacache_reset(bmain, scene, ptr); rna_Fluid_update(bmain, scene, ptr); } @@ -107,10 +180,6 @@ static void rna_Fluid_reset_dependency(Main *bmain, Scene *scene, PointerRNA *pt BKE_fluid_modifier_reset(settings->mmd); # endif - if (settings->mmd && settings->mmd->domain) { - settings->mmd->domain->point_cache[0]->flag |= PTCACHE_OUTDATED; - } - rna_Fluid_dependency_update(bmain, scene, ptr); } @@ -161,7 +230,7 @@ static void rna_Fluid_flip_parts_update(Main *bmain, Scene *scene, PointerRNA *p /* Only create a particle system in liquid domain mode. */ if (mmd->domain->type != FLUID_DOMAIN_TYPE_LIQUID) { - rna_Fluid_reset(bmain, scene, ptr); + rna_Fluid_domain_reset(bmain, scene, ptr); return; } @@ -1260,14 +1329,14 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) RNA_def_property_int_sdna(prop, NULL, "adapt_res"); RNA_def_property_range(prop, 0, 512); RNA_def_property_ui_text(prop, "Additional", "Maximum number of additional cells"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_datacache_reset"); prop = RNA_def_property(srna, "adapt_margin", PROP_INT, PROP_NONE); RNA_def_property_int_sdna(prop, NULL, "adapt_margin"); RNA_def_property_range(prop, 2, 24); RNA_def_property_ui_text( prop, "Margin", "Margin added around fluid to minimize boundary interference"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_datacache_reset"); prop = RNA_def_property(srna, "adapt_threshold", PROP_FLOAT, PROP_NONE); RNA_def_property_range(prop, 0.0, 1.0); @@ -1276,14 +1345,14 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) prop, "Threshold", "Minimum amount of fluid a cell can contain before it is considered empty"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_datacache_reset"); prop = RNA_def_property(srna, "use_adaptive_domain", PROP_BOOLEAN, PROP_NONE); RNA_def_property_boolean_sdna(prop, NULL, "flags", FLUID_DOMAIN_USE_ADAPTIVE_DOMAIN); RNA_def_property_ui_text( prop, "Adaptive Domain", "Adapt simulation resolution and size to fluid"); RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_domain_reset"); /* fluid domain options */ @@ -1297,44 +1366,44 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) "Resolution used for the fluid domain. Value corresponds to the longest domain side " "(resolution for other domain sides is calculated automatically)"); RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_domain_reset"); prop = RNA_def_property(srna, "use_collision_border_front", PROP_BOOLEAN, PROP_NONE); RNA_def_property_boolean_sdna(prop, NULL, "border_collisions", FLUID_DOMAIN_BORDER_FRONT); RNA_def_property_ui_text(prop, "Front", "Enable collisions with front domain border"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_datacache_reset"); prop = RNA_def_property(srna, "use_collision_border_back", PROP_BOOLEAN, PROP_NONE); RNA_def_property_boolean_sdna(prop, NULL, "border_collisions", FLUID_DOMAIN_BORDER_BACK); RNA_def_property_ui_text(prop, "Back", "Enable collisions with back domain border"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_datacache_reset"); prop = RNA_def_property(srna, "use_collision_border_right", PROP_BOOLEAN, PROP_NONE); RNA_def_property_boolean_sdna(prop, NULL, "border_collisions", FLUID_DOMAIN_BORDER_RIGHT); RNA_def_property_ui_text(prop, "Right", "Enable collisions with right domain border"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_datacache_reset"); prop = RNA_def_property(srna, "use_collision_border_left", PROP_BOOLEAN, PROP_NONE); RNA_def_property_boolean_sdna(prop, NULL, "border_collisions", FLUID_DOMAIN_BORDER_LEFT); RNA_def_property_ui_text(prop, "Left", "Enable collisions with left domain border"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_datacache_reset"); prop = RNA_def_property(srna, "use_collision_border_top", PROP_BOOLEAN, PROP_NONE); RNA_def_property_boolean_sdna(prop, NULL, "border_collisions", FLUID_DOMAIN_BORDER_TOP); RNA_def_property_ui_text(prop, "Top", "Enable collisions with top domain border"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_datacache_reset"); prop = RNA_def_property(srna, "use_collision_border_bottom", PROP_BOOLEAN, PROP_NONE); RNA_def_property_boolean_sdna(prop, NULL, "border_collisions", FLUID_DOMAIN_BORDER_BOTTOM); RNA_def_property_ui_text(prop, "Bottom", "Enable collisions with bottom domain border"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_datacache_reset"); prop = RNA_def_property(srna, "gravity", PROP_FLOAT, PROP_ACCELERATION); RNA_def_property_float_sdna(prop, NULL, "gravity"); 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"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_datacache_reset"); prop = RNA_def_property(srna, "domain_type", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "type"); @@ -1347,7 +1416,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) prop = RNA_def_property(srna, "delete_in_obstacle", PROP_BOOLEAN, PROP_NONE); RNA_def_property_boolean_sdna(prop, NULL, "flags", FLUID_DOMAIN_DELETE_IN_OBSTACLE); RNA_def_property_ui_text(prop, "Clear In Obstacle", "Delete fluid inside obstacles"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_datacache_reset"); /* smoke domain options */ @@ -1359,7 +1428,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) prop, "Buoyancy Density", "Buoyant force based on smoke density (higher value results in faster rising smoke)"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_datacache_reset"); prop = RNA_def_property(srna, "beta", PROP_FLOAT, PROP_NONE); RNA_def_property_float_sdna(prop, NULL, "beta"); @@ -1369,7 +1438,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) prop, "Buoyancy Heat", "Buoyant force based on smoke heat (higher value results in faster rising smoke)"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_datacache_reset"); prop = RNA_def_property(srna, "dissolve_speed", PROP_INT, PROP_NONE); RNA_def_property_int_sdna(prop, NULL, "diss_speed"); @@ -1379,23 +1448,23 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) prop, "Dissolve Speed", "Determine how quickly the smoke dissolves (lower value makes smoke disappear faster)"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_datacache_reset"); prop = RNA_def_property(srna, "vorticity", PROP_FLOAT, PROP_NONE); RNA_def_property_float_sdna(prop, NULL, "vorticity"); RNA_def_property_range(prop, 0.0, 4.0); RNA_def_property_ui_text(prop, "Vorticity", "Amount of turbulence and rotation in smoke"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_datacache_reset"); prop = RNA_def_property(srna, "highres_sampling", PROP_ENUM, PROP_NONE); RNA_def_property_enum_items(prop, smoke_highres_sampling_items); RNA_def_property_ui_text(prop, "Emitter", "Method for sampling the high resolution flow"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_datacache_reset"); prop = RNA_def_property(srna, "use_dissolve_smoke", PROP_BOOLEAN, PROP_NONE); RNA_def_property_boolean_sdna(prop, NULL, "flags", FLUID_DOMAIN_USE_DISSOLVE); RNA_def_property_ui_text(prop, "Dissolve Smoke", "Let smoke disappear over time"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_datacache_reset"); prop = RNA_def_property(srna, "use_dissolve_smoke_log", PROP_BOOLEAN, PROP_NONE); RNA_def_property_boolean_sdna(prop, NULL, "flags", FLUID_DOMAIN_USE_DISSOLVE_LOG); @@ -1403,7 +1472,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) prop, "Logarithmic Dissolve", "Dissolve smoke in a logarithmic fashion. Dissolves quickly at first, but lingers longer"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_datacache_reset"); /* flame options */ @@ -1412,19 +1481,19 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) RNA_def_property_ui_range(prop, 0.01, 2.0, 1.0, 5); RNA_def_property_ui_text( prop, "Speed", "Speed of the burning reaction (higher value results in smaller flames)"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_datacache_reset"); prop = RNA_def_property(srna, "flame_smoke", PROP_FLOAT, PROP_NONE); RNA_def_property_range(prop, 0.0, 8.0); RNA_def_property_ui_range(prop, 0.0, 4.0, 1.0, 5); RNA_def_property_ui_text(prop, "Smoke", "Amount of smoke created by burning fuel"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_datacache_reset"); prop = RNA_def_property(srna, "flame_vorticity", PROP_FLOAT, PROP_NONE); RNA_def_property_range(prop, 0.0, 2.0); RNA_def_property_ui_range(prop, 0.0, 1.0, 1.0, 5); RNA_def_property_ui_text(prop, "Vorticity", "Additional vorticity for the flames"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_datacache_reset"); prop = RNA_def_property(srna, "flame_ignition", PROP_FLOAT, PROP_NONE); RNA_def_property_range(prop, 0.5, 5.0); @@ -1433,7 +1502,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) prop, "Minimum", "Minimum temperature of the flames (higher value results in faster rising flames)"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_datacache_reset"); prop = RNA_def_property(srna, "flame_max_temp", PROP_FLOAT, PROP_NONE); RNA_def_property_range(prop, 1.0, 10.0); @@ -1442,12 +1511,12 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) prop, "Maximum", "Maximum temperature of the flames (higher value results in faster rising flames)"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_datacache_reset"); prop = RNA_def_property(srna, "flame_smoke_color", PROP_FLOAT, PROP_COLOR_GAMMA); RNA_def_property_array(prop, 3); RNA_def_property_ui_text(prop, "Smoke Color", "Color of smoke emitted from burning fuel"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_datacache_reset"); /* noise options */ @@ -1456,19 +1525,20 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) RNA_def_property_range(prop, 0.0, 10.0); RNA_def_property_ui_range(prop, 0.0, 10.0, 1, 2); RNA_def_property_ui_text(prop, "Strength", "Strength of noise"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_noisecache_reset"); prop = RNA_def_property(srna, "noise_pos_scale", PROP_FLOAT, PROP_NONE); RNA_def_property_float_sdna(prop, NULL, "noise_pos_scale"); RNA_def_property_range(prop, 0.0001, 10.0); RNA_def_property_ui_text( prop, "Scale", "Scale of noise (higher value results in larger vortices)"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_noisecache_reset"); prop = RNA_def_property(srna, "noise_time_anim", PROP_FLOAT, PROP_NONE); RNA_def_property_float_sdna(prop, NULL, "noise_time_anim"); RNA_def_property_range(prop, 0.0001, 10.0); RNA_def_property_ui_text(prop, "Time", "Animation time of noise"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_noisecache_reset"); prop = RNA_def_property(srna, "noise_scale", PROP_INT, PROP_NONE); RNA_def_property_int_sdna(prop, NULL, "noise_scale"); @@ -1479,7 +1549,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) "The noise simulation is scaled up by this factor (compared to the " "base resolution of the domain)"); RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_domain_reset"); prop = RNA_def_property(srna, "noise_type", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "noise_type"); @@ -1487,7 +1557,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) RNA_def_property_ui_text( prop, "Noise Method", "Noise method which is used during the high-res simulation"); RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_domain_reset"); prop = RNA_def_property(srna, "use_noise", PROP_BOOLEAN, PROP_NONE); RNA_def_property_boolean_sdna(prop, NULL, "flags", FLUID_DOMAIN_USE_NOISE); @@ -1501,7 +1571,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) RNA_def_property_enum_sdna(prop, NULL, "simulation_method"); RNA_def_property_enum_items(prop, simulation_methods); RNA_def_property_ui_text(prop, "Simulation Method", "Change the underlying simulation method"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_domain_reset"); prop = RNA_def_property(srna, "flip_ratio", PROP_FLOAT, PROP_NONE); RNA_def_property_range(prop, 0.0, 1.0); @@ -1510,18 +1580,18 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) "FLIP Ratio", "PIC/FLIP Ratio. A value of 1.0 will result in a completely FLIP based simulation. Use a " "lower value for simulations which should produce smaller splashes"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_datacache_reset"); prop = RNA_def_property(srna, "particle_randomness", PROP_FLOAT, PROP_NONE); RNA_def_property_range(prop, 0.0, 10.0); RNA_def_property_ui_text(prop, "Randomness", "Randomness factor for particle sampling"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_datacache_reset"); prop = RNA_def_property(srna, "particle_number", PROP_INT, PROP_NONE); RNA_def_property_range(prop, 1, 5); RNA_def_property_ui_text( prop, "Number", "Particle number factor (higher value results in more particles)"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_datacache_reset"); prop = RNA_def_property(srna, "particle_min", PROP_INT, PROP_NONE); RNA_def_property_int_sdna(prop, NULL, "particle_minimum"); @@ -1530,7 +1600,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) "Minimum", "Minimum number of particles per cell (ensures that each cell has at " "least this amount of particles)"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_datacache_reset"); prop = RNA_def_property(srna, "particle_max", PROP_INT, PROP_NONE); RNA_def_property_int_sdna(prop, NULL, "particle_maximum"); @@ -1539,7 +1609,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) "Maximum", "Maximum number of particles per cell (ensures that each cell has at " "most this amount of particles)"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_datacache_reset"); prop = RNA_def_property(srna, "particle_radius", PROP_FLOAT, PROP_NONE); RNA_def_property_range(prop, 0.0, 10.0); @@ -1547,7 +1617,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) "Radius", "Particle radius factor. Increase this value if the simulation appears " "to leak volume, decrease it if the simulation seems to gain volume"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_datacache_reset"); prop = RNA_def_property(srna, "particle_band_width", PROP_FLOAT, PROP_NONE); RNA_def_property_range(prop, 0.0, 1000.0); @@ -1555,7 +1625,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) prop, "Width", "Particle (narrow) band width (higher value results in thicker band and more particles)"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_datacache_reset"); prop = RNA_def_property(srna, "use_flip_particles", PROP_BOOLEAN, PROP_NONE); RNA_def_property_boolean_sdna(prop, NULL, "particle_type", FLUID_DOMAIN_PARTICLE_FLIP); @@ -1569,7 +1639,8 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) prop, "Fractional Obstacles", "Fractional obstacles improve and smoothen the fluid-obstacle boundary"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_datacache_reset"); prop = RNA_def_property(srna, "fractions_threshold", PROP_FLOAT, PROP_NONE); RNA_def_property_range(prop, 0.001, 1.0); @@ -1579,7 +1650,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) "Determines how much fluid is allowed in an obstacle cell " "(higher values will tag a boundary cell as an obstacle easier " "and reduce the boundary smoothening effect)"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_datacache_reset"); /* diffusion options */ @@ -1588,7 +1659,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) RNA_def_property_ui_text( prop, "Use Diffusion", "Enable fluid diffusion settings (e.g. viscosity, surface tension)"); RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_domain_reset"); prop = RNA_def_property(srna, "surface_tension", PROP_FLOAT, PROP_NONE); RNA_def_property_range(prop, 0.0, 100.0); @@ -1596,7 +1667,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) prop, "Tension", "Surface tension of liquid (higher value results in greater hydrophobic behaviour)"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_datacache_reset"); prop = RNA_def_property(srna, "viscosity_base", PROP_FLOAT, PROP_NONE); RNA_def_property_float_sdna(prop, NULL, "viscosity_base"); @@ -1605,7 +1676,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) prop, "Viscosity Base", "Viscosity setting: value that is multiplied by 10 to the power of (exponent*-1)"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_datacache_reset"); prop = RNA_def_property(srna, "viscosity_exponent", PROP_INT, PROP_NONE); RNA_def_property_int_sdna(prop, NULL, "viscosity_exponent"); @@ -1615,12 +1686,12 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) "Viscosity Exponent", "Negative exponent for the viscosity value (to simplify entering small values " "e.g. 5*10^-6)"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_datacache_reset"); prop = RNA_def_property(srna, "domain_size", PROP_FLOAT, PROP_NONE); RNA_def_property_range(prop, 0.001, 10000.0); RNA_def_property_ui_text(prop, "Meters", "Domain size in meters (longest domain side)"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_domain_reset"); /* mesh options options */ @@ -1630,7 +1701,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) prop, "Upper Concavity", "Upper mesh concavity bound (high values tend to smoothen and fill out concave regions)"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_meshcache_reset"); prop = RNA_def_property(srna, "mesh_concave_lower", PROP_FLOAT, PROP_NONE); RNA_def_property_range(prop, 0.0, 10.0); @@ -1638,17 +1709,17 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) prop, "Lower Concavity", "Lower mesh concavity bound (high values tend to smoothen and fill out concave regions)"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_meshcache_reset"); prop = RNA_def_property(srna, "mesh_smoothen_pos", PROP_INT, PROP_NONE); RNA_def_property_range(prop, 0, 100); RNA_def_property_ui_text(prop, "Smoothen Pos", "Positive mesh smoothening"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_meshcache_reset"); prop = RNA_def_property(srna, "mesh_smoothen_neg", PROP_INT, PROP_NONE); RNA_def_property_range(prop, 0, 100); RNA_def_property_ui_text(prop, "Smoothen Neg", "Negative mesh smoothening"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_meshcache_reset"); prop = RNA_def_property(srna, "mesh_scale", PROP_INT, PROP_NONE); RNA_def_property_int_sdna(prop, NULL, "mesh_scale"); @@ -1660,7 +1731,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) "resolution of the domain). For best meshing, it is recommended to " "adjust the mesh particle radius alongside this value"); RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_domain_reset"); prop = RNA_def_property(srna, "mesh_generator", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "mesh_generator"); @@ -1689,7 +1760,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) "Caches velocities of mesh vertices. These will be used " "(automatically) when rendering with motion blur enabled"); RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_domain_reset"); prop = RNA_def_property(srna, "mesh_particle_radius", PROP_FLOAT, PROP_NONE); RNA_def_property_range(prop, 0.0, 10.0); @@ -1697,7 +1768,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) "Radius", "Particle radius factor (higher value results in larger (meshed) " "particles). Needs to be adjusted after changing the mesh scale"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_meshcache_reset"); /* secondary particles options */ @@ -1709,7 +1780,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) "Minimum Wave Crest Potential", "Lower clamping threshold for marking fluid cells as wave crests " "(lower value results in more marked cells)"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_particlescache_reset"); prop = RNA_def_property(srna, "sndparticle_potential_max_wavecrest", PROP_FLOAT, PROP_NONE); RNA_def_property_float_sdna(prop, NULL, "sndparticle_tau_max_wc"); @@ -1719,7 +1790,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) "Maximum Wave Crest Potential", "Upper clamping threshold for marking fluid cells as wave crests " "(higher value results in less marked cells)"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_particlescache_reset"); prop = RNA_def_property(srna, "sndparticle_potential_min_trappedair", PROP_FLOAT, PROP_NONE); RNA_def_property_float_sdna(prop, NULL, "sndparticle_tau_min_ta"); @@ -1729,7 +1800,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) "Minimum Trapped Air Potential", "Lower clamping threshold for marking fluid cells where air is trapped " "(lower value results in more marked cells)"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_particlescache_reset"); prop = RNA_def_property(srna, "sndparticle_potential_max_trappedair", PROP_FLOAT, PROP_NONE); RNA_def_property_float_sdna(prop, NULL, "sndparticle_tau_max_ta"); @@ -1739,7 +1810,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) "Maximum Trapped Air Potential", "Upper clamping threshold for marking fluid cells where air is trapped " "(higher value results in less marked cells)"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_particlescache_reset"); prop = RNA_def_property(srna, "sndparticle_potential_min_energy", PROP_FLOAT, PROP_NONE); RNA_def_property_float_sdna(prop, NULL, "sndparticle_tau_min_k"); @@ -1750,7 +1821,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) "Minimum Kinetic Energy Potential", "Lower clamping threshold that indicates the fluid speed where cells start to emit " "particles (lower values result in generally more particles)"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_particlescache_reset"); prop = RNA_def_property(srna, "sndparticle_potential_max_energy", PROP_FLOAT, PROP_NONE); RNA_def_property_float_sdna(prop, NULL, "sndparticle_tau_max_k"); @@ -1761,7 +1832,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) "Maximum Kinetic Energy Potential", "Upper clamping threshold that indicates the fluid speed where cells no longer emit more " "particles (higher value results in generally less particles)"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_particlescache_reset"); prop = RNA_def_property(srna, "sndparticle_sampling_wavecrest", PROP_INT, PROP_NONE); RNA_def_property_int_sdna(prop, NULL, "sndparticle_k_wc"); @@ -1770,7 +1841,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) RNA_def_property_ui_text(prop, "Wave Crest Sampling", "Maximum number of particles generated per wave crest cell per frame"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_particlescache_reset"); prop = RNA_def_property(srna, "sndparticle_sampling_trappedair", PROP_INT, PROP_NONE); RNA_def_property_int_sdna(prop, NULL, "sndparticle_k_ta"); @@ -1779,7 +1850,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) RNA_def_property_ui_text(prop, "Trapped Air Sampling", "Maximum number of particles generated per trapped air cell per frame"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_particlescache_reset"); prop = RNA_def_property(srna, "sndparticle_bubble_buoyancy", PROP_FLOAT, PROP_NONE); RNA_def_property_float_sdna(prop, NULL, "sndparticle_k_b"); @@ -1789,7 +1860,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) "Bubble Buoyancy", "Amount of buoyancy force that rises bubbles (high value results in " "bubble movement mainly upwards)"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_particlescache_reset"); prop = RNA_def_property(srna, "sndparticle_bubble_drag", PROP_FLOAT, PROP_NONE); RNA_def_property_float_sdna(prop, NULL, "sndparticle_k_d"); @@ -1799,28 +1870,28 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) "Bubble Drag", "Amount of drag force that moves bubbles along with the fluid (high " "value results in bubble movement mainly along with the fluid)"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_particlescache_reset"); prop = RNA_def_property(srna, "sndparticle_life_min", PROP_FLOAT, PROP_NONE); RNA_def_property_float_sdna(prop, NULL, "sndparticle_l_min"); RNA_def_property_range(prop, 0.0, 10000.0); RNA_def_property_ui_range(prop, 0.0, 10000.0, 100.0, 1); RNA_def_property_ui_text(prop, "Minimum Lifetime", "Lowest possible particle lifetime"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_particlescache_reset"); prop = RNA_def_property(srna, "sndparticle_life_max", PROP_FLOAT, PROP_NONE); RNA_def_property_float_sdna(prop, NULL, "sndparticle_l_max"); RNA_def_property_range(prop, 0.0, 10000.0); RNA_def_property_ui_range(prop, 0.0, 10000.0, 100.0, 1); RNA_def_property_ui_text(prop, "Maximum Lifetime", "Highest possible particle lifetime"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_particlescache_reset"); prop = RNA_def_property(srna, "sndparticle_boundary", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "sndparticle_boundary"); RNA_def_property_enum_items(prop, sndparticle_boundary_items); RNA_def_property_ui_text( prop, "Particles in Boundary", "How particles that left the domain are treated"); - RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_particlescache_reset"); prop = RNA_def_property(srna, "sndparticle_combined_export", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "sndparticle_combined_export"); @@ -1839,7 +1910,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) "Potential Radius", "Radius to compute potential for each cell (higher values are slower " "but create smoother potential grids)"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_particlescache_reset"); prop = RNA_def_property(srna, "sndparticle_update_radius", PROP_INT, PROP_NONE); RNA_def_property_int_sdna(prop, NULL, "sndparticle_update_radius"); @@ -1849,7 +1920,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) "Update Radius", "Radius to compute position update for each particle (higher values " "are slower but particles move less chaotic)"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_particlescache_reset"); prop = RNA_def_property(srna, "particle_scale", PROP_INT, PROP_NONE); RNA_def_property_int_sdna(prop, NULL, "particle_scale"); @@ -1860,7 +1931,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) "The particle simulation is scaled up by this factor (compared to the " "base resolution of the domain)"); RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_domain_reset"); prop = RNA_def_property(srna, "use_spray_particles", PROP_BOOLEAN, PROP_NONE); RNA_def_property_boolean_sdna(prop, NULL, "particle_type", FLUID_DOMAIN_PARTICLE_SPRAY); @@ -1892,13 +1963,13 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) RNA_def_property_float_sdna(prop, NULL, "guide_alpha"); RNA_def_property_range(prop, 1.0, 100.0); RNA_def_property_ui_text(prop, "Weight", "Guiding weight (higher value results in greater lag)"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_guidingcache_reset"); prop = RNA_def_property(srna, "guide_beta", PROP_INT, PROP_NONE); RNA_def_property_int_sdna(prop, NULL, "guide_beta"); RNA_def_property_range(prop, 1, 50); RNA_def_property_ui_text(prop, "Size", "Guiding size (higher value results in larger vortices)"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_guidingcache_reset"); prop = RNA_def_property(srna, "guide_vel_factor", PROP_FLOAT, PROP_NONE); RNA_def_property_float_sdna(prop, NULL, "guide_vel_factor"); @@ -1907,7 +1978,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) prop, "Velocity Factor", "Guiding velocity factor (higher value results in greater guiding velocities)"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_guidingcache_reset"); prop = RNA_def_property(srna, "guide_source", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "guide_source"); @@ -1924,13 +1995,13 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) "", "Use velocities from this object for the guiding effect (object needs " "to have fluid modifier and be of type domain))"); - RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Fluid_update"); + RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Fluid_guidingcache_reset"); prop = RNA_def_property(srna, "use_guide", PROP_BOOLEAN, PROP_NONE); RNA_def_property_boolean_sdna(prop, NULL, "flags", FLUID_DOMAIN_USE_GUIDE); RNA_def_property_ui_text(prop, "Use Guiding", "Enable fluid guiding"); RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_guidingcache_reset"); /* cache options */ @@ -1968,7 +2039,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) prop, NULL, "rna_Fluid_cachetype_mesh_set", "rna_Fluid_cachetype_mesh_itemf"); RNA_def_property_ui_text( prop, "File Format", "Select the file format to be used for caching surface data"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_meshcache_reset"); prop = RNA_def_property(srna, "cache_data_format", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "cache_data_format"); @@ -1977,7 +2048,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) prop, NULL, "rna_Fluid_cachetype_data_set", "rna_Fluid_cachetype_volume_itemf"); RNA_def_property_ui_text( prop, "File Format", "Select the file format to be used for caching volumetric data"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_datacache_reset"); prop = RNA_def_property(srna, "cache_particle_format", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "cache_particle_format"); @@ -1986,7 +2057,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) prop, NULL, "rna_Fluid_cachetype_particle_set", "rna_Fluid_cachetype_particle_itemf"); RNA_def_property_ui_text( prop, "File Format", "Select the file format to be used for caching particle data"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_particlescache_reset"); prop = RNA_def_property(srna, "cache_noise_format", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "cache_noise_format"); @@ -1995,21 +2066,21 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) prop, NULL, "rna_Fluid_cachetype_noise_set", "rna_Fluid_cachetype_volume_itemf"); RNA_def_property_ui_text( prop, "File Format", "Select the file format to be used for caching noise data"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_noisecache_reset"); prop = RNA_def_property(srna, "cache_type", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "cache_type"); RNA_def_property_enum_items(prop, cache_types); RNA_def_property_enum_funcs(prop, NULL, "rna_Fluid_cachetype_set", NULL); RNA_def_property_ui_text(prop, "Type", "Change the cache type of the simulation"); - RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Fluid_domain_reset"); prop = RNA_def_property(srna, "cache_directory", PROP_STRING, PROP_DIRPATH); RNA_def_property_string_maxlength(prop, FILE_MAX); RNA_def_property_string_funcs(prop, NULL, NULL, "rna_Fluid_cache_directory_set"); RNA_def_property_string_sdna(prop, NULL, "cache_directory"); RNA_def_property_ui_text(prop, "Cache directory", "Directory that contains fluid cache files"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, NULL); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_update"); prop = RNA_def_property(srna, "is_cache_baking_data", PROP_BOOLEAN, PROP_NONE); RNA_def_property_boolean_sdna(prop, NULL, "cache_flag", FLUID_DOMAIN_BAKING_DATA); @@ -2069,7 +2140,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) "only needed if you plan to analyze the cache (e.g. view grids, velocity vectors, " "particles) in Mantaflow directly (outside of Blender) after baking the simulation"); RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_domain_reset"); /* time options */ @@ -2077,19 +2148,19 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) RNA_def_property_float_sdna(prop, NULL, "time_scale"); RNA_def_property_range(prop, 0.0001, 10.0); RNA_def_property_ui_text(prop, "Time Scale", "Adjust simulation speed"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_datacache_reset"); prop = RNA_def_property(srna, "cfl_condition", PROP_FLOAT, PROP_NONE); RNA_def_property_float_sdna(prop, NULL, "cfl_condition"); RNA_def_property_range(prop, 0.0, 10.0); RNA_def_property_ui_text( prop, "CFL", "Maximal velocity per cell (higher value results in greater timesteps)"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_datacache_reset"); prop = RNA_def_property(srna, "use_adaptive_timesteps", PROP_BOOLEAN, PROP_NONE); RNA_def_property_boolean_sdna(prop, NULL, "flags", FLUID_DOMAIN_USE_ADAPTIVE_TIME); RNA_def_property_ui_text(prop, "Use Adaptive Time Steps", ""); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_resetCache"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_datacache_reset"); prop = RNA_def_property(srna, "timesteps_min", PROP_INT, PROP_NONE); RNA_def_property_int_sdna(prop, NULL, "timesteps_minimum"); @@ -2097,7 +2168,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) RNA_def_property_ui_range(prop, 0, 100, 1, -1); RNA_def_property_ui_text( prop, "Minimum", "Minimum number of simulation steps to perform for one frame"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_datacache_reset"); prop = RNA_def_property(srna, "timesteps_max", PROP_INT, PROP_NONE); RNA_def_property_int_sdna(prop, NULL, "timesteps_maximum"); @@ -2105,7 +2176,7 @@ static void rna_def_fluid_domain_settings(BlenderRNA *brna) RNA_def_property_ui_range(prop, 0, 100, 1, -1); RNA_def_property_ui_text( prop, "Maximum", "Maximum number of simulation steps to perform for one frame"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_datacache_reset"); /* display settings */ @@ -2316,26 +2387,26 @@ static void rna_def_fluid_flow_settings(BlenderRNA *brna) RNA_def_property_range(prop, 0.0, 10); RNA_def_property_ui_range(prop, 0.0, 1.0, 1.0, 4); RNA_def_property_ui_text(prop, "Density", ""); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_flow_reset"); prop = RNA_def_property(srna, "smoke_color", PROP_FLOAT, PROP_COLOR_GAMMA); RNA_def_property_float_sdna(prop, NULL, "color"); RNA_def_property_array(prop, 3); RNA_def_property_ui_text(prop, "Smoke Color", "Color of smoke"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_flow_reset"); prop = RNA_def_property(srna, "fuel_amount", PROP_FLOAT, PROP_NONE); RNA_def_property_range(prop, 0.0, 10); RNA_def_property_ui_range(prop, 0.0, 5.0, 1.0, 4); RNA_def_property_ui_text(prop, "Flame Rate", ""); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_flow_reset"); prop = RNA_def_property(srna, "temperature", PROP_FLOAT, PROP_NONE); RNA_def_property_float_sdna(prop, NULL, "temperature"); RNA_def_property_range(prop, -10, 10); RNA_def_property_ui_range(prop, -10, 10, 1, 1); RNA_def_property_ui_text(prop, "Temp. Diff.", "Temperature difference to ambient temperature"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_flow_reset"); prop = RNA_def_property(srna, "particle_system", PROP_POINTER, PROP_NONE); RNA_def_property_pointer_sdna(prop, NULL, "psys"); @@ -2349,13 +2420,13 @@ static void rna_def_fluid_flow_settings(BlenderRNA *brna) RNA_def_property_enum_items(prop, flow_type_items); RNA_def_property_enum_funcs(prop, NULL, "rna_Fluid_flowtype_set", NULL); RNA_def_property_ui_text(prop, "Flow Type", "Change type of fluid in the simulation"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_flow_reset"); prop = RNA_def_property(srna, "flow_behavior", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "behavior"); RNA_def_property_enum_items(prop, flow_behavior_items); RNA_def_property_ui_text(prop, "Flow Behavior", "Change flow behavior in the simulation"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_flow_reset"); prop = RNA_def_property(srna, "flow_source", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "source"); @@ -2363,20 +2434,20 @@ static void rna_def_fluid_flow_settings(BlenderRNA *brna) RNA_def_property_enum_funcs( prop, NULL, "rna_Fluid_flowsource_set", "rna_Fluid_flowsource_itemf"); RNA_def_property_ui_text(prop, "Source", "Change how fluid is emitted"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_flow_reset"); prop = RNA_def_property(srna, "use_absolute", PROP_BOOLEAN, PROP_NONE); RNA_def_property_boolean_sdna(prop, NULL, "flags", FLUID_FLOW_ABSOLUTE); RNA_def_property_ui_text(prop, "Absolute Density", "Only allow given density value in emitter area and will not add up"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_flow_reset"); prop = RNA_def_property(srna, "use_initial_velocity", PROP_BOOLEAN, PROP_NONE); RNA_def_property_boolean_sdna(prop, NULL, "flags", FLUID_FLOW_INITVELOCITY); RNA_def_property_ui_text( prop, "Initial Velocity", "Fluid has some initial velocity when it is emitted"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_flow_reset"); prop = RNA_def_property(srna, "velocity_factor", PROP_FLOAT, PROP_NONE); RNA_def_property_float_sdna(prop, NULL, "vel_multi"); @@ -2386,28 +2457,28 @@ static void rna_def_fluid_flow_settings(BlenderRNA *brna) "Source", "Multiplier of source velocity passed to fluid (source velocity is " "non-zero only if object is moving)"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_flow_reset"); prop = RNA_def_property(srna, "velocity_normal", PROP_FLOAT, PROP_NONE); RNA_def_property_float_sdna(prop, NULL, "vel_normal"); RNA_def_property_range(prop, -100.0, 100.0); RNA_def_property_ui_range(prop, -2.0, 2.0, 0.05, 5); RNA_def_property_ui_text(prop, "Normal", "Amount of normal directional velocity"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_flow_reset"); prop = RNA_def_property(srna, "velocity_random", PROP_FLOAT, PROP_NONE); RNA_def_property_float_sdna(prop, NULL, "vel_random"); RNA_def_property_range(prop, 0.0, 10.0); RNA_def_property_ui_range(prop, 0.0, 2.0, 0.05, 5); RNA_def_property_ui_text(prop, "Random", "Amount of random velocity"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_flow_reset"); prop = RNA_def_property(srna, "velocity_coord", PROP_FLOAT, PROP_XYZ); RNA_def_property_float_sdna(prop, NULL, "vel_coord"); RNA_def_property_array(prop, 3); RNA_def_property_range(prop, -1000.1, 1000.1); RNA_def_property_ui_text(prop, "Initial", "Initial velocity in X, Y and Z direction"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_flow_reset"); prop = RNA_def_property(srna, "volume_density", PROP_FLOAT, PROP_NONE); RNA_def_property_range(prop, 0.0, 1.0); @@ -2416,7 +2487,7 @@ static void rna_def_fluid_flow_settings(BlenderRNA *brna) "Volume Emission", "Controls fluid emission from within the mesh (higher value results in " "greater emissions from inside the mesh)"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_flow_reset"); prop = RNA_def_property(srna, "surface_distance", PROP_FLOAT, PROP_NONE); RNA_def_property_range(prop, 0.0, 10.0); @@ -2425,7 +2496,7 @@ static void rna_def_fluid_flow_settings(BlenderRNA *brna) "Surface Emission", "Controls fluid emission from the mesh surface (higher value results " "in emission further away from the mesh surface"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_flow_reset"); prop = RNA_def_property(srna, "use_plane_init", PROP_BOOLEAN, PROP_NONE); RNA_def_property_boolean_sdna(prop, NULL, "flags", FLUID_FLOW_USE_PLANE_INIT); @@ -2434,24 +2505,24 @@ static void rna_def_fluid_flow_settings(BlenderRNA *brna) "Is Planar", "Treat this object as a planar and unclosed mesh. Fluid will only be emitted from the mesh " "surface and based on the surface emission value"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_flow_reset"); prop = RNA_def_property(srna, "particle_size", PROP_FLOAT, PROP_NONE); RNA_def_property_range(prop, 0.1, 20.0); RNA_def_property_ui_range(prop, 0.5, 5.0, 0.05, 5); RNA_def_property_ui_text(prop, "Size", "Particle size in simulation cells"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_flow_reset"); prop = RNA_def_property(srna, "use_particle_size", PROP_BOOLEAN, PROP_NONE); RNA_def_property_boolean_sdna(prop, NULL, "flags", FLUID_FLOW_USE_PART_SIZE); RNA_def_property_ui_text( prop, "Set Size", "Set particle size in simulation cells or use nearest cell"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_flow_reset"); prop = RNA_def_property(srna, "use_inflow", PROP_BOOLEAN, PROP_NONE); RNA_def_property_boolean_sdna(prop, NULL, "flags", FLUID_FLOW_USE_INFLOW); RNA_def_property_ui_text(prop, "Enabled", "Control when to apply inflow"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_flow_reset"); prop = RNA_def_property(srna, "subframes", PROP_INT, PROP_NONE); RNA_def_property_range(prop, 0, 200); @@ -2460,7 +2531,7 @@ static void rna_def_fluid_flow_settings(BlenderRNA *brna) "Subframes", "Number of additional samples to take between frames to improve " "quality of fast moving flows"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_flow_reset"); prop = RNA_def_property(srna, "density_vertex_group", PROP_STRING, PROP_NONE); RNA_def_property_string_funcs(prop, @@ -2469,41 +2540,41 @@ static void rna_def_fluid_flow_settings(BlenderRNA *brna) "rna_FluidFlow_density_vgroup_set"); RNA_def_property_ui_text( prop, "Vertex Group", "Name of vertex group which determines surface emission rate"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_flow_reset"); prop = RNA_def_property(srna, "use_texture", PROP_BOOLEAN, PROP_NONE); RNA_def_property_boolean_sdna(prop, NULL, "flags", FLUID_FLOW_TEXTUREEMIT); RNA_def_property_ui_text(prop, "Use Texture", "Use a texture to control emission strength"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_flow_reset"); prop = RNA_def_property(srna, "texture_map_type", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "texture_type"); RNA_def_property_enum_items(prop, flow_texture_types); RNA_def_property_ui_text(prop, "Mapping", "Texture mapping type"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_flow_reset"); prop = RNA_def_property(srna, "uv_layer", PROP_STRING, PROP_NONE); RNA_def_property_string_sdna(prop, NULL, "uvlayer_name"); RNA_def_property_ui_text(prop, "UV Map", "UV map name"); RNA_def_property_string_funcs(prop, NULL, NULL, "rna_FluidFlow_uvlayer_set"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_flow_reset"); prop = RNA_def_property(srna, "noise_texture", PROP_POINTER, PROP_NONE); RNA_def_property_flag(prop, PROP_EDITABLE); RNA_def_property_ui_text(prop, "Texture", "Texture that controls emission strength"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_flow_reset"); prop = RNA_def_property(srna, "texture_size", PROP_FLOAT, PROP_NONE); RNA_def_property_range(prop, 0.01, 10.0); RNA_def_property_ui_range(prop, 0.1, 5.0, 0.05, 5); RNA_def_property_ui_text(prop, "Size", "Size of texture mapping"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_flow_reset"); prop = RNA_def_property(srna, "texture_offset", PROP_FLOAT, PROP_NONE); RNA_def_property_range(prop, 0.0, 200.0); RNA_def_property_ui_range(prop, 0.0, 100.0, 0.05, 5); RNA_def_property_ui_text(prop, "Offset", "Z-offset of texture mapping"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_flow_reset"); } static void rna_def_fluid_effector_settings(BlenderRNA *brna) @@ -2553,36 +2624,36 @@ static void rna_def_fluid_effector_settings(BlenderRNA *brna) RNA_def_property_enum_sdna(prop, NULL, "type"); RNA_def_property_enum_items(prop, effector_type_items); RNA_def_property_ui_text(prop, "Effector Type", "Change type of effector in the simulation"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_effector_reset"); prop = RNA_def_property(srna, "surface_distance", PROP_FLOAT, PROP_NONE); RNA_def_property_range(prop, 0.0, 10.0); RNA_def_property_ui_range(prop, 0.0, 10.0, 0.05, 5); RNA_def_property_ui_text( prop, "Surface", "Additional distance around mesh surface to consider as effector"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_effector_reset"); prop = RNA_def_property(srna, "use_plane_init", PROP_BOOLEAN, PROP_NONE); RNA_def_property_boolean_sdna(prop, NULL, "flags", FLUID_EFFECTOR_USE_PLANE_INIT); RNA_def_property_ui_text(prop, "Is Planar", "Treat this object as a planar, unclosed mesh"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_domain_reset"); prop = RNA_def_property(srna, "velocity_factor", PROP_FLOAT, PROP_NONE); RNA_def_property_float_sdna(prop, NULL, "vel_multi"); RNA_def_property_range(prop, -100.0, 100.0); RNA_def_property_ui_text(prop, "Source", "Multiplier of obstacle velocity"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_effector_reset"); prop = RNA_def_property(srna, "guide_mode", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "guide_mode"); RNA_def_property_enum_items(prop, fluid_guide_mode_items); RNA_def_property_ui_text(prop, "Guiding mode", "How to create guiding velocities"); - RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Fluid_update"); + RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Fluid_effector_reset"); prop = RNA_def_property(srna, "use_effector", PROP_BOOLEAN, PROP_NONE); RNA_def_property_boolean_sdna(prop, NULL, "flags", FLUID_EFFECTOR_USE_EFFEC); RNA_def_property_ui_text(prop, "Enabled", "Control when to apply the effector"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_effector_reset"); prop = RNA_def_property(srna, "subframes", PROP_INT, PROP_NONE); RNA_def_property_range(prop, 0, 200); @@ -2591,7 +2662,7 @@ static void rna_def_fluid_effector_settings(BlenderRNA *brna) "Subframes", "Number of additional samples to take between frames to improve " "quality of fast moving effector objects"); - RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_reset"); + RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Fluid_effector_reset"); } void RNA_def_fluid(BlenderRNA *brna) -- cgit v1.2.3 From d19277c72f1a5acc08eefde9c6c05e2cd4358205 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebasti=C3=A1n=20Barschkis?= Date: Sun, 19 Apr 2020 19:43:05 +0200 Subject: Fluid: Added missing outflow object type to enable / disable flow flag There is no reason to not include outflow objects here too. --- release/scripts/startup/bl_ui/properties_physics_fluid.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/release/scripts/startup/bl_ui/properties_physics_fluid.py b/release/scripts/startup/bl_ui/properties_physics_fluid.py index 960d2dff101..d6d2526384a 100644 --- a/release/scripts/startup/bl_ui/properties_physics_fluid.py +++ b/release/scripts/startup/bl_ui/properties_physics_fluid.py @@ -236,8 +236,8 @@ class PHYSICS_PT_settings(PhysicButtonsPanel, Panel): col = grid.column() col.prop(flow, "flow_behavior", expand=False) - if flow.flow_behavior in {'INFLOW'}: - col.prop(flow, "use_inflow", text="Use Inflow") + if flow.flow_behavior in {'INFLOW', 'OUTFLOW'}: + col.prop(flow, "use_inflow", text="Use Flow") col.prop(flow, "subframes", text="Sampling Substeps") -- cgit v1.2.3 From fdea3dd7e7109a814561e4a83ff3331badf04e24 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebasti=C3=A1n=20Barschkis?= Date: Sun, 19 Apr 2020 20:15:57 +0200 Subject: Fluid: Fix for inconsistent behavior with flow and effector objects Fixes issue with flow and effector objects which were not being used after resuming a bake job. This issue has been reported in T75729 and T75758. --- intern/mantaflow/extern/manta_fluid_API.h | 1 + intern/mantaflow/intern/MANTA_main.cpp | 11 +- intern/mantaflow/intern/MANTA_main.h | 5 + intern/mantaflow/intern/manta_fluid_API.cpp | 4 + intern/mantaflow/intern/strings/fluid_script.h | 12 +- intern/mantaflow/intern/strings/liquid_script.h | 6 +- intern/mantaflow/intern/strings/smoke_script.h | 1 + source/blender/blenkernel/intern/fluid.c | 457 ++++++++++++------------ 8 files changed, 273 insertions(+), 224 deletions(-) diff --git a/intern/mantaflow/extern/manta_fluid_API.h b/intern/mantaflow/extern/manta_fluid_API.h index 85cc04b4a52..7825ad14d7d 100644 --- a/intern/mantaflow/extern/manta_fluid_API.h +++ b/intern/mantaflow/extern/manta_fluid_API.h @@ -107,6 +107,7 @@ float *manta_get_phistatic_in(struct MANTA *fluid); float *manta_get_phiobs_in(struct MANTA *fluid); float *manta_get_phiobsstatic_in(struct MANTA *fluid); float *manta_get_phiout_in(struct MANTA *fluid); +float *manta_get_phioutstatic_in(struct MANTA *fluid); /* Smoke functions */ void manta_smoke_export_script(struct MANTA *smoke, struct FluidModifierData *mmd); diff --git a/intern/mantaflow/intern/MANTA_main.cpp b/intern/mantaflow/intern/MANTA_main.cpp index 539e3080c54..a56ce4c1f60 100644 --- a/intern/mantaflow/intern/MANTA_main.cpp +++ b/intern/mantaflow/intern/MANTA_main.cpp @@ -141,6 +141,7 @@ MANTA::MANTA(int *res, FluidModifierData *mmd) : mCurrentID(++solverID) mPhiIn = nullptr; mPhiStaticIn = nullptr; mPhiOutIn = nullptr; + mPhiOutStaticIn = nullptr; mPhi = nullptr; // Mesh @@ -1926,6 +1927,7 @@ void MANTA::exportSmokeScript(FluidModifierData *mmd) bool obstacle = mmd->domain->active_fields & FLUID_DOMAIN_ACTIVE_OBSTACLE; bool guiding = mmd->domain->active_fields & FLUID_DOMAIN_ACTIVE_GUIDE; bool invel = mmd->domain->active_fields & FLUID_DOMAIN_ACTIVE_INVEL; + bool outflow = mmd->domain->active_fields & FLUID_DOMAIN_ACTIVE_OUTFLOW; std::string manta_script; @@ -1968,6 +1970,8 @@ void MANTA::exportSmokeScript(FluidModifierData *mmd) manta_script += fluid_alloc_obstacle; if (invel) manta_script += fluid_alloc_invel; + if (outflow) + manta_script += fluid_alloc_outflow; // Noise field if (noise) @@ -2032,6 +2036,7 @@ void MANTA::exportLiquidScript(FluidModifierData *mmd) bool fractions = mmd->domain->flags & FLUID_DOMAIN_USE_FRACTIONS; bool guiding = mmd->domain->active_fields & FLUID_DOMAIN_ACTIVE_GUIDE; bool invel = mmd->domain->active_fields & FLUID_DOMAIN_ACTIVE_INVEL; + bool outflow = mmd->domain->active_fields & FLUID_DOMAIN_ACTIVE_OUTFLOW; std::string manta_script; @@ -2070,6 +2075,8 @@ void MANTA::exportLiquidScript(FluidModifierData *mmd) manta_script += fluid_alloc_fractions; if (invel) manta_script += fluid_alloc_invel; + if (outflow) + manta_script += fluid_alloc_outflow; // Domain init manta_script += header_gridinit + liquid_init_phi; @@ -3119,6 +3126,8 @@ void MANTA::updatePointers() if (mUsingOutflow) { mPhiOutIn = (float *)pyObjectToPointer(callPythonFunction("phiOutIn" + solver_ext, func)); + mPhiOutStaticIn = (float *)pyObjectToPointer( + callPythonFunction("phiOutSIn" + solver_ext, func)); } if (mUsingObstacle) { mPhiObsIn = (float *)pyObjectToPointer(callPythonFunction("phiObsIn" + solver_ext, func)); @@ -3230,7 +3239,7 @@ bool MANTA::hasConfig(FluidModifierData *mmd, int framenr) bool MANTA::hasData(FluidModifierData *mmd, int framenr) { - std::string filename = (mUsingSmoke) ? FLUID_DOMAIN_FILE_DENSITY : FLUID_DOMAIN_FILE_PHI; + std::string filename = (mUsingSmoke) ? FLUID_DOMAIN_FILE_DENSITY : FLUID_DOMAIN_FILE_PP; std::string extension = getCacheFileEnding(mmd->domain->cache_data_format); return BLI_exists(getFile(mmd, FLUID_DOMAIN_DIR_DATA, filename, extension, framenr).c_str()); } diff --git a/intern/mantaflow/intern/MANTA_main.h b/intern/mantaflow/intern/MANTA_main.h index caac63d8e39..21946431f28 100644 --- a/intern/mantaflow/intern/MANTA_main.h +++ b/intern/mantaflow/intern/MANTA_main.h @@ -405,6 +405,10 @@ struct MANTA { { return mPhiOutIn; } + inline float *getPhiOutStaticIn() + { + return mPhiOutStaticIn; + } inline float *getPhi() { return mPhi; @@ -844,6 +848,7 @@ struct MANTA { float *mPhiObsStaticIn; float *mPhiGuideIn; float *mPhiOutIn; + float *mPhiOutStaticIn; float *mPhi; // Mesh fields diff --git a/intern/mantaflow/intern/manta_fluid_API.cpp b/intern/mantaflow/intern/manta_fluid_API.cpp index b4582051c3c..49bc224b3fa 100644 --- a/intern/mantaflow/intern/manta_fluid_API.cpp +++ b/intern/mantaflow/intern/manta_fluid_API.cpp @@ -390,6 +390,10 @@ float *manta_get_phiout_in(MANTA *fluid) { return fluid->getPhiOutIn(); } +float *manta_get_phioutstatic_in(MANTA *fluid) +{ + return fluid->getPhiOutStaticIn(); +} /* Smoke functions */ void manta_smoke_export_script(MANTA *smoke, FluidModifierData *mmd) diff --git a/intern/mantaflow/intern/strings/fluid_script.h b/intern/mantaflow/intern/strings/fluid_script.h index e81a44109ef..dd2111db7d7 100644 --- a/intern/mantaflow/intern/strings/fluid_script.h +++ b/intern/mantaflow/intern/strings/fluid_script.h @@ -261,7 +261,7 @@ const std::string fluid_alloc_obstacle = "\n\ mantaMsg('Allocating obstacle data')\n\ numObs_s$ID$ = s$ID$.create(RealGrid)\n\ -phiObsSIn_s$ID$ = s$ID$.create(LevelsetGrid) # helper for static obstacles\n\ +phiObsSIn_s$ID$ = s$ID$.create(LevelsetGrid) # helper for static obstacle objects\n\ phiObsIn_s$ID$ = s$ID$.create(LevelsetGrid)\n\ obvel_s$ID$ = s$ID$.create(MACGrid)\n\ obvelC_s$ID$ = s$ID$.create(Vec3Grid)\n\ @@ -311,7 +311,15 @@ z_invel_s$ID$ = s$ID$.create(RealGrid)\n"; const std::string fluid_alloc_outflow = "\n\ mantaMsg('Allocating outflow data')\n\ -phiOutIn_s$ID$ = s$ID$.create(LevelsetGrid)\n"; +phiOutSIn_s$ID$ = s$ID$.create(LevelsetGrid) # helper for static outflow objects\n\ +phiOutIn_s$ID$ = s$ID$.create(LevelsetGrid)\n\ +\n\ +# Set some initial values\n\ +phiOutSIn_s$ID$.setConst(9999)\n\ +phiOutIn_s$ID$.setConst(9999)\n\ +\n\ +if 'fluid_data_dict_resume_s$ID$' in globals():\n\ + fluid_data_dict_resume_s$ID$.update(phiOutIn=phiOutIn_s$ID$)\n"; ////////////////////////////////////////////////////////////////////// // PRE / POST STEP diff --git a/intern/mantaflow/intern/strings/liquid_script.h b/intern/mantaflow/intern/strings/liquid_script.h index 34994f115d7..f20b218427c 100644 --- a/intern/mantaflow/intern/strings/liquid_script.h +++ b/intern/mantaflow/intern/strings/liquid_script.h @@ -191,6 +191,7 @@ def liquid_adaptive_step_$ID$(framenr):\n\ phi_s$ID$.join(phiIn_s$ID$)\n\ \n\ if using_outflow_s$ID$:\n\ + phiOutIn_s$ID$.join(phiOutSIn_s$ID$) # Join static outflow map\n\ phiOut_s$ID$.join(phiOutIn_s$ID$)\n\ \n\ if using_fractions_s$ID$:\n\ @@ -206,6 +207,9 @@ def liquid_adaptive_step_$ID$(framenr):\n\ extrapolateVec3Simple(vel=invelC_s$ID$, phi=phiIn_s$ID$, distance=6, inside=True)\n\ resampleVec3ToMac(source=invelC_s$ID$, target=invel_s$ID$)\n\ pVel_pp$ID$.setSource(invel_s$ID$, isMAC=True)\n\ + # ensure that pvel has vel as source (important when resuming bake jobs)\n\ + else:\n\ + pVel_pp$ID$.setSource(vel_s$ID$, isMAC=True)\n\ \n\ sampleLevelsetWithParticles(phi=phiIn_s$ID$, flags=flags_s$ID$, parts=pp_s$ID$, discretization=particleNumber_s$ID$, randomness=randomness_s$ID$)\n\ flags_s$ID$.updateFromLevelset(phi_s$ID$)\n\ @@ -363,7 +367,7 @@ def liquid_step_particles_$ID$():\n\ interpolateGrid(target=phiOut_sp$ID$, source=phiOut_s$ID$)\n\ \n\ # phiIn not needed, bwidth to 0 because we are omitting flags.initDomain()\n\ - setObstacleFlags(flags=flags_sp$ID$, phiObs=phiObs_sp$ID$, phiOut=None, phiIn=None, boundaryWidth=0)\n\ + setObstacleFlags(flags=flags_sp$ID$, phiObs=phiObs_sp$ID$, phiOut=phiOut_sp$ID$, phiIn=None, boundaryWidth=0)\n\ flags_sp$ID$.updateFromLevelset(levelset=phi_sp$ID$)\n\ \n\ # Actual secondary particle simulation\n\ diff --git a/intern/mantaflow/intern/strings/smoke_script.h b/intern/mantaflow/intern/strings/smoke_script.h index cb651eb40b3..146106fd147 100644 --- a/intern/mantaflow/intern/strings/smoke_script.h +++ b/intern/mantaflow/intern/strings/smoke_script.h @@ -296,6 +296,7 @@ def smoke_adaptive_step_$ID$(framenr):\n\ extrapolateLsSimple(phi=phiIn_s$ID$, distance=3, inside=False)\n\ \n\ if using_outflow_s$ID$:\n\ + phiOutIn_s$ID$.join(phiOutSIn_s$ID$) # Join static outflow map\n\ phiOut_s$ID$.join(phiOutIn_s$ID$)\n\ \n\ setObstacleFlags(flags=flags_s$ID$, phiObs=phiObs_s$ID$, phiOut=phiOut_s$ID$, phiIn=phiIn_s$ID$, boundaryWidth=1)\n\ diff --git a/source/blender/blenkernel/intern/fluid.c b/source/blender/blenkernel/intern/fluid.c index 578a6a13bb7..08b5b788afd 100644 --- a/source/blender/blenkernel/intern/fluid.c +++ b/source/blender/blenkernel/intern/fluid.c @@ -1192,32 +1192,50 @@ static void update_obstacleflags(FluidDomainSettings *mds, mds->active_fields = active_fields; } -static void update_obstacles(Depsgraph *depsgraph, - Scene *scene, - Object *ob, - FluidDomainSettings *mds, - float time_per_frame, - float frame_length, - int frame, - float dt) +static bool escape_effectorobject(Object *flowobj, + FluidDomainSettings *mds, + FluidEffectorSettings *mes, + int frame) { - FluidObjectBB *bb_maps = NULL; - Object **effecobjs = NULL; - uint numeffecobjs = 0, effec_index = 0; - bool is_first_frame = (frame == mds->cache_frame_start); + bool is_static = is_static_object(flowobj); - effecobjs = BKE_collision_objects_create( - depsgraph, ob, mds->effector_group, &numeffecobjs, eModifierType_Fluid); + bool use_effector = (mes->flags & FLUID_EFFECTOR_USE_EFFEC); - /* Update all effector related flags and ensure that corresponding grids get initialized. */ - update_obstacleflags(mds, ob, effecobjs, numeffecobjs); - ensure_obstaclefields(mds); + bool is_resume = (mds->cache_frame_pause_data == frame); + bool is_adaptive = (mds->flags & FLUID_DOMAIN_USE_ADAPTIVE_DOMAIN); + bool is_first_frame = (frame == mds->cache_frame_start); - /* Initialize effector maps for each flow. */ - bb_maps = MEM_callocN(sizeof(struct FluidObjectBB) * numeffecobjs, "fluid_effector_bb_maps"); + /* Cannot use static mode with adaptive domain. + * The adaptive domain might expand and only later discover the static object. */ + if (is_adaptive) { + is_static = false; + } + /* Skip flow objects with disabled inflow flag. */ + if (!use_effector) { + return true; + } + /* Skip static effector objects after initial frame. */ + if (is_static && !is_first_frame && !is_resume) { + return true; + } + return false; +} + +static void compute_obstaclesemission(Scene *scene, + FluidObjectBB *bb_maps, + struct Depsgraph *depsgraph, + float dt, + Object **effecobjs, + int frame, + float frame_length, + FluidDomainSettings *mds, + uint numeffecobjs, + float time_per_frame) +{ + bool is_first_frame = (frame == mds->cache_frame_start); /* Prepare effector maps. */ - for (effec_index = 0; effec_index < numeffecobjs; effec_index++) { + for (int effec_index = 0; effec_index < numeffecobjs; effec_index++) { Object *effecobj = effecobjs[effec_index]; FluidModifierData *mmd2 = (FluidModifierData *)modifiers_findByType(effecobj, eModifierType_Fluid); @@ -1233,20 +1251,8 @@ static void update_obstacles(Depsgraph *depsgraph, int subframes = mes->subframes; FluidObjectBB *bb = &bb_maps[effec_index]; - bool is_static = is_static_object(effecobj); - /* Cannot use static mode with adaptive domain. - * The adaptive domain might expand and only later in the simulations discover the static - * object. */ - if (mds->flags & FLUID_DOMAIN_USE_ADAPTIVE_DOMAIN) { - is_static = false; - } - - /* Optimization: Static objects don't need emission computation after first frame. */ - if (is_static && !is_first_frame) { - continue; - } - /* Optimization: Skip effector objects with disabled effec flag. */ - if ((mes->flags & FLUID_EFFECTOR_USE_EFFEC) == 0) { + /* Optimization: Skip this object under certain conditions. */ + if (escape_effectorobject(effecobj, mds, mes, frame)) { continue; } @@ -1314,6 +1320,44 @@ static void update_obstacles(Depsgraph *depsgraph, } } } +} + +static void update_obstacles(Depsgraph *depsgraph, + Scene *scene, + Object *ob, + FluidDomainSettings *mds, + float time_per_frame, + float frame_length, + int frame, + float dt) +{ + FluidObjectBB *bb_maps = NULL; + Object **effecobjs = NULL; + uint numeffecobjs = 0; + bool is_resume = (mds->cache_frame_pause_data == frame); + bool is_first_frame = (frame == mds->cache_frame_start); + + effecobjs = BKE_collision_objects_create( + depsgraph, ob, mds->effector_group, &numeffecobjs, eModifierType_Fluid); + + /* Update all effector related flags and ensure that corresponding grids get initialized. */ + update_obstacleflags(mds, ob, effecobjs, numeffecobjs); + ensure_obstaclefields(mds); + + /* Allocate effector map for each effector object. */ + bb_maps = MEM_callocN(sizeof(struct FluidObjectBB) * numeffecobjs, "fluid_effector_bb_maps"); + + /* Initialize effector map for each effector object. */ + compute_obstaclesemission(scene, + bb_maps, + depsgraph, + dt, + effecobjs, + frame, + frame_length, + mds, + numeffecobjs, + time_per_frame); float *vel_x = manta_get_ob_velocity_x(mds->fluid); float *vel_y = manta_get_ob_velocity_y(mds->fluid); @@ -1364,7 +1408,7 @@ static void update_obstacles(Depsgraph *depsgraph, } /* Prepare grids from effector objects. */ - for (effec_index = 0; effec_index < numeffecobjs; effec_index++) { + for (int effec_index = 0; effec_index < numeffecobjs; effec_index++) { Object *effecobj = effecobjs[effec_index]; FluidModifierData *mmd2 = (FluidModifierData *)modifiers_findByType(effecobj, eModifierType_Fluid); @@ -1374,18 +1418,11 @@ static void update_obstacles(Depsgraph *depsgraph, continue; } - bool is_static = is_static_object(effecobj); /* Cannot use static mode with adaptive domain. * The adaptive domain might expand and only later in the simulations discover the static * object. */ - if (mds->flags & FLUID_DOMAIN_USE_ADAPTIVE_DOMAIN) { - is_static = false; - } - - /* Optimization: Static objects don't need emission application after first frame. */ - if (is_static && !is_first_frame) { - continue; - } + bool is_static = is_static_object(effecobj) && + ((mds->flags & FLUID_DOMAIN_USE_ADAPTIVE_DOMAIN) == 0); /* Check for initialized effector object. */ if ((mmd2->type & MOD_FLUID_TYPE_EFFEC) && mmd2->effector) { @@ -1425,53 +1462,35 @@ static void update_obstacles(Depsgraph *depsgraph, continue; } - /* Apply static effectors to obstacle grid. */ - if (is_static && is_first_frame) { - if (mes->type == FLUID_EFFECTOR_TYPE_COLLISION) { - apply_effector_fields(mes, - d_index, - distance_map[e_index], - phi_obsstatic_in, - numobjs_map[e_index], - num_obstacles, - 0.0f, - NULL, - 0.0f, - NULL, - 0.0f, - NULL); - } + if (mes->type == FLUID_EFFECTOR_TYPE_COLLISION) { + float *levelset = ((is_first_frame || is_resume) && is_static) ? phi_obsstatic_in : + phi_obs_in; + apply_effector_fields(mes, + d_index, + distance_map[e_index], + levelset, + numobjs_map[e_index], + num_obstacles, + velocity_map[e_index * 3], + vel_x, + velocity_map[e_index * 3 + 1], + vel_y, + velocity_map[e_index * 3 + 2], + vel_z); } - /* Apply moving effectors to obstacle grid. */ - else if (!is_static) { - if (mes->type == FLUID_EFFECTOR_TYPE_COLLISION) { - apply_effector_fields(mes, - d_index, - distance_map[e_index], - phi_obs_in, - numobjs_map[e_index], - num_obstacles, - velocity_map[e_index * 3], - vel_x, - velocity_map[e_index * 3 + 1], - vel_y, - velocity_map[e_index * 3 + 2], - vel_z); - } - if (mes->type == FLUID_EFFECTOR_TYPE_GUIDE) { - apply_effector_fields(mes, - d_index, - distance_map[e_index], - phi_guide_in, - numobjs_map[e_index], - num_guides, - velocity_map[e_index * 3], - vel_x_guide, - velocity_map[e_index * 3 + 1], - vel_y_guide, - velocity_map[e_index * 3 + 2], - vel_z_guide); - } + if (mes->type == FLUID_EFFECTOR_TYPE_GUIDE) { + apply_effector_fields(mes, + d_index, + distance_map[e_index], + phi_guide_in, + numobjs_map[e_index], + num_guides, + velocity_map[e_index * 3], + vel_x_guide, + velocity_map[e_index * 3 + 1], + vel_y_guide, + velocity_map[e_index * 3 + 2], + vel_z_guide); } } } @@ -2468,12 +2487,13 @@ BLI_INLINE void apply_outflow_fields(int index, float *color_b, float *phiout) { - /* determine outflow cells - phiout used in smoke and liquids */ + /* Set levelset value for liquid inflow. + * Ensure that distance value is "joined" into the levelset. */ if (phiout) { - phiout[index] = distance_value; + phiout[index] = MIN2(distance_value, phiout[index]); } - /* set smoke outflow */ + /* Set smoke outflow, i.e. reset cell to zero. */ if (density) { density[index] = 0.0f; } @@ -2702,32 +2722,68 @@ static void update_flowsflags(FluidDomainSettings *mds, mds->active_fields = active_fields; } -static void update_flowsfluids(struct Depsgraph *depsgraph, - Scene *scene, - Object *ob, +static bool escape_flowsobject(Object *flowobj, FluidDomainSettings *mds, - float time_per_frame, - float frame_length, - int frame, - float dt) + FluidFlowSettings *mfs, + int frame) { - FluidObjectBB *bb_maps = NULL; - Object **flowobjs = NULL; - uint numflowobj = 0, flow_index = 0; - bool is_first_frame = (frame == mds->cache_frame_start); - - flowobjs = BKE_collision_objects_create( - depsgraph, ob, mds->fluid_group, &numflowobj, eModifierType_Fluid); - - /* Update all flow related flags and ensure that corresponding grids get initialized. */ - update_flowsflags(mds, ob, flowobjs, numflowobj); - ensure_flowsfields(mds); + bool use_velocity = (mfs->flags & FLUID_FLOW_INITVELOCITY); + bool is_static = is_static_object(flowobj); + + bool liquid_flow = mfs->type == FLUID_FLOW_TYPE_LIQUID; + bool gas_flow = (mfs->type == FLUID_FLOW_TYPE_SMOKE || mfs->type == FLUID_FLOW_TYPE_FIRE || + mfs->type == FLUID_FLOW_TYPE_SMOKEFIRE); + bool is_geometry = (mfs->behavior == FLUID_FLOW_BEHAVIOR_GEOMETRY); + bool is_inflow = (mfs->behavior == FLUID_FLOW_BEHAVIOR_INFLOW); + bool is_outflow = (mfs->behavior == FLUID_FLOW_BEHAVIOR_OUTFLOW); + bool use_flow = (mfs->flags & FLUID_FLOW_USE_INFLOW); + + bool liquid_domain = mds->type == FLUID_DOMAIN_TYPE_LIQUID; + bool gas_domain = mds->type == FLUID_DOMAIN_TYPE_GAS; + bool is_adaptive = (mds->flags & FLUID_DOMAIN_USE_ADAPTIVE_DOMAIN); + bool is_resume = (mds->cache_frame_pause_data == frame); + bool is_first_frame = (mds->cache_frame_start == frame); + + /* Cannot use static mode with adaptive domain. + * The adaptive domain might expand and only later discover the static object. */ + if (is_adaptive) { + is_static = false; + } + /* Skip flow objects with disabled inflow flag. */ + if ((is_inflow || is_outflow) && !use_flow) { + return true; + } + /* No need to compute emission value if it won't be applied. */ + if (liquid_flow && is_geometry && !is_first_frame) { + return true; + } + /* Skip flow object if it does not "belong" to this domain type. */ + if ((liquid_flow && gas_domain) || (gas_flow && liquid_domain)) { + return true; + } + /* Optimization: Static liquid flow objects don't need emission after first frame. + * TODO (sebbas): Also do not use static mode if initial velocities are enabled. */ + if (liquid_flow && is_static && !is_first_frame && !is_resume && !use_velocity) { + return true; + } + return false; +} - /* Initialize emission maps for each flow. */ - bb_maps = MEM_callocN(sizeof(struct FluidObjectBB) * numflowobj, "fluid_flow_bb_maps"); +static void compute_flowsemission(Scene *scene, + FluidObjectBB *bb_maps, + struct Depsgraph *depsgraph, + float dt, + Object **flowobjs, + int frame, + float frame_length, + FluidDomainSettings *mds, + uint numflowobjs, + float time_per_frame) +{ + bool is_first_frame = (frame == mds->cache_frame_start); /* Prepare flow emission maps. */ - for (flow_index = 0; flow_index < numflowobj; flow_index++) { + for (int flow_index = 0; flow_index < numflowobjs; flow_index++) { Object *flowobj = flowobjs[flow_index]; FluidModifierData *mmd2 = (FluidModifierData *)modifiers_findByType(flowobj, eModifierType_Fluid); @@ -2743,37 +2799,8 @@ static void update_flowsfluids(struct Depsgraph *depsgraph, int subframes = mfs->subframes; FluidObjectBB *bb = &bb_maps[flow_index]; - bool use_velocity = mfs->flags & FLUID_FLOW_INITVELOCITY; - bool is_static = is_static_object(flowobj); - /* Cannot use static mode with adaptive domain. - * The adaptive domain might expand and only later in the simulations discover the static - * object. */ - if (mds->flags & FLUID_DOMAIN_USE_ADAPTIVE_DOMAIN) { - is_static = false; - } - - /* Optimization: Skip flow objects with disabled inflow flag. */ - if (mfs->behavior == FLUID_FLOW_BEHAVIOR_INFLOW && - (mfs->flags & FLUID_FLOW_USE_INFLOW) == 0) { - continue; - } - /* Optimization: No need to compute emission value if it won't be applied. */ - if (mfs->behavior == FLUID_FLOW_BEHAVIOR_GEOMETRY && !is_first_frame) { - continue; - } - /* Optimization: Skip flow object if it does not "belong" to this domain type. */ - if (mfs->type == FLUID_FLOW_TYPE_LIQUID && mds->type == FLUID_DOMAIN_TYPE_GAS) { - continue; - } - if ((mfs->type == FLUID_FLOW_TYPE_SMOKE || mfs->type == FLUID_FLOW_TYPE_FIRE || - mfs->type == FLUID_FLOW_TYPE_SMOKEFIRE) && - mds->type == FLUID_DOMAIN_TYPE_LIQUID) { - continue; - } - /* Optimization: Static liquid flow objects don't need emission computation after first - * frame. - * TODO (sebbas): Also do not use static mode if initial velocities are enabled. */ - if (mfs->type == FLUID_FLOW_TYPE_LIQUID && is_static && !is_first_frame && !use_velocity) { + /* Optimization: Skip this object under certain conditions. */ + if (escape_flowsobject(flowobj, mds, mfs, frame)) { continue; } @@ -2862,15 +2889,55 @@ static void update_flowsfluids(struct Depsgraph *depsgraph, frame_length, dt); # endif +} + +static void update_flowsfluids(struct Depsgraph *depsgraph, + Scene *scene, + Object *ob, + FluidDomainSettings *mds, + float time_per_frame, + float frame_length, + int frame, + float dt) +{ + FluidObjectBB *bb_maps = NULL; + Object **flowobjs = NULL; + uint numflowobjs = 0; + bool is_resume = (mds->cache_frame_pause_data == frame); + bool is_first_frame = (mds->cache_frame_start == frame); + + flowobjs = BKE_collision_objects_create( + depsgraph, ob, mds->fluid_group, &numflowobjs, eModifierType_Fluid); + + /* Update all flow related flags and ensure that corresponding grids get initialized. */ + update_flowsflags(mds, ob, flowobjs, numflowobjs); + ensure_flowsfields(mds); + + /* Allocate emission map for each flow object. */ + bb_maps = MEM_callocN(sizeof(struct FluidObjectBB) * numflowobjs, "fluid_flow_bb_maps"); + + /* Initialize emission map for each flow object. */ + compute_flowsemission(scene, + bb_maps, + depsgraph, + dt, + flowobjs, + frame, + frame_length, + mds, + numflowobjs, + time_per_frame); /* Adjust domain size if needed. Only do this once for every frame. */ if (mds->type == FLUID_DOMAIN_TYPE_GAS && mds->flags & FLUID_DOMAIN_USE_ADAPTIVE_DOMAIN) { - adaptive_domain_adjust(mds, ob, bb_maps, numflowobj, dt); + adaptive_domain_adjust(mds, ob, bb_maps, numflowobjs, dt); } float *phi_in = manta_get_phi_in(mds->fluid); float *phistatic_in = manta_get_phistatic_in(mds->fluid); float *phiout_in = manta_get_phiout_in(mds->fluid); + float *phioutstatic_in = manta_get_phioutstatic_in(mds->fluid); + float *density = manta_smoke_get_density(mds->fluid); float *color_r = manta_smoke_get_color_r(mds->fluid); float *color_g = manta_smoke_get_color_g(mds->fluid); @@ -2893,16 +2960,18 @@ static void update_flowsfluids(struct Depsgraph *depsgraph, float *velz_initial = manta_get_in_velocity_z(mds->fluid); uint z; - bool use_adaptivedomain = (mds->flags & FLUID_DOMAIN_USE_ADAPTIVE_DOMAIN); - /* Grid reset before writing again. */ for (z = 0; z < mds->res[0] * mds->res[1] * mds->res[2]; z++) { + /* Only reset static phi on first frame, dynamic phi gets reset every time. */ + if (phistatic_in && is_first_frame) { + phistatic_in[z] = PHI_MAX; + } if (phi_in) { phi_in[z] = PHI_MAX; } - /* Only reset static inflow on first frame. Only use static inflow without adaptive domains. */ - if (phistatic_in && (is_first_frame || use_adaptivedomain)) { - phistatic_in[z] = PHI_MAX; + /* Only reset static phi on first frame, dynamic phi gets reset every time. */ + if (phioutstatic_in && is_first_frame) { + phioutstatic_in[z] = PHI_MAX; } if (phiout_in) { phiout_in[z] = PHI_MAX; @@ -2934,7 +3003,7 @@ static void update_flowsfluids(struct Depsgraph *depsgraph, } /* Apply emission data for every flow object. */ - for (flow_index = 0; flow_index < numflowobj; flow_index++) { + for (int flow_index = 0; flow_index < numflowobjs; flow_index++) { Object *flowobj = flowobjs[flow_index]; FluidModifierData *mmd2 = (FluidModifierData *)modifiers_findByType(flowobj, eModifierType_Fluid); @@ -2948,38 +3017,11 @@ static void update_flowsfluids(struct Depsgraph *depsgraph, if ((mmd2->type & MOD_FLUID_TYPE_FLOW) && mmd2->flow) { FluidFlowSettings *mfs = mmd2->flow; - bool use_velocity = mfs->flags & FLUID_FLOW_INITVELOCITY; - bool use_inflow = (mfs->flags & FLUID_FLOW_USE_INFLOW); - bool is_liquid = (mfs->type == FLUID_FLOW_TYPE_LIQUID); bool is_inflow = (mfs->behavior == FLUID_FLOW_BEHAVIOR_INFLOW); bool is_geometry = (mfs->behavior == FLUID_FLOW_BEHAVIOR_GEOMETRY); bool is_outflow = (mfs->behavior == FLUID_FLOW_BEHAVIOR_OUTFLOW); - - bool is_static = is_static_object(flowobj); - /* Cannot use static mode with adaptive domain. - * The adaptive domain might expand and only later in the simulations discover the static - * object. */ - if (mds->flags & FLUID_DOMAIN_USE_ADAPTIVE_DOMAIN) { - is_static = false; - } - - /* Optimization: Skip flow objects with disabled flow flag. */ - if (is_inflow && !use_inflow) { - continue; - } - /* Optimization: Liquid objects don't always need emission application after first frame. */ - if (is_liquid && !is_first_frame) { - - /* Skip static liquid objects that are not on the first frame. - * TODO (sebbas): Also do not use static mode if initial velocities are enabled. */ - if (is_static && !use_velocity) { - continue; - } - /* Liquid geometry objects don't need emission application after first frame. */ - if (is_geometry) { - continue; - } - } + bool is_static = is_static_object(flowobj) && + ((mds->flags & FLUID_DOMAIN_USE_ADAPTIVE_DOMAIN) == 0); FluidObjectBB *bb = &bb_maps[flow_index]; float *velocity_map = bb->velocity; @@ -3012,6 +3054,8 @@ static void update_flowsfluids(struct Depsgraph *depsgraph, /* Delete fluid in outflow regions. */ if (is_outflow) { + float *levelset = ((is_first_frame || is_resume) && is_static) ? phioutstatic_in : + phiout_in; apply_outflow_fields(d_index, distance_map[e_index], density_in, @@ -3021,7 +3065,7 @@ static void update_flowsfluids(struct Depsgraph *depsgraph, color_r_in, color_g_in, color_b_in, - phiout_in); + levelset); } /* Do not apply inflow after the first frame when in geometry mode. */ else if (is_geometry && !is_first_frame) { @@ -3046,31 +3090,10 @@ static void update_flowsfluids(struct Depsgraph *depsgraph, phi_in, emission_in); } - /* Static liquid objects need inflow application onto static phi grid. */ - else if (is_inflow && is_liquid && is_static && is_first_frame) { - apply_inflow_fields(mfs, - 0.0f, - distance_map[e_index], - d_index, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - phistatic_in, - NULL); - } /* Main inflow application. */ else if (is_geometry || is_inflow) { + float *levelset = ((is_first_frame || is_resume) && is_static) ? phistatic_in : + phi_in; apply_inflow_fields(mfs, emission_map[e_index], distance_map[e_index], @@ -3089,7 +3112,7 @@ static void update_flowsfluids(struct Depsgraph *depsgraph, color_g, color_b_in, color_b, - phi_in, + levelset, emission_in); if (mfs->flags & FLUID_FLOW_INITVELOCITY) { velx_initial[d_index] = velocity_map[e_index * 3]; @@ -3607,12 +3630,6 @@ static int manta_step( mds->time_per_frame = time_per_frame; mds->time_total = time_total; - - /* If user requested stop, quit baking */ - if (G.is_break && !mode_replay) { - result = 0; - break; - } } if (mds->type == FLUID_DOMAIN_TYPE_GAS && result) { @@ -3724,6 +3741,11 @@ static void BKE_fluid_modifier_processDomain(FluidModifierData *mmd, return; } + /* Reset fluid if no fluid present. */ + if (!mds->fluid || mds->cache_flag & FLUID_DOMAIN_OUTDATED_DATA) { + BKE_fluid_modifier_reset_ex(mmd, false); + } + /* Ensure cache directory is not relative. */ const char *relbase = modifier_path_relbase_from_global(ob); BLI_path_abs(mds->cache_directory, relbase); @@ -3741,14 +3763,9 @@ static void BKE_fluid_modifier_processDomain(FluidModifierData *mmd, MEM_freeN(objs); } - /* Reset fluid if no fluid present. */ - if (!mds->fluid || mds->cache_flag & FLUID_DOMAIN_OUTDATED_DATA) { - BKE_fluid_modifier_reset_ex(mmd, false); - - /* Fluid domain init must not fail in order to continue modifier evaluation. */ - if (!BKE_fluid_modifier_init(mmd, depsgraph, ob, scene, me)) { - return; - } + /* Fluid domain init must not fail in order to continue modifier evaluation. */ + if (!mds->fluid && !BKE_fluid_modifier_init(mmd, depsgraph, ob, scene, me)) { + return; } BLI_assert(mds->fluid); -- cgit v1.2.3 From 6485d8b78a9b284eb2771175e961d5a5eeb86502 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebasti=C3=A1n=20Barschkis?= Date: Sun, 19 Apr 2020 21:13:27 +0200 Subject: Fluid: Fix for caches being released when file is loaded --- source/blender/blenkernel/intern/fluid.c | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/source/blender/blenkernel/intern/fluid.c b/source/blender/blenkernel/intern/fluid.c index 08b5b788afd..0f6b85b366b 100644 --- a/source/blender/blenkernel/intern/fluid.c +++ b/source/blender/blenkernel/intern/fluid.c @@ -4163,6 +4163,12 @@ struct Mesh *BKE_fluid_modifier_do( mmd->domain->cache_flag &= ~FLUID_DOMAIN_OUTDATED_PARTICLES; mmd->domain->cache_flag &= ~FLUID_DOMAIN_OUTDATED_GUIDE; } + else if (mmd->type & MOD_FLUID_TYPE_FLOW && mmd->flow) { + mmd->flow->flags &= ~FLUID_FLOW_NEEDS_UPDATE; + } + else if (mmd->type & MOD_FLUID_TYPE_EFFEC && mmd->effector) { + mmd->effector->flags &= ~FLUID_EFFECTOR_NEEDS_UPDATE; + } if (!result) { result = BKE_mesh_copy_for_eval(me, false); } -- cgit v1.2.3 From f148bd3795ea352642b33d11a027347abac11367 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebasti=C3=A1n=20Barschkis?= Date: Wed, 22 Apr 2020 14:58:41 +0200 Subject: Fluid: Fixes for cache 'Replay' mode General fixes and improvements for the cache. Previous commits on fluids broke the 'Replay' cache a bit. --- source/blender/blenkernel/intern/fluid.c | 58 ++++++++++++++--------------- source/blender/blenloader/intern/readfile.c | 6 +++ 2 files changed, 33 insertions(+), 31 deletions(-) diff --git a/source/blender/blenkernel/intern/fluid.c b/source/blender/blenkernel/intern/fluid.c index 0f6b85b366b..bde0abe1499 100644 --- a/source/blender/blenkernel/intern/fluid.c +++ b/source/blender/blenkernel/intern/fluid.c @@ -1149,7 +1149,6 @@ static void ensure_obstaclefields(FluidDomainSettings *mds) } static void update_obstacleflags(FluidDomainSettings *mds, - Object *domain, Object **coll_ob_array, int coll_ob_array_len) { @@ -1178,7 +1177,6 @@ static void update_obstacleflags(FluidDomainSettings *mds, } if (mes->flags & FLUID_EFFECTOR_NEEDS_UPDATE) { mes->flags &= ~FLUID_EFFECTOR_NEEDS_UPDATE; - BKE_fluid_cache_free_all(mds, domain); mds->cache_flag |= FLUID_DOMAIN_OUTDATED_DATA; } if (mes->type == FLUID_EFFECTOR_TYPE_COLLISION) { @@ -1341,7 +1339,7 @@ static void update_obstacles(Depsgraph *depsgraph, depsgraph, ob, mds->effector_group, &numeffecobjs, eModifierType_Fluid); /* Update all effector related flags and ensure that corresponding grids get initialized. */ - update_obstacleflags(mds, ob, effecobjs, numeffecobjs); + update_obstacleflags(mds, effecobjs, numeffecobjs); ensure_obstaclefields(mds); /* Allocate effector map for each effector object. */ @@ -2637,10 +2635,7 @@ static void ensure_flowsfields(FluidDomainSettings *mds) } } -static void update_flowsflags(FluidDomainSettings *mds, - Object *domain, - Object **flowobjs, - int numflowobj) +static void update_flowsflags(FluidDomainSettings *mds, Object **flowobjs, int numflowobj) { int active_fields = mds->active_fields; uint flow_index; @@ -2668,7 +2663,6 @@ static void update_flowsflags(FluidDomainSettings *mds, } if (mfs->flags & FLUID_FLOW_NEEDS_UPDATE) { mfs->flags &= ~FLUID_FLOW_NEEDS_UPDATE; - BKE_fluid_cache_free_all(mds, domain); mds->cache_flag |= FLUID_DOMAIN_OUTDATED_DATA; } if (mfs->flags & FLUID_FLOW_INITVELOCITY) { @@ -2910,7 +2904,7 @@ static void update_flowsfluids(struct Depsgraph *depsgraph, depsgraph, ob, mds->fluid_group, &numflowobjs, eModifierType_Fluid); /* Update all flow related flags and ensure that corresponding grids get initialized. */ - update_flowsflags(mds, ob, flowobjs, numflowobjs); + update_flowsflags(mds, flowobjs, numflowobjs); ensure_flowsfields(mds); /* Allocate emission map for each flow object. */ @@ -3092,8 +3086,9 @@ static void update_flowsfluids(struct Depsgraph *depsgraph, } /* Main inflow application. */ else if (is_geometry || is_inflow) { - float *levelset = ((is_first_frame || is_resume) && is_static) ? phistatic_in : - phi_in; + float *levelset = ((is_first_frame || is_resume) && is_static && !is_geometry) ? + phistatic_in : + phi_in; apply_inflow_fields(mfs, emission_map[e_index], distance_map[e_index], @@ -3731,18 +3726,8 @@ static void BKE_fluid_modifier_processDomain(FluidModifierData *mmd, return; } - bool bake_outdated = mds->cache_flag & - (FLUID_DOMAIN_OUTDATED_DATA | FLUID_DOMAIN_OUTDATED_NOISE | - FLUID_DOMAIN_OUTDATED_MESH | FLUID_DOMAIN_OUTDATED_PARTICLES | - FLUID_DOMAIN_OUTDATED_GUIDE); - - /* Exit early if cache is outdated. */ - if (bake_outdated) { - return; - } - - /* Reset fluid if no fluid present. */ - if (!mds->fluid || mds->cache_flag & FLUID_DOMAIN_OUTDATED_DATA) { + /* Reset fluid if no fluid present. Also resets active fields. */ + if (!mds->fluid) { BKE_fluid_modifier_reset_ex(mmd, false); } @@ -3750,19 +3735,29 @@ static void BKE_fluid_modifier_processDomain(FluidModifierData *mmd, const char *relbase = modifier_path_relbase_from_global(ob); BLI_path_abs(mds->cache_directory, relbase); + /* Ensure that all flags are up to date before doing any baking and/or cache reading. */ objs = BKE_collision_objects_create( depsgraph, ob, mds->fluid_group, &numobj, eModifierType_Fluid); - update_flowsflags(mds, ob, objs, numobj); + update_flowsflags(mds, objs, numobj); if (objs) { MEM_freeN(objs); } objs = BKE_collision_objects_create( depsgraph, ob, mds->effector_group, &numobj, eModifierType_Fluid); - update_obstacleflags(mds, ob, objs, numobj); + update_obstacleflags(mds, objs, numobj); if (objs) { MEM_freeN(objs); } + /* If the just updated flags now carry the 'outdated' flag, reset the cache here! + * Plus sanity check: Do not clear cache on file load. */ + if (mds->cache_flag & FLUID_DOMAIN_OUTDATED_DATA && + ((mds->flags & FLUID_DOMAIN_FILE_LOAD) == 0)) { + mds->cache_flag &= ~FLUID_DOMAIN_OUTDATED_DATA; + BKE_fluid_cache_free_all(mds, ob); + BKE_fluid_modifier_reset_ex(mmd, false); + } + /* Fluid domain init must not fail in order to continue modifier evaluation. */ if (!mds->fluid && !BKE_fluid_modifier_init(mmd, depsgraph, ob, scene, me)) { return; @@ -4082,6 +4077,8 @@ static void BKE_fluid_modifier_processDomain(FluidModifierData *mmd, } } } + + mds->flags &= ~FLUID_DOMAIN_FILE_LOAD; mmd->time = scene_framenr; } @@ -4163,12 +4160,7 @@ struct Mesh *BKE_fluid_modifier_do( mmd->domain->cache_flag &= ~FLUID_DOMAIN_OUTDATED_PARTICLES; mmd->domain->cache_flag &= ~FLUID_DOMAIN_OUTDATED_GUIDE; } - else if (mmd->type & MOD_FLUID_TYPE_FLOW && mmd->flow) { - mmd->flow->flags &= ~FLUID_FLOW_NEEDS_UPDATE; - } - else if (mmd->type & MOD_FLUID_TYPE_EFFEC && mmd->effector) { - mmd->effector->flags &= ~FLUID_EFFECTOR_NEEDS_UPDATE; - } + if (!result) { result = BKE_mesh_copy_for_eval(me, false); } @@ -4717,6 +4709,7 @@ static void BKE_fluid_modifier_freeFlow(FluidModifierData *mmd) } mmd->flow->verts_old = NULL; mmd->flow->numverts = 0; + mmd->flow->flags &= ~FLUID_FLOW_NEEDS_UPDATE; MEM_freeN(mmd->flow); mmd->flow = NULL; @@ -4736,6 +4729,7 @@ static void BKE_fluid_modifier_freeEffector(FluidModifierData *mmd) } mmd->effector->verts_old = NULL; mmd->effector->numverts = 0; + mmd->effector->flags &= ~FLUID_EFFECTOR_NEEDS_UPDATE; MEM_freeN(mmd->effector); mmd->effector = NULL; @@ -4774,6 +4768,7 @@ static void BKE_fluid_modifier_reset_ex(struct FluidModifierData *mmd, bool need } mmd->flow->verts_old = NULL; mmd->flow->numverts = 0; + mmd->flow->flags &= ~FLUID_FLOW_NEEDS_UPDATE; } else if (mmd->effector) { if (mmd->effector->verts_old) { @@ -4781,6 +4776,7 @@ static void BKE_fluid_modifier_reset_ex(struct FluidModifierData *mmd, bool need } mmd->effector->verts_old = NULL; mmd->effector->numverts = 0; + mmd->effector->flags &= ~FLUID_EFFECTOR_NEEDS_UPDATE; } } diff --git a/source/blender/blenloader/intern/readfile.c b/source/blender/blenloader/intern/readfile.c index 83d14761daa..8837dccb837 100644 --- a/source/blender/blenloader/intern/readfile.c +++ b/source/blender/blenloader/intern/readfile.c @@ -5316,6 +5316,12 @@ static void lib_link_object(FileData *fd, Main *bmain, Object *ob) /* Flag for refreshing the simulation after loading */ mmd->domain->flags |= FLUID_DOMAIN_FILE_LOAD; } + else if (mmd && (mmd->type == MOD_FLUID_TYPE_FLOW) && mmd->flow) { + mmd->flow->flags &= ~FLUID_FLOW_NEEDS_UPDATE; + } + else if (mmd && (mmd->type == MOD_FLUID_TYPE_EFFEC) && mmd->effector) { + mmd->effector->flags &= ~FLUID_EFFECTOR_NEEDS_UPDATE; + } } /* texture field */ -- cgit v1.2.3 From 07ed64aae6fde5429ffe0ab7e30d240009a98e37 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebasti=C3=A1n=20Barschkis?= Date: Wed, 22 Apr 2020 15:00:52 +0200 Subject: Fluid: Use maximum for initial velocity grid application Using MAX2 when writing intial velocities into the grid prevents overriding initial velocities when using multiple flow objects that are close to each other. --- source/blender/blenkernel/intern/fluid.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/source/blender/blenkernel/intern/fluid.c b/source/blender/blenkernel/intern/fluid.c index bde0abe1499..9709b74516b 100644 --- a/source/blender/blenkernel/intern/fluid.c +++ b/source/blender/blenkernel/intern/fluid.c @@ -3110,9 +3110,9 @@ static void update_flowsfluids(struct Depsgraph *depsgraph, levelset, emission_in); if (mfs->flags & FLUID_FLOW_INITVELOCITY) { - velx_initial[d_index] = velocity_map[e_index * 3]; - vely_initial[d_index] = velocity_map[e_index * 3 + 1]; - velz_initial[d_index] = velocity_map[e_index * 3 + 2]; + velx_initial[d_index] = MAX2(velx_initial[d_index], velocity_map[e_index * 3]); + vely_initial[d_index] = MAX2(vely_initial[d_index], velocity_map[e_index * 3 + 1]); + velz_initial[d_index] = MAX2(velz_initial[d_index], velocity_map[e_index * 3 + 2]); } } } -- cgit v1.2.3 From 0fe3e38b57191af258583b0e40ba36586ad7fa94 Mon Sep 17 00:00:00 2001 From: Sergey Sharybin Date: Wed, 22 Apr 2020 16:32:16 +0200 Subject: Cleanup: Spelling in function name Should be no functional changes. --- source/blender/blenkernel/BKE_subdiv_ccg.h | 2 +- source/blender/blenkernel/intern/pbvh.c | 2 +- source/blender/blenkernel/intern/subdiv_ccg.c | 2 +- source/blender/editors/sculpt_paint/sculpt.c | 10 +++++----- source/blender/gpu/intern/gpu_buffers.c | 2 +- 5 files changed, 9 insertions(+), 9 deletions(-) diff --git a/source/blender/blenkernel/BKE_subdiv_ccg.h b/source/blender/blenkernel/BKE_subdiv_ccg.h index 6f886a4b850..7c7638e65d2 100644 --- a/source/blender/blenkernel/BKE_subdiv_ccg.h +++ b/source/blender/blenkernel/BKE_subdiv_ccg.h @@ -305,7 +305,7 @@ void BKE_subdiv_ccg_neighbor_coords_get(const SubdivCCG *subdiv_ccg, const bool include_duplicates, SubdivCCGNeighbors *r_neighbors); -int BKE_subdiv_cgg_grid_to_face_index(const SubdivCCG *subdiv_ccg, const int grid_index); +int BKE_subdiv_ccg_grid_to_face_index(const SubdivCCG *subdiv_ccg, const int grid_index); #ifdef __cplusplus } diff --git a/source/blender/blenkernel/intern/pbvh.c b/source/blender/blenkernel/intern/pbvh.c index 33aa20fa1e4..e6d672ad9d9 100644 --- a/source/blender/blenkernel/intern/pbvh.c +++ b/source/blender/blenkernel/intern/pbvh.c @@ -388,7 +388,7 @@ void BKE_pbvh_sync_face_sets_to_grids(PBVH *bvh) const int gridsize = bvh->gridkey.grid_size; for (int i = 0; i < bvh->totgrid; i++) { BLI_bitmap *gh = bvh->grid_hidden[i]; - const int face_index = BKE_subdiv_cgg_grid_to_face_index(bvh->subdiv_ccg, i); + const int face_index = BKE_subdiv_ccg_grid_to_face_index(bvh->subdiv_ccg, i); if (!gh && bvh->face_sets[face_index] < 0) { gh = bvh->grid_hidden[i] = BLI_BITMAP_NEW(bvh->gridkey.grid_area, "partialvis_update_grids"); } diff --git a/source/blender/blenkernel/intern/subdiv_ccg.c b/source/blender/blenkernel/intern/subdiv_ccg.c index 521aeb60e66..0ae32701cd5 100644 --- a/source/blender/blenkernel/intern/subdiv_ccg.c +++ b/source/blender/blenkernel/intern/subdiv_ccg.c @@ -1781,7 +1781,7 @@ void BKE_subdiv_ccg_neighbor_coords_get(const SubdivCCG *subdiv_ccg, #endif } -int BKE_subdiv_cgg_grid_to_face_index(const SubdivCCG *subdiv_ccg, const int grid_index) +int BKE_subdiv_ccg_grid_to_face_index(const SubdivCCG *subdiv_ccg, const int grid_index) { // Subdiv *subdiv = subdiv_ccg->subdiv; /* UNUSED */ // OpenSubdiv_TopologyRefiner *topology_refiner = subdiv->topology_refiner; /* UNUSED */ diff --git a/source/blender/editors/sculpt_paint/sculpt.c b/source/blender/editors/sculpt_paint/sculpt.c index 66f66bfceb8..9b00feb1cf8 100644 --- a/source/blender/editors/sculpt_paint/sculpt.c +++ b/source/blender/editors/sculpt_paint/sculpt.c @@ -222,7 +222,7 @@ int SCULPT_active_face_set_get(SculptSession *ss) case PBVH_FACES: return ss->face_sets[ss->active_face_index]; case PBVH_GRIDS: { - const int face_index = BKE_subdiv_cgg_grid_to_face_index(ss->subdiv_ccg, + const int face_index = BKE_subdiv_ccg_grid_to_face_index(ss->subdiv_ccg, ss->active_grid_index); return ss->face_sets[face_index]; } @@ -359,7 +359,7 @@ bool SCULPT_vertex_all_face_sets_visible_get(SculptSession *ss, int index) case PBVH_GRIDS: { const CCGKey *key = BKE_pbvh_get_grid_key(ss->pbvh); const int grid_index = index / key->grid_area; - const int face_index = BKE_subdiv_cgg_grid_to_face_index(ss->subdiv_ccg, grid_index); + const int face_index = BKE_subdiv_ccg_grid_to_face_index(ss->subdiv_ccg, grid_index); return ss->face_sets[face_index] > 0; } } @@ -382,7 +382,7 @@ void SCULPT_vertex_face_set_set(SculptSession *ss, int index, int face_set) case PBVH_GRIDS: { const CCGKey *key = BKE_pbvh_get_grid_key(ss->pbvh); const int grid_index = index / key->grid_area; - const int face_index = BKE_subdiv_cgg_grid_to_face_index(ss->subdiv_ccg, grid_index); + const int face_index = BKE_subdiv_ccg_grid_to_face_index(ss->subdiv_ccg, grid_index); if (ss->face_sets[face_index] > 0) { ss->face_sets[face_index] = abs(face_set); } @@ -409,7 +409,7 @@ int SCULPT_vertex_face_set_get(SculptSession *ss, int index) case PBVH_GRIDS: { const CCGKey *key = BKE_pbvh_get_grid_key(ss->pbvh); const int grid_index = index / key->grid_area; - const int face_index = BKE_subdiv_cgg_grid_to_face_index(ss->subdiv_ccg, grid_index); + const int face_index = BKE_subdiv_ccg_grid_to_face_index(ss->subdiv_ccg, grid_index); return ss->face_sets[face_index]; } } @@ -433,7 +433,7 @@ bool SCULPT_vertex_has_face_set(SculptSession *ss, int index, int face_set) case PBVH_GRIDS: { const CCGKey *key = BKE_pbvh_get_grid_key(ss->pbvh); const int grid_index = index / key->grid_area; - const int face_index = BKE_subdiv_cgg_grid_to_face_index(ss->subdiv_ccg, grid_index); + const int face_index = BKE_subdiv_ccg_grid_to_face_index(ss->subdiv_ccg, grid_index); return ss->face_sets[face_index] == face_set; } } diff --git a/source/blender/gpu/intern/gpu_buffers.c b/source/blender/gpu/intern/gpu_buffers.c index 8b562413ce8..03e0d1829c5 100644 --- a/source/blender/gpu/intern/gpu_buffers.c +++ b/source/blender/gpu/intern/gpu_buffers.c @@ -741,7 +741,7 @@ void GPU_pbvh_grid_buffers_update(GPU_PBVH_Buffers *buffers, uchar face_set_color[4] = {UCHAR_MAX, UCHAR_MAX, UCHAR_MAX, UCHAR_MAX}; if (show_face_sets && subdiv_ccg && sculpt_face_sets) { - const int face_index = BKE_subdiv_cgg_grid_to_face_index(subdiv_ccg, grid_index); + const int face_index = BKE_subdiv_ccg_grid_to_face_index(subdiv_ccg, grid_index); const int fset = abs(sculpt_face_sets[face_index]); /* Skip for the default color Face Set to render it white. */ -- cgit v1.2.3 From 138b0c970efbfb732ddee0530e073537582b6df8 Mon Sep 17 00:00:00 2001 From: Antonio Vazquez Date: Wed, 22 Apr 2020 16:39:44 +0200 Subject: GPencil: Change Thickness Profile icon --- release/scripts/startup/bl_ui/properties_paint_common.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/release/scripts/startup/bl_ui/properties_paint_common.py b/release/scripts/startup/bl_ui/properties_paint_common.py index a13f39da4a9..6be1aa40bf2 100644 --- a/release/scripts/startup/bl_ui/properties_paint_common.py +++ b/release/scripts/startup/bl_ui/properties_paint_common.py @@ -1089,7 +1089,7 @@ def brush_basic_gpencil_paint_settings(layout, context, brush, *, compact=False) settings = context.tool_settings.gpencil_sculpt if compact: row = layout.row(align=True) - row.prop(settings, "use_thickness_curve", text="", icon='CURVE_DATA') + row.prop(settings, "use_thickness_curve", text="", icon='SPHERECURVE') sub = row.row(align=True) sub.active = settings.use_thickness_curve sub.popover( -- cgit v1.2.3 From cf5147f69f0e3c650cf4aadd8515371ce61d27be Mon Sep 17 00:00:00 2001 From: Brecht Van Lommel Date: Wed, 22 Apr 2020 16:27:25 +0200 Subject: Fix T74423: Cycles rendering artifacts with CUDA 10.2 Work around what appears to be a compiler bug, just changing the code a bit without any functional changes. --- intern/cycles/kernel/kernel_jitter.h | 39 ++++++++++++++++++------------------ intern/cycles/kernel/kernel_random.h | 4 +++- 2 files changed, 23 insertions(+), 20 deletions(-) diff --git a/intern/cycles/kernel/kernel_jitter.h b/intern/cycles/kernel/kernel_jitter.h index 5b6e3bbf501..b9c48b86a5d 100644 --- a/intern/cycles/kernel/kernel_jitter.h +++ b/intern/cycles/kernel/kernel_jitter.h @@ -199,32 +199,33 @@ ccl_device float pmj_sample_1D(KernelGlobals *kg, int sample, int rng_hash, int { /* Fallback to random */ if (sample >= NUM_PMJ_SAMPLES) { - int p = rng_hash + dimension; + const int p = rng_hash + dimension; return cmj_randfloat(sample, p); } - uint tmp_rng = cmj_hash_simple(dimension, rng_hash); - int index = ((dimension % NUM_PMJ_PATTERNS) * NUM_PMJ_SAMPLES + sample) * 2; - return __uint_as_float(kernel_tex_fetch(__sample_pattern_lut, index) ^ (tmp_rng & 0x007fffff)) - - 1.0f; + else { + const uint mask = cmj_hash_simple(dimension, rng_hash) & 0x007fffff; + const int index = ((dimension % NUM_PMJ_PATTERNS) * NUM_PMJ_SAMPLES + sample) * 2; + return __uint_as_float(kernel_tex_fetch(__sample_pattern_lut, index) ^ mask) - 1.0f; + } } -ccl_device void pmj_sample_2D( - KernelGlobals *kg, int sample, int rng_hash, int dimension, float *fx, float *fy) +ccl_device float2 pmj_sample_2D(KernelGlobals *kg, int sample, int rng_hash, int dimension) { if (sample >= NUM_PMJ_SAMPLES) { - int p = rng_hash + dimension; - *fx = cmj_randfloat(sample, p); - *fy = cmj_randfloat(sample, p + 1); - return; + const int p = rng_hash + dimension; + const float fx = cmj_randfloat(sample, p); + const float fy = cmj_randfloat(sample, p + 1); + return make_float2(fx, fy); + } + else { + const int index = ((dimension % NUM_PMJ_PATTERNS) * NUM_PMJ_SAMPLES + sample) * 2; + const uint maskx = cmj_hash_simple(dimension, rng_hash) & 0x007fffff; + const uint masky = cmj_hash_simple(dimension + 1, rng_hash) & 0x007fffff; + const float fx = __uint_as_float(kernel_tex_fetch(__sample_pattern_lut, index) ^ maskx) - 1.0f; + const float fy = __uint_as_float(kernel_tex_fetch(__sample_pattern_lut, index + 1) ^ masky) - + 1.0f; + return make_float2(fx, fy); } - uint tmp_rng = cmj_hash_simple(dimension, rng_hash); - int index = ((dimension % NUM_PMJ_PATTERNS) * NUM_PMJ_SAMPLES + sample) * 2; - *fx = __uint_as_float(kernel_tex_fetch(__sample_pattern_lut, index) ^ (tmp_rng & 0x007fffff)) - - 1.0f; - tmp_rng = cmj_hash_simple(dimension + 1, rng_hash); - *fy = __uint_as_float(kernel_tex_fetch(__sample_pattern_lut, index + 1) ^ - (tmp_rng & 0x007fffff)) - - 1.0f; } CCL_NAMESPACE_END diff --git a/intern/cycles/kernel/kernel_random.h b/intern/cycles/kernel/kernel_random.h index f4c3b36e778..a9b17854f25 100644 --- a/intern/cycles/kernel/kernel_random.h +++ b/intern/cycles/kernel/kernel_random.h @@ -102,7 +102,9 @@ ccl_device_forceinline void path_rng_2D(KernelGlobals *kg, return; #endif if (kernel_data.integrator.sampling_pattern == SAMPLING_PATTERN_PMJ) { - pmj_sample_2D(kg, sample, rng_hash, dimension, fx, fy); + const float2 f = pmj_sample_2D(kg, sample, rng_hash, dimension); + *fx = f.x; + *fy = f.y; return; } #ifdef __CMJ__ -- cgit v1.2.3 From 45f8d1783ba8b4adc32f5c39d95d1bc39c37aa5d Mon Sep 17 00:00:00 2001 From: Sergey Sharybin Date: Tue, 21 Apr 2020 12:49:12 +0200 Subject: Cleanup: Fix strict compiler warning --- source/blender/blenkernel/intern/fluid.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/blender/blenkernel/intern/fluid.c b/source/blender/blenkernel/intern/fluid.c index 9709b74516b..a26feb2d06b 100644 --- a/source/blender/blenkernel/intern/fluid.c +++ b/source/blender/blenkernel/intern/fluid.c @@ -3846,7 +3846,7 @@ static void BKE_fluid_modifier_processDomain(FluidModifierData *mmd, prev_guide = manta_has_guiding(mds->fluid, mmd, prev_frame, guide_parent); /* Unused for now. */ - UNUSED_VARS(prev_guide, next_mesh, next_guide); + UNUSED_VARS(has_guide, prev_guide, next_mesh, next_guide); bool with_gdomain; with_gdomain = (mds->guide_source == FLUID_DOMAIN_GUIDE_SRC_DOMAIN); -- cgit v1.2.3