Workspace: better default for ambient light

- A collection has an override for casting shadows. When not set, the
objects in the collection will not cast any shadows.

release/scripts/startup/bl_ui/properties_collection.py

@@ -167,9 +167,28 @@ class COLLECTION_PT_paint_vertex_mode_settings(CollectionButtonsPanel, Panel):
         col.template_override_property(collection_props, scene_props, "use_wire")
 
 
+class COLLECTION_PT_workbench_settings(CollectionButtonsPanel, Panel):
+    bl_label = "Workbench Settings"
+    COMPAT_ENGINES = {'BLENDER_WORKBENCH'}
+
+    @classmethod
+    def poll(cls, context):
+        return context.engine in cls.COMPAT_ENGINES
+
+    def draw(self, context):
+        layout = self.layout
+        scene_props = context.scene.collection_properties['BLENDER_WORKBENCH']
+        collection = get_collection_from_context(context)
+        collection_props = collection.engine_overrides['BLENDER_WORKBENCH']
+
+        col = layout.column()
+        col.template_override_property(collection_props, scene_props, "show_shadows")
+
+
 classes = (
     COLLECTION_PT_context_collection,
     COLLECTION_PT_clay_settings,
+    COLLECTION_PT_workbench_settings,
     COLLECTION_PT_object_mode_settings,
     COLLECTION_PT_edit_mode_settings,
     COLLECTION_PT_paint_weight_mode_settings,

release/scripts/startup/bl_ui/properties_render.py

@@ -767,6 +767,8 @@ class RENDER_PT_workbench_environment_light(RenderButtonsPanel, Panel):
         col.prop(props, "diffuse_light_z_pos", text="Front/Back")
         col.prop(props, "diffuse_light_z_neg", text="")
 
+        layout.prop(props, "light_direction", text="")
+
 
 classes = (
     RENDER_MT_presets,

release/scripts/startup/bl_ui/space_view3d.py

@@ -3551,6 +3551,10 @@ class VIEW3D_PT_shading(Panel):
             col.separator()
             col.row().prop(shading, "single_color_mode", expand=True)
             col.prop(shading, "show_object_overlap")
+            col.prop(shading, "show_shadows")
+            if shading.show_shadows:
+                col.prop(shading, "ambient_light_intensity")
+
 
             if shading.light == 'STUDIO':
                 # TODO: don't store these settings in the scene

source/blender/blenloader/intern/versioning_280.c

@@ -1068,6 +1068,10 @@ void blo_do_versions_280(FileData *fd, Library *UNUSED(lib), Main *main)
 							}
 						}
 					}
+					if (sl->spacetype == SPACE_VIEW3D) {
+						View3D *v3d = (View3D *)sl;
+						v3d->drawtype_ambient_intensity = 0.5;
+					}
 				}
 			}
 		}

source/blender/draw/CMakeLists.txt

@@ -211,6 +211,8 @@ data_to_c_simple(engines/eevee/shaders/volumetric_integration_frag.glsl SRC)
 data_to_c_simple(engines/workbench/shaders/workbench_prepass_vert.glsl SRC)
 data_to_c_simple(engines/workbench/shaders/workbench_prepass_frag.glsl SRC)
 data_to_c_simple(engines/workbench/shaders/workbench_composite_frag.glsl SRC)
+data_to_c_simple(engines/workbench/shaders/workbench_shadow_vert.glsl SRC)
+data_to_c_simple(engines/workbench/shaders/workbench_shadow_geom.glsl SRC)
 data_to_c_simple(engines/workbench/shaders/workbench_background_lib.glsl SRC)
 data_to_c_simple(engines/workbench/shaders/workbench_common_lib.glsl SRC)
 data_to_c_simple(engines/workbench/shaders/workbench_data_lib.glsl SRC)

source/blender/draw/engines/workbench/shaders/workbench_composite_frag.glsl

@@ -6,8 +6,8 @@ uniform sampler2D colorBuffer;
 uniform sampler2D normalBuffer;
 /* normalBuffer contains viewport normals */
 uniform vec2 invertedViewportSize;
-
 uniform vec3 objectOverlapColor = vec3(0.0);
+uniform float lightMultiplier;
 
 layout(std140) uniform world_block {
 	WorldData world_data;
@@ -52,11 +52,11 @@ void main()
 	vec3 normal_viewport = texelFetch(normalBuffer, texel, 0).rgb;
 #endif /* WORKBENCH_ENCODE_NORMALS */
 	vec3 diffuse_light = get_world_diffuse_light(world_data, normal_viewport);
-	vec3 shaded_color = diffuse_light * diffuse_color.rgb;
+	vec3 shaded_color = diffuse_light * diffuse_color.rgb * lightMultiplier;
 
 #else /* V3D_LIGHTING_STUDIO */
 	vec3 diffuse_color = texelFetch(colorBuffer, texel, 0).rgb;
-	vec3 shaded_color = diffuse_color;
+	vec3 shaded_color = diffuse_color * lightMultiplier;
 #endif /* V3D_LIGHTING_STUDIO */
 
 

source/blender/draw/engines/workbench/shaders/workbench_shadow_geom.glsl

@@ -0,0 +1,64 @@
+#define EPSILON 0.0000001
+#define INFINITE 100.0
+
+layout(triangles) in;
+layout(triangle_strip, max_vertices=14) out;
+
+uniform mat4 ModelMatrix;
+uniform mat4 ModelViewProjectionMatrix;
+
+uniform vec3 lightDirection = vec3(0.57, 0.57, -0.57);
+vec3 face_normal(vec3 v1, vec3 v2, vec3 v3) {
+	return normalize(cross(v2 - v1, v3 - v1));
+}
+void emit_side_quad(vec4 v1, vec4 v2, vec4 light_direction) {
+	gl_Position = ModelViewProjectionMatrix * (v1 + light_direction * EPSILON);
+	EmitVertex();
+	gl_Position = ModelViewProjectionMatrix * (v1 + light_direction * INFINITE);
+	EmitVertex();
+	gl_Position = ModelViewProjectionMatrix * (v2 + light_direction * EPSILON);
+	EmitVertex();
+	gl_Position = ModelViewProjectionMatrix * (v2 + light_direction * INFINITE);
+	EmitVertex();
+	EndPrimitive();
+}
+void emit_front_cap(vec4 v1, vec4 v2, vec4 v3, vec4 light_direction) {
+	gl_Position = ModelViewProjectionMatrix * (v1 + light_direction * EPSILON);
+	EmitVertex();
+	gl_Position = ModelViewProjectionMatrix * (v2 + light_direction * EPSILON);
+	EmitVertex();
+	gl_Position = ModelViewProjectionMatrix * (v3 + light_direction * EPSILON);
+	EmitVertex();
+	EndPrimitive();
+}
+
+void emit_back_cap(vec4 v1, vec4 v2, vec4 v3, vec4 light_direction) {
+	gl_Position = ModelViewProjectionMatrix * (v3 + light_direction * INFINITE);
+	EmitVertex();
+	gl_Position = ModelViewProjectionMatrix * (v2 + light_direction * INFINITE);
+	EmitVertex();
+	gl_Position = ModelViewProjectionMatrix * (v1 + light_direction * INFINITE);
+	EmitVertex();
+	EndPrimitive();
+}
+
+void main()
+{
+	/* light_direction: Light direction in object space TODO: Move to world space */
+	vec3 light_direction = normalize((vec4(lightDirection, 0.0) * ModelMatrix).xyz);
+	vec4 v1 = gl_in[0].gl_Position;
+	vec4 v2 = gl_in[1].gl_Position;
+	vec4 v3 = gl_in[2].gl_Position;
+	bool backface = dot(face_normal(v1.xyz, v2.xyz, v3.xyz), light_direction) > 0.0;
+
+	if (backface) {
+		vec4 light_direction4 = vec4(light_direction, 0.0);
+		/* emit side faces */
+		emit_side_quad(v2, v1, light_direction4);
+		emit_side_quad(v3, v2, light_direction4);
+		emit_side_quad(v1, v3, light_direction4);
+		/* emit front and back cap */
+		emit_front_cap(v3, v2, v1, light_direction4);
+		emit_back_cap(v3, v2, v1, light_direction4);
+	}
+}

source/blender/draw/engines/workbench/shaders/workbench_shadow_vert.glsl

@@ -0,0 +1,12 @@
+in vec3 pos;
+in vec3 N1;
+in vec3 N2;
+flat out vec3 faceNormal1;
+flat out vec3 faceNormal2;
+void main()
+{
+	/* Pass through, MVP calculation happens in geometry shader */
+	faceNormal1 = N1;
+	faceNormal2 = N2;
+	gl_Position = vec4(pos, 1.0);
+}

source/blender/draw/engines/workbench/solid_mode.c

@@ -59,8 +59,10 @@ static void workbench_solid_cache_finish(void *vedata)
 	workbench_materials_cache_finish(data);
 }
 
-static void workbench_solid_draw_background(void *UNUSED(vedata))
+static void workbench_solid_draw_background(void *vedata)
 {
+	WORKBENCH_Data * data = (WORKBENCH_Data *)vedata;
+	workbench_materials_draw_background(data);
 }
 
 static void workbench_solid_draw_scene(void *vedata)

source/blender/draw/engines/workbench/workbench_engine.c

@@ -51,6 +51,7 @@ static void workbench_layer_collection_settings_create(RenderEngine *UNUSED(engi
 
 	BKE_collection_engine_property_add_float(props, "random_object_color_saturation", 0.5f);
 	BKE_collection_engine_property_add_float(props, "random_object_color_value", 0.9f);
+	BKE_collection_engine_property_add_bool(props, "show_shadows", true);
 }
 
 static void workbench_view_layer_settings_create(RenderEngine *UNUSED(engine), IDProperty *props)
@@ -72,6 +73,9 @@ static void workbench_view_layer_settings_create(RenderEngine *UNUSED(engine), I
 	BKE_collection_engine_property_add_float_array(props, "diffuse_light_y_neg", diffuse_y_neg, 3);
 	BKE_collection_engine_property_add_float_array(props, "diffuse_light_z_pos", diffuse_z_pos, 3);
 	BKE_collection_engine_property_add_float_array(props, "diffuse_light_z_neg", diffuse_z_neg, 3);
+
+	const float light_direction[3] = {-0.577350269, -0.577350269, 0.577350269};
+	BKE_collection_engine_property_add_float_array(props, "light_direction", light_direction, 3);
 }
 
 /* Note: currently unused, we may want to register so we can see this when debugging the view. */

source/blender/draw/engines/workbench/workbench_materials.c

@@ -37,23 +37,31 @@
 #include "UI_resources.h"
 
 /* *********** STATIC *********** */
+
+//#define DEBUG_SHADOW_VOLUME
 #define MAX_SHADERS 255
+
 static struct {
 	struct GPUShader *prepass_sh_cache[MAX_SHADERS];
 	struct GPUShader *composite_sh_cache[MAX_SHADERS];
+	struct GPUShader *shadow_sh;
 
 	struct GPUTexture *object_id_tx; /* ref only, not alloced */
 	struct GPUTexture *color_buffer_tx; /* ref only, not alloced */
 	struct GPUTexture *normal_buffer_tx; /* ref only, not alloced */
 
+	float light_direction[3]; /* world light direction for shadows */
 	int next_object_id;
-} e_data = {{NULL}};
+} e_data = {NULL};
 
 /* Shaders */
 extern char datatoc_workbench_prepass_vert_glsl[];
 extern char datatoc_workbench_prepass_frag_glsl[];
 extern char datatoc_workbench_composite_frag_glsl[];
 
+extern char datatoc_workbench_shadow_vert_glsl[];
+extern char datatoc_workbench_shadow_geom_glsl[];
+
 extern char datatoc_workbench_background_lib_glsl[];
 extern char datatoc_workbench_common_lib_glsl[];
 extern char datatoc_workbench_data_lib_glsl[];
@@ -64,7 +72,7 @@ extern DrawEngineType draw_engine_workbench_solid;
 
 #define OBJECT_ID_PASS_ENABLED(wpd) (wpd->drawtype_options & V3D_DRAWOPTION_OBJECT_OVERLAP)
 #define NORMAL_VIEWPORT_PASS_ENABLED(wpd) (wpd->drawtype_lighting & V3D_LIGHTING_STUDIO)
-
+#define SHADOW_ENABLED(wpd) (wpd->drawtype_options & V3D_DRAWOPTION_SHADOW)
 static char *workbench_build_defines(WORKBENCH_PrivateData *wpd)
 {
 	char *str = NULL;
@@ -127,7 +135,8 @@ static char *workbench_build_prepass_frag(void)
 
 static int get_shader_index(WORKBENCH_PrivateData *wpd)
 {
-	return (wpd->drawtype_options << 2) + wpd->drawtype_lighting;
+	const int DRAWOPTIONS_MASK = V3D_DRAWOPTION_OBJECT_OVERLAP;
+	return ((wpd->drawtype_options & DRAWOPTIONS_MASK) << 2) + wpd->drawtype_lighting;
 }
 
 static void select_deferred_shaders(WORKBENCH_PrivateData *wpd)
@@ -209,6 +218,7 @@ void workbench_materials_engine_init(WORKBENCH_Data *vedata)
 		memset(e_data.prepass_sh_cache,   0x00, sizeof(struct GPUShader *) * MAX_SHADERS);
 		memset(e_data.composite_sh_cache, 0x00, sizeof(struct GPUShader *) * MAX_SHADERS);
 		e_data.next_object_id = 1;
+		e_data.shadow_sh = DRW_shader_create(datatoc_workbench_shadow_vert_glsl, datatoc_workbench_shadow_geom_glsl, NULL, NULL);
 	}
 
 	if (!stl->g_data) {
@@ -239,6 +249,7 @@ void workbench_materials_engine_init(WORKBENCH_Data *vedata)
 	{
 		int state = DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS;
 		psl->prepass_pass = DRW_pass_create("Prepass", state);
+		
 	}
 }
 
@@ -248,6 +259,22 @@ void workbench_materials_engine_free()
 		DRW_SHADER_FREE_SAFE(e_data.prepass_sh_cache[index]);
 		DRW_SHADER_FREE_SAFE(e_data.composite_sh_cache[index]);
 	}
+	DRW_SHADER_FREE_SAFE(e_data.shadow_sh);
+}
+
+static void workbench_composite_uniforms(WORKBENCH_PrivateData *wpd, DRWShadingGroup *grp)
+{
+	DefaultTextureList *dtxl = DRW_viewport_texture_list_get();
+	DRW_shgroup_uniform_texture_ref(grp, "depthBuffer", &dtxl->depth);
+	DRW_shgroup_uniform_texture_ref(grp, "colorBuffer", &e_data.color_buffer_tx);
+	if (OBJECT_ID_PASS_ENABLED(wpd)) {
+		DRW_shgroup_uniform_texture_ref(grp, "objectId", &e_data.object_id_tx);
+	}
+	if (NORMAL_VIEWPORT_PASS_ENABLED(wpd)) {
+		DRW_shgroup_uniform_texture_ref(grp, "normalBuffer", &e_data.normal_buffer_tx);
+	}
+	DRW_shgroup_uniform_block(grp, "world_block", wpd->world_ubo);
+	DRW_shgroup_uniform_vec2(grp, "invertedViewportSize", DRW_viewport_invert_size_get(), 1);
 }
 
 void workbench_materials_cache_init(WORKBENCH_Data *vedata)
@@ -255,11 +282,11 @@ void workbench_materials_cache_init(WORKBENCH_Data *vedata)
 	WORKBENCH_StorageList *stl = vedata->stl;
 	WORKBENCH_PassList *psl = vedata->psl;
 	WORKBENCH_PrivateData *wpd = stl->g_data;
-	DefaultTextureList *dtxl = DRW_viewport_texture_list_get();
 	DRWShadingGroup *grp;
 	const DRWContextState *draw_ctx = DRW_context_state_get();
 	ViewLayer *view_layer = draw_ctx->view_layer;
 	IDProperty *props = BKE_view_layer_engine_evaluated_get(view_layer, COLLECTION_MODE_NONE, RE_engine_id_BLENDER_WORKBENCH);
+	static float light_multiplier = 1.0f;
 
 	const DRWContextState *DCS = DRW_context_state_get();
 
@@ -269,10 +296,12 @@ void workbench_materials_cache_init(WORKBENCH_Data *vedata)
 	if (v3d) {
 		wpd->drawtype_lighting = v3d->drawtype_lighting;
 		wpd->drawtype_options = v3d->drawtype_options;
+		wpd->drawtype_ambient_intensity = v3d->drawtype_ambient_intensity;
 	}
 	else {
 		wpd->drawtype_lighting = V3D_LIGHTING_STUDIO;
 		wpd->drawtype_options = 0;
+		wpd->drawtype_ambient_intensity = 0.5;
 	}
 
 	select_deferred_shaders(wpd);
@@ -287,26 +316,42 @@ void workbench_materials_cache_init(WORKBENCH_Data *vedata)
 		copy_v3_v3(wd->diffuse_light_y_neg, BKE_collection_engine_property_value_get_float_array(props, "diffuse_light_y_neg"));
 		copy_v3_v3(wd->diffuse_light_z_pos, BKE_collection_engine_property_value_get_float_array(props, "diffuse_light_z_pos"));
 		copy_v3_v3(wd->diffuse_light_z_neg, BKE_collection_engine_property_value_get_float_array(props, "diffuse_light_z_neg"));
-
-		psl->composite_pass = DRW_pass_create("Composite", DRW_STATE_WRITE_COLOR);
-		grp = DRW_shgroup_create(wpd->composite_sh, psl->composite_pass);
-		DRW_shgroup_uniform_texture_ref(grp, "depthBuffer", &dtxl->depth);
-		DRW_shgroup_uniform_texture_ref(grp, "colorBuffer", &e_data.color_buffer_tx);
-		if (OBJECT_ID_PASS_ENABLED(wpd)) {
-			DRW_shgroup_uniform_texture_ref(grp, "objectId", &e_data.object_id_tx);
-		}
-		if (NORMAL_VIEWPORT_PASS_ENABLED(wpd)) {
-			DRW_shgroup_uniform_texture_ref(grp, "normalBuffer", &e_data.normal_buffer_tx);
-		}
 		wpd->world_ubo = DRW_uniformbuffer_create(sizeof(WORKBENCH_UBO_World), NULL);
-		DRW_shgroup_uniform_block(grp, "world_block", wpd->world_ubo);
 		DRW_uniformbuffer_update(wpd->world_ubo, &wpd->world_data);
-		DRW_shgroup_uniform_vec2(grp, "invertedViewportSize", DRW_viewport_invert_size_get(), 1);
 
+		copy_v3_v3(e_data.light_direction, BKE_collection_engine_property_value_get_float_array(props, "light_direction"));
+		negate_v3(e_data.light_direction);
+
+		psl->composite_pass = DRW_pass_create("Composite", DRW_STATE_WRITE_COLOR | DRW_STATE_STENCIL_EQUAL);
+		grp = DRW_shgroup_create(wpd->composite_sh, psl->composite_pass);
+		workbench_composite_uniforms(wpd, grp);
+		DRW_shgroup_stencil_mask(grp, 0x00);
+		DRW_shgroup_uniform_float(grp, "lightMultiplier", &light_multiplier, 1);
 		DRW_shgroup_call_add(grp, DRW_cache_fullscreen_quad_get(), NULL);
+
+		if (SHADOW_ENABLED(wpd)) {
+#ifdef DEBUG_SHADOW_VOLUME
+			psl->shadow_pass = DRW_pass_create("Shadow", DRW_STATE_DEPTH_LESS | DRW_STATE_WRITE_COLOR);
+			grp = DRW_shgroup_create(e_data.shadow_sh, psl->shadow_pass);
+			DRW_shgroup_uniform_vec3(grp, "lightDirection", e_data.light_direction, 1);
+			DRW_shgroup_stencil_mask(grp, 0xFF);
+			wpd->shadow_shgrp = grp;
+#else
+			psl->shadow_pass = DRW_pass_create("Shadow", DRW_STATE_DEPTH_GREATER | DRW_STATE_WRITE_STENCIL | DRW_STATE_STENCIL_DEPTH_FAIL_INCR_DECR_WRAP);
+			grp = DRW_shgroup_create(e_data.shadow_sh, psl->shadow_pass);
+			DRW_shgroup_uniform_vec3(grp, "lightDirection", e_data.light_direction, 1);
+			DRW_shgroup_stencil_mask(grp, 0xFF);
+			wpd->shadow_shgrp = grp;
+
+			psl->composite_shadow_pass = DRW_pass_create("Composite Shadow", DRW_STATE_WRITE_COLOR | DRW_STATE_STENCIL_NEQUAL);
+			grp = DRW_shgroup_create(wpd->composite_sh, psl->composite_shadow_pass);
+			DRW_shgroup_stencil_mask(grp, 0x00);
+			workbench_composite_uniforms(wpd, grp);
+			DRW_shgroup_uniform_float(grp, "lightMultiplier", &wpd->drawtype_ambient_intensity, 1);
+			DRW_shgroup_call_add(grp, DRW_cache_fullscreen_quad_get(), NULL);
+#endif
+		}
 	}
-
-
 }
 static WORKBENCH_MaterialData *get_or_create_material_data(WORKBENCH_Data *vedata, IDProperty *props, Object *ob, Material *mat)
 {
@@ -331,6 +376,7 @@ static WORKBENCH_MaterialData *get_or_create_material_data(WORKBENCH_Data *vedat
 	if (material == NULL) {
 		material = MEM_mallocN(sizeof(WORKBENCH_MaterialData), __func__);
 		material->shgrp = DRW_shgroup_create(wpd->prepass_sh, psl->prepass_pass);
+		DRW_shgroup_stencil_mask(material->shgrp, 0xFF);
 		material->object_id = engine_object_data->object_id;
 		copy_v3_v3(material->color, material_template.color);
 		DRW_shgroup_uniform_vec3(material->shgrp, "object_color", material->color, 1);
@@ -373,6 +419,9 @@ static void workbench_cache_populate_particles(WORKBENCH_Data *vedata, IDPropert
 
 void workbench_materials_solid_cache_populate(WORKBENCH_Data *vedata, Object *ob)
 {
+	WORKBENCH_StorageList *stl = vedata->stl;
+	WORKBENCH_PrivateData *wpd = stl->g_data;
+
 	if (!DRW_object_is_renderable(ob))
 		return;
 
@@ -416,6 +465,16 @@ void workbench_materials_solid_cache_populate(WORKBENCH_Data *vedata, Object *ob
 				}
 			}
 		}
+
+		if (SHADOW_ENABLED(wpd)) {
+			const bool ob_show_shadows = BKE_collection_engine_property_value_get_bool(props, "show_shadows");
+			if (ob_show_shadows) {
+				struct Gwn_Batch *geom_shadow = DRW_cache_object_surface_get(ob);
+				if (geom_shadow) {
+					DRW_shgroup_call_object_add(wpd->shadow_shgrp, geom_shadow, ob);
+				}
+			}
+		}	
 	}
 }
 
@@ -423,6 +482,22 @@ void workbench_materials_cache_finish(WORKBENCH_Data *UNUSED(vedata))
 {
 }
 
+void workbench_materials_draw_background(WORKBENCH_Data *vedata)
+{
+	WORKBENCH_StorageList *stl = vedata->stl;
+	WORKBENCH_FramebufferList *fbl = vedata->fbl;
+	WORKBENCH_PrivateData *wpd = stl->g_data;
+	const float clear_depth = 1.0f;
+	const float clear_color[4] = {0.0f, 0.0f, 0.0f, 0.0f};
+	unsigned int clear_stencil = 0xFF;
+
+	GPU_framebuffer_bind(fbl->prepass_fb);
+	int clear_bits = GPU_DEPTH_BIT;
+	clear_bits |= (OBJECT_ID_PASS_ENABLED(wpd)) ? GPU_COLOR_BIT : 0;
+	clear_bits |= (SHADOW_ENABLED(wpd)) ? GPU_STENCIL_BIT : 0;
+	GPU_framebuffer_clear(fbl->prepass_fb, clear_bits, clear_color, clear_depth, clear_stencil);
+}
+
 void workbench_materials_draw_scene(WORKBENCH_Data *vedata)
 {
 	WORKBENCH_PassList *psl = vedata->psl;
@@ -430,20 +505,27 @@ void workbench_materials_draw_scene(WORKBENCH_Data *vedata)
 	WORKBENCH_FramebufferList *fbl = vedata->fbl;
 	WORKBENCH_PrivateData *wpd = stl->g_data;
 	DefaultFramebufferList *dfbl = DRW_viewport_framebuffer_list_get();
-	const float clear_depth = 1.0f;
 
+	/* clear in background */
 	GPU_framebuffer_bind(fbl->prepass_fb);
-	if (OBJECT_ID_PASS_ENABLED(wpd)) {
-		const float clear_color[4] = {0.0f, 0.0f, 0.0f, 0.0f};
-		GPU_framebuffer_clear_color_depth(fbl->prepass_fb, clear_color, clear_depth);
+	DRW_draw_pass(psl->prepass_pass);
+	if (SHADOW_ENABLED(wpd)) {
+#ifdef DEBUG_SHADOW_VOLUME
+		GPU_framebuffer_bind(dfbl->default_fb);
+		DRW_draw_pass(psl->composite_pass);
+		DRW_draw_pass(psl->shadow_pass);
+#else
+		GPU_framebuffer_bind(dfbl->depth_only_fb);
+		DRW_draw_pass(psl->shadow_pass);
+		GPU_framebuffer_bind(dfbl->default_fb);
+		DRW_draw_pass(psl->composite_pass);
+		DRW_draw_pass(psl->composite_shadow_pass);
+#endif
 	}
 	else {
-		GPU_framebuffer_clear_depth(fbl->prepass_fb, clear_depth);
+		GPU_framebuffer_bind(dfbl->default_fb);
+		DRW_draw_pass(psl->composite_pass);
 	}
-	DRW_draw_pass(psl->prepass_pass);
-
-	GPU_framebuffer_bind(dfbl->color_only_fb);
-	DRW_draw_pass(psl->composite_pass);
 
 	BLI_ghash_free(wpd->material_hash, NULL, MEM_freeN);
 	DRW_UBO_FREE_SAFE(wpd->world_ubo);

source/blender/draw/engines/workbench/workbench_private.h

@@ -44,7 +44,10 @@ typedef struct WORKBENCH_StorageList {
 
 typedef struct WORKBENCH_PassList {
 	struct DRWPass *prepass_pass;
+	struct DRWPass *shadow_pass;
 	struct DRWPass *composite_pass;
+	struct DRWPass *composite_shadow_pass;
+	struct DRWPass *composite_light_pass;
 } WORKBENCH_PassList;
 
 typedef struct WORKBENCH_Data {
@@ -73,7 +76,10 @@ typedef struct WORKBENCH_PrivateData {
 	struct GPUShader *composite_sh;
 	short drawtype_lighting;
 	short drawtype_options;
+	float drawtype_ambient_intensity;
+
 	struct GPUUniformBuffer *world_ubo;
+	struct DRWShadingGroup *shadow_shgrp;
 	WORKBENCH_UBO_World world_data;
 } WORKBENCH_PrivateData; /* Transient data */
 
@@ -108,6 +114,7 @@ void workbench_solid_materials_free(void);
 /* workbench_materials.c */
 void workbench_materials_engine_init(WORKBENCH_Data *vedata);
 void workbench_materials_engine_free(void);
+void workbench_materials_draw_background(WORKBENCH_Data *vedata);
 void workbench_materials_draw_scene(WORKBENCH_Data *vedata);
 void workbench_materials_cache_init(WORKBENCH_Data *vedata);
 void workbench_materials_solid_cache_populate(WORKBENCH_Data *vedata, Object *ob);

source/blender/draw/intern/DRW_render.h

@@ -273,8 +273,10 @@ typedef enum {
 	DRW_STATE_ADDITIVE_FULL = (1 << 19), /* Same as DRW_STATE_ADDITIVE but let alpha accumulate without premult. */
 	DRW_STATE_BLEND_PREMUL  = (1 << 20), /* Use that if color is already premult by alpha. */
 
-	DRW_STATE_WRITE_STENCIL    = (1 << 27),
-	DRW_STATE_STENCIL_EQUAL    = (1 << 28),
+	DRW_STATE_WRITE_STENCIL          = (1 << 27),
+	DRW_STATE_STENCIL_EQUAL          = (1 << 28),
+	DRW_STATE_STENCIL_NEQUAL         = (1 << 29),
+	DRW_STATE_STENCIL_DEPTH_FAIL_INCR_DECR_WRAP = (1 << 30),
 } DRWState;
 
 #define DRW_STATE_DEFAULT (DRW_STATE_WRITE_DEPTH | DRW_STATE_WRITE_COLOR | DRW_STATE_DEPTH_LESS)

source/blender/draw/intern/draw_manager_exec.c

@@ -278,7 +278,9 @@ void drw_state_set(DRWState state)
 		DRWState test;
 		if (CHANGED_ANY_STORE_VAR(
 		        DRW_STATE_WRITE_STENCIL |
-		        DRW_STATE_STENCIL_EQUAL,
+		        DRW_STATE_STENCIL_DEPTH_FAIL_INCR_DECR_WRAP |
+		        DRW_STATE_STENCIL_EQUAL |
+		        DRW_STATE_STENCIL_NEQUAL,
 		        test))
 		{
 			if (test) {
@@ -286,14 +288,25 @@ void drw_state_set(DRWState state)
 
 				/* Stencil Write */
 				if ((state & DRW_STATE_WRITE_STENCIL) != 0) {
-					glStencilMask(0xFF);
-					glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
+					if ((state & DRW_STATE_STENCIL_DEPTH_FAIL_INCR_DECR_WRAP) != 0) {
+						glStencilMask(0xFF);
+						glStencilOpSeparate(GL_BACK,  GL_KEEP, GL_INCR_WRAP, GL_KEEP);
+						glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_DECR_WRAP, GL_KEEP);
+					}
+					else {
+						glStencilMask(0xFF);
+						glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
+					}
 				}
 				/* Stencil Test */
 				else if ((state & DRW_STATE_STENCIL_EQUAL) != 0) {
 					glStencilMask(0x00); /* disable write */
 					DST.stencil_mask = 0;
 				}
+				else if ((state & DRW_STATE_STENCIL_NEQUAL) != 0) {
+					glStencilMask(0x00); /* disable write */
+					DST.stencil_mask = 0;
+				}
 				else {
 					BLI_assert(0);
 				}
@@ -317,7 +330,10 @@ void drw_state_set(DRWState state)
 
 static void drw_stencil_set(unsigned int mask)
 {
-	if (DST.stencil_mask != mask) {
+	/* NOTE: need to ask to hypersomniac: Why check for difference? when mask is set to 0 it will not work.? 
+	  Should we remove the test?
+	*/
+	if (DST.stencil_mask != mask || (DST.state & DRW_STATE_STENCIL_NEQUAL) != 0) {
 		/* Stencil Write */
 		if ((DST.state & DRW_STATE_WRITE_STENCIL) != 0) {
 			glStencilFunc(GL_ALWAYS, mask, 0xFF);
@@ -328,6 +344,10 @@ static void drw_stencil_set(unsigned int mask)
 			glStencilFunc(GL_EQUAL, mask, 0xFF);
 			DST.stencil_mask = mask;
 		}
+		else if ((DST.state & DRW_STATE_STENCIL_NEQUAL) != 0) {
+			glStencilFunc(GL_NOTEQUAL, mask, 0xFF);
+			DST.stencil_mask = mask;
+		}
 	}
 }
 

source/blender/editors/space_view3d/space_view3d.c

@@ -323,6 +323,7 @@ static SpaceLink *view3d_new(const ScrArea *UNUSED(sa), const Scene *scene)
 	v3d->gridsubdiv = 10;
 	v3d->drawtype = OB_SOLID;
 	v3d->drawtype_lighting = V3D_LIGHTING_STUDIO;
+	v3d->drawtype_ambient_intensity = 0.5;
 
 	v3d->gridflag = V3D_SHOW_X | V3D_SHOW_Y | V3D_SHOW_FLOOR;
 	

source/blender/makesdna/DNA_view3d_types.h

@@ -90,6 +90,7 @@ enum {
 	V3D_DRAWOPTION_OBJECT_OVERLAP = (1 << 1),
 	V3D_DRAWOPTION_SINGLE_COLOR   = (1 << 2),
 	V3D_DRAWOPTION_OBJECT_COLOR   = (1 << 4),
+	V3D_DRAWOPTION_SHADOW         = (1 << 5),
 };
 #define V3D_DRAWOPTION_SOLID_COLOR_MASK (V3D_DRAWOPTION_SINGLE_COLOR | V3D_DRAWOPTION_RANDOMIZE | V3D_DRAWOPTION_OBJECT_COLOR | V3D_DRAWOPTION_MATERIAL_COLOR)
 
@@ -258,9 +259,9 @@ typedef struct View3D {
 	short drawtype_lighting;
 	short drawtype_options;
 	short pad5;
+	float drawtype_ambient_intensity;
 
 	int overlays;
-	int pad6;
 
 	View3DDebug debug;
 } View3D;

source/blender/makesrna/intern/rna_layer.c

@@ -319,6 +319,9 @@ static void rna_LayerEngineSettings_##_ENGINE_##_##_NAME_##_set(PointerRNA *ptr,
 #define RNA_LAYER_ENGINE_WORKBENCH_GET_SET_INT(_NAME_) \
 	RNA_LAYER_ENGINE_GET_SET(int, Workbench, COLLECTION_MODE_NONE, _NAME_)
 
+#define RNA_LAYER_ENGINE_WORKBENCH_GET_SET_BOOL(_NAME_) \
+	RNA_LAYER_ENGINE_GET_SET(bool, Workbench, COLLECTION_MODE_NONE, _NAME_)
+
 /* mode engines */
 
 #define RNA_LAYER_MODE_OBJECT_GET_SET_FLOAT(_NAME_) \
@@ -367,6 +370,7 @@ RNA_LAYER_ENGINE_CLAY_GET_SET_FLOAT(hair_brightness_randomness)
 /* Collection settings */
 RNA_LAYER_ENGINE_WORKBENCH_GET_SET_FLOAT(random_object_color_saturation)
 RNA_LAYER_ENGINE_WORKBENCH_GET_SET_FLOAT(random_object_color_value)
+RNA_LAYER_ENGINE_WORKBENCH_GET_SET_FLOAT(show_shadows)
 /* View Layer settings */
 RNA_LAYER_ENGINE_WORKBENCH_GET_SET_FLOAT_ARRAY(diffuse_light_x_pos, 3)
 RNA_LAYER_ENGINE_WORKBENCH_GET_SET_FLOAT_ARRAY(diffuse_light_x_neg, 3)
@@ -374,6 +378,8 @@ RNA_LAYER_ENGINE_WORKBENCH_GET_SET_FLOAT_ARRAY(diffuse_light_y_pos, 3)
 RNA_LAYER_ENGINE_WORKBENCH_GET_SET_FLOAT_ARRAY(diffuse_light_y_neg, 3)
 RNA_LAYER_ENGINE_WORKBENCH_GET_SET_FLOAT_ARRAY(diffuse_light_z_pos, 3)
 RNA_LAYER_ENGINE_WORKBENCH_GET_SET_FLOAT_ARRAY(diffuse_light_z_neg, 3)
+RNA_LAYER_ENGINE_WORKBENCH_GET_SET_FLOAT_ARRAY(light_direction, 3)
+RNA_LAYER_ENGINE_WORKBENCH_GET_SET_FLOAT(ambient_light_intensity)
 
 /* eevee engine */
 /* ViewLayer settings. */
@@ -1758,6 +1764,22 @@ static void rna_def_view_layer_engine_settings_workbench(BlenderRNA *brna)
 	RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
 	RNA_def_property_update(prop, NC_SCENE | ND_LAYER_CONTENT, "rna_ViewLayerEngineSettings_update");
 
+	prop = RNA_def_property(srna, "light_direction", PROP_FLOAT, PROP_DIRECTION);
+	RNA_def_property_array(prop, 3);
+	RNA_def_property_float_funcs(prop, "rna_LayerEngineSettings_Workbench_light_direction_get", "rna_LayerEngineSettings_Workbench_light_direction_set", NULL);
+	RNA_def_property_ui_text(prop, "Light Direction", "Direction of the light for shadow calculation");
+	RNA_def_property_range(prop, 0.0f, 1.0f);
+	RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
+	RNA_def_property_update(prop, NC_SCENE | ND_LAYER_CONTENT, "rna_ViewLayerEngineSettings_update");
+
+	prop = RNA_def_property(srna, "ambient_light_intensity", PROP_FLOAT, PROP_NONE);
+	RNA_def_property_float_funcs(prop, "rna_LayerEngineSettings_Workbench_ambient_light_intensity_get", "rna_LayerEngineSettings_Workbench_ambient_light_intensity_set", NULL);
+	RNA_def_property_ui_text(prop, "Ambient Light", "Intensity of ambient light for shadows");
+	RNA_def_property_range(prop, 0.0f, 1.0f);
+	RNA_def_property_ui_range(prop, 0.00f, 1.0f, 1, 3);
+	RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
+	RNA_def_property_update(prop, NC_SCENE | ND_LAYER_CONTENT, "rna_ViewLayerEngineSettings_update");
+
 	RNA_define_verify_sdna(1); /* not in sdna */
 }
 
@@ -1785,6 +1807,13 @@ static void rna_def_layer_collection_engine_settings_workbench(BlenderRNA *brna)
 	RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
 	RNA_def_property_update(prop, 0, "rna_LayerCollectionEngineSettings_update");
 
+	prop = RNA_def_property(srna, "show_shadows", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_boolean_funcs(prop, "rna_LayerEngineSettings_Workbench_show_shadows_get", "rna_LayerEngineSettings_Workbench_show_shadows_set");
+	RNA_def_property_boolean_default(prop, true);
+	RNA_def_property_ui_text(prop, "Cast Shadows", "Show the shadows casted by the objects for this collection");
+	RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
+	RNA_def_property_update(prop, 0, "rna_LayerCollectionEngineSettings_update");
+
 	RNA_define_verify_sdna(1); /* not in sdna */
 }
 

source/blender/makesrna/intern/rna_space.c

@@ -2235,6 +2235,21 @@ static void rna_def_space_view3d_shading(BlenderRNA *brna)
 	                                  NULL);
 	RNA_def_property_ui_text(prop, "Color", "Single Color Mode");
 	RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, "rna_3DViewShading_type_update");
+
+	prop = RNA_def_property(srna, "show_shadows", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_boolean_sdna(prop, NULL, "drawtype_options", V3D_DRAWOPTION_SHADOW);
+	RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
+	RNA_def_property_ui_text(prop, "Shadow", "Show Shadow");
+	RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, "rna_3DViewShading_type_update");
+
+	prop = RNA_def_property(srna, "ambient_light_intensity", PROP_FLOAT, PROP_NONE);
+	RNA_def_property_float_sdna(prop, NULL, "drawtype_ambient_intensity");
+	RNA_def_property_float_default(prop, 0.5);
+	RNA_def_property_ui_text(prop, "Ambient Light", "Intensity of ambient light for shadows");
+	RNA_def_property_range(prop, 0.0f, 1.0f);
+	RNA_def_property_ui_range(prop, 0.00f, 1.0f, 1, 3);
+	RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
+	RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, "rna_3DViewShading_type_update");
 }
 
 static void rna_def_space_view3d_overlay(BlenderRNA *brna)