Merge branch '28' into custom-manipulatorscustom-manipulators

1 files changed, 134 insertions, 113 deletions

diff --git a/source/blender/blenkernel/intern/object.c b/source/blender/blenkernel/intern/object.c
index 68e5ddf8583..a47e88a8e48 100644
--- a/source/blender/blenkernel/intern/object.c
+++ b/source/blender/blenkernel/intern/object.c
@@ -319,7 +319,7 @@ void BKE_object_link_modifiers(struct Object *ob_dst, const struct Object *ob_sr
 		modifier_unique_name(&ob_dst->modifiers, nmd);
 	}
 
-	BKE_object_copy_particlesystems(ob_dst, ob_src);
+	BKE_object_copy_particlesystems(ob_dst, ob_src, 0);
 
 	/* TODO: smoke?, cloth? */
 }
@@ -337,14 +337,14 @@ void BKE_object_free_derived_caches(Object *ob)
 		Mesh *me = ob->data;
 
 		if (me && me->bb) {
-			atomic_fetch_and_or_uint32((uint*)&me->bb->flag, BOUNDBOX_DIRTY);
+			atomic_fetch_and_or_uint32((uint *)&me->bb->flag, BOUNDBOX_DIRTY);
 		}
 	}
 	else if (ELEM(ob->type, OB_SURF, OB_CURVE, OB_FONT)) {
 		Curve *cu = ob->data;
 
 		if (cu && cu->bb) {
-			atomic_fetch_and_or_uint32((uint*)&cu->bb->flag, BOUNDBOX_DIRTY);
+			atomic_fetch_and_or_uint32((uint *)&cu->bb->flag, BOUNDBOX_DIRTY);
 		}
 	}
 
@@ -365,6 +365,8 @@ void BKE_object_free_derived_caches(Object *ob)
 	}
 
 	if (ob->mesh_evaluated != NULL) {
+		/* Restore initial pointer. */
+		ob->data = ob->mesh_evaluated->id.newid;
 		/* Evaluated mesh points to edit mesh, but does not own it. */
 		ob->mesh_evaluated->edit_btmesh = NULL;
 		BKE_mesh_free(ob->mesh_evaluated);
@@ -560,6 +562,15 @@ bool BKE_object_is_in_wpaint_select_vert(Object *ob)
 	return false;
 }
 
+/**
+ * Return if the object is visible, as evaluated by depsgraph
+ * Keep in sync with rna_object.c (object.is_visible).
+ */
+bool BKE_object_is_visible(Object *ob)
+{
+	return (ob->base_flag & BASE_VISIBLED) != 0;
+}
+
 bool BKE_object_exists_check(Object *obtest)
 {
 	Object *ob;
@@ -703,7 +714,7 @@ Object *BKE_object_add_only_object(Main *bmain, int type, const char *name)
 	if (!name)
 		name = get_obdata_defname(type);
 
-	ob = BKE_libblock_alloc(bmain, ID_OB, name);
+	ob = BKE_libblock_alloc(bmain, ID_OB, name, 0);
 
 	/* default object vars */
 	ob->type = type;
@@ -832,7 +843,7 @@ static LodLevel *lod_level_select(Object *ob, const float camera_position[3])
 
 bool BKE_object_lod_is_usable(Object *ob, SceneLayer *sl)
 {
-	bool active = (sl) ? ob == OBACT_NEW : false;
+	bool active = (sl) ? ob == OBACT_NEW(sl) : false;
 	return (ob->mode == OB_MODE_OBJECT || !active);
 }
 
@@ -873,7 +884,7 @@ struct Object *BKE_object_lod_matob_get(Object *ob, SceneLayer *sl)
 #endif  /* WITH_GAMEENGINE */
 
 
-SoftBody *copy_softbody(const SoftBody *sb, bool copy_caches)
+SoftBody *copy_softbody(const SoftBody *sb, const int flag)
 {
 	SoftBody *sbn;
 	
@@ -881,7 +892,7 @@ SoftBody *copy_softbody(const SoftBody *sb, bool copy_caches)
 	
 	sbn = MEM_dupallocN(sb);
 
-	if (copy_caches == false) {
+	if ((flag & LIB_ID_COPY_CACHES) == 0) {
 		sbn->totspring = sbn->totpoint = 0;
 		sbn->bpoint = NULL;
 		sbn->bspring = NULL;
@@ -910,7 +921,7 @@ SoftBody *copy_softbody(const SoftBody *sb, bool copy_caches)
 	
 	sbn->scratch = NULL;
 
-	sbn->pointcache = BKE_ptcache_copy_list(&sbn->ptcaches, &sb->ptcaches, copy_caches);
+	sbn->pointcache = BKE_ptcache_copy_list(&sbn->ptcaches, &sb->ptcaches, flag);
 
 	if (sb->effector_weights)
 		sbn->effector_weights = MEM_dupallocN(sb->effector_weights);
@@ -918,7 +929,7 @@ SoftBody *copy_softbody(const SoftBody *sb, bool copy_caches)
 	return sbn;
 }
 
-BulletSoftBody *copy_bulletsoftbody(const BulletSoftBody *bsb)
+BulletSoftBody *copy_bulletsoftbody(const BulletSoftBody *bsb, const int UNUSED(flag))
 {
 	BulletSoftBody *bsbn;
 
@@ -929,7 +940,7 @@ BulletSoftBody *copy_bulletsoftbody(const BulletSoftBody *bsb)
 	return bsbn;
 }
 
-ParticleSystem *BKE_object_copy_particlesystem(ParticleSystem *psys)
+ParticleSystem *BKE_object_copy_particlesystem(ParticleSystem *psys, const int flag)
 {
 	ParticleSystem *psysn;
 	ParticleData *pa;
@@ -966,7 +977,7 @@ ParticleSystem *BKE_object_copy_particlesystem(ParticleSystem *psys)
 
 	if (psys->clmd) {
 		psysn->clmd = (ClothModifierData *)modifier_new(eModifierType_Cloth);
-		modifier_copyData((ModifierData *)psys->clmd, (ModifierData *)psysn->clmd);
+		modifier_copyData_ex((ModifierData *)psys->clmd, (ModifierData *)psysn->clmd, flag);
 		psys->hair_in_dm = psys->hair_out_dm = NULL;
 	}
 
@@ -985,7 +996,8 @@ ParticleSystem *BKE_object_copy_particlesystem(ParticleSystem *psys)
 	BLI_listbase_clear(&psysn->childcachebufs);
 	psysn->renderdata = NULL;
 	
-	psysn->pointcache = BKE_ptcache_copy_list(&psysn->ptcaches, &psys->ptcaches, false);
+	/* XXX Never copy caches here? */
+	psysn->pointcache = BKE_ptcache_copy_list(&psysn->ptcaches, &psys->ptcaches, flag & ~LIB_ID_COPY_CACHES);
 
 	/* XXX - from reading existing code this seems correct but intended usage of
 	 * pointcache should /w cloth should be added in 'ParticleSystem' - campbell */
@@ -993,12 +1005,14 @@ ParticleSystem *BKE_object_copy_particlesystem(ParticleSystem *psys)
 		psysn->clmd->point_cache = psysn->pointcache;
 	}
 
-	id_us_plus((ID *)psysn->part);
+	if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
+		id_us_plus((ID *)psysn->part);
+	}
 
 	return psysn;
 }
 
-void BKE_object_copy_particlesystems(Object *ob_dst, const Object *ob_src)
+void BKE_object_copy_particlesystems(Object *ob_dst, const Object *ob_src, const int flag)
 {
 	ParticleSystem *psys, *npsys;
 	ModifierData *md;
@@ -1010,7 +1024,7 @@ void BKE_object_copy_particlesystems(Object *ob_dst, const Object *ob_src)
 
 	BLI_listbase_clear(&ob_dst->particlesystem);
 	for (psys = ob_src->particlesystem.first; psys; psys = psys->next) {
-		npsys = BKE_object_copy_particlesystem(psys);
+		npsys = BKE_object_copy_particlesystem(psys, flag);
 
 		BLI_addtail(&ob_dst->particlesystem, npsys);
 
@@ -1047,23 +1061,25 @@ void BKE_object_copy_softbody(Object *ob_dst, const Object *ob_src)
 {
 	if (ob_src->soft) {
 		ob_dst->softflag = ob_src->softflag;
-		ob_dst->soft = copy_softbody(ob_src->soft, false);
+		ob_dst->soft = copy_softbody(ob_src->soft, 0);
 	}
 }
 
-static void copy_object_pose(Object *obn, const Object *ob)
+static void copy_object_pose(Object *obn, const Object *ob, const int flag)
 {
 	bPoseChannel *chan;
 	
 	/* note: need to clear obn->pose pointer first, so that BKE_pose_copy_data works (otherwise there's a crash) */
 	obn->pose = NULL;
-	BKE_pose_copy_data(&obn->pose, ob->pose, 1);    /* 1 = copy constraints */
+	BKE_pose_copy_data_ex(&obn->pose, ob->pose, flag, true);  /* true = copy constraints */
 
 	for (chan = obn->pose->chanbase.first; chan; chan = chan->next) {
 		bConstraint *con;
 		
 		chan->flag &= ~(POSE_LOC | POSE_ROT | POSE_SIZE);
 		
+		/* XXX Remapping object pointing onto itself should be handled by generic BKE_library_remap stuff, but...
+		 *     the flush_constraint_targets callback am not sure about, so will delay that for now. */
 		for (con = chan->constraints.first; con; con = con->next) {
 			const bConstraintTypeInfo *cti = BKE_constraint_typeinfo_get(con);
 			ListBase targets = {NULL, NULL};
@@ -1084,13 +1100,10 @@ static void copy_object_pose(Object *obn, const Object *ob)
 	}
 }
 
-static void copy_object_lod(Object *obn, const Object *ob)
+static void copy_object_lod(Object *obn, const Object *ob, const int UNUSED(flag))
 {
 	BLI_duplicatelist(&obn->lodlevels, &ob->lodlevels);
 
-	if (obn->lodlevels.first)
-		((LodLevel *)obn->lodlevels.first)->source = obn;
-
 	obn->currentlod = (LodLevel *)obn->lodlevels.first;
 }
 
@@ -1135,100 +1148,101 @@ void BKE_object_transform_copy(Object *ob_tar, const Object *ob_src)
 	copy_v3_v3(ob_tar->size, ob_src->size);
 }
 
-Object *BKE_object_copy_ex(Main *bmain, const Object *ob, bool copy_caches)
+/**
+ * Only copy internal data of Object ID from source to already allocated/initialized destination.
+ * You probably nerver want to use that directly, use id_copy or BKE_id_copy_ex for typical needs.
+ *
+ * WARNING! This function will not handle ID user count!
+ *
+ * \param flag  Copying options (see BKE_library.h's LIB_ID_COPY_... flags for more).
+ */
+void BKE_object_copy_data(Main *UNUSED(bmain), Object *ob_dst, const Object *ob_src, const int flag)
 {
-	Object *obn;
 	ModifierData *md;
-	int a;
 
-	obn = BKE_libblock_copy(bmain, &ob->id);
-	
-	if (ob->totcol) {
-		obn->mat = MEM_dupallocN(ob->mat);
-		obn->matbits = MEM_dupallocN(ob->matbits);
-		obn->totcol = ob->totcol;
+	/* We never handle usercount here for own data. */
+	const int flag_subdata = flag | LIB_ID_CREATE_NO_USER_REFCOUNT;
+
+	if (ob_src->totcol) {
+		ob_dst->mat = MEM_dupallocN(ob_src->mat);
+		ob_dst->matbits = MEM_dupallocN(ob_src->matbits);
+		ob_dst->totcol = ob_src->totcol;
 	}
 
-	if (ob->iuser) obn->iuser = MEM_dupallocN(ob->iuser);
+	if (ob_src->iuser) ob_dst->iuser = MEM_dupallocN(ob_src->iuser);
 	
-	if (ob->bb) obn->bb = MEM_dupallocN(ob->bb);
-	obn->flag &= ~OB_FROMGROUP;
+	if (ob_src->bb) ob_dst->bb = MEM_dupallocN(ob_src->bb);
+	ob_dst->flag &= ~OB_FROMGROUP;
 	
-	BLI_listbase_clear(&obn->modifiers);
+	BLI_listbase_clear(&ob_dst->modifiers);
 	
-	for (md = ob->modifiers.first; md; md = md->next) {
+	for (md = ob_src->modifiers.first; md; md = md->next) {
 		ModifierData *nmd = modifier_new(md->type);
 		BLI_strncpy(nmd->name, md->name, sizeof(nmd->name));
-		modifier_copyData(md, nmd);
-		BLI_addtail(&obn->modifiers, nmd);
+		modifier_copyData_ex(md, nmd, flag_subdata);
+		BLI_addtail(&ob_dst->modifiers, nmd);
 	}
 
-	BLI_listbase_clear(&obn->prop);
-	BKE_bproperty_copy_list(&obn->prop, &ob->prop);
+	BLI_listbase_clear(&ob_dst->prop);
+	BKE_bproperty_copy_list(&ob_dst->prop, &ob_src->prop);
 
-	BKE_sca_logic_copy(obn, ob);
+	BKE_sca_logic_copy(ob_dst, ob_src, flag_subdata);
 
-	if (ob->pose) {
-		copy_object_pose(obn, ob);
+	if (ob_src->pose) {
+		copy_object_pose(ob_dst, ob_src, flag_subdata);
 		/* backwards compat... non-armatures can get poses in older files? */
-		if (ob->type == OB_ARMATURE)
-			BKE_pose_rebuild(obn, obn->data);
+		if (ob_src->type == OB_ARMATURE)
+			BKE_pose_rebuild(ob_dst, ob_dst->data);
 	}
-	defgroup_copy_list(&obn->defbase, &ob->defbase);
-	BKE_object_facemap_copy_list(&obn->fmaps, &ob->fmaps);
-	BKE_constraints_copy(&obn->constraints, &ob->constraints, true);
+	defgroup_copy_list(&ob_dst->defbase, &ob_src->defbase);
+	BKE_object_facemap_copy_list(&ob_dst->fmaps, &ob_src->fmaps);
+	BKE_constraints_copy_ex(&ob_dst->constraints, &ob_src->constraints, flag_subdata, true);
 
-	obn->mode = OB_MODE_OBJECT;
-	obn->sculpt = NULL;
+	ob_dst->mode = OB_MODE_OBJECT;
+	ob_dst->sculpt = NULL;
 
-	/* increase user numbers */
-	id_us_plus((ID *)obn->data);
-	id_us_plus((ID *)obn->poselib);
-	id_us_plus((ID *)obn->gpd);
-	id_us_plus((ID *)obn->dup_group);
+	if (ob_src->pd) {
+		ob_dst->pd = MEM_dupallocN(ob_src->pd);
+		if (ob_dst->pd->rng) {
+			ob_dst->pd->rng = MEM_dupallocN(ob_src->pd->rng);
+		}
+	}
+	ob_dst->soft = copy_softbody(ob_src->soft, flag_subdata);
+	ob_dst->bsoft = copy_bulletsoftbody(ob_src->bsoft, flag_subdata);
+	ob_dst->rigidbody_object = BKE_rigidbody_copy_object(ob_src, flag_subdata);
+	ob_dst->rigidbody_constraint = BKE_rigidbody_copy_constraint(ob_src, flag_subdata);
 
-	for (a = 0; a < obn->totcol; a++) id_us_plus((ID *)obn->mat[a]);
+	BKE_object_copy_particlesystems(ob_dst, ob_src, flag_subdata);
 	
-	if (ob->pd) {
-		obn->pd = MEM_dupallocN(ob->pd);
-		if (obn->pd->tex)
-			id_us_plus(&(obn->pd->tex->id));
-		if (obn->pd->rng)
-			obn->pd->rng = MEM_dupallocN(ob->pd->rng);
-	}
-	obn->soft = copy_softbody(ob->soft, copy_caches);
-	obn->bsoft = copy_bulletsoftbody(ob->bsoft);
-	obn->rigidbody_object = BKE_rigidbody_copy_object(ob);
-	obn->rigidbody_constraint = BKE_rigidbody_copy_constraint(ob);
-
-	BKE_object_copy_particlesystems(obn, ob);
-	
-	obn->derivedDeform = NULL;
-	obn->derivedFinal = NULL;
+	ob_dst->derivedDeform = NULL;
+	ob_dst->derivedFinal = NULL;
 
-	BLI_listbase_clear(&obn->gpulamp);
-	BLI_listbase_clear(&obn->pc_ids);
-	BLI_listbase_clear(&obn->drawdata);
+	BLI_listbase_clear(&ob_dst->gpulamp);
+	BLI_listbase_clear(&ob_dst->drawdata);
+	BLI_listbase_clear(&ob_dst->pc_ids);
 
-	obn->mpath = NULL;
+	ob_dst->mpath = NULL;
 
-	copy_object_lod(obn, ob);
+	copy_object_lod(ob_dst, ob_src, flag_subdata);
 	
-	/* Copy runtime surve data. */
-	obn->curve_cache = NULL;
-
-	BKE_id_copy_ensure_local(bmain, &ob->id, &obn->id);
+	/* Do not copy runtime curve data. */
+	ob_dst->curve_cache = NULL;
 
 	/* Do not copy object's preview (mostly due to the fact renderers create temp copy of objects). */
-	obn->preview = NULL;
-
-	return obn;
+	if ((flag & LIB_ID_COPY_NO_PREVIEW) == 0 && false) {  /* XXX TODO temp hack */
+		BKE_previewimg_id_copy(&ob_dst->id, &ob_src->id);
+	}
+	else {
+		ob_dst->preview = NULL;
+	}
 }
 
 /* copy objects, will re-initialize cached simulation data */
 Object *BKE_object_copy(Main *bmain, const Object *ob)
 {
-	return BKE_object_copy_ex(bmain, ob, false);
+	Object *ob_copy;
+	BKE_id_copy_ex(bmain, &ob->id, (ID **)&ob_copy, 0, false);
+	return ob_copy;
 }
 
 void BKE_object_make_local_ex(Main *bmain, Object *ob, const bool lib_local, const bool clear_proxy)
@@ -1304,10 +1318,10 @@ static void armature_set_id_extern(Object *ob)
 	unsigned int lay = arm->layer_protected;
 	
 	for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
-		if (!(pchan->bone->layer & lay)) {
+		if (!(pchan->bone->layer & lay))
 			id_lib_extern((ID *)pchan->custom);
-		}
 	}
+			
 }
 
 void BKE_object_copy_proxy_drivers(Object *ob, Object *target)
@@ -1426,7 +1440,7 @@ void BKE_object_make_proxy(Object *ob, Object *target, Object *gob)
 	
 	/* type conversions */
 	if (target->type == OB_ARMATURE) {
-		copy_object_pose(ob, target);   /* data copy, object pointers in constraints */
+		copy_object_pose(ob, target, 0);   /* data copy, object pointers in constraints */
 		BKE_pose_rest(ob->pose);            /* clear all transforms in channels */
 		BKE_pose_rebuild(ob, ob->data); /* set all internal links */
 		
@@ -1709,13 +1723,16 @@ static bool ob_parcurve(Scene *scene, Object *ob, Object *par, float mat[4][4])
 	Curve *cu = par->data;
 	float vec[4], dir[3], quat[4], radius, ctime;
 
+	/* TODO: Make sure this doesn't crash. */
+#if 0
 	/* only happens on reload file, but violates depsgraph still... fix! */
 	if (par->curve_cache == NULL) {
 		if (scene == NULL) {
 			return false;
 		}
-		BKE_displist_make_curveTypes(scene, par, 0);
+		BKE_displist_make_curveTypes(eval_ctx, scene, par, 0);
 	}
+#endif
 
 	if (par->curve_cache->path == NULL) {
 		return false;
@@ -2096,8 +2113,9 @@ static bool where_is_object_parslow(Object *ob, float obmat[4][4], float slowmat
 }
 
 /* note, scene is the active scene while actual_scene is the scene the object resides in */
-void BKE_object_where_is_calc_time_ex(Scene *scene, Object *ob, float ctime,
-                                      RigidBodyWorld *rbw, float r_originmat[3][3])
+void BKE_object_where_is_calc_time_ex(
+        const EvaluationContext *eval_ctx, Scene *scene, Object *ob, float ctime,
+        RigidBodyWorld *rbw, float r_originmat[3][3])
 {
 	if (ob == NULL) return;
 	
@@ -2132,7 +2150,7 @@ void BKE_object_where_is_calc_time_ex(Scene *scene, Object *ob, float ctime,
 	if (ob->constraints.first && !(ob->transflag & OB_NO_CONSTRAINTS)) {
 		bConstraintOb *cob;
 		cob = BKE_constraints_make_evalob(scene, ob, NULL, CONSTRAINT_OBTYPE_OBJECT);
-		BKE_constraints_solve(&ob->constraints, cob, ctime);
+		BKE_constraints_solve(eval_ctx, &ob->constraints, cob, ctime);
 		BKE_constraints_clear_evalob(cob);
 	}
 	
@@ -2141,9 +2159,9 @@ void BKE_object_where_is_calc_time_ex(Scene *scene, Object *ob, float ctime,
 	else ob->transflag &= ~OB_NEG_SCALE;
 }
 
-void BKE_object_where_is_calc_time(Scene *scene, Object *ob, float ctime)
+void BKE_object_where_is_calc_time(const EvaluationContext *eval_ctx, Scene *scene, Object *ob, float ctime)
 {
-	BKE_object_where_is_calc_time_ex(scene, ob, ctime, NULL, NULL);
+	BKE_object_where_is_calc_time_ex(eval_ctx, scene, ob, ctime, NULL, NULL);
 }
 
 /* get object transformation matrix without recalculating dependencies and
@@ -2168,17 +2186,17 @@ void BKE_object_where_is_calc_mat4(Scene *scene, Object *ob, float obmat[4][4])
 	}
 }
 
-void BKE_object_where_is_calc_ex(Scene *scene, RigidBodyWorld *rbw, Object *ob, float r_originmat[3][3])
+void BKE_object_where_is_calc_ex(const EvaluationContext *eval_ctx, Scene *scene, RigidBodyWorld *rbw, Object *ob, float r_originmat[3][3])
 {
-	BKE_object_where_is_calc_time_ex(scene, ob, BKE_scene_frame_get(scene), rbw, r_originmat);
+	BKE_object_where_is_calc_time_ex(eval_ctx, scene, ob, BKE_scene_frame_get(scene), rbw, r_originmat);
 }
-void BKE_object_where_is_calc(Scene *scene, Object *ob)
+void BKE_object_where_is_calc(const EvaluationContext *eval_ctx, Scene *scene, Object *ob)
 {
-	BKE_object_where_is_calc_time_ex(scene, ob, BKE_scene_frame_get(scene), NULL, NULL);
+	BKE_object_where_is_calc_time_ex(eval_ctx, scene, ob, BKE_scene_frame_get(scene), NULL, NULL);
 }
 
 /* for calculation of the inverse parent transform, only used for editor */
-void BKE_object_workob_calc_parent(Scene *scene, Object *ob, Object *workob)
+void BKE_object_workob_calc_parent(const EvaluationContext *eval_ctx, Scene *scene, Object *ob, Object *workob)
 {
 	BKE_object_workob_clear(workob);
 	
@@ -2200,7 +2218,7 @@ void BKE_object_workob_calc_parent(Scene *scene, Object *ob, Object *workob)
 
 	BLI_strncpy(workob->parsubstr, ob->parsubstr, sizeof(workob->parsubstr));
 
-	BKE_object_where_is_calc(scene, workob);
+	BKE_object_where_is_calc(eval_ctx, scene, workob);
 }
 
 /* see BKE_pchan_apply_mat4() for the equivalent 'pchan' function */
@@ -2531,7 +2549,7 @@ void BKE_scene_foreach_display_point(
 	Base *base;
 	Object *ob;
 
-	for (base = FIRSTBASE_NEW; base; base = base->next) {
+	for (base = FIRSTBASE_NEW(sl); base; base = base->next) {
 		if (((base->flag & BASE_VISIBLED) != 0) && ((base->flag & BASE_SELECTED) != 0)) {
 			ob = base->object;
 
@@ -2630,7 +2648,7 @@ bool BKE_object_parent_loop_check(const Object *par, const Object *ob)
 /* the main object update call, for object matrix, constraints, keys and displist (modifiers) */
 /* requires flags to be set! */
 /* Ideally we shouldn't have to pass the rigid body world, but need bigger restructuring to avoid id */
-void BKE_object_handle_update_ex(EvaluationContext *eval_ctx,
+void BKE_object_handle_update_ex(const EvaluationContext *eval_ctx,
                                  Scene *scene, Object *ob,
                                  RigidBodyWorld *rbw,
                                  const bool do_proxy_update)
@@ -2679,7 +2697,7 @@ void BKE_object_handle_update_ex(EvaluationContext *eval_ctx,
 					copy_m4_m4(ob->obmat, ob->proxy_from->obmat);
 			}
 			else
-				BKE_object_where_is_calc_ex(scene, rbw, ob, NULL);
+				BKE_object_where_is_calc_ex(eval_ctx, scene, rbw, ob, NULL);
 		}
 		
 		if (ob->recalc & OB_RECALC_DATA) {
@@ -2709,7 +2727,7 @@ void BKE_object_handle_update_ex(EvaluationContext *eval_ctx,
  * e.g. "scene" <-- set 1 <-- set 2 ("ob" lives here) <-- set 3 <-- ... <-- set n
  * rigid bodies depend on their world so use BKE_object_handle_update_ex() to also pass along the corrent rigid body world
  */
-void BKE_object_handle_update(EvaluationContext *eval_ctx, Scene *scene, Object *ob)
+void BKE_object_handle_update(const EvaluationContext *eval_ctx, Scene *scene, Object *ob)
 {
 	BKE_object_handle_update_ex(eval_ctx, scene, ob, NULL, true);
 }
@@ -2718,7 +2736,7 @@ void BKE_object_sculpt_modifiers_changed(Object *ob)
 {
 	SculptSession *ss = ob->sculpt;
 
-	if (ss) {
+	if (ss && ss->building_vp_handle == false) {
 		if (!ss->cache) {
 			/* we free pbvh on changes, except during sculpt since it can't deal with
 			 * changing PVBH node organization, we hope topology does not change in
@@ -2729,6 +2747,9 @@ void BKE_object_sculpt_modifiers_changed(Object *ob)
 			}
 
 			BKE_sculptsession_free_deformMats(ob->sculpt);
+
+			/* In vertex/weight paint, force maps to be rebuilt. */
+			BKE_sculptsession_free_vwpaint_data(ob->sculpt);
 		}
 		else {
 			PBVHNode **nodes;
@@ -3625,9 +3646,9 @@ static void object_cacheIgnoreClear(Object *ob, int state)
 /* Note: this function should eventually be replaced by depsgraph functionality.
  * Avoid calling this in new code unless there is a very good reason for it!
  */
-bool BKE_object_modifier_update_subframe(Scene *scene, Object *ob, bool update_mesh,
-                                         int parent_recursion, float frame,
-                                         int type)
+bool BKE_object_modifier_update_subframe(
+        const EvaluationContext *eval_ctx, Scene *scene, Object *ob, bool update_mesh,
+        int parent_recursion, float frame, int type)
 {
 	ModifierData *md = modifiers_findByType(ob, (ModifierType)type);
 	bConstraint *con;
@@ -3650,8 +3671,8 @@ bool BKE_object_modifier_update_subframe(Scene *scene, Object *ob, bool update_m
 	if (parent_recursion) {
 		int recursion = parent_recursion - 1;
 		bool no_update = false;
-		if (ob->parent) no_update |= BKE_object_modifier_update_subframe(scene, ob->parent, 0, recursion, frame, type);
-		if (ob->track) no_update |= BKE_object_modifier_update_subframe(scene, ob->track, 0, recursion, frame, type);
+		if (ob->parent) no_update |= BKE_object_modifier_update_subframe(eval_ctx, scene, ob->parent, 0, recursion, frame, type);
+		if (ob->track) no_update |= BKE_object_modifier_update_subframe(eval_ctx, scene, ob->track, 0, recursion, frame, type);
 
 		/* skip subframe if object is parented
 		 *  to vertex of a dynamic paint canvas */
@@ -3668,7 +3689,7 @@ bool BKE_object_modifier_update_subframe(Scene *scene, Object *ob, bool update_m
 				cti->get_constraint_targets(con, &targets);
 				for (ct = targets.first; ct; ct = ct->next) {
 					if (ct->tar)
-						BKE_object_modifier_update_subframe(scene, ct->tar, 0, recursion, frame, type);
+						BKE_object_modifier_update_subframe(eval_ctx, scene, ct->tar, 0, recursion, frame, type);
 				}
 				/* free temp targets */
 				if (cti->flush_constraint_targets)
@@ -3688,7 +3709,7 @@ bool BKE_object_modifier_update_subframe(Scene *scene, Object *ob, bool update_m
 		object_cacheIgnoreClear(ob, 0);
 	}
 	else
-		BKE_object_where_is_calc_time(scene, ob, frame);
+		BKE_object_where_is_calc_time(eval_ctx, scene, ob, frame);
 
 	/* for curve following objects, parented curve has to be updated too */
 	if (ob->type == OB_CURVE) {
@@ -3699,7 +3720,7 @@ bool BKE_object_modifier_update_subframe(Scene *scene, Object *ob, bool update_m
 	if (ob->type == OB_ARMATURE) {
 		bArmature *arm = ob->data;
 		BKE_animsys_evaluate_animdata(scene, &arm->id, arm->adt, frame, ADT_RECALC_ANIM);
-		BKE_pose_where_is(scene, ob);
+		BKE_pose_where_is(eval_ctx, scene, ob);
 	}
 
 	return false;