1 files changed, 319 insertions, 242 deletions

diff --git a/source/blender/blenkernel/intern/scene.c b/source/blender/blenkernel/intern/scene.c
index 1e8c1a0db05..41a4998c1ea 100644
--- a/source/blender/blenkernel/intern/scene.c
+++ b/source/blender/blenkernel/intern/scene.c
@@ -125,17 +125,6 @@ void free_avicodecdata(AviCodecData *acd)
 	}
 }
 
-void free_qtcodecdata(QuicktimeCodecData *qcd)
-{
-	if (qcd) {
-		if (qcd->cdParms) {
-			MEM_freeN(qcd->cdParms);
-			qcd->cdParms = NULL;
-			qcd->cdSize = 0;
-		}
-	}
-}
-
 static void remove_sequencer_fcurves(Scene *sce)
 {
 	AnimData *adt = BKE_animdata_from_id(&sce->id);
@@ -154,210 +143,299 @@ static void remove_sequencer_fcurves(Scene *sce)
 	}
 }
 
-Scene *BKE_scene_copy(Main *bmain, Scene *sce, int type)
+/* flag -- copying options (see BKE_library.h's LIB_ID_COPY_... flags for more). */
+ToolSettings *BKE_toolsettings_copy(ToolSettings *toolsettings, const int flag)
 {
-	Scene *scen;
-	SceneRenderLayer *srl, *new_srl;
-	FreestyleLineSet *lineset;
-	ToolSettings *ts;
-	Base *base, *obase;
-	
-	if (type == SCE_COPY_EMPTY) {
-		ListBase rl, rv;
-		scen = BKE_scene_add(bmain, sce->id.name + 2);
-		
-		rl = scen->r.layers;
-		rv = scen->r.views;
-		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->unit = sce->unit;
-		scen->physics_settings = sce->physics_settings;
-		scen->gm = sce->gm;
-		scen->audio = sce->audio;
+	if (toolsettings == NULL) {
+		return NULL;
+	}
+	ToolSettings *ts = MEM_dupallocN(toolsettings);
+	if (ts->vpaint) {
+		ts->vpaint = MEM_dupallocN(ts->vpaint);
+		BKE_paint_copy(&ts->vpaint->paint, &ts->vpaint->paint, flag);
+	}
+	if (ts->wpaint) {
+		ts->wpaint = MEM_dupallocN(ts->wpaint);
+		BKE_paint_copy(&ts->wpaint->paint, &ts->wpaint->paint, flag);
+	}
+	if (ts->sculpt) {
+		ts->sculpt = MEM_dupallocN(ts->sculpt);
+		BKE_paint_copy(&ts->sculpt->paint, &ts->sculpt->paint, flag);
+	}
+	if (ts->uvsculpt) {
+		ts->uvsculpt = MEM_dupallocN(ts->uvsculpt);
+		BKE_paint_copy(&ts->uvsculpt->paint, &ts->uvsculpt->paint, flag);
+	}
 
-		if (sce->id.properties)
-			scen->id.properties = IDP_CopyProperty(sce->id.properties);
+	BKE_paint_copy(&ts->imapaint.paint, &ts->imapaint.paint, flag);
+	ts->imapaint.paintcursor = NULL;
+	ts->particle.paintcursor = NULL;
+	ts->particle.scene = NULL;
+	ts->particle.object = NULL;
 
-		MEM_freeN(scen->toolsettings);
-		BKE_sound_destroy_scene(scen);
+	/* duplicate Grease Pencil Drawing Brushes */
+	BLI_listbase_clear(&ts->gp_brushes);
+	for (bGPDbrush *brush = toolsettings->gp_brushes.first; brush; brush = brush->next) {
+		bGPDbrush *newbrush = BKE_gpencil_brush_duplicate(brush);
+		BLI_addtail(&ts->gp_brushes, newbrush);
 	}
-	else {
-		scen = BKE_libblock_copy(bmain, &sce->id);
-		BLI_duplicatelist(&(scen->base), &(sce->base));
-		
-		id_us_plus((ID *)scen->world);
-		id_us_plus((ID *)scen->set);
-		/* id_us_plus((ID *)scen->gm.dome.warptext); */  /* XXX Not refcounted? see readfile.c */
-
-		scen->ed = NULL;
-		scen->theDag = NULL;
-		scen->depsgraph = NULL;
-		scen->obedit = NULL;
-		scen->stats = NULL;
-		scen->fps_info = NULL;
-
-		if (sce->rigidbody_world)
-			scen->rigidbody_world = BKE_rigidbody_world_copy(sce->rigidbody_world);
-
-		BLI_duplicatelist(&(scen->markers), &(sce->markers));
-		BLI_duplicatelist(&(scen->transform_spaces), &(sce->transform_spaces));
-		BLI_duplicatelist(&(scen->r.layers), &(sce->r.layers));
-		BLI_duplicatelist(&(scen->r.views), &(sce->r.views));
-		BKE_keyingsets_copy(&(scen->keyingsets), &(sce->keyingsets));
 
-		if (sce->nodetree) {
-			/* ID's are managed on both copy and switch */
-			scen->nodetree = ntreeCopyTree(bmain, sce->nodetree);
-			BKE_libblock_relink_ex(bmain, scen->nodetree, &sce->id, &scen->id, false);
-		}
+	/* duplicate Grease Pencil interpolation curve */
+	ts->gp_interpolate.custom_ipo = curvemapping_copy(ts->gp_interpolate.custom_ipo);
+	return ts;
+}
 
-		obase = sce->base.first;
-		base = scen->base.first;
-		while (base) {
-			id_us_plus(&base->object->id);
-			if (obase == sce->basact) scen->basact = base;
-	
-			obase = obase->next;
-			base = base->next;
+void BKE_toolsettings_free(ToolSettings *toolsettings)
+{
+	if (toolsettings == NULL) {
+		return;
+	}
+	if (toolsettings->vpaint) {
+		BKE_paint_free(&toolsettings->vpaint->paint);
+		MEM_freeN(toolsettings->vpaint);
+	}
+	if (toolsettings->wpaint) {
+		BKE_paint_free(&toolsettings->wpaint->paint);
+		MEM_freeN(toolsettings->wpaint);
+	}
+	if (toolsettings->sculpt) {
+		BKE_paint_free(&toolsettings->sculpt->paint);
+		MEM_freeN(toolsettings->sculpt);
+	}
+	if (toolsettings->uvsculpt) {
+		BKE_paint_free(&toolsettings->uvsculpt->paint);
+		MEM_freeN(toolsettings->uvsculpt);
+	}
+	BKE_paint_free(&toolsettings->imapaint.paint);
+
+	/* free Grease Pencil Drawing Brushes */
+	BKE_gpencil_free_brushes(&toolsettings->gp_brushes);
+	BLI_freelistN(&toolsettings->gp_brushes);
+
+	/* free Grease Pencil interpolation curve */
+	if (toolsettings->gp_interpolate.custom_ipo) {
+		curvemapping_free(toolsettings->gp_interpolate.custom_ipo);
+	}
+
+	MEM_freeN(toolsettings);
+}
+
+/**
+ * Only copy internal data of Scene 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_scene_copy_data(Main *bmain, Scene *sce_dst, const Scene *sce_src, const int flag)
+{
+	/* We never handle usercount here for own data. */
+	const int flag_subdata = flag | LIB_ID_CREATE_NO_USER_REFCOUNT;
+
+	sce_dst->ed = NULL;
+	sce_dst->theDag = NULL;
+	sce_dst->depsgraph = NULL;
+	sce_dst->obedit = NULL;
+	sce_dst->stats = NULL;
+	sce_dst->fps_info = NULL;
+
+	BLI_duplicatelist(&(sce_dst->base), &(sce_src->base));
+	for (Base *base_dst = sce_dst->base.first, *base_src = sce_src->base.first;
+	     base_dst;
+	     base_dst = base_dst->next, base_src = base_src->next)
+	{
+		if (base_src == sce_src->basact) {
+			sce_dst->basact = base_dst;
 		}
+	}
 
-		/* copy action and remove animation used by sequencer */
-		BKE_animdata_copy_id_action(&scen->id, false);
+	BLI_duplicatelist(&(sce_dst->markers), &(sce_src->markers));
+	BLI_duplicatelist(&(sce_dst->transform_spaces), &(sce_src->transform_spaces));
+	BLI_duplicatelist(&(sce_dst->r.layers), &(sce_src->r.layers));
+	BLI_duplicatelist(&(sce_dst->r.views), &(sce_src->r.views));
+	BKE_keyingsets_copy(&(sce_dst->keyingsets), &(sce_src->keyingsets));
 
-		if (type != SCE_COPY_FULL)
-			remove_sequencer_fcurves(scen);
+	if (sce_src->nodetree) {
+		/* Note: nodetree is *not* in bmain, however this specific case is handled at lower level
+		 *       (see BKE_libblock_copy_ex()). */
+		BKE_id_copy_ex(bmain, (ID *)sce_src->nodetree, (ID **)&sce_dst->nodetree, flag, false);
+		BKE_libblock_relink_ex(bmain, sce_dst->nodetree, (void *)(&sce_src->id), &sce_dst->id, false);
+	}
 
-		/* copy Freestyle settings */
-		new_srl = scen->r.layers.first;
-		for (srl = sce->r.layers.first; srl; srl = srl->next) {
-			BKE_freestyle_config_copy(&new_srl->freestyleConfig, &srl->freestyleConfig);
-			if (type == SCE_COPY_FULL) {
-				for (lineset = new_srl->freestyleConfig.linesets.first; lineset; lineset = lineset->next) {
-					if (lineset->linestyle) {
-						id_us_plus((ID *)lineset->linestyle);
-						lineset->linestyle = BKE_linestyle_copy(bmain, lineset->linestyle);
-					}
-				}
-			}
-			new_srl = new_srl->next;
+	if (sce_src->rigidbody_world) {
+		sce_dst->rigidbody_world = BKE_rigidbody_world_copy(sce_src->rigidbody_world, flag_subdata);
+	}
+
+	/* copy Freestyle settings */
+	for (SceneRenderLayer *srl_dst = sce_dst->r.layers.first, *srl_src = sce_src->r.layers.first;
+	     srl_src;
+	     srl_dst = srl_dst->next, srl_src = srl_src->next)
+	{
+		if (srl_dst->prop != NULL) {
+			srl_dst->prop = IDP_CopyProperty_ex(srl_dst->prop, flag_subdata);
 		}
+		BKE_freestyle_config_copy(&srl_dst->freestyleConfig, &srl_src->freestyleConfig, flag_subdata);
 	}
 
 	/* copy color management settings */
-	BKE_color_managed_display_settings_copy(&scen->display_settings, &sce->display_settings);
-	BKE_color_managed_view_settings_copy(&scen->view_settings, &sce->view_settings);
-	BKE_color_managed_colorspace_settings_copy(&scen->sequencer_colorspace_settings, &sce->sequencer_colorspace_settings);
+	BKE_color_managed_display_settings_copy(&sce_dst->display_settings, &sce_src->display_settings);
+	BKE_color_managed_view_settings_copy(&sce_dst->view_settings, &sce_src->view_settings);
+	BKE_color_managed_colorspace_settings_copy(&sce_dst->sequencer_colorspace_settings, &sce_src->sequencer_colorspace_settings);
 
-	BKE_color_managed_display_settings_copy(&scen->r.im_format.display_settings, &sce->r.im_format.display_settings);
-	BKE_color_managed_view_settings_copy(&scen->r.im_format.view_settings, &sce->r.im_format.view_settings);
+	BKE_color_managed_display_settings_copy(&sce_dst->r.im_format.display_settings, &sce_src->r.im_format.display_settings);
+	BKE_color_managed_view_settings_copy(&sce_dst->r.im_format.view_settings, &sce_src->r.im_format.view_settings);
 
-	BKE_color_managed_display_settings_copy(&scen->r.bake.im_format.display_settings, &sce->r.bake.im_format.display_settings);
-	BKE_color_managed_view_settings_copy(&scen->r.bake.im_format.view_settings, &sce->r.bake.im_format.view_settings);
+	BKE_color_managed_display_settings_copy(&sce_dst->r.bake.im_format.display_settings, &sce_src->r.bake.im_format.display_settings);
+	BKE_color_managed_view_settings_copy(&sce_dst->r.bake.im_format.view_settings, &sce_src->r.bake.im_format.view_settings);
 
-	curvemapping_copy_data(&scen->r.mblur_shutter_curve, &sce->r.mblur_shutter_curve);
+	curvemapping_copy_data(&sce_dst->r.mblur_shutter_curve, &sce_src->r.mblur_shutter_curve);
 
 	/* tool settings */
-	scen->toolsettings = MEM_dupallocN(sce->toolsettings);
-
-	ts = scen->toolsettings;
-	if (ts) {
-		if (ts->vpaint) {
-			ts->vpaint = MEM_dupallocN(ts->vpaint);
-			ts->vpaint->paintcursor = NULL;
-			ts->vpaint->vpaint_prev = NULL;
-			ts->vpaint->wpaint_prev = NULL;
-			BKE_paint_copy(&ts->vpaint->paint, &ts->vpaint->paint);
-		}
-		if (ts->wpaint) {
-			ts->wpaint = MEM_dupallocN(ts->wpaint);
-			ts->wpaint->paintcursor = NULL;
-			ts->wpaint->vpaint_prev = NULL;
-			ts->wpaint->wpaint_prev = NULL;
-			BKE_paint_copy(&ts->wpaint->paint, &ts->wpaint->paint);
-		}
-		if (ts->sculpt) {
-			ts->sculpt = MEM_dupallocN(ts->sculpt);
-			BKE_paint_copy(&ts->sculpt->paint, &ts->sculpt->paint);
-		}
+	sce_dst->toolsettings = BKE_toolsettings_copy(sce_dst->toolsettings, flag_subdata);
 
-		BKE_paint_copy(&ts->imapaint.paint, &ts->imapaint.paint);
-		ts->imapaint.paintcursor = NULL;
-		id_us_plus((ID *)ts->imapaint.stencil);
-		ts->particle.paintcursor = NULL;
-		
-		/* duplicate Grease Pencil Drawing Brushes */
-		BLI_listbase_clear(&ts->gp_brushes);
-		for (bGPDbrush *brush = sce->toolsettings->gp_brushes.first; brush; brush = brush->next) {
-			bGPDbrush *newbrush = BKE_gpencil_brush_duplicate(brush);
-			BLI_addtail(&ts->gp_brushes, newbrush);
-		}
-		
-		/* duplicate Grease Pencil interpolation curve */
-		ts->gp_interpolate.custom_ipo = curvemapping_copy(ts->gp_interpolate.custom_ipo);
-	}
-	
 	/* make a private copy of the avicodecdata */
-	if (sce->r.avicodecdata) {
-		scen->r.avicodecdata = MEM_dupallocN(sce->r.avicodecdata);
-		scen->r.avicodecdata->lpFormat = MEM_dupallocN(scen->r.avicodecdata->lpFormat);
-		scen->r.avicodecdata->lpParms = MEM_dupallocN(scen->r.avicodecdata->lpParms);
-	}
-	
-	/* make a private copy of the qtcodecdata */
-	if (sce->r.qtcodecdata) {
-		scen->r.qtcodecdata = MEM_dupallocN(sce->r.qtcodecdata);
-		scen->r.qtcodecdata->cdParms = MEM_dupallocN(scen->r.qtcodecdata->cdParms);
+	if (sce_src->r.avicodecdata) {
+		sce_dst->r.avicodecdata = MEM_dupallocN(sce_src->r.avicodecdata);
+		sce_dst->r.avicodecdata->lpFormat = MEM_dupallocN(sce_dst->r.avicodecdata->lpFormat);
+		sce_dst->r.avicodecdata->lpParms = MEM_dupallocN(sce_dst->r.avicodecdata->lpParms);
 	}
-	
-	if (sce->r.ffcodecdata.properties) { /* intentionally check scen not sce. */
-		scen->r.ffcodecdata.properties = IDP_CopyProperty(sce->r.ffcodecdata.properties);
+
+	if (sce_src->r.ffcodecdata.properties) { /* intentionally check sce_dst not sce_src. */  /* XXX ??? comment outdated... */
+		sce_dst->r.ffcodecdata.properties = IDP_CopyProperty_ex(sce_src->r.ffcodecdata.properties, flag_subdata);
 	}
 
-	/* NOTE: part of SCE_COPY_LINK_DATA and SCE_COPY_FULL operations
-	 * are done outside of blenkernel with ED_objects_single_users! */
+	/* before scene copy */
+	BKE_sound_create_scene(sce_dst);
 
-	/*  camera */
-	if (type == SCE_COPY_LINK_DATA || type == SCE_COPY_FULL) {
-		ID_NEW_REMAP(scen->camera);
+	/* Copy sequencer, this is local data! */
+	if (sce_src->ed) {
+		sce_dst->ed = MEM_callocN(sizeof(*sce_dst->ed), __func__);
+		sce_dst->ed->seqbasep = &sce_dst->ed->seqbase;
+		BKE_sequence_base_dupli_recursive(
+		            sce_src, sce_dst, &sce_dst->ed->seqbase, &sce_src->ed->seqbase, SEQ_DUPE_ALL, flag_subdata);
 	}
-	
-	/* before scene copy */
-	BKE_sound_create_scene(scen);
 
-	/* world */
-	if (type == SCE_COPY_FULL) {
-		if (scen->world) {
-			id_us_plus((ID *)scen->world);
-			scen->world = BKE_world_copy(bmain, scen->world);
-			BKE_animdata_copy_id_action((ID *)scen->world, false);
+	if ((flag & LIB_ID_COPY_NO_PREVIEW) == 0) {
+		BKE_previewimg_id_copy(&sce_dst->id, &sce_src->id);
+	}
+	else {
+		sce_dst->preview = NULL;
+	}
+}
+
+Scene *BKE_scene_copy(Main *bmain, Scene *sce, int type)
+{
+	Scene *sce_copy;
+
+	/* TODO this should/could most likely be replaced by call to more generic code at some point...
+	 * But for now, let's keep it well isolated here. */
+	if (type == SCE_COPY_EMPTY) {
+		ListBase rl, rv;
+
+		sce_copy = BKE_scene_add(bmain, sce->id.name + 2);
+
+		rl = sce_copy->r.layers;
+		rv = sce_copy->r.views;
+		curvemapping_free_data(&sce_copy->r.mblur_shutter_curve);
+		sce_copy->r = sce->r;
+		sce_copy->r.layers = rl;
+		sce_copy->r.actlay = 0;
+		sce_copy->r.views = rv;
+		sce_copy->unit = sce->unit;
+		sce_copy->physics_settings = sce->physics_settings;
+		sce_copy->gm = sce->gm;
+		sce_copy->audio = sce->audio;
+
+		if (sce->id.properties)
+			sce_copy->id.properties = IDP_CopyProperty(sce->id.properties);
+
+		MEM_freeN(sce_copy->toolsettings);
+		BKE_sound_destroy_scene(sce_copy);
+
+		/* copy color management settings */
+		BKE_color_managed_display_settings_copy(&sce_copy->display_settings, &sce->display_settings);
+		BKE_color_managed_view_settings_copy(&sce_copy->view_settings, &sce->view_settings);
+		BKE_color_managed_colorspace_settings_copy(&sce_copy->sequencer_colorspace_settings, &sce->sequencer_colorspace_settings);
+
+		BKE_color_managed_display_settings_copy(&sce_copy->r.im_format.display_settings, &sce->r.im_format.display_settings);
+		BKE_color_managed_view_settings_copy(&sce_copy->r.im_format.view_settings, &sce->r.im_format.view_settings);
+
+		BKE_color_managed_display_settings_copy(&sce_copy->r.bake.im_format.display_settings, &sce->r.bake.im_format.display_settings);
+		BKE_color_managed_view_settings_copy(&sce_copy->r.bake.im_format.view_settings, &sce->r.bake.im_format.view_settings);
+
+		curvemapping_copy_data(&sce_copy->r.mblur_shutter_curve, &sce->r.mblur_shutter_curve);
+
+		/* tool settings */
+		sce_copy->toolsettings = BKE_toolsettings_copy(sce->toolsettings, 0);
+
+		/* make a private copy of the avicodecdata */
+		if (sce->r.avicodecdata) {
+			sce_copy->r.avicodecdata = MEM_dupallocN(sce->r.avicodecdata);
+			sce_copy->r.avicodecdata->lpFormat = MEM_dupallocN(sce_copy->r.avicodecdata->lpFormat);
+			sce_copy->r.avicodecdata->lpParms = MEM_dupallocN(sce_copy->r.avicodecdata->lpParms);
 		}
 
-		if (sce->ed) {
-			scen->ed = MEM_callocN(sizeof(Editing), "addseq");
-			scen->ed->seqbasep = &scen->ed->seqbase;
-			BKE_sequence_base_dupli_recursive(sce, scen, &scen->ed->seqbase, &sce->ed->seqbase, SEQ_DUPE_ALL);
+		if (sce->r.ffcodecdata.properties) { /* intentionally check scen not sce. */
+			sce_copy->r.ffcodecdata.properties = IDP_CopyProperty(sce->r.ffcodecdata.properties);
 		}
+
+		/* before scene copy */
+		BKE_sound_create_scene(sce_copy);
+
+		/* grease pencil */
+		sce_copy->gpd = NULL;
+
+		sce_copy->preview = NULL;
+
+		return sce_copy;
 	}
-	
-	/* grease pencil */
-	if (scen->gpd) {
+	else {
+		BKE_id_copy_ex(bmain, (ID *)sce, (ID **)&sce_copy, LIB_ID_COPY_ACTIONS, false);
+		id_us_min(&sce_copy->id);
+		id_us_ensure_real(&sce_copy->id);
+
+		/* Extra actions, most notably SCE_FULL_COPY also duplicates several 'children' datablocks... */
+
 		if (type == SCE_COPY_FULL) {
-			scen->gpd = BKE_gpencil_data_duplicate(bmain, scen->gpd, false);
-		}
-		else if (type == SCE_COPY_EMPTY) {
-			scen->gpd = NULL;
+			/* Copy Freestyle LineStyle datablocks. */
+			for (SceneRenderLayer *srl_dst = sce_copy->r.layers.first; srl_dst; srl_dst = srl_dst->next) {
+				for (FreestyleLineSet *lineset = srl_dst->freestyleConfig.linesets.first; lineset; lineset = lineset->next) {
+					if (lineset->linestyle) {
+						/* XXX Not copying anim/actions here? */
+						BKE_id_copy_ex(bmain, (ID *)lineset->linestyle, (ID **)&lineset->linestyle, 0, false);
+					}
+				}
+			}
+
+			/* Full copy of world (included animations) */
+			if (sce_copy->world) {
+				BKE_id_copy_ex(bmain, (ID *)sce_copy->world, (ID **)&sce_copy->world, LIB_ID_COPY_ACTIONS, false);
+			}
+
+			/* Full copy of GreasePencil. */
+			/* XXX Not copying anim/actions here? */
+			if (sce_copy->gpd) {
+				BKE_id_copy_ex(bmain, (ID *)sce_copy->gpd, (ID **)&sce_copy->gpd, 0, false);
+			}
 		}
 		else {
-			id_us_plus((ID *)scen->gpd);
+			/* Remove sequencer if not full copy */
+			/* XXX Why in Hell? :/ */
+			remove_sequencer_fcurves(sce_copy);
+			BKE_sequencer_editing_free(sce_copy);
 		}
-	}
 
-	BKE_previewimg_id_copy(&scen->id, &sce->id);
+		/* NOTE: part of SCE_COPY_LINK_DATA and SCE_COPY_FULL operations
+		 * are done outside of blenkernel with ED_objects_single_users! */
 
-	return scen;
+		/*  camera */
+		if (ELEM(type, SCE_COPY_LINK_DATA, SCE_COPY_FULL)) {
+			ID_NEW_REMAP(sce_copy->camera);
+		}
+
+		return sce_copy;
+	}
 }
 
 void BKE_scene_groups_relink(Scene *sce)
@@ -406,57 +484,27 @@ void BKE_scene_free(Scene *sce)
 		MEM_freeN(sce->r.avicodecdata);
 		sce->r.avicodecdata = NULL;
 	}
-	if (sce->r.qtcodecdata) {
-		free_qtcodecdata(sce->r.qtcodecdata);
-		MEM_freeN(sce->r.qtcodecdata);
-		sce->r.qtcodecdata = NULL;
-	}
 	if (sce->r.ffcodecdata.properties) {
 		IDP_FreeProperty(sce->r.ffcodecdata.properties);
 		MEM_freeN(sce->r.ffcodecdata.properties);
 		sce->r.ffcodecdata.properties = NULL;
 	}
-	
+
 	for (srl = sce->r.layers.first; srl; srl = srl->next) {
+		if (srl->prop != NULL) {
+			IDP_FreeProperty(srl->prop);
+			MEM_freeN(srl->prop);
+		}
 		BKE_freestyle_config_free(&srl->freestyleConfig);
 	}
-	
+
 	BLI_freelistN(&sce->markers);
 	BLI_freelistN(&sce->transform_spaces);
 	BLI_freelistN(&sce->r.layers);
 	BLI_freelistN(&sce->r.views);
 	
-	if (sce->toolsettings) {
-		if (sce->toolsettings->vpaint) {
-			BKE_paint_free(&sce->toolsettings->vpaint->paint);
-			MEM_freeN(sce->toolsettings->vpaint);
-		}
-		if (sce->toolsettings->wpaint) {
-			BKE_paint_free(&sce->toolsettings->wpaint->paint);
-			MEM_freeN(sce->toolsettings->wpaint);
-		}
-		if (sce->toolsettings->sculpt) {
-			BKE_paint_free(&sce->toolsettings->sculpt->paint);
-			MEM_freeN(sce->toolsettings->sculpt);
-		}
-		if (sce->toolsettings->uvsculpt) {
-			BKE_paint_free(&sce->toolsettings->uvsculpt->paint);
-			MEM_freeN(sce->toolsettings->uvsculpt);
-		}
-		BKE_paint_free(&sce->toolsettings->imapaint.paint);
-		
-		/* free Grease Pencil Drawing Brushes */
-		BKE_gpencil_free_brushes(&sce->toolsettings->gp_brushes);
-		BLI_freelistN(&sce->toolsettings->gp_brushes);
-		
-		/* free Grease Pencil interpolation curve */
-		if (sce->toolsettings->gp_interpolate.custom_ipo) {
-			curvemapping_free(sce->toolsettings->gp_interpolate.custom_ipo);
-		}
-		
-		MEM_freeN(sce->toolsettings);
-		sce->toolsettings = NULL;
-	}
+	BKE_toolsettings_free(sce->toolsettings);
+	sce->toolsettings = NULL;
 	
 	DAG_scene_free(sce);
 	if (sce->depsgraph)
@@ -566,7 +614,7 @@ void BKE_scene_init(Scene *sce)
 
 	sce->r.seq_prev_type = OB_SOLID;
 	sce->r.seq_rend_type = OB_SOLID;
-	sce->r.seq_flag = R_SEQ_GL_PREV;
+	sce->r.seq_flag = 0;
 
 	sce->r.threads = 1;
 
@@ -660,7 +708,8 @@ void BKE_scene_init(Scene *sce)
 	pset->draw_step = 2;
 	pset->fade_frames = 2;
 	pset->selectmode = SCE_SELECT_PATH;
-	for (a = 0; a < PE_TOT_BRUSH; a++) {
+
+	for (a = 0; a < ARRAY_SIZE(pset->brush); a++) {
 		pset->brush[a].strength = 0.5f;
 		pset->brush[a].size = 50;
 		pset->brush[a].step = 10;
@@ -825,7 +874,7 @@ Scene *BKE_scene_add(Main *bmain, const char *name)
 {
 	Scene *sce;
 
-	sce = BKE_libblock_alloc(bmain, ID_SCE, name);
+	sce = BKE_libblock_alloc(bmain, ID_SCE, name, 0);
 	id_us_min(&sce->id);
 	id_us_ensure_real(&sce->id);
 
@@ -1063,6 +1112,10 @@ Object *BKE_scene_camera_find(Scene *sc)
 #ifdef DURIAN_CAMERA_SWITCH
 Object *BKE_scene_camera_switch_find(Scene *scene)
 {
+	if (scene->r.mode & R_NO_CAMERA_SWITCH) {
+		return NULL;
+	}
+
 	TimeMarker *m;
 	int cfra = scene->r.cfra;
 	int frame = -(MAXFRAME + 1);
@@ -1438,6 +1491,8 @@ typedef struct ThreadedObjectUpdateState {
 	bool has_mballs;
 #endif
 
+	int num_threads;
+
 	/* Execution statistics */
 	bool has_updated_objects;
 	ListBase *statistics;
@@ -1486,7 +1541,7 @@ static void scene_update_object_func(TaskPool * __restrict pool, void *taskdata,
 		double start_time = 0.0;
 		bool add_to_stats = false;
 
-		if (G.debug & G_DEBUG_DEPSGRAPH) {
+		if (G.debug & G_DEBUG_DEPSGRAPH_EVAL) {
 			if (object->recalc & OB_RECALC_ALL) {
 				printf("Thread %d: update object %s\n", threadid, object->id.name);
 			}
@@ -1509,8 +1564,6 @@ static void scene_update_object_func(TaskPool * __restrict pool, void *taskdata,
 		if (add_to_stats) {
 			StatisicsEntry *entry;
 
-			BLI_assert(threadid < BLI_pool_get_num_threads(pool));
-
 			entry = MEM_mallocN(sizeof(StatisicsEntry), "update thread statistics");
 			entry->object = object;
 			entry->start_time = start_time;
@@ -1539,10 +1592,9 @@ static void scene_update_object_add_task(void *node, void *user_data)
 
 static void print_threads_statistics(ThreadedObjectUpdateState *state)
 {
-	int i, tot_thread;
 	double finish_time;
 
-	if ((G.debug & G_DEBUG_DEPSGRAPH) == 0) {
+	if ((G.debug & G_DEBUG_DEPSGRAPH_EVAL) == 0) {
 		return;
 	}
 
@@ -1567,10 +1619,9 @@ static void print_threads_statistics(ThreadedObjectUpdateState *state)
 	}
 #else
 	finish_time = PIL_check_seconds_timer();
-	tot_thread = BLI_system_thread_count();
 	int total_objects = 0;
 
-	for (i = 0; i < tot_thread; i++) {
+	for (int i = 0; i < state->num_threads; i++) {
 		int thread_total_objects = 0;
 		double thread_total_time = 0.0;
 		StatisicsEntry *entry;
@@ -1630,10 +1681,11 @@ static bool scene_need_update_objects(Main *bmain)
 
 static void scene_update_objects(EvaluationContext *eval_ctx, Main *bmain, Scene *scene, Scene *scene_parent)
 {
-	TaskScheduler *task_scheduler = BLI_task_scheduler_get();
+	TaskScheduler *task_scheduler;
 	TaskPool *task_pool;
 	ThreadedObjectUpdateState state;
 	bool need_singlethread_pass;
+	bool need_free_scheduler;
 
 	/* Early check for whether we need to invoke all the task-based
 	 * things (spawn new ppol, traverse dependency graph and so on).
@@ -1650,13 +1702,23 @@ static void scene_update_objects(EvaluationContext *eval_ctx, Main *bmain, Scene
 	state.scene = scene;
 	state.scene_parent = scene_parent;
 
+	if (G.debug & G_DEBUG_DEPSGRAPH_NO_THREADS) {
+		task_scheduler = BLI_task_scheduler_create(1);
+		need_free_scheduler = true;
+	}
+	else {
+		task_scheduler = BLI_task_scheduler_get();
+		need_free_scheduler = false;
+	}
+
 	/* Those are only needed when blender is run with --debug argument. */
-	if (G.debug & G_DEBUG_DEPSGRAPH) {
+	if (G.debug & G_DEBUG_DEPSGRAPH_EVAL) {
 		const int tot_thread = BLI_task_scheduler_num_threads(task_scheduler);
 		state.statistics = MEM_callocN(tot_thread * sizeof(*state.statistics),
 		                               "scene update objects stats");
 		state.has_updated_objects = false;
 		state.base_time = PIL_check_seconds_timer();
+		state.num_threads = tot_thread;
 	}
 
 #ifdef MBALL_SINGLETHREAD_HACK
@@ -1664,15 +1726,12 @@ static void scene_update_objects(EvaluationContext *eval_ctx, Main *bmain, Scene
 #endif
 
 	task_pool = BLI_task_pool_create(task_scheduler, &state);
-	if (G.debug & G_DEBUG_DEPSGRAPH_NO_THREADS) {
-		BLI_pool_set_num_threads(task_pool, 1);
-	}
 
 	DAG_threaded_update_begin(scene, scene_update_object_add_task, task_pool);
 	BLI_task_pool_work_and_wait(task_pool);
 	BLI_task_pool_free(task_pool);
 
-	if (G.debug & G_DEBUG_DEPSGRAPH) {
+	if (G.debug & G_DEBUG_DEPSGRAPH_EVAL) {
 		print_threads_statistics(&state);
 		MEM_freeN(state.statistics);
 	}
@@ -1699,6 +1758,10 @@ static void scene_update_objects(EvaluationContext *eval_ctx, Main *bmain, Scene
 	if (need_singlethread_pass) {
 		scene_update_all_bases(eval_ctx, scene, scene_parent);
 	}
+
+	if (need_free_scheduler) {
+		BLI_task_scheduler_free(task_scheduler);
+	}
 }
 
 static void scene_update_tagged_recursive(EvaluationContext *eval_ctx, Main *bmain, Scene *scene, Scene *scene_parent)
@@ -1757,12 +1820,16 @@ static void prepare_mesh_for_viewport_render(Main *bmain, Scene *scene)
 	if (obedit) {
 		Mesh *mesh = obedit->data;
 		if ((obedit->type == OB_MESH) &&
-		    ((obedit->id.tag & LIB_TAG_ID_RECALC_ALL) ||
-		     (mesh->id.tag & LIB_TAG_ID_RECALC_ALL)))
+		    ((obedit->id.recalc & ID_RECALC_ALL) ||
+		     (mesh->id.recalc & ID_RECALC_ALL)))
 		{
 			if (check_rendered_viewport_visible(bmain)) {
 				BMesh *bm = mesh->edit_btmesh->bm;
-				BM_mesh_bm_to_me(bm, mesh, (&(struct BMeshToMeshParams){0}));
+				BM_mesh_bm_to_me(
+				        bm, mesh,
+				        (&(struct BMeshToMeshParams){
+				            .calc_object_remap = true,
+				        }));
 				DAG_id_tag_update(&mesh->id, 0);
 			}
 		}
@@ -1782,7 +1849,7 @@ void BKE_scene_update_tagged(EvaluationContext *eval_ctx, Main *bmain, Scene *sc
 	/* (re-)build dependency graph if needed */
 	for (sce_iter = scene; sce_iter; sce_iter = sce_iter->set) {
 		DAG_scene_relations_update(bmain, sce_iter);
-		/* Uncomment this to check if graph was properly tagged for update. */
+		/* Uncomment this to check if dependency graph was properly tagged for update. */
 #if 0
 #ifdef WITH_LEGACY_DEPSGRAPH
 		if (use_new_eval)
@@ -1820,8 +1887,6 @@ void BKE_scene_update_tagged(EvaluationContext *eval_ctx, Main *bmain, Scene *sc
 #endif
 	{
 		DEG_evaluate_on_refresh(eval_ctx, scene->depsgraph, scene);
-		/* TODO(sergey): This is to beocme a node in new depsgraph. */
-		BKE_mask_update_scene(bmain, scene);
 	}
 
 	/* update sound system animation (TODO, move to depsgraph) */
@@ -1896,7 +1961,7 @@ void BKE_scene_update_for_newframe_ex(EvaluationContext *eval_ctx, Main *bmain,
 #ifdef WITH_LEGACY_DEPSGRAPH
 	bool use_new_eval = !DEG_depsgraph_use_legacy();
 #else
-	/* TODO(sergey): Pass to evaluation routines instead of storing layer in the graph? */
+	/* TODO(sergey): Pass to evaluation routines instead of storing layer in the dependency graph? */
 	(void) do_invisible_flush;
 #endif
 
@@ -1938,11 +2003,10 @@ void BKE_scene_update_for_newframe_ex(EvaluationContext *eval_ctx, Main *bmain,
 		/* Following 2 functions are recursive
 		 * so don't call within 'scene_update_tagged_recursive' */
 		DAG_scene_update_flags(bmain, sce, lay, true, do_invisible_flush);   // only stuff that moves or needs display still
+		BKE_mask_evaluate_all_masks(bmain, ctime, true);
 	}
 #endif
 
-	BKE_mask_evaluate_all_masks(bmain, ctime, true);
-
 	/* Update animated cache files for modifiers. */
 	BKE_cachefile_update_frame(bmain, sce, ctime, (((double)sce->r.frs_sec) / (double)sce->r.frs_sec_base));
 
@@ -2053,6 +2117,11 @@ bool BKE_scene_remove_render_layer(Main *bmain, Scene *scene, SceneRenderLayer *
 
 	BKE_freestyle_config_free(&srl->freestyleConfig);
 
+	if (srl->prop) {
+		IDP_FreeProperty(srl->prop);
+		MEM_freeN(srl->prop);
+	}
+
 	BLI_remlink(&scene->r.layers, srl);
 	MEM_freeN(srl);
 
@@ -2115,7 +2184,7 @@ bool BKE_scene_remove_render_view(Scene *scene, SceneRenderView *srv)
 
 int get_render_subsurf_level(const RenderData *r, int lvl, bool for_render)
 {
-	if (r->mode & R_SIMPLIFY)  {
+	if (r->mode & R_SIMPLIFY) {
 		if (for_render)
 			return min_ii(r->simplify_subsurf_render, lvl);
 		else
@@ -2286,6 +2355,14 @@ int BKE_scene_num_threads(const Scene *scene)
 	return BKE_render_num_threads(&scene->r);
 }
 
+int BKE_render_preview_pixel_size(const RenderData *r)
+{
+	if (r->preview_pixel_size == 0) {
+		return (U.pixelsize > 1.5f) ? 2 : 1;
+	}
+	return r->preview_pixel_size;
+}
+
 /* Apply the needed correction factor to value, based on unit_type (only length-related are affected currently)
  * and unit->scale_length.
  */