[Bf-blender-cvs] [1e97e0a671d] asset-engine: Merge branch 'id_override_static' into id_o2.8

Bastien Montagne noreply at git.blender.org
Tue Nov 7 15:20:40 CET 2017


Commit: 1e97e0a671d3b6858cb3062a98f0813d23a64be7
Author: Bastien Montagne
Date:   Tue Nov 7 10:59:40 2017 +0100
Branches: asset-engine
https://developer.blender.org/rB1e97e0a671d3b6858cb3062a98f0813d23a64be7

Merge branch 'id_override_static' into id_o2.8

Conflicts:
	source/blender/blenloader/intern/readfile.c
	source/blender/blenloader/intern/writefile.c
	source/blender/depsgraph/intern/builder/deg_builder_nodes.cc
	source/blender/editors/interface/interface_ops.c
	source/blender/makesdna/DNA_ID.h
	source/blender/makesrna/intern/rna_ID.c

===================================================================



===================================================================

diff --cc source/blender/blenkernel/intern/library.c
index 46d5a725959,ce168898d00..8585dfea316
--- a/source/blender/blenkernel/intern/library.c
+++ b/source/blender/blenkernel/intern/library.c
@@@ -689,6 -677,69 +690,71 @@@ bool id_copy(Main *bmain, const ID *id
  	return BKE_id_copy_ex(bmain, id, newid, 0, test);
  }
  
+ /** Does a mere memory swap over the whole IDs data (including type-specific memory).
+  *  \note Most internal ID data itself is not swapped (only IDProperties are). */
+ void BKE_id_swap(ID *id_a, ID *id_b)
+ {
+ 	BLI_assert(GS(id_a->name) == GS(id_b->name));
+ 
+ 	const ID id_a_back = *id_a;
+ 	const ID id_b_back = *id_b;
+ 
+ #define CASE_SWAP(_gs, _type) \
+ 	case _gs: \
+ 		SWAP(_type, *(_type *)id_a, *(_type *)id_b); \
+ 		break
+ 
+ 	switch ((ID_Type)GS(id_a->name)) {
+ 		CASE_SWAP(ID_SCE, Scene);
+ 		CASE_SWAP(ID_LI, Library);
+ 		CASE_SWAP(ID_OB, Object);
+ 		CASE_SWAP(ID_ME, Mesh);
+ 		CASE_SWAP(ID_CU, Curve);
+ 		CASE_SWAP(ID_MB, MetaBall);
+ 		CASE_SWAP(ID_MA, Material);
+ 		CASE_SWAP(ID_TE, Tex);
+ 		CASE_SWAP(ID_IM, Image);
+ 		CASE_SWAP(ID_LT, Lattice);
+ 		CASE_SWAP(ID_LA, Lamp);
++		CASE_SWAP(ID_LP, LightProbe);
+ 		CASE_SWAP(ID_CA, Camera);
+ 		CASE_SWAP(ID_KE, Key);
+ 		CASE_SWAP(ID_WO, World);
+ 		CASE_SWAP(ID_SCR, bScreen);
+ 		CASE_SWAP(ID_VF, VFont);
+ 		CASE_SWAP(ID_TXT, Text);
+ 		CASE_SWAP(ID_SPK, Speaker);
+ 		CASE_SWAP(ID_SO, bSound);
+ 		CASE_SWAP(ID_GR, Group);
+ 		CASE_SWAP(ID_AR, bArmature);
+ 		CASE_SWAP(ID_AC, bAction);
+ 		CASE_SWAP(ID_NT, bNodeTree);
+ 		CASE_SWAP(ID_BR, Brush);
+ 		CASE_SWAP(ID_PA, ParticleSettings);
+ 		CASE_SWAP(ID_WM, wmWindowManager);
++		CASE_SWAP(ID_WS, WorkSpace);
+ 		CASE_SWAP(ID_GD, bGPdata);
+ 		CASE_SWAP(ID_MC, MovieClip);
+ 		CASE_SWAP(ID_MSK, Mask);
+ 		CASE_SWAP(ID_LS, FreestyleLineStyle);
+ 		CASE_SWAP(ID_PAL, Palette);
+ 		CASE_SWAP(ID_PC, PaintCurve);
+ 		CASE_SWAP(ID_CF, CacheFile);
+ 		case ID_IP:
+ 			break;  /* Deprecated. */
+ 	}
+ 
+ #undef CASE_SWAP
+ 
+ 	/* Restore original ID's internal data. */
+ 	*id_a = id_a_back;
+ 	*id_b = id_b_back;
+ 
+ 	/* Exception: IDProperties. */
+ 	id_a->properties = id_b_back.properties;
+ 	id_b->properties = id_a_back.properties;
+ }
+ 
  /** Does *not* set ID->newid pointer. */
  bool id_single_user(bContext *C, ID *id, PointerRNA *ptr, PropertyRNA *prop)
  {
diff --cc source/blender/blenkernel/intern/library_override.c
index 00000000000,c6ad7deaf63..64ba06342cb
mode 000000,100644..100644
--- a/source/blender/blenkernel/intern/library_override.c
+++ b/source/blender/blenkernel/intern/library_override.c
@@@ -1,0 -1,657 +1,657 @@@
+ /*
+  * ***** BEGIN GPL LICENSE BLOCK *****
+  *
+  * This program is free software; you can redistribute it and/or
+  * modify it under the terms of the GNU General Public License
+  * as published by the Free Software Foundation; either version 2
+  * of the License, or (at your option) any later version.
+  *
+  * This program is distributed in the hope that it will be useful,
+  * but WITHOUT ANY WARRANTY; without even the implied warranty of
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  * GNU General Public License for more details.
+  *
+  * You should have received a copy of the GNU General Public License
+  * along with this program; if not, write to the Free Software Foundation,
+  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+  *
+  * The Original Code is Copyright (C) 2016 by Blender Foundation.
+  * All rights reserved.
+  *
+  * Contributor(s): Bastien Montagne.
+  *
+  * ***** END GPL LICENSE BLOCK *****
+  */
+ 
+ /** \file blender/blenkernel/intern/library_override.c
+  *  \ingroup bke
+  */
+ 
+ #include <stdlib.h>
+ 
+ #include "MEM_guardedalloc.h"
+ 
+ #include "DNA_ID.h"
+ #include "DNA_object_types.h"
+ 
 -#include "BKE_depsgraph.h"
++#include "DEG_depsgraph.h"
+ #include "BKE_library.h"
+ #include "BKE_library_override.h"
+ #include "BKE_library_remap.h"
+ #include "BKE_main.h"
+ 
+ #include "BLI_utildefines.h"
+ #include "BLI_listbase.h"
+ #include "BLI_string.h"
+ 
+ #include "RNA_access.h"
+ #include "RNA_types.h"
+ 
+ #include "PIL_time.h"
+ #include "PIL_time_utildefines.h"
+ 
+ #define OVERRIDE_AUTO_CHECK_DELAY 0.2  /* 200ms between auto-override checks. */
+ 
+ static void bke_override_property_copy(IDOverrideProperty *op_dst, IDOverrideProperty *op_src);
+ static void bke_override_property_operation_copy(IDOverridePropertyOperation *opop_dst, IDOverridePropertyOperation *opop_src);
+ 
+ static void bke_override_property_clear(IDOverrideProperty *op);
+ static void bke_override_property_operation_clear(IDOverridePropertyOperation *opop);
+ 
+ /** Initialize empty overriding of \a reference_id by \a local_id. */
+ IDOverride *BKE_override_init(ID *local_id, ID *reference_id)
+ {
+ 	/* If reference_id is NULL, we are creating an override template for purely local data.
+ 	 * Else, reference *must* be linked data. */
+ 	BLI_assert(reference_id == NULL || reference_id->lib != NULL);
+ 	BLI_assert(local_id->override == NULL);
+ 
+ 	if (reference_id != NULL && reference_id->override != NULL && reference_id->override->reference == NULL) {
+ 		/* reference ID has an override template, use it! */
+ 		BKE_override_copy(local_id, reference_id);
+ 		return local_id->override;
+ 	}
+ 
+ 	/* Else, generate new empty override. */
+ 	local_id->override = MEM_callocN(sizeof(*local_id->override), __func__);
+ 	local_id->override->reference = reference_id;
+ 	id_us_plus(reference_id);
+ 	local_id->tag &= ~LIB_TAG_OVERRIDE_OK;
+ 	/* TODO do we want to add tag or flag to referee to mark it as such? */
+ 	return local_id->override;
+ }
+ 
+ /** Deep copy of a whole override from \a src_id to \a dst_id. */
+ void BKE_override_copy(ID *dst_id, const ID *src_id)
+ {
+ 	BLI_assert(src_id->override != NULL);
+ 
+ 	if (dst_id->override != NULL) {
+ 		if (src_id->override == NULL) {
+ 			BKE_override_free(&dst_id->override);
+ 			return;
+ 		}
+ 		else {
+ 			BKE_override_clear(dst_id->override);
+ 		}
+ 	}
+ 	else if (src_id->override == NULL) {
+ 		return;
+ 	}
+ 	else {
+ 		BKE_override_init(dst_id, NULL);
+ 	}
+ 
+ 	/* Source is already overriding data, we copy it but reuse it's reference for dest ID.
+ 	 * otherwise, source is only an override template, it then becomes reference of dest ID. */
+ 	dst_id->override->reference = src_id->override->reference ? src_id->override->reference : (ID *)src_id;
+ 	id_us_plus(dst_id->override->reference);
+ 
+ 	BLI_duplicatelist(&dst_id->override->properties, &src_id->override->properties);
+ 	for (IDOverrideProperty *op_dst = dst_id->override->properties.first, *op_src = src_id->override->properties.first;
+ 	     op_dst;
+ 	     op_dst = op_dst->next, op_src = op_src->next)
+ 	{
+ 		bke_override_property_copy(op_dst, op_src);
+ 	}
+ 
+ 	dst_id->tag &= ~LIB_TAG_OVERRIDE_OK;
+ }
+ 
+ /** Clear any overriding data from given \a override. */
+ void BKE_override_clear(IDOverride *override)
+ {
+ 	BLI_assert(override != NULL);
+ 
+ 	for (IDOverrideProperty *op = override->properties.first; op; op = op->next) {
+ 		bke_override_property_clear(op);
+ 	}
+ 	BLI_freelistN(&override->properties);
+ 
+ 	id_us_min(override->reference);
+ 	/* override->storage should never be refcounted... */
+ }
+ 
+ /** Free given \a override. */
+ void BKE_override_free(struct IDOverride **override)
+ {
+ 	BLI_assert(*override != NULL);
+ 
+ 	BKE_override_clear(*override);
+ 	MEM_freeN(*override);
+ 	*override = NULL;
+ }
+ 
+ /** Create an overriden local copy of linked reference. */
+ ID *BKE_override_create_from(Main *bmain, ID *reference_id)
+ {
+ 	BLI_assert(reference_id != NULL);
+ 	BLI_assert(reference_id->lib != NULL);
+ 
+ 	ID *local_id;
+ 
+ 	if (!id_copy(bmain, reference_id, (ID **)&local_id, false)) {
+ 		return NULL;
+ 	}
+ 	id_us_min(local_id);
+ 
+ 	BKE_override_init(local_id, reference_id);
+ 	local_id->flag |= LIB_AUTOOVERRIDE;
+ 
+ 	/* Remapping, we obviously only want to affect local data (and not our own reference pointer to overriden ID). */
+ 	BKE_libblock_remap(bmain, reference_id, local_id, ID_REMAP_SKIP_INDIRECT_USAGE | ID_REMAP_SKIP_STATIC_OVERRIDE);
+ 
+ 	return local_id;
+ }
+ 
+ /**
+  * Find override property from given RNA path, if it exists.
+  */
+ IDOverrideProperty *BKE_override_property_find(IDOverride *override, const char *rna_path)
+ {
+ 	/* XXX TODO we'll most likely want a runtime ghash to store taht mapping at some point. */
+ 	return BLI_findstring_ptr(&override->properties, rna_path, offsetof(IDOverrideProperty, rna_path));
+ }
+ 
+ /**
+  * Find override property from given RNA path, or create it if it does not exist.
+  */
+ IDOverrideProperty *BKE_override_property_get(IDOverride *override, const char *rna_path, bool *r_created)
+ {
+ 	/* XXX TODO we'll most likely want a runtime ghash to store taht mapping at some point. */
+ 	IDOverrideProperty *op = BKE_override_property_find(override, rna_path);
+ 
+ 	if (op == NULL) {
+ 		op = MEM_callocN(sizeof(IDOverrideProperty), __func__);
+ 		op->rna_path = BLI_strdup(rna_path);
+ 		BLI_addtail(&override->properties, op);
+ 
+ 		if (r_created) {
+ 			*r_created = true;
+ 		}
+ 	}
+ 	else if (r_created) {
+ 		*r_created = false;
+ 	}
+ 
+ 	return op;
+ }
+ 
+ void bke_override_property_copy(IDOverrideProperty *op_dst, IDOverrideProperty *op_src)
+ {
+ 	op_dst->rna_path = BLI_strdup(op_src->rna_path);
+ 	BLI_duplicatelist(&op_dst->operations, &op_src->operations);
+ 
+ 	for (IDOverridePropertyOperation *opop_dst = op_dst->operations.first, *opop_src = op_src->operations.first;
+ 	     opop_dst;
+ 	     opop_dst = opop_dst->next, opop_src = opop_src->next)
+ 	{
+ 		bke_override_property_operation_copy(opop_dst, opop_src);
+ 	}
+ }
+ 
+ void bke_override_property_clear(IDOverrideProperty *op)
+ {
+ 	BLI_assert(op->rna_path != NULL);
+ 
+ 	MEM_freeN(op->rna_path);
+ 
+ 	for (IDOverridePropertyOperation *opop = op->operations.first; opop; opop = opop->next) {
+ 		bke_override_property_operation_clear(opop);
+ 	}
+ 	BLI_freelistN(&op->operations);
+ }
+ 
+ /**
+  * Remove and free given \a override_property from given ID \a override.
+  */
+ void BKE_override_property_delete(IDOverride *override, IDOverrideProperty *override_property)
+ {
+ 

@@ Diff output truncated at 10240 characters. @@



More information about the Bf-blender-cvs mailing list