Base list refcount with Bastien Montagne

This does not include objects from nested collections.
Missing bits: objects.link, objects.unlink

source/blender/blenkernel/BKE_scene.h

@@ -44,6 +44,8 @@ struct Main;
 struct Object;
 struct QuicktimeCodecData;
 struct RenderData;
+struct LayerCollection;
+struct SceneLayer;
 struct SceneRenderLayer;
 struct Scene;
 struct UnitSettings;
@@ -95,6 +97,19 @@ int BKE_scene_base_iter_next(struct EvaluationContext *eval_ctx, struct SceneBas
 void BKE_scene_base_flag_to_objects(struct Scene *scene);
 void BKE_scene_base_flag_from_objects(struct Scene *scene);
 
+/* base functions */
+void         BKE_scene_layer_base_unref(struct SceneLayer *sl, struct Base *base);
+struct Base *BKE_scene_layer_base_find_by_name(struct SceneLayer *sl, const char *name);
+struct Base *BKE_scene_layer_base_find(struct SceneLayer *sl, struct Object *ob);
+struct Base *BKE_scene_layer_collection_base_find(struct LayerCollection *lc, struct Object *ob);
+struct Base *BKE_scene_layer_base_add(struct SceneLayer *sl, struct LayerCollection *lc, struct Object *ob);
+void         BKE_scene_layer_base_unlink(struct Scene *scene, struct LayerCollection *lc, struct Base *base);
+void         BKE_scene_layer_base_deselect_all(struct SceneLayer *sl);
+void         BKE_scene_layer_base_select(struct SceneLayer *sl, struct Base *selbase);
+
+void BKE_scene_layer_base_flag_to_objects(struct SceneLayer *sl);
+void BKE_scene_layer_base_flag_from_objects(struct SceneLayer *sl);
+
 void BKE_scene_set_background(struct Main *bmain, struct Scene *sce);
 struct Scene *BKE_scene_set_name(struct Main *bmain, const char *name);
 
@@ -124,6 +139,16 @@ void BKE_scene_update_tagged(struct EvaluationContext *eval_ctx, struct Main *bm
 void BKE_scene_update_for_newframe(struct EvaluationContext *eval_ctx, struct Main *bmain, struct Scene *sce, unsigned int lay);
 void BKE_scene_update_for_newframe_ex(struct EvaluationContext *eval_ctx, struct Main *bmain, struct Scene *sce, unsigned int lay, bool do_invisible_flush);
 
+struct SceneLayer *BKE_scene_layer_from_collection(struct Scene *scene, struct LayerCollection *lc);
+struct SceneLayer *BKE_scene_add_layer(struct Scene *sce, const char *name);
+bool BKE_scene_remove_layer(struct Main *main, struct Scene *scene, struct SceneLayer *sl);
+struct LayerCollection *BKE_scene_add_collection(struct SceneLayer *sl, struct LayerCollection *lc_parent, const char *name);
+bool BKE_scene_remove_collection(struct SceneLayer *sl, struct LayerCollection *lc_parent, struct LayerCollection *lc);
+
+struct LayerCollection *BKE_scene_layer_collection_active(struct SceneLayer *sl);
+int BKE_scene_layer_collection_count(struct SceneLayer *sl);
+int BKE_scene_layer_collection_findindex(struct SceneLayer *sl, struct LayerCollection *lc);
+
 struct SceneRenderLayer *BKE_scene_add_render_layer(struct Scene *sce, const char *name);
 bool BKE_scene_remove_render_layer(struct Main *main, struct Scene *scene, struct SceneRenderLayer *srl);
 

source/blender/blenkernel/intern/scene.c

@@ -103,6 +103,9 @@
 
 #include "bmesh.h"
 
+/* prototypes */
+static void layer_collections_free(SceneLayer *sl, ListBase *lb);
+
 const char *RE_engine_id_BLENDER_RENDER = "BLENDER_RENDER";
 const char *RE_engine_id_BLENDER_GAME = "BLENDER_GAME";
 const char *RE_engine_id_CYCLES = "CYCLES";
@@ -155,22 +158,25 @@ static void remove_sequencer_fcurves(Scene *sce)
 Scene *BKE_scene_copy(Main *bmain, Scene *sce, int type)
 {
 	Scene *scen;
+	SceneLayer *sl, *new_sl;
 	SceneRenderLayer *srl, *new_srl;
 	FreestyleLineSet *lineset;
 	ToolSettings *ts;
 	Base *base, *obase;
 	
 	if (type == SCE_COPY_EMPTY) {
-		ListBase rl, rv;
+		ListBase rl, rv, scl;
 		scen = BKE_scene_add(bmain, sce->id.name + 2);
 		
 		rl = scen->r.layers;
 		rv = scen->r.views;
+		scl = scen->layers;
 		curvemapping_free_data(&scen->r.mblur_shutter_curve);
 		scen->r = sce->r;
 		scen->r.layers = rl;
 		scen->r.actlay = 0;
 		scen->r.views = rv;
+		scen->layers = scl;
 		scen->unit = sce->unit;
 		scen->physics_settings = sce->physics_settings;
 		scen->gm = sce->gm;
@@ -244,6 +250,36 @@ Scene *BKE_scene_copy(Main *bmain, Scene *sce, int type)
 			}
 			new_srl = new_srl->next;
 		}
+
+		BLI_duplicatelist(&(scen->layers), &(sce->layers));
+		new_sl = scen->layers.first;
+		for (sl = sce->layers.first; sl; sl = sl->next) {
+			sl->obedit = NULL;
+
+			BLI_duplicatelist(&(new_sl->base), &(sl->base));
+
+			obase = sl->base.first;
+			base = new_sl->base.first;
+
+			while (base) {
+				id_us_plus(&base->object->id);
+				if (obase == sl->basact) new_sl->basact = base;
+
+				obase = obase->next;
+				base = base->next;
+			}
+
+			BLI_duplicatelist(&(new_sl->collections), &(sl->collections));
+
+			LayerCollection *lcn = new_sl->collections.first;
+			for (LayerCollection *lc = sl->collections.first; lc; lc = lc->next) {
+				BLI_duplicatelist(&(lcn->elements), &(lc->elements));
+				BLI_duplicatelist(&(lcn->overrides), &(lc->overrides));
+				lcn = lcn->next;
+			}
+
+			new_sl = new_sl->next;
+		}
 	}
 
 	/* copy color management settings */
@@ -372,6 +408,7 @@ void BKE_scene_make_local(Main *bmain, Scene *sce, const bool lib_local)
 /** Free (or release) any data used by this scene (does not free the scene itself). */
 void BKE_scene_free(Scene *sce)
 {
+	SceneLayer *sl;
 	SceneRenderLayer *srl;
 
 	BKE_animdata_free((ID *)sce, false);
@@ -462,6 +499,13 @@ void BKE_scene_free(Scene *sce)
 
 	BKE_previewimg_free(&sce->preview);
 	curvemapping_free_data(&sce->r.mblur_shutter_curve);
+
+	for (sl = sce->layers.first; sl; sl = sl->next) {
+		sl->basact = NULL;
+		layer_collections_free(sl, &sl->collections);
+		BLI_freelistN(&sl->base);
+	}
+	BLI_freelistN(&sce->layers);
 }
 
 void BKE_scene_init(Scene *sce)
@@ -792,6 +836,8 @@ void BKE_scene_init(Scene *sce)
 	sce->toolsettings->gpencil_v2d_align = GP_PROJECT_VIEWSPACE;
 	sce->toolsettings->gpencil_seq_align = GP_PROJECT_VIEWSPACE;
 	sce->toolsettings->gpencil_ima_align = GP_PROJECT_VIEWSPACE;
+
+	BKE_scene_add_layer(sce, NULL);
 }
 
 Scene *BKE_scene_add(Main *bmain, const char *name)
@@ -825,6 +871,73 @@ Base *BKE_scene_base_find(Scene *scene, Object *ob)
 	return BLI_findptr(&scene->base, ob, offsetof(Base, object));
 }
 
+Base *BKE_scene_layer_base_find_by_name(struct SceneLayer *sl, const char *name)
+{
+	Base *base;
+
+	for (base = sl->base.first; base; base = base->next) {
+		if (STREQ(base->object->id.name + 2, name)) {
+			break;
+		}
+	}
+
+	return base;
+}
+
+Base *BKE_scene_layer_base_find(SceneLayer *sl, Object *ob)
+{
+	return BLI_findptr(&sl->base, ob, offsetof(Base, object));
+}
+
+Base *BKE_scene_layer_collection_base_find(LayerCollection *lc, Object *ob)
+{
+	for (LinkData *link = lc->elements.first; link; link = link->next) {
+		Base *base = link->data;
+
+		if (base->object == ob) {
+			return base;
+		}
+	}
+	return NULL;
+}
+
+static Base *scene_layer_base_add(SceneLayer *sl, Object *ob)
+{
+	Base *b = MEM_callocN(sizeof(*b), __func__);
+	BLI_addhead(&sl->base, b);
+
+	b->object = ob;
+	b->flag = ob->flag;
+	b->lay = ob->lay;
+	b->refcount = 1;
+
+	return b;
+}
+
+Base *BKE_scene_layer_base_add(SceneLayer *sl, LayerCollection *lc, Object *ob)
+{
+	Base *base = BKE_scene_layer_base_find(sl, ob);
+
+	if (base == NULL) {
+		base = scene_layer_base_add(sl, ob);
+	}
+
+	/* Only bump id count for collection, but refcount we do it for both */
+	id_us_plus(&ob->id);
+	BLI_addtail(&lc->elements, BLI_genericNodeN(base));
+	base->refcount++;
+	return base;
+}
+
+void BKE_scene_layer_base_unlink(Scene *scene, LayerCollection *lc, Base *base)
+{
+	SceneLayer *sl = BKE_scene_layer_from_collection(scene, lc);
+	LinkData *ld = BLI_findptr(&lc->elements, base, offsetof(LinkData, data));
+
+	BLI_remlink(&lc->elements, ld);
+	BKE_scene_layer_base_unref(sl, base);
+}
+
 /**
  * Sets the active scene, mainly used when running in background mode (``--scene`` command line argument).
  * This is also called to set the scene directly, bypassing windowing code.
@@ -1171,6 +1284,25 @@ void BKE_scene_base_select(Scene *sce, Base *selbase)
 	sce->basact = selbase;
 }
 
+void BKE_scene_layer_base_deselect_all(SceneLayer *sl)
+{
+	Base *b;
+
+	for (b = sl->base.first; b; b = b->next) {
+		b->flag &= ~SELECT;
+		b->object->flag = b->flag;
+	}
+}
+
+void BKE_scene_layer_base_select(SceneLayer *sl, Base *selbase)
+{
+	selbase->flag |= SELECT;
+	selbase->object->flag = selbase->flag;
+
+	sl->basact = selbase;
+}
+
+
 /* checks for cycle, returns 1 if it's all OK */
 bool BKE_scene_validate_setscene(Main *bmain, Scene *sce)
 {
@@ -1986,6 +2118,229 @@ void BKE_scene_update_for_newframe_ex(EvaluationContext *eval_ctx, Main *bmain,
 #endif
 }
 
+/* Scene Layers */
+
+/* Recursively get the collection for a given index */
+static LayerCollection *collection_from_index(ListBase *lb, const int number, int *i)
+{
+	for (LayerCollection *lc = lb->first; lc; lc = lc->next) {
+		if (*i == number) {
+			return lc;
+		}
+
+		(*i)++;
+
+		LayerCollection *lc_nested = collection_from_index(&lc->collections, number, i);
+		if (lc_nested) {
+			return lc_nested;
+		}
+	}
+	return NULL;
+}
+
+LayerCollection *BKE_scene_layer_collection_active(SceneLayer *sl)
+{
+	int i = 0;
+	return collection_from_index(&sl->collections, sl->active_collection, &i);
+}
+
+/* Recursively get the count of collections */
+static int collection_count(ListBase *lb)
+{
+	int i = 0;
+	for (LayerCollection *lc = lb->first; lc; lc = lc->next) {
+		i += collection_count(&lc->collections) + 1;
+	}
+	return i;
+}
+
+int BKE_scene_layer_collection_count(SceneLayer *sl)
+{
+	return collection_count(&sl->collections);
+}
+
+/* Recursively get the index for a given collection */
+static int index_from_collection(ListBase *lb, LayerCollection *lc, int *i)
+{
+	for (LayerCollection *lcol = lb->first; lcol; lcol = lcol->next) {
+		if (lcol == lc) {
+			return *i;
+		}
+
+		(*i)++;
+
+		int i_nested = index_from_collection(&lcol->collections, lc, i);
+		if (i_nested != -1) {
+			return i_nested;
+		}
+	}
+	return -1;
+}
+
+/* return -1 */
+int BKE_scene_layer_collection_findindex(SceneLayer *sl, LayerCollection *lc)
+{
+	int i = 0;
+	return index_from_collection(&sl->collections, lc, &i);
+}
+
+/* Recursively check if collection is inside the collection ListBase */
+static bool collection_in_collections(ListBase *lb, LayerCollection *lc)
+{
+	for (LayerCollection *laycol = lb->first; laycol; laycol = laycol->next) {
+		if (laycol == lc)
+			return true;
+
+		if (collection_in_collections(&laycol->collections, lc))
+			return true;
+	}
+	return false;
+}
+
+SceneLayer *BKE_scene_layer_from_collection(Scene *scene, LayerCollection *lc)
+{
+	for (SceneLayer *sl = scene->layers.first; sl; sl = sl->next) {
+		if (collection_in_collections(&sl->collections, lc)) {
+			return sl;
+		}
+	}
+	return NULL;
+}
+
+/* lc_parent is optional, to be used only for nested collections */
+LayerCollection *BKE_scene_add_collection(SceneLayer *sl, LayerCollection *lc_parent, const char *name)
+{
+	ListBase *lb = (lc_parent ? &lc_parent->collections : &sl->collections);
+	LayerCollection *lc_new;
+
+	lc_new = MEM_callocN(sizeof(LayerCollection), "new layer collection");
+	BLI_strncpy(lc_new->name, name, sizeof(lc_new->name));
+	BLI_uniquename(&sl->collections, lc_new, DATA_("Collection"), '.', offsetof(LayerCollection, name), sizeof(lc_new->name));
+	BLI_addtail(lb, lc_new);
+
+	return lc_new;
+}
+
+void BKE_scene_layer_base_unref(SceneLayer* sl, Base *base)
+{
+	base->refcount--;
+	/* It only exists in the SceneLayer */
+	if (base->refcount == 1) {
+
+#ifdef LAYERS_RIGID_BODY
+		/* remove rigid body constraint from world before removing object */
+		if (base->object->rigidbody_constraint)
+			BKE_rigidbody_remove_constraint(sce, base->object);
+		/* remove rigid body object from world before removing object */
+		if (base->object->rigidbody_object)
+			BKE_rigidbody_remove_object(sce, base->object);
+#endif
+		if (sl->basact == base)
+			sl->basact = NULL;
+
+		BLI_remlink(&sl->base, base);
+		MEM_freeN(base);
+	}
+}
+
+static void layer_collection_free(SceneLayer *sl, LayerCollection *lc)
+{
+	for (LinkData *ld = lc->elements.first; ld; ld = ld->next) {
+		BKE_scene_layer_base_unref(sl, ld->data);
+	}
+
+	BLI_freelistN(&lc->elements);
+	BLI_freelistN(&lc->overrides);
+	layer_collections_free(sl, &lc->collections);
+}
+
+static void layer_collections_free(SceneLayer *sl, ListBase *lb)
+{
+	for (LayerCollection *lc = lb->first; lc; lc = lc->next) {
+		layer_collection_free(sl, lc);
+	}
+	BLI_freelistN(lb);
+}
+
+/* lc_parent is optional, to be used only for nested collections */
+bool BKE_scene_remove_collection(SceneLayer *sl, LayerCollection *lc_parent, LayerCollection *lc)
+{
+	ListBase *lb = (lc_parent ? &lc_parent->collections : &sl->collections);
+	const int act = BLI_findindex(lb, lc);
+
+	if (act == -1) {
+		return false;
+	}
+
+	BLI_remlink(lb, lc);
+	layer_collection_free(sl, lc);
+	MEM_freeN(lc);
+
+	/* TODO only change active_collection if necessary */
+	sl->active_collection = 0;
+
+	return true;
+}
+
+/* return default layer */
+SceneLayer *BKE_scene_add_layer(Scene *sce, const char *name)
+{
+	SceneLayer *sl;
+
+	if (!name)
+		name = DATA_("SceneLayer");
+
+	sl = MEM_callocN(sizeof(SceneLayer), "new scene layer");
+	BLI_strncpy(sl->name, name, sizeof(sl->name));
+	BLI_uniquename(&sce->layers, sl, DATA_("Layer"), '.', offsetof(SceneLayer, name), sizeof(sl->name));
+
+	/* Initial collection */
+	BKE_scene_add_collection(sl, NULL, "Collection");
+	BLI_addtail(&sce->layers, sl);
+	return sl;
+}
+
+bool BKE_scene_remove_layer(Main *bmain, Scene *scene, SceneLayer *sl)
+{
+	const int act = BLI_findindex(&scene->layers, sl);
+	if (act == -1) {
+		return false;
+	}
+	else if ( (scene->layers.first == scene->layers.last) &&
+	          (scene->layers.first == sl))
+	{
+		/* ensure 1 layer is kept */
+		return false;
+	}
+
+	BLI_remlink(&scene->layers, sl);
+
+	BLI_freelistN(&sl->base);
+
+	layer_collections_free(sl, &sl->collections);
+
+	MEM_freeN(sl);
+
+	/* TODO only change active_layer if necessary */
+	scene->active_layer = 0;
+
+	for (Scene *sce = bmain->scene.first; sce; sce = sce->id.next) {
+		if (sce->nodetree) {
+			bNode *node;
+			for (node = sce->nodetree->nodes.first; node; node = node->next) {
+				if (node->type == CMP_NODE_R_LAYERS && (Scene *)node->id == scene) {
+					if (node->custom1 == act)
+						node->custom1 = 0;
+					else if (node->custom1 > act)
+						node->custom1--;
+				}
+			}
+		}
+	}
+
+	return true;
+}
+
 /* return default layer, also used to patch old files */
 SceneRenderLayer *BKE_scene_add_render_layer(Scene *sce, const char *name)
 {
@@ -2205,6 +2560,26 @@ void BKE_scene_base_flag_from_objects(struct Scene *scene)
 	}
 }
 
+void BKE_scene_layer_base_flag_to_objects(struct SceneLayer *sl)
+{
+	Base *base = sl->base.first;
+
+	while (base) {
+		base->object->flag = base->flag;
+		base = base->next;
+	}
+}
+
+void BKE_scene_layer_base_flag_from_objects(struct SceneLayer *sl)
+{
+	Base *base = sl->base.first;
+
+	while (base) {
+		base->flag = base->object->flag;
+		base = base->next;
+	}
+}
+
 void BKE_scene_disable_color_management(Scene *scene)
 {
 	ColorManagedDisplaySettings *display_settings = &scene->display_settings;

source/blender/blenloader/CMakeLists.txt

@@ -53,6 +53,7 @@ set(SRC
 	intern/versioning_250.c
 	intern/versioning_260.c
 	intern/versioning_270.c
+	intern/versioning_280.c
 	intern/versioning_defaults.c
 	intern/versioning_legacy.c
 	intern/writefile.c

source/blender/blenloader/intern/readfile.c

@@ -5234,6 +5234,7 @@ static void lib_link_scene(FileData *fd, Main *main)
 	Scene *sce;
 	Base *base, *next;
 	Sequence *seq;
+	SceneLayer *sl;
 	SceneRenderLayer *srl;
 	FreestyleModuleConfig *fmc;
 	FreestyleLineSet *fls;
@@ -5359,6 +5360,22 @@ static void lib_link_scene(FileData *fd, Main *main)
 				sce->nodetree->id.lib = sce->id.lib;
 				composite_patch(sce->nodetree, sce);
 			}
+
+			for (sl = sce->layers.first; sl; sl = sl->next) {
+				for (base = sl->base.first; base; base = next) {
+					next = base->next;
+
+					base->object = newlibadr_us(fd, sce->id.lib, base->object);
+
+					if (base->object == NULL) {
+						blo_reportf_wrap(fd->reports, RPT_WARNING, TIP_("LIB: object lost from scene: '%s'"),
+						                 sce->id.name + 2);
+						BLI_remlink(&sl->base, base);
+						if (base == sl->basact) sl->basact = NULL;
+						MEM_freeN(base);
+					}
+				}
+			}
 			
 			for (srl = sce->r.layers.first; srl; srl = srl->next) {
 				srl->mat_override = newlibadr_us(fd, sce->id.lib, srl->mat_override);
@@ -5480,12 +5497,30 @@ static void direct_link_view_settings(FileData *fd, ColorManagedViewSettings *vi
 		direct_link_curvemapping(fd, view_settings->curve_mapping);
 }
 
+/* recursively direct link the layer collections */
+static void direct_link_layer_collections(FileData *fd , ListBase *lb)
+{
+	link_list(fd, lb);
+	for (LayerCollection *lc = lb->first; lc; lc = lc->next) {
+		link_list(fd, &(lc->overrides));
+		link_list(fd, &lc->elements);
+
+		for (LinkData *ld = lc->elements.first; ld; ld = ld->next) {
+			ld->data = newdataadr(fd, ld->data);
+			((Base *)ld->data)->refcount++;
+		}
+
+		direct_link_layer_collections(fd, &lc->collections);
+	}
+}
+
 static void direct_link_scene(FileData *fd, Scene *sce)
 {
 	Editing *ed;
 	Sequence *seq;
 	MetaStack *ms;
 	RigidBodyWorld *rbw;
+	SceneLayer *sl;
 	SceneRenderLayer *srl;
 	
 	sce->theDag = NULL;
@@ -5719,6 +5754,20 @@ static void direct_link_scene(FileData *fd, Scene *sce)
 	sce->preview = direct_link_preview_image(fd, sce->preview);
 
 	direct_link_curvemapping(fd, &sce->r.mblur_shutter_curve);
+
+	link_list(fd, &(sce->layers));
+	for (sl = sce->layers.first; sl; sl = sl->next) {
+		sl->obedit = NULL;
+		sl->basact = newdataadr(fd, sl->basact);
+
+		link_list(fd, &(sl->base));
+		for (Base *base = sl->base.first; base; base = base->next) {
+			base->refcount++;
+		}
+
+		/* recursively direct link the layer collections */
+		direct_link_layer_collections(fd, &(sl->collections));
+	}
 }
 
 /* ************ READ WM ***************** */
@@ -7959,6 +8008,7 @@ static void do_versions(FileData *fd, Library *lib, Main *main)
 	blo_do_versions_250(fd, lib, main);
 	blo_do_versions_260(fd, lib, main);
 	blo_do_versions_270(fd, lib, main);
+	blo_do_versions_280(fd, lib, main);
 
 	/* WATCH IT!!!: pointers from libdata have not been converted yet here! */
 	/* WATCH IT 2!: Userdef struct init see do_versions_userdef() above! */
@@ -8988,6 +9038,7 @@ static void expand_object(FileData *fd, Main *mainvar, Object *ob)
 static void expand_scene(FileData *fd, Main *mainvar, Scene *sce)
 {
 	Base *base;
+	SceneLayer *sl;
 	SceneRenderLayer *srl;
 	FreestyleModuleConfig *module;
 	FreestyleLineSet *lineset;
@@ -9054,6 +9105,12 @@ static void expand_scene(FileData *fd, Main *mainvar, Scene *sce)
 	}
 
 	expand_doit(fd, mainvar, sce->clip);
+
+	for (sl = sce->layers.first; sl; sl = sl->next) {
+		for (base = sl->base.first; base; base = base->next) {
+			expand_doit(fd, mainvar, base->object);
+		}
+	}
 }
 
 static void expand_camera(FileData *fd, Main *mainvar, Camera *ca)

source/blender/blenloader/intern/readfile.h

@@ -34,6 +34,8 @@
 #define __READFILE_H__
 
 #include "zlib.h"
+#include "DNA_sdna_types.h"
+#include "DNA_space_types.h"
 #include "DNA_windowmanager_types.h"  /* for ReportType */
 
 struct OldNewMap;
@@ -169,6 +171,7 @@ void blo_do_versions_pre250(struct FileData *fd, struct Library *lib, struct Mai
 void blo_do_versions_250(struct FileData *fd, struct Library *lib, struct Main *main);
 void blo_do_versions_260(struct FileData *fd, struct Library *lib, struct Main *main);
 void blo_do_versions_270(struct FileData *fd, struct Library *lib, struct Main *main);
+void blo_do_versions_280(struct FileData *fd, struct Library *lib, struct Main *main);
 
 #endif
 

source/blender/blenloader/intern/versioning_280.c

@@ -0,0 +1,118 @@
+/*
+ * ***** 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.
+ *
+ * Contributor(s): Blender Foundation
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ *
+ */
+
+/** \file blender/blenloader/intern/versioning_280.c
+ *  \ingroup blenloader
+ */
+
+/* for MinGW32 definition of NULL, could use BLI_blenlib.h instead too */
+#include <stddef.h>
+
+/* allow readfile to use deprecated functionality */
+#define DNA_DEPRECATED_ALLOW
+
+#include "DNA_object_types.h"
+#include "DNA_scene_types.h"
+#include "DNA_genfile.h"
+
+#include "BKE_main.h"
+#include "BKE_scene.h"
+
+#include "BLI_listbase.h"
+#include "BLI_string.h"
+
+#include "BLO_readfile.h"
+
+#include "readfile.h"
+
+#include "MEM_guardedalloc.h"
+
+void blo_do_versions_280(FileData *fd, Library *UNUSED(lib), Main *main)
+{
+	if (!DNA_struct_elem_find(fd->filesdna, "Scene", "ListBase", "layers")) {
+		for (Scene *scene = main->scene.first; scene; scene = scene->id.next) {
+			SceneLayer *sl = MEM_callocN(sizeof(SceneLayer), "initial scene layer");
+			BLI_strncpy(sl->name, "Layer", sizeof(sl->name));
+
+			LayerCollection *collections[20] = {NULL};
+			scene->active_layer = 0;
+
+			BLI_addhead(&scene->layers, sl);
+			int lay_used = 0;
+
+			for (int i = 0; i < 20; i++) {
+				LayerCollection *collection = MEM_callocN(sizeof(LayerCollection), "doversion layer collections");
+				collection->flag = COLLECTION_SELECTABLE;
+
+				if (scene->lay & (1 << i)) {
+					collection->flag |= COLLECTION_VISIBLE;
+				}
+
+				BLI_snprintf(collection->name, sizeof(collection->name), "%d", i + 1);
+				collections[i] = collection;
+			}
+
+			Base *base = scene->base.first;
+			while (base) {
+				Base *base_new = MEM_dupallocN(base);
+				base_new->refcount++;
+				BLI_addtail(&sl->base, base_new);
+
+				if (base == scene->basact) {
+					sl->basact = base_new;
+				}
+
+				lay_used |= base->lay & ((1 << 20) - 1); /* ignore localview */
+
+				for (int i = 0; i < 20; i++) {
+					if ((base->lay & (1 << i)) != 0) {
+						BLI_addtail(&collections[i]->elements, BLI_genericNodeN(base_new));
+						base_new->refcount++;
+					}
+				}
+				base = base->next;
+			}
+
+			/* We should always have at least one layer, and one collection at all times */
+			if (lay_used == 0) {
+				lay_used  = (1 << 0);
+			}
+
+			/* Cleanup */
+			for (int i = 0; i < 20; i++) {
+				if ((lay_used & (1 << i)) != 0) {
+					BLI_addtail(&sl->collections, collections[i]);
+				}
+				else {
+					MEM_freeN(collections[i]);
+				}
+			}
+
+			/*
+			 * TODO handle existing SceneRenderLayer
+			 * for (SceneRenderLayer *srl = scene->r.layers.first; srl; srl = srl->next);
+			 */
+		}
+	}
+
+}

source/blender/blenloader/intern/versioning_defaults.c

@@ -25,6 +25,9 @@
  *  \ingroup blenloader
  */
 
+/* allow readfile to use deprecated functionality */
+#define DNA_DEPRECATED_ALLOW
+
 #include "BLI_utildefines.h"
 #include "BLI_listbase.h"
 #include "BLI_math.h"

source/blender/blenloader/intern/writefile.c

@@ -2401,6 +2401,17 @@ static void write_paint(WriteData *wd, Paint *p)
 	}
 }
 
+/* recursively write the layer collections structs */
+static void write_layer_collections(WriteData *wd, ListBase *lb)
+{
+	writelist(wd, DATA, LayerCollection, lb);
+	for (LayerCollection *lc = lb->first; lc; lc = lc->next) {
+		writelist(wd, DATA, CollectionOverride, &lc->overrides);
+		writelist(wd, DATA, LinkData, &lc->elements);
+		write_layer_collections(wd, &(lc->collections));
+	}
+}
+
 static void write_scenes(WriteData *wd, ListBase *scebase)
 {
 	Scene *sce;
@@ -2411,6 +2422,7 @@ static void write_scenes(WriteData *wd, ListBase *scebase)
 	Strip *strip;
 	TimeMarker *marker;
 	TransformOrientation *ts;
+	SceneLayer *sl;
 	SceneRenderLayer *srl;
 	SceneRenderView *srv;
 	ToolSettings *tos;
@@ -2585,6 +2597,15 @@ static void write_scenes(WriteData *wd, ListBase *scebase)
 			writestruct(wd, DATA, TransformOrientation, 1, ts);
 		}
 
+		/* writing scene layers to the blend file */
+		writelist(wd, DATA, SceneLayer, &sce->layers);
+		for (sl = sce->layers.first; sl; sl = sl->next) {
+			writelist(wd, DATA, Base, &sl->base);
+
+			/* recursively write the layer collections structs */
+			write_layer_collections(wd, &sl->collections);
+		}
+
 		for (srl = sce->r.layers.first; srl; srl = srl->next) {
 			writestruct(wd, DATA, SceneRenderLayer, 1, srl);
 			for (fmc = srl->freestyleConfig.modules.first; fmc; fmc = fmc->next) {

source/blender/makesdna/DNA_defs.h

@@ -58,6 +58,15 @@
 #endif
 
 
+/* 2.8: Allow toggling warnings for members that'll be deprecated during layer system rewrite. */
+#define DNA_DEPRECATED_LAYERS_ALLOW
+
+#ifdef DNA_DEPRECATED_LAYERS_ALLOW
+#  define DNA_DEPRECATED_LAYERS
+#else
+#  define DNA_DEPRECATED_LAYERS DNA_DEPRECATED
+#endif
+
 /* hrmf, we need a better include then this */
 #include "../blenlib/BLI_sys_types.h" /* needed for int64_t only! */
 

source/blender/makesdna/DNA_object_types.h

@@ -142,8 +142,8 @@ typedef struct Object {
 	ListBase defbase;   /* list of bDeformGroup (vertex groups) names and flag only */
 	ListBase modifiers; /* list of ModifierData structures */
 
-	int mode;           /* Local object mode */
-	int restore_mode;   /* Keep track of what mode to return to after toggling a mode */
+	int mode DNA_DEPRECATED_LAYERS; /* Local object mode - deprecated in 2.8 */
+	int restore_mode DNA_DEPRECATED_LAYERS; /* Keep track of what mode to return to after toggling a mode - deprecated in 2.8 */
 
 	/* materials */
 	struct Material **mat;	/* material slots */

source/blender/makesdna/DNA_scene_types.h

@@ -69,15 +69,59 @@ struct ColorSpace;
 /* ************************************************************* */
 /* Scene Data */
 
-/* Base - Wrapper for referencing Objects in a Scene */
+/* Base - Wrapper for referencing Objects in a SceneLayer */
 typedef struct Base {
 	struct Base *next, *prev;
-	unsigned int lay, selcol;
-	int flag;
+	unsigned int lay DNA_DEPRECATED_LAYERS;	/* deprecated in 2.8 */
+	unsigned int selcol;
+	short flag;
 	short sx, sy;
+	short refcount;
 	struct Object *object;
 } Base;
 
+/* ************************************************************* */
+
+typedef struct CollectionOverride {
+	struct CollectionOverride *next, *prev;
+	char name[64];		/* MAX_NAME */
+	/* TODO - proper data */
+} CollectionOverride;
+
+/* Layers Data */
+typedef struct LayerCollection {
+	struct LayerCollection *next, *prev;
+	char name[64];		/* MAX_NAME */
+	short flag;
+	short pad[3];
+	ListBase elements;
+	ListBase overrides;
+	ListBase collections;	/* nested collections */
+	/* TODO dynamic adding of elements (name based) */
+} LayerCollection;
+
+/* Render Layer */
+typedef struct SceneLayer {
+	struct SceneLayer *next, *prev;
+
+	char name[64];			/* MAX_NAME */
+
+	char engine[32];		/* render engine */
+
+	int mode;				/* active object mode */
+	int restore_mode;		/* Keep track of what mode to return to after toggling a mode */
+	int pad;
+	short active_collection;
+	short pad2;
+
+	ListBase base;
+	struct Base *basact;	/* active base */
+	struct Object *obedit;	/* name replaces old G.obedit */
+
+	ListBase collections;
+} SceneLayer;
+
+
 /* ************************************************************* */
 /* Output Format Data */
 
@@ -665,8 +709,8 @@ typedef struct RenderData {
 	rcti disprect;
 	
 	/* information on different layers to be rendered */
-	ListBase layers;
-	short actlay;
+	ListBase layers DNA_DEPRECATED_LAYERS; /* deprecated in 2.8 */
+	short actlay DNA_DEPRECATED_LAYERS; /* deprecated in 2.8 */
 	
 	/* number of mblur samples */
 	short mblur_samples;
@@ -748,7 +792,7 @@ typedef struct RenderData {
 	float unit_line_thickness; /* in pixels */
 
 	/* render engine */
-	char engine[32];
+	char engine[32] DNA_DEPRECATED_LAYERS; /* deprecated in 2.8 */
 
 	/* Cycles baking */
 	struct BakeData bake;
@@ -1549,9 +1593,9 @@ typedef struct Scene {
 	
 	struct Scene *set;
 	
-	ListBase base;
-	struct Base *basact;		/* active base */
-	struct Object *obedit;		/* name replaces old G.obedit */
+	ListBase base DNA_DEPRECATED_LAYERS;
+	struct Base *basact DNA_DEPRECATED_LAYERS;		/* active base - deprecated in 2.8 */
+	struct Object *obedit DNA_DEPRECATED_LAYERS;	/* name replaces old G.obedit - deprecated in 2.8 */
 	
 	float cursor[3];			/* 3d cursor location */
 	float twcent[3];			/* center for transform widget */
@@ -1594,7 +1638,9 @@ typedef struct Scene {
 	void *pad1;
 	struct  DagForest *theDag;
 	short dagflags;
-	short pad3;
+
+	/* to be named (workflow layers, view layers, render layers, ...) */
+	short active_layer;
 
 	/* User-Defined KeyingSets */
 	int active_keyingset;			/* index of the active KeyingSet. first KeyingSet has index 1, 'none' active is 0, 'add new' is -1 */
@@ -1628,6 +1674,9 @@ typedef struct Scene {
 	struct RigidBodyWorld *rigidbody_world;
 
 	struct PreviewImage *preview;
+
+	/* to be named (workflow layers, view layers, render layers, ...) */
+	ListBase layers;
 } Scene;
 
 /* **************** RENDERDATA ********************* */
@@ -2219,6 +2268,13 @@ typedef enum eGPencil_Placement_Flags {
 #define	USER_UNIT_OPT_SPLIT		1
 #define USER_UNIT_ROT_RADIANS	2
 
+/* Collection */
+/* Collection->flag */
+enum {
+	COLLECTION_VISIBLE    = (1 << 0),
+	COLLECTION_SELECTABLE = (1 << 1),
+};
+
 #ifdef __cplusplus
 }
 #endif

source/blender/makesdna/intern/makesdna.c

@@ -497,6 +497,10 @@ static int preprocess_include(char *maindata, int len)
 		else if (cp[-1] == '*' && cp[0] == ' ') {
 			/* pointers with a space */
 		}	/* skip special keywords */
+		else if (strncmp("DNA_DEPRECATED_LAYERS", cp, 21) == 0) {
+			a -= 20;
+			cp += 20;
+		}
 		else if (strncmp("DNA_DEPRECATED", cp, 14) == 0) {
 			/* single values are skipped already, so decrement 1 less */
 			a -= 13;

source/blender/makesrna/intern/rna_scene.c

@@ -632,6 +632,87 @@ static void rna_Scene_object_unlink(Scene *scene, ReportList *reports, Object *o
 	WM_main_add_notifier(NC_SCENE | ND_OB_ACTIVE, scene);
 }
 
+static Base *rna_LayerCollection_object_link(ID *id, LayerCollection *lc, Main *bmain, ReportList *reports, Object *ob)
+{
+	Base *base;
+	Scene *scene = (Scene *)id;
+	SceneLayer *sl = BKE_scene_layer_from_collection(scene, lc);
+
+	if (BKE_scene_layer_collection_base_find(lc, ob)) {
+		BKE_reportf(reports, RPT_ERROR, "Object '%s' is already in collection '%s'", ob->id.name + 2, lc->name);
+		return NULL;
+	}
+
+	base = BKE_scene_layer_base_add(sl, lc, ob);
+
+	/* TODO(sergey): Only update relations for the current scene layer. */
+	DAG_relations_tag_update(bmain);
+	DAG_id_tag_update(&ob->id, OB_RECALC_OB | OB_RECALC_DATA | OB_RECALC_TIME);
+
+	/* slows down importers too much, run scene.update() */
+	/* DAG_srelations_tag_update(G.main); */
+
+	WM_main_add_notifier(NC_SCENE | ND_OB_ACTIVE, scene);
+
+	return base;
+}
+
+static void rna_LayerCollection_object_unlink(ID *id, LayerCollection *lc, ReportList *reports, Object *ob)
+{
+	Scene *scene = (Scene *)id;
+	SceneLayer *sl = BKE_scene_layer_from_collection(scene, lc);
+	Base *base = BKE_scene_layer_collection_base_find(lc, ob);
+
+	if (!base) {
+		BKE_reportf(reports, RPT_ERROR, "Object '%s' is not in this collection '%s'", ob->id.name + 2, lc->name);
+		return;
+	}
+
+	if (((base->flag & SELECT) != 0) && sl->mode != OB_MODE_OBJECT) {
+		BKE_reportf(reports, RPT_ERROR, "Object '%s' must be in object mode to unlink", ob->id.name + 2);
+		return;
+	}
+
+	BKE_scene_layer_base_unlink(scene, lc, base);
+	id_us_min(&ob->id);
+
+	/* needed otherwise the depgraph will contain freed objects which can crash, see [#20958] */
+	DAG_relations_tag_update(G.main);
+
+	WM_main_add_notifier(NC_SCENE | ND_OB_ACTIVE, scene);
+}
+
+static int rna_Scene_layer_object_bases_lookup_string(PointerRNA *ptr, const char *key, PointerRNA *r_ptr)
+{
+	SceneLayer *sl = (SceneLayer *)ptr->data;
+	Base *base;
+
+	for (base = sl->base.first; base; base = base->next) {
+		if (STREQLEN(base->object->id.name + 2, key, sizeof(base->object->id.name) - 2)) {
+			*r_ptr = rna_pointer_inherit_refine(ptr, &RNA_ObjectBase, base);
+			return true;
+		}
+	}
+
+	return false;
+}
+
+static PointerRNA rna_Scene_layer_objects_get(CollectionPropertyIterator *iter)
+{
+	ListBaseIterator *internal = &iter->internal.listbase;
+
+	/* we are actually iterating a Base list, so override get */
+	return rna_pointer_inherit_refine(&iter->parent, &RNA_Object, ((Base *)internal->link)->object);
+}
+
+static PointerRNA rna_LayerCollection_objects_get(CollectionPropertyIterator *iter)
+{
+	ListBaseIterator *internal = &iter->internal.listbase;
+
+	/* we are actually iterating a Base list, so override get */
+	return rna_pointer_inherit_refine(&iter->parent, &RNA_Object, ((Base *)((LinkData *)internal->link)->data)->object);
+}
+
 static void rna_Scene_skgen_etch_template_set(PointerRNA *ptr, PointerRNA value)
 {
 	ToolSettings *ts = (ToolSettings *)ptr->data;
@@ -674,6 +755,13 @@ static void rna_Scene_set_set(PointerRNA *ptr, PointerRNA value)
 	scene->set = set;
 }
 
+static void rna_Scene_view3d_update(Main *bmain, Scene *UNUSED(scene_unused), PointerRNA *ptr)
+{
+	Scene *scene = (Scene *)ptr->data;
+
+	BKE_screen_view3d_main_sync(&bmain->screen, scene);
+}
+
 static void rna_Scene_layer_set(PointerRNA *ptr, const int *values)
 {
 	Scene *scene = (Scene *)ptr->data;
@@ -688,13 +776,6 @@ static int rna_Scene_active_layer_get(PointerRNA *ptr)
 	return (int)(log(scene->layact) / M_LN2);
 }
 
-static void rna_Scene_view3d_update(Main *bmain, Scene *UNUSED(scene_unused), PointerRNA *ptr)
-{
-	Scene *scene = (Scene *)ptr->data;
-
-	BKE_screen_view3d_main_sync(&bmain->screen, scene);
-}
-
 static void rna_Scene_layer_update(Main *bmain, Scene *scene, PointerRNA *ptr)
 {
 	rna_Scene_view3d_update(bmain, scene, ptr);
@@ -1335,6 +1416,183 @@ static void rna_FFmpegSettings_codec_settings_update(Main *UNUSED(bmain), Scene
 }
 #endif
 
+static PointerRNA rna_Scene_layer_active_object_get(PointerRNA *ptr)
+{
+	SceneLayer *sl = (SceneLayer *)ptr->data;
+	return rna_pointer_inherit_refine(ptr, &RNA_Object, sl->basact ? sl->basact->object : NULL);
+}
+
+static void rna_Scene_layer_active_object_set(PointerRNA *ptr, PointerRNA value)
+{
+	SceneLayer *sl = (SceneLayer *)ptr->data;
+	if (value.data)
+		sl->basact = BKE_scene_layer_base_find(sl, (Object *)value.data);
+	else
+		sl->basact = NULL;
+}
+
+static LayerCollection *rna_LayerNestedCollection_new(ID *id, LayerCollection *lc, const char *name)
+{
+	Scene *scene = (Scene *)id;
+	SceneLayer *sl = BKE_scene_layer_from_collection(scene, lc);
+	LayerCollection *lc_new = BKE_scene_add_collection(sl, lc, name);
+
+	DAG_id_tag_update(id, 0);
+	WM_main_add_notifier(NC_SCENE | ND_LAYER, NULL);
+
+	return lc_new;
+}
+
+static void rna_LayerNestedCollection_remove(
+        ID *id, LayerCollection *lc_parent, ReportList *reports, PointerRNA *lc_ptr)
+{
+	Scene *scene = (Scene *)id;
+	SceneLayer *sl = BKE_scene_layer_from_collection(scene, lc_parent);
+	LayerCollection *lc = lc_ptr->data;
+
+	if (!BKE_scene_remove_collection(sl, lc_parent, lc)) {
+		BKE_reportf(reports, RPT_ERROR, "Nested collection '%s' could not be removed from collection '%s'",
+		            lc->name, lc_parent->name );
+		return;
+	}
+
+	RNA_POINTER_INVALIDATE(lc_ptr);
+
+	DAG_id_tag_update(&scene->id, 0);
+	WM_main_add_notifier(NC_SCENE | ND_LAYER, NULL);
+}
+
+static int rna_Layer_active_collection_index_get(PointerRNA *ptr)
+{
+	SceneLayer *sl = (SceneLayer *)ptr->data;
+	return sl->active_collection;
+}
+
+static void rna_Layer_active_collection_index_set(PointerRNA *ptr, int value)
+{
+	SceneLayer *sl = (SceneLayer *)ptr->data;
+	int num_collections = BKE_scene_layer_collection_count(sl);
+	sl->active_collection = min_ff(value, num_collections - 1);
+}
+
+static void rna_Layer_active_collection_index_range(
+        PointerRNA *ptr, int *min, int *max, int *UNUSED(softmin), int *UNUSED(softmax))
+{
+	SceneLayer *sl = (SceneLayer *)ptr->data;
+	*min = 0;
+	*max = max_ii(0, BKE_scene_layer_collection_count(sl) - 1);
+}
+
+static PointerRNA rna_Layer_active_collection_get(PointerRNA *ptr)
+{
+	SceneLayer *sl = (SceneLayer *)ptr->data;
+	LayerCollection *lc = BKE_scene_layer_collection_active(sl);
+	return rna_pointer_inherit_refine(ptr, &RNA_LayerCollection, lc);
+}
+
+static void rna_Layer_active_collection_set(PointerRNA *ptr, PointerRNA value)
+{
+	SceneLayer *sl = (SceneLayer *)ptr->data;
+	LayerCollection *lc = (LayerCollection *)value.data;
+	const int index = BKE_scene_layer_collection_findindex(sl, lc);
+	if (index != -1) sl->active_collection = index;
+}
+
+static LayerCollection *rna_LayerCollection_new(ID *id, SceneLayer *sl, const char *name)
+{
+	LayerCollection *lc = BKE_scene_add_collection(sl, NULL, name);
+
+	DAG_id_tag_update(id, 0);
+	WM_main_add_notifier(NC_SCENE | ND_LAYER, NULL);
+
+	return lc;
+}
+
+static void rna_LayerCollection_remove(
+        ID *id, SceneLayer *sl, ReportList *reports, PointerRNA *lc_ptr)
+{
+	Scene *scene = (Scene *)id;
+	LayerCollection *lc = lc_ptr->data;
+
+	if (!BKE_scene_remove_collection(sl, NULL, lc)) {
+		BKE_reportf(reports, RPT_ERROR, "Layer collection '%s' could not be removed from layer '%s'",
+		            lc->name, sl->name );
+		return;
+	}
+
+	RNA_POINTER_INVALIDATE(lc_ptr);
+
+	DAG_id_tag_update(&scene->id, 0);
+	WM_main_add_notifier(NC_SCENE | ND_LAYER, NULL);
+}
+
+static int rna_Scene_active_scene_layer_index_get(PointerRNA *ptr)
+{
+	Scene *scene = (Scene *)ptr->data;
+	return scene->active_layer;
+}
+
+static void rna_Scene_active_scene_layer_index_set(PointerRNA *ptr, int value)
+{
+	Scene *scene = (Scene *)ptr->data;
+	int num_layers = BLI_listbase_count(&scene->layers);
+	scene->active_layer = min_ff(value, num_layers - 1);
+}
+
+static void rna_Scene_active_scene_layer_index_range(
+        PointerRNA *ptr, int *min, int *max, int *UNUSED(softmin), int *UNUSED(softmax))
+{
+	Scene *scene = (Scene *)ptr->data;
+
+	*min = 0;
+	*max = max_ii(0, BLI_listbase_count(&scene->layers) - 1);
+}
+
+static PointerRNA rna_Scene_active_scene_layer_get(PointerRNA *ptr)
+{
+	Scene *scene = (Scene *)ptr->data;
+	SceneLayer *sl = BLI_findlink(&scene->layers, scene->active_layer);
+
+	return rna_pointer_inherit_refine(ptr, &RNA_SceneLayer, sl);
+}
+
+static void rna_Scene_active_scene_layer_set(PointerRNA *ptr, PointerRNA value)
+{
+	Scene *scene = (Scene *)ptr->data;
+	SceneLayer *sl = (SceneLayer *)value.data;
+	const int index = BLI_findindex(&scene->layers, sl);
+	if (index != -1) scene->active_layer = index;
+}
+
+static SceneLayer *rna_SceneLayer_new(ID *id, Scene *UNUSED(sce), const char *name)
+{
+	Scene *scene = (Scene *)id;
+	SceneLayer *sl = BKE_scene_add_layer(scene, name);
+
+	DAG_id_tag_update(&scene->id, 0);
+	WM_main_add_notifier(NC_SCENE | ND_LAYER, NULL);
+
+	return sl;
+}
+
+static void rna_SceneLayer_remove(
+        ID *id, Scene *UNUSED(sce), Main *bmain, ReportList *reports, PointerRNA *sl_ptr)
+{
+	Scene *scene = (Scene *)id;
+	SceneLayer *sl = sl_ptr->data;
+
+	if (!BKE_scene_remove_layer(bmain, scene, sl)) {
+		BKE_reportf(reports, RPT_ERROR, "Scene layer '%s' could not be removed from scene '%s'",
+		            sl->name, scene->id.name + 2);
+		return;
+	}
+
+	RNA_POINTER_INVALIDATE(sl_ptr);
+
+	DAG_id_tag_update(&scene->id, 0);
+	WM_main_add_notifier(NC_SCENE | ND_LAYER, NULL);
+}
+
 static int rna_RenderSettings_active_layer_index_get(PointerRNA *ptr)
 {
 	RenderData *rd = (RenderData *)ptr->data;
@@ -1535,6 +1793,42 @@ static void rna_Scene_use_view_map_cache_update(Main *UNUSED(bmain), Scene *UNUS
 #endif
 }
 
+static void rna_LayerCollection_name_set(PointerRNA *ptr, const char *value)
+{
+	SceneLayer *sl = (SceneLayer *)ptr->id.data;
+	LayerCollection *lc = (LayerCollection *)ptr->data;
+	char oldname[sizeof(lc->name)];
+
+	BLI_strncpy(oldname, lc->name, sizeof(lc->name));
+
+	BLI_strncpy_utf8(lc->name, value, sizeof(lc->name));
+	BLI_uniquename(&sl->collections, sl, DATA_("LayerCollection"), '.', offsetof(LayerCollection, name), sizeof(lc->name));
+}
+
+static void rna_SceneLayer_name_set(PointerRNA *ptr, const char *value)
+{
+	Scene *scene = (Scene *)ptr->id.data;
+	SceneLayer *sl = (SceneLayer *)ptr->data;
+	char oldname[sizeof(sl->name)];
+
+	BLI_strncpy(oldname, sl->name, sizeof(sl->name));
+
+	BLI_strncpy_utf8(sl->name, value, sizeof(sl->name));
+	BLI_uniquename(&scene->layers, sl, DATA_("SceneLayer"), '.', offsetof(SceneLayer, name), sizeof(sl->name));
+
+	if (scene->nodetree) {
+		bNode *node;
+		int index = BLI_findindex(&scene->layers, sl);
+
+		for (node = scene->nodetree->nodes.first; node; node = node->next) {
+			if (node->type == CMP_NODE_R_LAYERS && node->id == NULL) {
+				if (node->custom1 == index)
+					BLI_strncpy(node->name, sl->name, NODE_MAXSTR);
+			}
+		}
+	}
+}
+
 static void rna_SceneRenderLayer_name_set(PointerRNA *ptr, const char *value)
 {
 	Scene *scene = (Scene *)ptr->id.data;
@@ -4903,6 +5197,276 @@ static void rna_def_gpu_fx(BlenderRNA *brna)
 	RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, "rna_GPUFXSettings_fx_update");
 }
 
+/* Scene Layers */
+
+/* layer.bases */
+static void rna_def_layer_bases(BlenderRNA *brna, PropertyRNA *cprop)
+{
+	StructRNA *srna;
+	PropertyRNA *prop;
+
+	RNA_def_property_srna(cprop, "LayerBases");
+	srna = RNA_def_struct(brna, "LayerBases", NULL);
+	RNA_def_struct_sdna(srna, "SceneLayer");
+	RNA_def_struct_ui_text(srna, "Layer Bases", "Collection of layer bases");
+
+	prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
+	RNA_def_property_struct_type(prop, "ObjectBase");
+	RNA_def_property_pointer_sdna(prop, NULL, "basact");
+	RNA_def_property_flag(prop, PROP_EDITABLE);
+	RNA_def_property_ui_text(prop, "Active Base", "Active object base in the scene layer");
+	RNA_def_property_update(prop, NC_SCENE | ND_OB_ACTIVE, NULL);
+}
+
+/* layer.objects */
+static void rna_def_layer_objects(BlenderRNA *brna, PropertyRNA *cprop)
+{
+	StructRNA *srna;
+	PropertyRNA *prop;
+
+	RNA_def_property_srna(cprop, "LayerObjects");
+	srna = RNA_def_struct(brna, "LayerObjects", NULL);
+	RNA_def_struct_sdna(srna, "SceneLayer");
+	RNA_def_struct_ui_text(srna, "Layer Objects", "Collection of layer objects");
+
+	prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
+	RNA_def_property_struct_type(prop, "Object");
+	RNA_def_property_pointer_funcs(prop, "rna_Scene_layer_active_object_get", "rna_Scene_layer_active_object_set", NULL, NULL);
+	RNA_def_property_flag(prop, PROP_EDITABLE | PROP_NEVER_UNLINK);
+	RNA_def_property_ui_text(prop, "Active Object", "Active object for this scene layer");
+	RNA_def_property_update(prop, NC_SCENE | ND_OB_ACTIVE, NULL);
+}
+
+/* collection.objects */
+static void rna_def_layer_collection_objects(BlenderRNA *brna, PropertyRNA *cprop)
+{
+	StructRNA *srna;
+	FunctionRNA *func;
+	PropertyRNA *parm;
+
+	RNA_def_property_srna(cprop, "CollectionObjects");
+	srna = RNA_def_struct(brna, "CollectionObjects", NULL);
+	RNA_def_struct_sdna(srna, "LayerCollection");
+	RNA_def_struct_ui_text(srna, "Collection Objects", "Collection of collection objects");
+
+	func = RNA_def_function(srna, "link", "rna_LayerCollection_object_link");
+	RNA_def_function_ui_description(func, "Link object to collection, run scene.update() after");
+	RNA_def_function_flag(func, FUNC_USE_SELF_ID | FUNC_USE_REPORTS | FUNC_USE_MAIN);
+	parm = RNA_def_pointer(func, "object", "Object", "", "Object to add to collection");
+	RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL);
+	parm = RNA_def_pointer(func, "base", "ObjectBase", "", "The newly created base");
+	RNA_def_function_return(func, parm);
+
+	func = RNA_def_function(srna, "unlink", "rna_LayerCollection_object_unlink");
+	RNA_def_function_ui_description(func, "Unlink object from collection");
+	RNA_def_function_flag(func, FUNC_USE_SELF_ID | FUNC_USE_REPORTS);
+	parm = RNA_def_pointer(func, "object", "Object", "", "Object to remove from collection");
+	RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL);
+}
+
+static void rna_def_layer_nested_collections(BlenderRNA *brna, PropertyRNA *cprop)
+{
+	StructRNA *srna;
+	FunctionRNA *func;
+	PropertyRNA *parm;
+
+	RNA_def_property_srna(cprop, "LayerNestedCollections");
+	srna = RNA_def_struct(brna, "LayerNestedCollections", NULL);
+	RNA_def_struct_sdna(srna, "LayerCollection");
+	RNA_def_struct_ui_text(srna, "Layer Collections", "Collection of layer collections");
+
+	func = RNA_def_function(srna, "new", "rna_LayerNestedCollection_new");
+	RNA_def_function_ui_description(func, "Add a nested layer collection to collection ");
+	RNA_def_function_flag(func, FUNC_USE_SELF_ID);
+	parm = RNA_def_string(func, "name", "LayerCollection", 0, "", "New name for the layer collection (not unique)");
+	RNA_def_property_flag(parm, PROP_REQUIRED);
+	parm = RNA_def_pointer(func, "result", "LayerCollection", "", "Newly created layer collection");
+	RNA_def_function_return(func, parm);
+
+	func = RNA_def_function(srna, "remove", "rna_LayerNestedCollection_remove");
+	RNA_def_function_ui_description(func, "Remove a layer collection");
+	RNA_def_function_flag(func, FUNC_USE_REPORTS | FUNC_USE_SELF_ID);
+	parm = RNA_def_pointer(func, "collection", "LayerCollection", "", "Layer collection to remove");
+	RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
+	RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
+}
+
+static void rna_def_layer_collection(BlenderRNA *brna)
+{
+	StructRNA *srna;
+	PropertyRNA *prop;
+
+	srna = RNA_def_struct(brna, "LayerCollection", NULL);
+	RNA_def_struct_ui_text(srna, "Collection", "Layer collection");
+
+	prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
+	RNA_def_property_string_funcs(prop, NULL, NULL, "rna_LayerCollection_name_set");
+	RNA_def_property_ui_text(prop, "Name", "Layer collection name");
+	RNA_def_struct_name_property(srna, prop);
+	RNA_def_property_update(prop, NC_SCENE | ND_LAYER_CONTENT, NULL);
+
+	prop = RNA_def_property(srna, "objects", PROP_COLLECTION, PROP_NONE);
+	RNA_def_property_collection_sdna(prop, NULL, "elements", NULL);
+	RNA_def_property_struct_type(prop, "Object");
+	RNA_def_property_ui_text(prop, "Objects", "");
+	RNA_def_property_collection_funcs(prop, NULL, NULL, NULL, "rna_LayerCollection_objects_get", NULL, NULL, NULL, NULL);
+	rna_def_layer_collection_objects(brna, prop);
+
+	/* TODO overrides */
+
+	prop = RNA_def_property(srna, "collections", PROP_COLLECTION, PROP_NONE);
+	RNA_def_property_collection_sdna(prop, NULL, "collections", NULL);
+	RNA_def_property_struct_type(prop, "LayerCollection");
+	RNA_def_property_ui_text(prop, "Layer Collections", "");
+	rna_def_layer_nested_collections(brna, prop);
+
+	/* Flags */
+	prop = RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", COLLECTION_VISIBLE);
+	RNA_def_property_ui_icon(prop, ICON_RESTRICT_VIEW_OFF, 0);
+	RNA_def_property_ui_text(prop, "Hide", "Restrict visiblity");
+	RNA_def_property_update(prop, NC_SCENE | ND_LAYER_CONTENT, NULL);
+
+	prop = RNA_def_property(srna, "hide_select", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", COLLECTION_SELECTABLE);
+	RNA_def_property_ui_icon(prop, ICON_RESTRICT_SELECT_OFF, 0);
+	RNA_def_property_ui_text(prop, "Hide Selectable", "Restrict selection");
+	RNA_def_property_update(prop, NC_SCENE | ND_LAYER_CONTENT, NULL);
+}
+
+static void rna_def_layer_collections(BlenderRNA *brna, PropertyRNA *cprop)
+{
+	StructRNA *srna;
+	PropertyRNA *prop;
+
+	FunctionRNA *func;
+	PropertyRNA *parm;
+
+	RNA_def_property_srna(cprop, "LayerCollections");
+	srna = RNA_def_struct(brna, "LayerCollections", NULL);
+	RNA_def_struct_sdna(srna, "SceneLayer");
+	RNA_def_struct_ui_text(srna, "Layer Collections", "Collection of layer collections");
+
+	prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
+	RNA_def_property_int_sdna(prop, NULL, "active_collection");
+	RNA_def_property_int_funcs(prop, "rna_Layer_active_collection_index_get",
+	                           "rna_Layer_active_collection_index_set",
+	                           "rna_Layer_active_collection_index_range");
+	RNA_def_property_ui_text(prop, "Active Collection Index", "Active index in layer collection array");
+	RNA_def_property_update(prop, NC_SCENE | ND_LAYER, NULL);
+
+	prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
+	RNA_def_property_struct_type(prop, "LayerCollection");
+	RNA_def_property_pointer_funcs(prop, "rna_Layer_active_collection_get",
+	                               "rna_Layer_active_collection_set", NULL, NULL);
+	RNA_def_property_flag(prop, PROP_EDITABLE | PROP_NEVER_NULL);
+	RNA_def_property_ui_text(prop, "Active Layer Collection", "Active Layer Collection");
+	RNA_def_property_update(prop, NC_SCENE | ND_LAYER, NULL);
+
+	func = RNA_def_function(srna, "new", "rna_LayerCollection_new");
+	RNA_def_function_ui_description(func, "Add a layer collection to layer");
+	RNA_def_function_flag(func, FUNC_USE_SELF_ID);
+	parm = RNA_def_string(func, "name", "LayerCollection", 0, "", "New name for the layer collection (not unique)");
+	RNA_def_property_flag(parm, PROP_REQUIRED);
+	parm = RNA_def_pointer(func, "result", "LayerCollection", "", "Newly created layer collection");
+	RNA_def_function_return(func, parm);
+
+	func = RNA_def_function(srna, "remove", "rna_LayerCollection_remove");
+	RNA_def_function_ui_description(func, "Remove a layer collection");
+	RNA_def_function_flag(func, FUNC_USE_REPORTS | FUNC_USE_SELF_ID);
+	parm = RNA_def_pointer(func, "collection", "LayerCollection", "", "Layer collection to remove");
+	RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
+	RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
+}
+
+static void rna_def_scene_layer(BlenderRNA *brna)
+{
+	StructRNA *srna;
+	PropertyRNA *prop;
+
+	srna = RNA_def_struct(brna, "SceneLayer", NULL);
+	RNA_def_struct_ui_text(srna, "Layer", "Scene layer");
+	RNA_def_struct_ui_icon(srna, ICON_RENDERLAYERS);
+
+	prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
+	RNA_def_property_string_funcs(prop, NULL, NULL, "rna_SceneLayer_name_set");
+	RNA_def_property_ui_text(prop, "Name", "Scene layer name");
+	RNA_def_struct_name_property(srna, prop);
+	RNA_def_property_update(prop, NC_SCENE | ND_LAYER_CONTENT, NULL);
+
+	prop = RNA_def_property(srna, "collections", PROP_COLLECTION, PROP_NONE);
+	RNA_def_property_collection_sdna(prop, NULL, "collections", NULL);
+	RNA_def_property_struct_type(prop, "LayerCollection");
+	RNA_def_property_ui_text(prop, "Layer Collections", "");
+	rna_def_layer_collections(brna, prop);
+
+	/* TODO engine */
+	/* TODO mode */
+
+	/* Bases/Objects */
+	prop = RNA_def_property(srna, "object_bases", PROP_COLLECTION, PROP_NONE);
+	RNA_def_property_collection_sdna(prop, NULL, "base", NULL);
+	RNA_def_property_struct_type(prop, "ObjectBase");
+	RNA_def_property_ui_text(prop, "Bases", "");
+	RNA_def_property_collection_funcs(prop, NULL, NULL, NULL, NULL, NULL, NULL,
+	                                  "rna_Scene_layer_object_bases_lookup_string", NULL);
+	rna_def_layer_bases(brna, prop);
+
+	prop = RNA_def_property(srna, "objects", PROP_COLLECTION, PROP_NONE);
+	RNA_def_property_collection_sdna(prop, NULL, "base", NULL);
+	RNA_def_property_struct_type(prop, "Object");
+	RNA_def_property_ui_text(prop, "Objects", "");
+	RNA_def_property_collection_funcs(prop, NULL, NULL, NULL, "rna_Scene_layer_objects_get", NULL, NULL, NULL, NULL);
+	rna_def_layer_objects(brna, prop);
+
+	/* Nestled Data */
+	rna_def_layer_collection(brna);
+}
+
+static void rna_def_scene_layers(BlenderRNA *brna, PropertyRNA *cprop)
+{
+	StructRNA *srna;
+	PropertyRNA *prop;
+
+	FunctionRNA *func;
+	PropertyRNA *parm;
+
+	RNA_def_property_srna(cprop, "SceneLayers");
+	srna = RNA_def_struct(brna, "SceneLayers", NULL);
+	RNA_def_struct_sdna(srna, "Scene");
+	RNA_def_struct_ui_text(srna, "Scene Layers", "Collection of scene layers");
+
+	prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
+	RNA_def_property_int_sdna(prop, NULL, "active_layer");
+	RNA_def_property_int_funcs(prop, "rna_Scene_active_scene_layer_index_get",
+	                           "rna_Scene_active_scene_layer_index_set",
+	                           "rna_Scene_active_scene_layer_index_range");
+	RNA_def_property_ui_text(prop, "Active Layer Index", "Active index in scene layer array");
+	RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
+
+	prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
+	RNA_def_property_struct_type(prop, "SceneLayer");
+	RNA_def_property_pointer_funcs(prop, "rna_Scene_active_scene_layer_get",
+	                               "rna_Scene_active_scene_layer_set", NULL, NULL);
+	RNA_def_property_flag(prop, PROP_EDITABLE | PROP_NEVER_NULL);
+	RNA_def_property_ui_text(prop, "Active Scene Layer", "Active Scene Layer");
+	RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
+
+	func = RNA_def_function(srna, "new", "rna_SceneLayer_new");
+	RNA_def_function_ui_description(func, "Add a scene layer to scene");
+	RNA_def_function_flag(func, FUNC_USE_SELF_ID);
+	parm = RNA_def_string(func, "name", "SceneLayer", 0, "", "New name for the scene layer (not unique)");
+	RNA_def_property_flag(parm, PROP_REQUIRED);
+	parm = RNA_def_pointer(func, "result", "SceneLayer", "", "Newly created scene layer");
+	RNA_def_function_return(func, parm);
+
+	func = RNA_def_function(srna, "remove", "rna_SceneLayer_remove");
+	RNA_def_function_ui_description(func, "Remove a scene layer");
+	RNA_def_function_flag(func, FUNC_USE_MAIN | FUNC_USE_REPORTS | FUNC_USE_SELF_ID);
+	parm = RNA_def_pointer(func, "layer", "SceneLayer", "", "Scene layer to remove");
+	RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
+	RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
+}
 
 static void rna_def_scene_render_layer(BlenderRNA *brna)
 {
@@ -7231,6 +7795,13 @@ void RNA_def_scene(BlenderRNA *brna)
 	RNA_def_property_struct_type(prop, "Depsgraph");
 	RNA_def_property_ui_text(prop, "Dependency Graph", "Dependencies in the scene data");
 
+	/* Layers */
+	prop = RNA_def_property(srna, "scene_layers", PROP_COLLECTION, PROP_NONE);
+	RNA_def_property_collection_sdna(prop, NULL, "layers", NULL);
+	RNA_def_property_struct_type(prop, "SceneLayer");
+	RNA_def_property_ui_text(prop, "Scene Layers", "");
+	rna_def_scene_layers(brna, prop);
+
 	/* Nestled Data  */
 	/* *** Non-Animated *** */
 	RNA_define_animate_sdna(false);
@@ -7246,6 +7817,7 @@ void RNA_def_scene(BlenderRNA *brna)
 	rna_def_selected_uv_element(brna);
 	rna_def_display_safe_areas(brna);
 	RNA_define_animate_sdna(true);
+	rna_def_scene_layer(brna);
 	/* *** Animated *** */
 	rna_def_scene_render_data(brna);
 	rna_def_scene_render_layer(brna);