Workspace: Move engines to workspace and Properties Editor cleanup

Engine is not stored in WorkSpaces. That defines the "context" engine, which
is used for the entire UI.

The engine used for the poll of nodes (add node menu, new nodes when "Use Nodes")
is obtained from context.

Introduce a ViewRender struct for viewport settings that are defined for
workspaces and scene. This struct will be populated with the hand-picked
settings that can be defined per workspace as per the 2.8 design.

* use_scene_settings
* properties editor: workshop + organize context path

Use Scene Settings
==================
For viewport drawing, Workspaces have an option to use the Scene render
settings (F12) instead of the viewport settings.

This way users can quickly preview the final render settings, engine and
View Layer. This will affect all the editors in that workspace, and it will be
clearly indicated in the top-bar.

Properties Editor: Add Workspace and organize context path
==========================================================

We now have the properties of:

Scene, Scene > Layer, Scene > World, Workspace

[Scene | Workspace] > Render Layer > Object
[Scene | Workspace] > Render Layer > Object > Data
(...)

Reviewers: Campbell Barton, Julian Eisel
Differential Revision: https://developer.blender.org/D2842

15 files changed, 407 insertions, 111 deletions

diff --git a/source/blender/blenkernel/BKE_context.h b/source/blender/blenkernel/BKE_context.h
index 350d7a40875..7b071dc01a5 100644
--- a/source/blender/blenkernel/BKE_context.h
+++ b/source/blender/blenkernel/BKE_context.h
@@ -54,6 +54,7 @@ struct SceneLayer;
 struct ScrArea;
 struct SpaceLink;
 struct View3D;
+struct ViewRender;
 struct RegionView3D;
 struct StructRNA;
 struct ToolSettings;
@@ -69,6 +70,7 @@ struct bGPDpalettecolor;
 struct bGPDbrush;
 struct wmWindow;
 struct wmWindowManager;
+struct RenderEngineType;
 struct SpaceText;
 struct SpaceImage;
 struct SpaceClip;
@@ -251,6 +253,8 @@ struct Scene *CTX_data_scene(const bContext *C);
 struct LayerCollection *CTX_data_layer_collection(const bContext *C);
 struct SceneCollection *CTX_data_scene_collection(const bContext *C);
 struct SceneLayer *CTX_data_scene_layer(const bContext *C);
+struct ViewRender *CTX_data_view_render(const bContext *C);
+struct RenderEngineType *CTX_data_engine(const bContext *C);
 struct ToolSettings *CTX_data_tool_settings(const bContext *C);
 
 const char *CTX_data_mode_string(const bContext *C);
diff --git a/source/blender/blenkernel/BKE_layer.h b/source/blender/blenkernel/BKE_layer.h
index 52d5405ec0a..1585742729c 100644
--- a/source/blender/blenkernel/BKE_layer.h
+++ b/source/blender/blenkernel/BKE_layer.h
@@ -57,7 +57,7 @@ struct WorkSpace;
 void BKE_layer_exit(void);
 
 struct SceneLayer *BKE_scene_layer_from_scene_get(const struct Scene *scene);
-struct SceneLayer *BKE_scene_layer_from_workspace_get(const struct WorkSpace *workspace);
+struct SceneLayer *BKE_scene_layer_from_workspace_get(const struct Scene *scene, const struct WorkSpace *workspace);
 struct SceneLayer *BKE_scene_layer_add(struct Scene *scene, const char *name);
 
 /* DEPRECATED */
@@ -65,8 +65,6 @@ struct SceneLayer *BKE_scene_layer_context_active_PLACEHOLDER(const struct Scene
 
 void BKE_scene_layer_free(struct SceneLayer *sl);
 
-void BKE_scene_layer_engine_set(struct SceneLayer *sl, const char *engine);
-
 void BKE_scene_layer_selected_objects_tag(struct SceneLayer *sl, const int tag);
 
 struct SceneLayer *BKE_scene_layer_find_from_collection(const struct Scene *scene, struct LayerCollection *lc);
@@ -167,6 +165,10 @@ void BKE_visible_objects_iterator_begin(BLI_Iterator *iter, void *data_in);
 void BKE_visible_objects_iterator_next(BLI_Iterator *iter);
 void BKE_visible_objects_iterator_end(BLI_Iterator *iter);
 
+void BKE_renderable_objects_iterator_begin(BLI_Iterator *iter, void *data_in);
+void BKE_renderable_objects_iterator_next(BLI_Iterator *iter);
+void BKE_renderable_objects_iterator_end(BLI_Iterator *iter);
+
 void BKE_selected_bases_iterator_begin(BLI_Iterator *iter, void *data_in);
 void BKE_selected_bases_iterator_next(BLI_Iterator *iter);
 void BKE_selected_bases_iterator_end(BLI_Iterator *iter);
@@ -248,6 +250,29 @@ void BKE_visible_bases_iterator_end(BLI_Iterator *iter);
 	ITER_END                                                                  \
 }
 
+typedef struct ObjectsRenderableIteratorData {
+	struct Scene *scene;
+
+	struct {
+		struct SceneLayer *scene_layer;
+		struct Base *base;
+		struct Scene *set;
+	} iter;
+} ObjectsRenderableIteratorData;
+
+#define FOREACH_OBJECT_RENDERABLE(scene_, _instance)                          \
+	ObjectsRenderableIteratorData data_ = {                                   \
+	    .scene = (scene_),                                                    \
+	};                                                                        \
+	ITER_BEGIN(BKE_renderable_objects_iterator_begin,                         \
+	           BKE_renderable_objects_iterator_next,                          \
+	           BKE_renderable_objects_iterator_end,                           \
+	           &data_, Object *, _instance)
+
+
+#define FOREACH_OBJECT_RENDERABLE_END                                         \
+	ITER_END
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/source/blender/blenkernel/BKE_node.h b/source/blender/blenkernel/BKE_node.h
index 3bb8f6c9ed3..fe9fb2598d0 100644
--- a/source/blender/blenkernel/BKE_node.h
+++ b/source/blender/blenkernel/BKE_node.h
@@ -74,6 +74,7 @@ struct PointerRNA;
 struct RenderData;
 struct Scene;
 struct Tex;
+struct ViewRender;
 struct SpaceNode;
 struct ARegion;
 struct ColorManagedViewSettings;
@@ -282,7 +283,7 @@ typedef struct bNodeTreeType {
 	/* callbacks */
 	void (*free_cache)(struct bNodeTree *ntree);
 	void (*free_node_cache)(struct bNodeTree *ntree, struct bNode *node);
-	void (*foreach_nodeclass)(struct Scene *scene, void *calldata, bNodeClassCallback func);	/* iteration over all node classes */
+	void (*foreach_nodeclass)(struct ViewRender *view_render, void *calldata, bNodeClassCallback func);	/* iteration over all node classes */
 	/* Check visibility in the node editor */
 	int (*poll)(const struct bContext *C, struct bNodeTreeType *ntreetype);
 	/* Select a node tree from the context */
diff --git a/source/blender/blenkernel/BKE_pointcache.h b/source/blender/blenkernel/BKE_pointcache.h
index f0819c8d79d..48fe8423233 100644
--- a/source/blender/blenkernel/BKE_pointcache.h
+++ b/source/blender/blenkernel/BKE_pointcache.h
@@ -90,6 +90,7 @@ struct ParticleKey;
 struct ParticleSystem;
 struct PointCache;
 struct Scene;
+struct SceneLayer;
 struct SmokeModifierData;
 struct SoftBody;
 struct RigidBodyWorld;
@@ -186,6 +187,7 @@ typedef struct PTCacheID {
 typedef struct PTCacheBaker {
 	struct Main *main;
 	struct Scene *scene;
+	struct SceneLayer *scene_layer;
 	int bake;
 	int render;
 	int anim_init;
@@ -319,7 +321,7 @@ struct PointCache *BKE_ptcache_copy_list(struct ListBase *ptcaches_new, const st
 /********************** Baking *********************/
 
 /* Bakes cache with cache_step sized jumps in time, not accurate but very fast. */
-void BKE_ptcache_quick_cache_all(struct Main *bmain, struct Scene *scene);
+void BKE_ptcache_quick_cache_all(struct Main *bmain, struct Scene *scene, struct SceneLayer *scene_layer);
 
 /* Bake cache or simulate to current frame with settings defined in the baker. */
 void BKE_ptcache_bake(struct PTCacheBaker *baker);
diff --git a/source/blender/blenkernel/BKE_scene.h b/source/blender/blenkernel/BKE_scene.h
index e517b65cf3e..b31cd1742a2 100644
--- a/source/blender/blenkernel/BKE_scene.h
+++ b/source/blender/blenkernel/BKE_scene.h
@@ -50,7 +50,8 @@ struct Scene;
 struct SceneCollection;
 struct SceneLayer;
 struct UnitSettings;
-struct Main;
+struct ViewRender;
+struct WorkSpace;
 
 typedef enum eSceneCopyMethod {
 	SCE_COPY_NEW       = 0,
@@ -62,11 +63,21 @@ typedef enum eSceneCopyMethod {
 
 /* Use as the contents of a 'for' loop: for (SETLOOPER(...)) { ... */
 #define SETLOOPER(_sce_basis, _sce_iter, _base)                               \
-	_sce_iter = _sce_basis, _base = _setlooper_base_step(&_sce_iter, NULL);   \
+	_sce_iter = _sce_basis, _base = _setlooper_base_step(&_sce_iter, BKE_scene_layer_from_scene_get(_sce_basis), NULL); \
+	_base;                                                                    \
+	_base = _setlooper_base_step(&_sce_iter, NULL, _base)
+
+#define SETLOOPER_SCENE_LAYER(_sce_basis, _scene_layer, _sce_iter, _base)     \
+	_sce_iter = _sce_basis, _base = _setlooper_base_step(&_sce_iter, _scene_layer, NULL);   \
 	_base;                                                                    \
-	_base = _setlooper_base_step(&_sce_iter, _base)
+	_base = _setlooper_base_step(&_sce_iter, NULL, _base)
 
-struct Base *_setlooper_base_step(struct Scene **sce_iter, struct Base *base);
+#define SETLOOPER_SET_ONLY(_sce_basis, _sce_iter, _base)     \
+	_sce_iter = _sce_basis, _base = _setlooper_base_step(&_sce_iter, NULL, NULL);   \
+	_base;                                                                    \
+	_base = _setlooper_base_step(&_sce_iter, NULL, _base)
+
+struct Base *_setlooper_base_step(struct Scene **sce_iter, struct SceneLayer *scene_layer, struct Base *base);
 
 void free_avicodecdata(struct AviCodecData *acd);
 
@@ -168,6 +179,22 @@ int BKE_render_num_threads(const struct RenderData *r);
 
 int BKE_render_preview_pixel_size(const struct RenderData *r);
 
+/**********************************/
+
+struct ViewRender *BKE_viewrender_get(struct Scene *scene, struct WorkSpace *workspace);
+void BKE_viewrender_init(struct ViewRender *view_render);
+void BKE_viewrender_free(struct ViewRender *view_render);
+void BKE_viewrender_copy(struct ViewRender *view_render_dst, const struct ViewRender *view_render_src);
+bool BKE_viewrender_use_new_shading_nodes(const struct ViewRender *view_render);
+bool BKE_viewrender_use_shading_nodes_custom(const struct ViewRender *view_render);
+bool BKE_viewrender_use_world_space_shading(const struct ViewRender *view_render);
+bool BKE_viewrender_use_spherical_stereo(const struct ViewRender *view_render);
+bool BKE_viewrender_uses_blender_internal(const struct ViewRender *view_render);
+bool BKE_viewrender_uses_blender_game(const struct ViewRender *view_render);
+bool BKE_viewrender_uses_blender_eevee(const struct ViewRender *view_render);
+
+/**********************************/
+
 double BKE_scene_unit_scale(const struct UnitSettings *unit, const int unit_type, double value);
 
 /* multiview */
diff --git a/source/blender/blenkernel/BKE_screen.h b/source/blender/blenkernel/BKE_screen.h
index 3cb78a427ab..2bbe5b0587e 100644
--- a/source/blender/blenkernel/BKE_screen.h
+++ b/source/blender/blenkernel/BKE_screen.h
@@ -85,7 +85,7 @@ typedef struct SpaceType {
 	void (*exit)(struct wmWindowManager *, struct ScrArea *);
 	/* Listeners can react to bContext changes */
 	void (*listener)(struct bScreen *sc, struct ScrArea *,
-	                 struct wmNotifier *, const struct Scene *scene);
+	                 struct wmNotifier *, struct Scene *scene, struct WorkSpace *workspace);
 	
 	/* refresh context, called after filereads, ED_area_tag_refresh() */
 	void (*refresh)(const struct bContext *, struct ScrArea *);
diff --git a/source/blender/blenkernel/BKE_sequencer.h b/source/blender/blenkernel/BKE_sequencer.h
index bcc06a4ab25..dfb6b47a4e4 100644
--- a/source/blender/blenkernel/BKE_sequencer.h
+++ b/source/blender/blenkernel/BKE_sequencer.h
@@ -422,7 +422,8 @@ struct Sequence *BKE_sequencer_add_movie_strip(struct bContext *C, ListBase *seq
 
 /* view3d draw callback, run when not in background view */
 typedef struct ImBuf *(*SequencerDrawView)(
-        const struct EvaluationContext *eval_ctx, struct Scene *, struct SceneLayer *sl, struct Object *, int, int,
+        const struct EvaluationContext *eval_ctx, struct Scene *,
+        struct SceneLayer *sl, struct Object *, int, int,
         unsigned int, int, bool, bool, bool,
         int, int, bool, const char *,
         struct GPUFX *, struct GPUOffScreen *, char[256]);
diff --git a/source/blender/blenkernel/BKE_workspace.h b/source/blender/blenkernel/BKE_workspace.h
index 43962c2eb35..67868ee961a 100644
--- a/source/blender/blenkernel/BKE_workspace.h
+++ b/source/blender/blenkernel/BKE_workspace.h
@@ -115,6 +115,12 @@ struct WorkSpaceLayout *BKE_workspace_hook_layout_for_workspace_get(
 void             BKE_workspace_hook_layout_for_workspace_set(
         struct WorkSpaceInstanceHook *hook, struct WorkSpace *workspace, struct WorkSpaceLayout *layout) ATTR_NONNULL();
 
+struct ViewRender *BKE_workspace_view_render_get(struct WorkSpace *workspace) GETTER_ATTRS;
+
+/* flags */
+bool BKE_workspace_use_scene_settings_get(const struct WorkSpace *workspace) GETTER_ATTRS;
+void BKE_workspace_use_scene_settings_set(struct WorkSpace *workspace, bool value) SETTER_ATTRS;
+
 #undef GETTER_ATTRS
 #undef SETTER_ATTRS
 
diff --git a/source/blender/blenkernel/intern/collision.c b/source/blender/blenkernel/intern/collision.c
index acb48a9646f..bc50fdd5a11 100644
--- a/source/blender/blenkernel/intern/collision.c
+++ b/source/blender/blenkernel/intern/collision.c
@@ -47,6 +47,7 @@
 
 #include "BKE_cloth.h"
 #include "BKE_effect.h"
+#include "BKE_layer.h"
 #include "BKE_modifier.h"
 #include "BKE_scene.h"
 
diff --git a/source/blender/blenkernel/intern/context.c b/source/blender/blenkernel/intern/context.c
index 4f1dd18b39c..bc75958ba33 100644
--- a/source/blender/blenkernel/intern/context.c
+++ b/source/blender/blenkernel/intern/context.c
@@ -57,6 +57,8 @@
 #include "BKE_sound.h"
 #include "BKE_workspace.h"
 
+#include "RE_engine.h"
+
 #include "RNA_access.h"
 
 #ifdef WITH_PYTHON
@@ -927,10 +929,36 @@ SceneLayer *CTX_data_scene_layer(const bContext *C)
 		return sl;
 	}
 	else {
-		return BKE_scene_layer_from_workspace_get(CTX_wm_workspace(C));
+		return BKE_scene_layer_from_workspace_get(CTX_data_scene(C), CTX_wm_workspace(C));
+	}
+}
+
+ViewRender *CTX_data_view_render(const bContext *C)
+{
+	ViewRender *view_render;
+
+	if (ctx_data_pointer_verify(C, "view_render", (void *)&view_render)) {
+		return view_render;
+	}
+	else {
+		Scene *scene = CTX_data_scene(C);
+		WorkSpace *workspace = CTX_wm_workspace(C);
+		return BKE_viewrender_get(scene, workspace);
 	}
 }
 
+RenderEngineType *CTX_data_engine(const bContext *C)
+{
+	const char *engine_id;
+
+	if (!ctx_data_pointer_verify(C, "engine", (void *)&engine_id)) {
+		ViewRender *view_render = CTX_data_view_render(C);
+		engine_id = view_render->engine_id;
+	}
+
+	return RE_engines_find(engine_id);
+}
+
 /**
  * This is tricky. Sometimes the user overrides the render_layer
  * but not the scene_collection. In this case what to do?
@@ -1247,7 +1275,8 @@ void CTX_data_eval_ctx(const bContext *C, EvaluationContext *eval_ctx)
 
 	Scene *scene = CTX_data_scene(C);
 	SceneLayer *scene_layer = CTX_data_scene_layer(C);
+	RenderEngineType *engine = CTX_data_engine(C);
 	DEG_evaluation_context_init_from_scene(eval_ctx,
-	                                       scene, scene_layer,
+	                                       scene, scene_layer, engine,
 	                                       DAG_EVAL_VIEWPORT);
 }
diff --git a/source/blender/blenkernel/intern/layer.c b/source/blender/blenkernel/intern/layer.c
index f20b96b8bc7..0e0290414a4 100644
--- a/source/blender/blenkernel/intern/layer.c
+++ b/source/blender/blenkernel/intern/layer.c
@@ -82,9 +82,14 @@ SceneLayer *BKE_scene_layer_from_scene_get(const Scene *scene)
 /**
  * Returns the SceneLayer to be used for drawing, outliner, and other context related areas.
  */
-SceneLayer *BKE_scene_layer_from_workspace_get(const struct WorkSpace *workspace)
+SceneLayer *BKE_scene_layer_from_workspace_get(const struct Scene *scene, const struct WorkSpace *workspace)
 {
-	return BKE_workspace_render_layer_get(workspace);
+	if (BKE_workspace_use_scene_settings_get(workspace)) {
+		return BKE_scene_layer_from_scene_get(scene);
+	}
+	else {
+		return BKE_workspace_render_layer_get(workspace);
+	}
 }
 
 /**
@@ -171,14 +176,6 @@ void BKE_scene_layer_free(SceneLayer *sl)
 }
 
 /**
- * Set the render engine of a renderlayer
- */
-void BKE_scene_layer_engine_set(SceneLayer *sl, const char *engine)
-{
-	BLI_strncpy_utf8(sl->engine, engine, sizeof(sl->engine));
-}
-
-/**
  * Tag all the selected objects of a renderlayer
  */
 void BKE_scene_layer_selected_objects_tag(SceneLayer *sl, const int tag)
@@ -1781,6 +1778,89 @@ void BKE_visible_bases_iterator_end(BLI_Iterator *UNUSED(iter))
 	/* do nothing */
 }
 
+void BKE_renderable_objects_iterator_begin(BLI_Iterator *iter, void *data_in)
+{
+	ObjectsRenderableIteratorData *data = data_in;
+
+	for (Scene *scene = data->scene; scene; scene = scene->set) {
+		for (SceneLayer *sl = scene->render_layers.first; sl; sl = sl->next) {
+			for (Base *base = sl->object_bases.first; base; base = base->next) {
+				 base->object->id.flag |=  LIB_TAG_DOIT;
+			}
+		}
+	}
+
+	SceneLayer *scene_layer = data->scene->render_layers.first;
+	data->iter.scene_layer = scene_layer;
+
+	Base base = {(Base *)scene_layer->object_bases.first, NULL};
+	data->iter.base = &base;
+
+	data->iter.set = NULL;
+
+	iter->data = data_in;
+	BKE_renderable_objects_iterator_next(iter);
+}
+
+void BKE_renderable_objects_iterator_next(BLI_Iterator *iter)
+{
+	ObjectsRenderableIteratorData *data = iter->data;
+	Base *base = data->iter.base->next;
+
+	/* There is still a base in the current scene layer. */
+	if (base != NULL) {
+		Object *ob = base->object;
+
+		iter->current = ob;
+		data->iter.base = base;
+
+		if ((base->flag & BASE_VISIBLED) == 0) {
+			BKE_renderable_objects_iterator_next(iter);
+		}
+		return;
+	}
+
+	/* Time to go to the next scene layer. */
+	if (data->iter.set == NULL) {
+		while ((data->iter.scene_layer = data->iter.scene_layer->next)) {
+			SceneLayer *scene_layer = data->iter.scene_layer;
+			if (scene_layer->flag & SCENE_LAYER_RENDER) {
+
+				Base base_iter = {(Base *)scene_layer->object_bases.first, NULL};
+				data->iter.base = &base_iter;
+
+				BKE_renderable_objects_iterator_next(iter);
+				return;
+			}
+		}
+
+		/* Setup the "set" for the next iteration. */
+		Scene scene = {.set = data->scene};
+		data->iter.set = &scene;
+		BKE_renderable_objects_iterator_next(iter);
+		return;
+	}
+
+	/* Look for an object in the next set. */
+	while ((data->iter.set = data->iter.set->set)) {
+		SceneLayer *scene_layer = BKE_scene_layer_from_scene_get(data->iter.set);
+
+		Base base_iter = {(Base *)scene_layer->object_bases.first, NULL};
+		data->iter.base = &base_iter;
+
+		BKE_renderable_objects_iterator_next(iter);
+		return;
+	}
+
+	iter->current = NULL;
+	iter->valid = false;
+}
+
+void BKE_renderable_objects_iterator_end(BLI_Iterator *UNUSED(iter))
+{
+	/* Do nothing - iter->data was static allocated, we can't free it. */
+}
+
 /* Evaluation  */
 
 /**
diff --git a/source/blender/blenkernel/intern/pointcache.c b/source/blender/blenkernel/intern/pointcache.c
index 5ec3156f4df..35d65551483 100644
--- a/source/blender/blenkernel/intern/pointcache.c
+++ b/source/blender/blenkernel/intern/pointcache.c
@@ -3509,13 +3509,14 @@ PointCache *BKE_ptcache_copy_list(ListBase *ptcaches_new, const ListBase *ptcach
  * every user action changing stuff, and then it runs a complete bake??? (ton) */
 
 /* Baking */
-void BKE_ptcache_quick_cache_all(Main *bmain, Scene *scene)
+void BKE_ptcache_quick_cache_all(Main *bmain, Scene *scene, SceneLayer *scene_layer)
 {
 	PTCacheBaker baker;
 
 	memset(&baker, 0, sizeof(baker));
 	baker.main = bmain;
 	baker.scene = scene;
+	baker.scene_layer = scene_layer;
 	baker.bake = 0;
 	baker.render = 0;
 	baker.anim_init = 0;
@@ -3541,6 +3542,7 @@ void BKE_ptcache_bake(PTCacheBaker *baker)
 {
 	Main *bmain = baker->main;
 	Scene *scene = baker->scene;
+	SceneLayer *scene_layer = baker->scene_layer;
 	Scene *sce_iter; /* SETLOOPER macro only */
 	Base *base;
 	ListBase pidlist;
@@ -3603,7 +3605,7 @@ void BKE_ptcache_bake(PTCacheBaker *baker)
 		}
 	}
 	else {
-		for (SETLOOPER(scene, sce_iter, base)) {
+		for (SETLOOPER_SCENE_LAYER(scene, scene_layer, sce_iter, base)) {
 			/* cache/bake everything in the scene */
 			BKE_ptcache_ids_from_object(&pidlist, base->object, scene, MAX_DUPLI_RECUR);
 
@@ -3714,7 +3716,7 @@ void BKE_ptcache_bake(PTCacheBaker *baker)
 		}
 	}
 	else {
-		for (SETLOOPER(scene, sce_iter, base)) {
+		for (SETLOOPER_SCENE_LAYER(scene, scene_layer, sce_iter, base)) {
 			BKE_ptcache_ids_from_object(&pidlist, base->object, scene, MAX_DUPLI_RECUR);
 
 			for (pid=pidlist.first; pid; pid=pid->next) {
diff --git a/source/blender/blenkernel/intern/scene.c b/source/blender/blenkernel/intern/scene.c
index 6b2d809c31a..f49ba37faaa 100644
--- a/source/blender/blenkernel/intern/scene.c
+++ b/source/blender/blenkernel/intern/scene.c
@@ -49,6 +49,7 @@
 #include "DNA_space_types.h"
 #include "DNA_view3d_types.h"
 #include "DNA_windowmanager_types.h"
+#include "DNA_workspace_types.h"
 #include "DNA_gpencil_types.h"
 
 #include "BLI_math.h"
@@ -905,7 +906,7 @@ void BKE_scene_init(Scene *sce)
 	sce->r.ffcodecdata.audio_bitrate = 192;
 	sce->r.ffcodecdata.audio_channels = 2;
 
-	BLI_strncpy(sce->r.engine, RE_engine_id_BLENDER_EEVEE, sizeof(sce->r.engine));
+	BKE_viewrender_init(&sce->view_render);
 
 	sce->audio.distance_model = 2.0f;
 	sce->audio.doppler_factor = 1.0f;
@@ -1541,9 +1542,11 @@ static bool check_rendered_viewport_visible(Main *bmain)
 	wmWindow *window;
 	for (window = wm->windows.first; window != NULL; window = window->next) {
 		const bScreen *screen = BKE_workspace_active_screen_get(window->workspace_hook);
+		WorkSpace *workspace = BKE_workspace_active_get(window->workspace_hook);
 		Scene *scene = window->scene;
+		ViewRender *view_render = BKE_viewrender_get(scene, workspace);
 		ScrArea *area;
-		RenderEngineType *type = RE_engines_find(scene->r.engine);
+		RenderEngineType *type = RE_engines_find(view_render->engine_id);
 		if ((type->draw_engine != NULL) || (type->render_to_view == NULL)) {
 			continue;
 		}
@@ -1833,38 +1836,32 @@ float get_render_aosss_error(const RenderData *r, float error)
 }
 
 /**
-  * Helper function for the SETLOOPER macro
+  * Helper function for the SETLOOPER and SETLOOPER_SCENE_LAYER macros
   *
   * It iterates over the bases of the active layer and then the bases
   * of the active layer of the background (set) scenes recursively.
   */
-Base *_setlooper_base_step(Scene **sce_iter, Base *base)
+Base *_setlooper_base_step(Scene **sce_iter, SceneLayer *scene_layer, Base *base)
 {
 	if (base && base->next) {
-		/* common case, step to the next */
+		/* Common case, step to the next. */
 		return base->next;
 	}
-	else if (base == NULL) {
-		/* first time looping, return the scenes first base */
-
-		/* for the first loop we should get the layer from context */
-		SceneLayer *sl = BKE_scene_layer_context_active_PLACEHOLDER((*sce_iter));
-		/* TODO For first scene (non-background set), we should pass the render layer as argument.
-		 * In some cases we want it to be the workspace one, in other the scene one. */
-		TODO_LAYER;
-
-		if (sl->object_bases.first) {
-			return (Base *)sl->object_bases.first;
+	else if ((base == NULL) && (scene_layer != NULL)) {
+		/* First time looping, return the scenes first base. */
+		/* For the first loop we should get the layer from workspace when available. */
+		if (scene_layer->object_bases.first) {
+			return (Base *)scene_layer->object_bases.first;
 		}
-		/* no base on this scene layer */
+		/* No base on this scene layer. */
 		goto next_set;
 	}
 	else {
 next_set:
-		/* reached the end, get the next base in the set */
+		/* Reached the end, get the next base in the set. */
 		while ((*sce_iter = (*sce_iter)->set)) {
-			SceneLayer *sl = BKE_scene_layer_from_scene_get((*sce_iter));
-			base = (Base *)sl->object_bases.first;
+			SceneLayer *scene_layer_set = BKE_scene_layer_from_scene_get((*sce_iter));
+			base = (Base *)scene_layer_set->object_bases.first;
 
 			if (base) {
 				return base;
@@ -1877,42 +1874,39 @@ next_set:
 
 bool BKE_scene_use_new_shading_nodes(const Scene *scene)
 {
-	const RenderEngineType *type = RE_engines_find(scene->r.engine);
-	return (type && type->flag & RE_USE_SHADING_NODES);
+	return BKE_viewrender_use_new_shading_nodes(&scene->view_render);
 }
 
 bool BKE_scene_use_shading_nodes_custom(Scene *scene)
 {
-	RenderEngineType *type = RE_engines_find(scene->r.engine);
-	return (type && type->flag & RE_USE_SHADING_NODES_CUSTOM);
+	return BKE_viewrender_use_shading_nodes_custom(&scene->view_render);
 }
 
 bool BKE_scene_use_world_space_shading(Scene *scene)
 {
-	const RenderEngineType *type = RE_engines_find(scene->r.engine);
+	RenderEngineType *type = RE_engines_find(scene->view_render.engine_id);
 	return ((scene->r.mode & R_USE_WS_SHADING) ||
 	        (type && (type->flag & RE_USE_SHADING_NODES)));
 }
 
 bool BKE_scene_use_spherical_stereo(Scene *scene)
 {
-	RenderEngineType *type = RE_engines_find(scene->r.engine);
-	return (type && type->flag & RE_USE_SPHERICAL_STEREO);
+	return BKE_viewrender_use_spherical_stereo(&scene->view_render);
 }
 
-bool BKE_scene_uses_blender_internal(const  Scene *scene)
+bool BKE_scene_uses_blender_internal(const Scene *scene)
 {
-	return STREQ(scene->r.engine, RE_engine_id_BLENDER_RENDER);
+	return BKE_viewrender_uses_blender_internal(&scene->view_render);
 }
 
 bool BKE_scene_uses_blender_game(const Scene *scene)
 {
-	return STREQ(scene->r.engine, RE_engine_id_BLENDER_GAME);
+	return BKE_viewrender_uses_blender_game(&scene->view_render);
 }
 
 bool BKE_scene_uses_blender_eevee(const Scene *scene)
 {
-	return STREQ(scene->r.engine, RE_engine_id_BLENDER_EEVEE);
+	return BKE_viewrender_uses_blender_eevee(&scene->view_render);
 }
 
 void BKE_scene_base_flag_to_objects(SceneLayer *sl)
@@ -2027,6 +2021,81 @@ int BKE_render_preview_pixel_size(const RenderData *r)
 	return r->preview_pixel_size;
 }
 
+/* ***************************************************** */
+/* render engine settings */
+
+ViewRender *BKE_viewrender_get(Scene *scene, WorkSpace *workspace)
+{
+	if (workspace == NULL || BKE_workspace_use_scene_settings_get(workspace)) {
+		return &scene->view_render;
+	}
+	return BKE_workspace_view_render_get(workspace);
+}
+
+/**
+ * Initialize a static created struct for WorkSpace and Scene to store the viewport
+ * related drawing data.
+ */
+void BKE_viewrender_init(ViewRender *view_render)
+{
+	BLI_strncpy(view_render->engine_id, RE_engine_id_BLENDER_EEVEE, sizeof(view_render->engine_id));
+}
+
+/**
+ * Do not free ViewRender itself since it's not even allocated.
+ */
+void BKE_viewrender_free(ViewRender *UNUSED(view_render))
+{
+	/* Do nothing. */
+}
+
+/**
+ * Copy used by libblock copying.
+ */
+void BKE_viewrender_copy(ViewRender *to, const ViewRender *from)
+{
+	*to = *from;
+}
+
+bool BKE_viewrender_use_new_shading_nodes(const ViewRender *view_render)
+{
+	RenderEngineType *type = RE_engines_find(view_render->engine_id);
+	return (type && type->flag & RE_USE_SHADING_NODES);
+}
+
+bool BKE_viewrender_use_shading_nodes_custom(const ViewRender *view_render)
+{
+	RenderEngineType *type = RE_engines_find(view_render->engine_id);
+	return (type && type->flag & RE_USE_SHADING_NODES_CUSTOM);
+}
+
+bool BKE_viewrender_use_spherical_stereo(const ViewRender *view_render)
+{
+	const char *engine_id = view_render->engine_id;
+	RenderEngineType *type = RE_engines_find(engine_id);
+	return (type && type->flag & RE_USE_SPHERICAL_STEREO);
+}
+
+bool BKE_viewrender_uses_blender_internal(const ViewRender *view_render)
+{
+	const char *engine_id = view_render->engine_id;
+	return STREQ(engine_id, RE_engine_id_BLENDER_RENDER);
+}
+
+bool BKE_viewrender_uses_blender_game(const ViewRender *view_render)
+{
+	const char *engine_id = view_render->engine_id;
+	return STREQ(engine_id, RE_engine_id_BLENDER_GAME);
+}
+
+bool BKE_viewrender_uses_blender_eevee(const ViewRender *view_render)
+{
+	const char *engine_id = view_render->engine_id;
+	return STREQ(engine_id, RE_engine_id_BLENDER_EEVEE);
+}
+
+/* ***************************************************** */
+
 /* Apply the needed correction factor to value, based on unit_type (only length-related are affected currently)
  * and unit->scale_length.
  */
diff --git a/source/blender/blenkernel/intern/sound.c b/source/blender/blenkernel/intern/sound.c
index a2568707b0a..6cf310461c1 100644
--- a/source/blender/blenkernel/intern/sound.c
+++ b/source/blender/blenkernel/intern/sound.c
@@ -806,13 +806,76 @@ void BKE_sound_read_waveform(bSound *sound, short *stop)
 	BLI_spin_unlock(sound->spinlock);
 }
 
-void BKE_sound_update_scene(Main *bmain, struct Scene *scene)
+static void sound_update_base(Scene *scene, Base *base, void *new_set)
 {
-	Object *ob;
-	Base *base;
+	Object *ob = base->object;
 	NlaTrack *track;
 	NlaStrip *strip;
 	Speaker *speaker;
+	float quat[4];
+
+	if ((ob->id.tag & LIB_TAG_DOIT) == 0) {
+		return;
+	}
+
+	ob->id.tag &= ~LIB_TAG_DOIT;
+
+	if ((ob->type != OB_SPEAKER) || !ob->adt) {
+		return;
+	}
+
+	for (track = ob->adt->nla_tracks.first; track; track = track->next) {
+		for (strip = track->strips.first; strip; strip = strip->next) {
+			if (strip->type != NLASTRIP_TYPE_SOUND) {
+				continue;
+			}
+			speaker = (Speaker *)ob->data;
+
+			if (AUD_removeSet(scene->speaker_handles, strip->speaker_handle)) {
+				if (speaker->sound) {
+					AUD_SequenceEntry_move(strip->speaker_handle, (double)strip->start / FPS, FLT_MAX, 0);
+				}
+				else {
+					AUD_Sequence_remove(scene->sound_scene, strip->speaker_handle);
+					strip->speaker_handle = NULL;
+				}
+			}
+			else {
+				if (speaker->sound) {
+					strip->speaker_handle = AUD_Sequence_add(scene->sound_scene,
+					                                        speaker->sound->playback_handle,
+					                                        (double)strip->start / FPS, FLT_MAX, 0);
+					AUD_SequenceEntry_setRelative(strip->speaker_handle, 0);
+				}
+			}
+
+			if (strip->speaker_handle) {
+				const bool mute = ((strip->flag & NLASTRIP_FLAG_MUTED) || (speaker->flag & SPK_MUTED));
+				AUD_addSet(new_set, strip->speaker_handle);
+				AUD_SequenceEntry_setVolumeMaximum(strip->speaker_handle, speaker->volume_max);
+				AUD_SequenceEntry_setVolumeMinimum(strip->speaker_handle, speaker->volume_min);
+				AUD_SequenceEntry_setDistanceMaximum(strip->speaker_handle, speaker->distance_max);
+				AUD_SequenceEntry_setDistanceReference(strip->speaker_handle, speaker->distance_reference);
+				AUD_SequenceEntry_setAttenuation(strip->speaker_handle, speaker->attenuation);
+				AUD_SequenceEntry_setConeAngleOuter(strip->speaker_handle, speaker->cone_angle_outer);
+				AUD_SequenceEntry_setConeAngleInner(strip->speaker_handle, speaker->cone_angle_inner);
+				AUD_SequenceEntry_setConeVolumeOuter(strip->speaker_handle, speaker->cone_volume_outer);
+
+				mat4_to_quat(quat, ob->obmat);
+				AUD_SequenceEntry_setAnimationData(strip->speaker_handle, AUD_AP_LOCATION, CFRA, ob->obmat[3], 1);
+				AUD_SequenceEntry_setAnimationData(strip->speaker_handle, AUD_AP_ORIENTATION, CFRA, quat, 1);
+				AUD_SequenceEntry_setAnimationData(strip->speaker_handle, AUD_AP_VOLUME, CFRA, &speaker->volume, 1);
+				AUD_SequenceEntry_setAnimationData(strip->speaker_handle, AUD_AP_PITCH, CFRA, &speaker->pitch, 1);
+				AUD_SequenceEntry_setSound(strip->speaker_handle, speaker->sound->playback_handle);
+				AUD_SequenceEntry_setMuted(strip->speaker_handle, mute);
+			}
+		}
+	}
+}
+
+void BKE_sound_update_scene(Main *bmain, Scene *scene)
+{
+	Base *base;
 	Scene *sce_it;
 
 	void *new_set = AUD_createSet();
@@ -821,59 +884,18 @@ void BKE_sound_update_scene(Main *bmain, struct Scene *scene)
 
 	/* cheap test to skip looping over all objects (no speakers is a common case) */
 	if (!BLI_listbase_is_empty(&bmain->speaker)) {
-		for (SETLOOPER(scene, sce_it, base)) {
-			ob = base->object;
-			if ((ob->type != OB_SPEAKER) || !ob->adt) {
-				continue;
-			}
-			for (track = ob->adt->nla_tracks.first; track; track = track->next) {
-				for (strip = track->strips.first; strip; strip = strip->next) {
-					if (strip->type != NLASTRIP_TYPE_SOUND) {
-						continue;
-					}
-					speaker = (Speaker *)ob->data;
-
-					if (AUD_removeSet(scene->speaker_handles, strip->speaker_handle)) {
-						if (speaker->sound) {
-							AUD_SequenceEntry_move(strip->speaker_handle, (double)strip->start / FPS, FLT_MAX, 0);
-						}
-						else {
-							AUD_Sequence_remove(scene->sound_scene, strip->speaker_handle);
-							strip->speaker_handle = NULL;
-						}
-					}
-					else {
-						if (speaker->sound) {
-							strip->speaker_handle = AUD_Sequence_add(scene->sound_scene,
-							                                        speaker->sound->playback_handle,
-							                                        (double)strip->start / FPS, FLT_MAX, 0);
-							AUD_SequenceEntry_setRelative(strip->speaker_handle, 0);
-						}
-					}
-
-					if (strip->speaker_handle) {
-						const bool mute = ((strip->flag & NLASTRIP_FLAG_MUTED) || (speaker->flag & SPK_MUTED));
-						AUD_addSet(new_set, strip->speaker_handle);
-						AUD_SequenceEntry_setVolumeMaximum(strip->speaker_handle, speaker->volume_max);
-						AUD_SequenceEntry_setVolumeMinimum(strip->speaker_handle, speaker->volume_min);
-						AUD_SequenceEntry_setDistanceMaximum(strip->speaker_handle, speaker->distance_max);
-						AUD_SequenceEntry_setDistanceReference(strip->speaker_handle, speaker->distance_reference);
-						AUD_SequenceEntry_setAttenuation(strip->speaker_handle, speaker->attenuation);
-						AUD_SequenceEntry_setConeAngleOuter(strip->speaker_handle, speaker->cone_angle_outer);
-						AUD_SequenceEntry_setConeAngleInner(strip->speaker_handle, speaker->cone_angle_inner);
-						AUD_SequenceEntry_setConeVolumeOuter(strip->speaker_handle, speaker->cone_volume_outer);
-
-						mat4_to_quat(quat, ob->obmat);
-						AUD_SequenceEntry_setAnimationData(strip->speaker_handle, AUD_AP_LOCATION, CFRA, ob->obmat[3], 1);
-						AUD_SequenceEntry_setAnimationData(strip->speaker_handle, AUD_AP_ORIENTATION, CFRA, quat, 1);
-						AUD_SequenceEntry_setAnimationData(strip->speaker_handle, AUD_AP_VOLUME, CFRA, &speaker->volume, 1);
-						AUD_SequenceEntry_setAnimationData(strip->speaker_handle, AUD_AP_PITCH, CFRA, &speaker->pitch, 1);
-						AUD_SequenceEntry_setSound(strip->speaker_handle, speaker->sound->playback_handle);
-						AUD_SequenceEntry_setMuted(strip->speaker_handle, mute);
-					}
-				}
+		BKE_main_id_tag_listbase(&bmain->object, LIB_TAG_DOIT, true);
+
+		for (SceneLayer *scene_layer = scene->render_layers.first; scene_layer; scene_layer = scene_layer->next) {
+			for (base = scene_layer->object_bases.first; base; base = base->next) {
+				sound_update_base(scene, base, new_set);
 			}
 		}
+
+		for (SETLOOPER_SET_ONLY(scene, sce_it, base)) {
+			sound_update_base(scene, base, new_set);
+		}
+
 	}
 
 	while ((handle = AUD_getSet(scene->speaker_handles))) {
diff --git a/source/blender/blenkernel/intern/workspace.c b/source/blender/blenkernel/intern/workspace.c
index 05dab9208e5..0747bde16d3 100644
--- a/source/blender/blenkernel/intern/workspace.c
+++ b/source/blender/blenkernel/intern/workspace.c
@@ -29,12 +29,14 @@
 
 #include "BLI_utildefines.h"
 #include "BLI_string.h"
+#include "BLI_string_utf8.h"
 #include "BLI_string_utils.h"
 #include "BLI_listbase.h"
 
 #include "BKE_global.h"
 #include "BKE_library.h"
 #include "BKE_main.h"
+#include "BKE_scene.h"
 #include "BKE_screen.h"
 #include "BKE_workspace.h"
 
@@ -161,6 +163,7 @@ void BKE_workspace_remove(Main *bmain, WorkSpace *workspace)
 		BKE_workspace_layout_remove(bmain, workspace, layout);
 	}
 
+	BKE_viewrender_free(&workspace->view_render);
 	BKE_libblock_free(bmain, workspace);
 }
 
@@ -430,3 +433,27 @@ void BKE_workspace_hook_layout_for_workspace_set(
 	hook->act_layout = layout;
 	workspace_relation_ensure_updated(&workspace->hook_layout_relations, hook, layout);
 }
+
+/**
+ * Get the render engine of a workspace, to be used in the viewport.
+ */
+ViewRender *BKE_workspace_view_render_get(WorkSpace *workspace)
+{
+	return &workspace->view_render;
+}
+
+/* Flags */
+bool BKE_workspace_use_scene_settings_get(const WorkSpace *workspace)
+{
+	return (workspace->flags & WORKSPACE_USE_SCENE_SETTINGS) != 0;
+}
+
+void BKE_workspace_use_scene_settings_set(WorkSpace *workspace, bool value)
+{
+	if (value) {
+		workspace->flags |= WORKSPACE_USE_SCENE_SETTINGS;
+	}
+	else {
+		workspace->flags &= ~WORKSPACE_USE_SCENE_SETTINGS;
+	}
+}