Fix crash when making objects to share same mesh
Make it more reliable and predictable way of getting pointer to an original mesh which came from copy-on-write engine. Related change: made it (hopefully) more clear name for flags.
This commit is contained in:
		@@ -2790,7 +2790,7 @@ static void editbmesh_calc_modifiers(
 | 
			
		||||
			}
 | 
			
		||||
			else {
 | 
			
		||||
				struct Mesh *mesh = ob->data;
 | 
			
		||||
				if (mesh->id.tag & LIB_TAG_COPY_ON_WRITE) {
 | 
			
		||||
				if (mesh->id.tag & LIB_TAG_COPIED_ON_WRITE) {
 | 
			
		||||
					BKE_mesh_runtime_ensure_edit_data(mesh);
 | 
			
		||||
					mesh->runtime.edit_data->vertexCos = MEM_dupallocN(deformedVerts);
 | 
			
		||||
				}
 | 
			
		||||
@@ -2832,7 +2832,7 @@ static void editbmesh_calc_modifiers(
 | 
			
		||||
	else {
 | 
			
		||||
		/* this is just a copy of the editmesh, no need to calc normals */
 | 
			
		||||
		struct Mesh *mesh = ob->data;
 | 
			
		||||
		if (mesh->id.tag & LIB_TAG_COPY_ON_WRITE) {
 | 
			
		||||
		if (mesh->id.tag & LIB_TAG_COPIED_ON_WRITE) {
 | 
			
		||||
			BKE_mesh_runtime_ensure_edit_data(mesh);
 | 
			
		||||
			if (mesh->runtime.edit_data->vertexCos != NULL)
 | 
			
		||||
				MEM_freeN((void *)mesh->runtime.edit_data->vertexCos);
 | 
			
		||||
@@ -2943,18 +2943,14 @@ static void mesh_finalize_eval(Object *object)
 | 
			
		||||
	if (mesh_eval->mat != NULL) {
 | 
			
		||||
		MEM_freeN(mesh_eval->mat);
 | 
			
		||||
	}
 | 
			
		||||
	/* Set flag which makes it easier to see what's going on in a debugger. */
 | 
			
		||||
	mesh_eval->id.tag |= LIB_TAG_COPIED_ON_WRITE_EVAL_RESULT;
 | 
			
		||||
	mesh_eval->mat = MEM_dupallocN(mesh->mat);
 | 
			
		||||
	mesh_eval->totcol = mesh->totcol;
 | 
			
		||||
	/* Make evaluated mesh to share same edit mesh pointer as original
 | 
			
		||||
	 * and copied meshes.
 | 
			
		||||
	 */
 | 
			
		||||
	mesh_eval->edit_btmesh = mesh->edit_btmesh;
 | 
			
		||||
	/* Special flags to help debugging and also to allow copy-on-write core
 | 
			
		||||
	 * to understand that on re-evaluation this mesh is to be preserved and
 | 
			
		||||
	 * to be remapped back to copied original mesh when used as object data.
 | 
			
		||||
	 */
 | 
			
		||||
	mesh_eval->id.tag |= LIB_TAG_COPY_ON_WRITE_EVAL;
 | 
			
		||||
	mesh_eval->id.orig_id = &mesh->id;
 | 
			
		||||
	/* Copy autosmooth settings from original mesh.
 | 
			
		||||
	 * This is not done by BKE_mesh_new_nomain_from_template(), so need to take
 | 
			
		||||
	 * extra care here.
 | 
			
		||||
@@ -2970,7 +2966,7 @@ static void mesh_finalize_eval(Object *object)
 | 
			
		||||
 | 
			
		||||
	/* Object is sometimes not evaluated!
 | 
			
		||||
	 * TODO(sergey): BAD TEMPORARY HACK FOR UNTIL WE ARE SMARTER */
 | 
			
		||||
	if (object->id.tag & LIB_TAG_COPY_ON_WRITE) {
 | 
			
		||||
	if (object->id.tag & LIB_TAG_COPIED_ON_WRITE) {
 | 
			
		||||
		object->data = mesh_eval;
 | 
			
		||||
	}
 | 
			
		||||
	else {
 | 
			
		||||
 
 | 
			
		||||
@@ -1057,7 +1057,7 @@ void BKE_lattice_modifiers_calc(struct Depsgraph *depsgraph, Scene *scene, Objec
 | 
			
		||||
		modifier_deformVerts_DM_deprecated(md, &mectx, NULL, vertexCos, numVerts);
 | 
			
		||||
	}
 | 
			
		||||
 | 
			
		||||
	if (ob->id.tag & LIB_TAG_COPY_ON_WRITE) {
 | 
			
		||||
	if (ob->id.tag & LIB_TAG_COPIED_ON_WRITE) {
 | 
			
		||||
		if (vertexCos) {
 | 
			
		||||
			BKE_lattice_vertexcos_apply(ob, vertexCos);
 | 
			
		||||
			MEM_freeN(vertexCos);
 | 
			
		||||
 
 | 
			
		||||
@@ -344,7 +344,9 @@ void BKE_object_free_derived_caches(Object *ob)
 | 
			
		||||
	if (ob->runtime.mesh_eval != NULL) {
 | 
			
		||||
		Mesh *mesh_eval = ob->runtime.mesh_eval;
 | 
			
		||||
		/* Restore initial pointer. */
 | 
			
		||||
		ob->data = mesh_eval->id.orig_id;
 | 
			
		||||
		if (ob->data == mesh_eval) {
 | 
			
		||||
			ob->data = ob->runtime.mesh_orig;
 | 
			
		||||
		}
 | 
			
		||||
		/* Evaluated mesh points to edit mesh, but does not own it. */
 | 
			
		||||
		mesh_eval->edit_btmesh = NULL;
 | 
			
		||||
		BKE_mesh_free(mesh_eval);
 | 
			
		||||
 
 | 
			
		||||
@@ -311,7 +311,7 @@ ID *DepsgraphNodeBuilder::get_cow_id(const ID *id_orig) const
 | 
			
		||||
 | 
			
		||||
ID *DepsgraphNodeBuilder::ensure_cow_id(ID *id_orig)
 | 
			
		||||
{
 | 
			
		||||
	if (id_orig->tag & LIB_TAG_COPY_ON_WRITE) {
 | 
			
		||||
	if (id_orig->tag & LIB_TAG_COPIED_ON_WRITE) {
 | 
			
		||||
		/* ID is already remapped to copy-on-write. */
 | 
			
		||||
		return id_orig;
 | 
			
		||||
	}
 | 
			
		||||
 
 | 
			
		||||
@@ -310,7 +310,7 @@ IDDepsNode *Depsgraph::find_id_node(const ID *id) const
 | 
			
		||||
 | 
			
		||||
IDDepsNode *Depsgraph::add_id_node(ID *id, ID *id_cow_hint)
 | 
			
		||||
{
 | 
			
		||||
	BLI_assert((id->tag & LIB_TAG_COPY_ON_WRITE) == 0);
 | 
			
		||||
	BLI_assert((id->tag & LIB_TAG_COPIED_ON_WRITE) == 0);
 | 
			
		||||
	IDDepsNode *id_node = find_id_node(id);
 | 
			
		||||
	if (!id_node) {
 | 
			
		||||
		DepsNodeFactory *factory = deg_type_get_factory(DEG_NODE_TYPE_ID_REF);
 | 
			
		||||
@@ -500,7 +500,7 @@ ID *Depsgraph::get_cow_id(const ID *id_orig) const
 | 
			
		||||
		 * We try to enforce that in debug builds, for for release we play a bit
 | 
			
		||||
		 * safer game here.
 | 
			
		||||
		 */
 | 
			
		||||
		if ((id_orig->tag & LIB_TAG_COPY_ON_WRITE) == 0) {
 | 
			
		||||
		if ((id_orig->tag & LIB_TAG_COPIED_ON_WRITE) == 0) {
 | 
			
		||||
			/* TODO(sergey): This is nice sanity check to have, but it fails
 | 
			
		||||
			 * in following situations:
 | 
			
		||||
			 *
 | 
			
		||||
 
 | 
			
		||||
@@ -240,6 +240,6 @@ ID *DEG_get_original_id(ID *id)
 | 
			
		||||
	if (id->orig_id == NULL) {
 | 
			
		||||
		return id;
 | 
			
		||||
	}
 | 
			
		||||
	BLI_assert((id->tag & LIB_TAG_COPY_ON_WRITE) != 0);
 | 
			
		||||
	BLI_assert((id->tag & LIB_TAG_COPIED_ON_WRITE) != 0);
 | 
			
		||||
	return (ID *)id->orig_id;
 | 
			
		||||
}
 | 
			
		||||
 
 | 
			
		||||
@@ -542,6 +542,7 @@ void update_special_pointers(const Depsgraph *depsgraph,
 | 
			
		||||
			BLI_assert(object_cow->derivedDeform == NULL);
 | 
			
		||||
			object_cow->mode = object_orig->mode;
 | 
			
		||||
			object_cow->sculpt = object_orig->sculpt;
 | 
			
		||||
			object_cow->runtime.mesh_orig = (Mesh *)object_cow->data;
 | 
			
		||||
			if (object_cow->type == OB_ARMATURE) {
 | 
			
		||||
				BKE_pose_remap_bone_pointers((bArmature *)object_cow->data,
 | 
			
		||||
				                             object_cow->pose);
 | 
			
		||||
@@ -724,12 +725,12 @@ static void deg_backup_object_runtime(
 | 
			
		||||
	Mesh *mesh_eval = object->runtime.mesh_eval;
 | 
			
		||||
	object_runtime_backup->runtime = object->runtime;
 | 
			
		||||
	BKE_object_runtime_reset(object);
 | 
			
		||||
	/* Currently object update will override actual object->data
 | 
			
		||||
	 * to an evaluated version. Need to make sure we don't have
 | 
			
		||||
	 * data set to evaluated one before free anything.
 | 
			
		||||
	/* Object update will override actual object->data to an evaluated version.
 | 
			
		||||
	 * Need to make sure we don't have data set to evaluated one before free
 | 
			
		||||
	 * anything.
 | 
			
		||||
	 */
 | 
			
		||||
	if (mesh_eval != NULL && object->data == mesh_eval) {
 | 
			
		||||
		object->data = mesh_eval->id.orig_id;
 | 
			
		||||
		object->data = object->runtime.mesh_orig;
 | 
			
		||||
	}
 | 
			
		||||
	/* Store curve cache and make sure we don't free it. */
 | 
			
		||||
	object_runtime_backup->curve_cache = object->curve_cache;
 | 
			
		||||
@@ -742,20 +743,33 @@ static void deg_restore_object_runtime(
 | 
			
		||||
        Object *object,
 | 
			
		||||
        const ObjectRuntimeBackup *object_runtime_backup)
 | 
			
		||||
{
 | 
			
		||||
	Mesh *mesh_orig = object->runtime.mesh_orig;
 | 
			
		||||
	object->runtime = object_runtime_backup->runtime;
 | 
			
		||||
	object->runtime.mesh_orig = mesh_orig;
 | 
			
		||||
	if (object->runtime.mesh_eval != NULL) {
 | 
			
		||||
		Mesh *mesh_eval = object->runtime.mesh_eval;
 | 
			
		||||
		/* Do same thing as object update: override actual object data
 | 
			
		||||
		 * pointer with evaluated datablock.
 | 
			
		||||
		 */
 | 
			
		||||
		if (object->type == OB_MESH) {
 | 
			
		||||
			object->data = mesh_eval;
 | 
			
		||||
			/* Evaluated mesh simply copied edit_btmesh pointer from
 | 
			
		||||
			 * original mesh during update, need to make sure no dead
 | 
			
		||||
			 * pointers are left behind.
 | 
			
		||||
		if (object->id.recalc & ID_RECALC_GEOMETRY) {
 | 
			
		||||
			/* If geometry is tagged for update it means, that part of
 | 
			
		||||
			 * evaluated mesh are not valid anymore. In this case we can not
 | 
			
		||||
			 * have any "persistent" pointers to point to an invalid data.
 | 
			
		||||
			 *
 | 
			
		||||
			 * We restore object's data datablock to an original copy of
 | 
			
		||||
			 * that datablock.
 | 
			
		||||
			 */
 | 
			
		||||
			Mesh *mesh = ((Mesh *)mesh_eval->id.orig_id);
 | 
			
		||||
			mesh_eval->edit_btmesh = mesh->edit_btmesh;
 | 
			
		||||
			object->data = mesh_orig;
 | 
			
		||||
		}
 | 
			
		||||
		else {
 | 
			
		||||
			Mesh *mesh_eval = object->runtime.mesh_eval;
 | 
			
		||||
			/* Do same thing as object update: override actual object data
 | 
			
		||||
			 * pointer with evaluated datablock.
 | 
			
		||||
			 */
 | 
			
		||||
			if (object->type == OB_MESH) {
 | 
			
		||||
				object->data = mesh_eval;
 | 
			
		||||
				/* Evaluated mesh simply copied edit_btmesh pointer from
 | 
			
		||||
				 * original mesh during update, need to make sure no dead
 | 
			
		||||
				 * pointers are left behind.
 | 
			
		||||
				*/
 | 
			
		||||
				mesh_eval->edit_btmesh = mesh_orig->edit_btmesh;
 | 
			
		||||
			}
 | 
			
		||||
		}
 | 
			
		||||
	}
 | 
			
		||||
	if (object_runtime_backup->curve_cache != NULL) {
 | 
			
		||||
@@ -995,8 +1009,8 @@ bool deg_validate_copy_on_write_datablock(ID *id_cow)
 | 
			
		||||
void deg_tag_copy_on_write_id(ID *id_cow, const ID *id_orig)
 | 
			
		||||
{
 | 
			
		||||
	BLI_assert(id_cow != id_orig);
 | 
			
		||||
	BLI_assert((id_orig->tag & LIB_TAG_COPY_ON_WRITE) == 0);
 | 
			
		||||
	id_cow->tag |= LIB_TAG_COPY_ON_WRITE;
 | 
			
		||||
	BLI_assert((id_orig->tag & LIB_TAG_COPIED_ON_WRITE) == 0);
 | 
			
		||||
	id_cow->tag |= LIB_TAG_COPIED_ON_WRITE;
 | 
			
		||||
	id_cow->orig_id = (ID *)id_orig;
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
 
 | 
			
		||||
@@ -467,8 +467,8 @@ enum {
 | 
			
		||||
	LIB_TAG_PRE_EXISTING    = 1 << 11,
 | 
			
		||||
 | 
			
		||||
	/* The datablock is a copy-on-write/localized version. */
 | 
			
		||||
	LIB_TAG_COPY_ON_WRITE   = 1 << 12,
 | 
			
		||||
	LIB_TAG_COPY_ON_WRITE_EVAL = 1 << 13,
 | 
			
		||||
	LIB_TAG_COPIED_ON_WRITE               = 1 << 12,
 | 
			
		||||
	LIB_TAG_COPIED_ON_WRITE_EVAL_RESULT   = 1 << 13,
 | 
			
		||||
	LIB_TAG_LOCALIZED = 1 << 14,
 | 
			
		||||
 | 
			
		||||
	/* RESET_NEVER tag datablock for freeing etc. behavior (usually set when copying real one into temp/runtime one). */
 | 
			
		||||
 
 | 
			
		||||
@@ -145,6 +145,11 @@ typedef struct ObjectDisplay {
 | 
			
		||||
 | 
			
		||||
/* Not saved in file! */
 | 
			
		||||
typedef struct Object_Runtime {
 | 
			
		||||
	/* Original mesh pointer, before object->data was changed to point
 | 
			
		||||
	 * to mesh_eval.
 | 
			
		||||
	 * Is assigned by dependency craph's copy-on-write evaluation.
 | 
			
		||||
	 */
 | 
			
		||||
	struct Mesh *mesh_orig;
 | 
			
		||||
	/* Mesh structure created during object evaluation.
 | 
			
		||||
	 * It has all modifiers applied.
 | 
			
		||||
	 */
 | 
			
		||||
 
 | 
			
		||||
		Reference in New Issue
	
	Block a user