Merge branch 'master' into blender2.8

22 files changed, 245 insertions, 267 deletions

diff --git a/intern/cycles/kernel/closure/bsdf_transparent.h b/intern/cycles/kernel/closure/bsdf_transparent.h
index 22ca7f3847e..79ee9dc4537 100644
--- a/intern/cycles/kernel/closure/bsdf_transparent.h
+++ b/intern/cycles/kernel/closure/bsdf_transparent.h
@@ -35,21 +35,38 @@
 
 CCL_NAMESPACE_BEGIN
 
-ccl_device void bsdf_transparent_setup(ShaderData *sd, const float3 weight)
+ccl_device void bsdf_transparent_setup(ShaderData *sd, const float3 weight, int path_flag)
 {
 	if(sd->flag & SD_TRANSPARENT) {
 		sd->closure_transparent_extinction += weight;
+
+		for(int i = 0; i < sd->num_closure; i++) {
+			ShaderClosure *sc = &sd->closure[i];
+
+			if(sc->type == CLOSURE_BSDF_TRANSPARENT_ID) {
+				sc->weight += weight;
+				sc->sample_weight += fabsf(average(weight));
+				break;
+			}
+		}
 	}
 	else {
 		sd->flag |= SD_BSDF|SD_TRANSPARENT;
 		sd->closure_transparent_extinction = weight;
-	}
 
-	ShaderClosure *bsdf = bsdf_alloc(sd, sizeof(ShaderClosure), weight);
+		if(path_flag & PATH_RAY_TERMINATE) {
+			/* In this case the number of closures is set to zero to disable
+			 * all others, but we still want to get transparency so increase
+			 * the number just for this. */
+			sd->num_closure_left = 1;
+		}
+
+		ShaderClosure *bsdf = bsdf_alloc(sd, sizeof(ShaderClosure), weight);
 
-	if(bsdf) {
-		bsdf->N = sd->N;
-		bsdf->type = CLOSURE_BSDF_TRANSPARENT_ID;
+		if(bsdf) {
+			bsdf->N = sd->N;
+			bsdf->type = CLOSURE_BSDF_TRANSPARENT_ID;
+		}
 	}
 }
 
diff --git a/intern/cycles/kernel/kernel_bake.h b/intern/cycles/kernel/kernel_bake.h
index 8788e89c40e..b3c2450d10e 100644
--- a/intern/cycles/kernel/kernel_bake.h
+++ b/intern/cycles/kernel/kernel_bake.h
@@ -51,7 +51,7 @@ ccl_device_inline void compute_light_pass(KernelGlobals *kg,
 	path_state_init(kg, &emission_sd, &state, rng_hash, sample, NULL);
 
 	/* evaluate surface shader */
-	shader_eval_surface(kg, sd, &state, state.flag, kernel_data.integrator.max_closures);
+	shader_eval_surface(kg, sd, &state, state.flag);
 
 	/* TODO, disable more closures we don't need besides transparent */
 	shader_bsdf_disable_transparency(kg, sd);
@@ -228,12 +228,12 @@ ccl_device float3 kernel_bake_evaluate_direct_indirect(KernelGlobals *kg,
 		}
 		else {
 			/* surface color of the pass only */
-			shader_eval_surface(kg, sd, state, 0, kernel_data.integrator.max_closures);
+			shader_eval_surface(kg, sd, state, 0);
 			return kernel_bake_shader_bsdf(kg, sd, type);
 		}
 	}
 	else {
-		shader_eval_surface(kg, sd, state, 0, kernel_data.integrator.max_closures);
+		shader_eval_surface(kg, sd, state, 0);
 		color = kernel_bake_shader_bsdf(kg, sd, type);
 	}
 
@@ -333,7 +333,7 @@ ccl_device void kernel_bake_evaluate(KernelGlobals *kg, ccl_global uint4 *input,
 		{
 			float3 N = sd.N;
 			if((sd.flag & SD_HAS_BUMP)) {
-				shader_eval_surface(kg, &sd, &state, 0, kernel_data.integrator.max_closures);
+				shader_eval_surface(kg, &sd, &state, 0);
 				N = shader_bsdf_average_normal(kg, &sd);
 			}
 
@@ -348,7 +348,7 @@ ccl_device void kernel_bake_evaluate(KernelGlobals *kg, ccl_global uint4 *input,
 		}
 		case SHADER_EVAL_EMISSION:
 		{
-			shader_eval_surface(kg, &sd, &state, 0, 0);
+			shader_eval_surface(kg, &sd, &state, PATH_RAY_EMISSION);
 			out = shader_emissive_eval(kg, &sd);
 			break;
 		}
diff --git a/intern/cycles/kernel/kernel_emission.h b/intern/cycles/kernel/kernel_emission.h
index 94b0a37ce62..5875249b404 100644
--- a/intern/cycles/kernel/kernel_emission.h
+++ b/intern/cycles/kernel/kernel_emission.h
@@ -67,13 +67,13 @@ ccl_device_noinline float3 direct_emissive_eval(KernelGlobals *kg,
 
 		ls->Ng = emission_sd->Ng;
 
-		/* no path flag, we're evaluating this for all closures. that's weak but
-		 * we'd have to do multiple evaluations otherwise */
+		/* No proper path flag, we're evaluating this for all closures. that's
+		 * weak but we'd have to do multiple evaluations otherwise. */
 		path_state_modify_bounce(state, true);
-		shader_eval_surface(kg, emission_sd, state, 0, 0);
+		shader_eval_surface(kg, emission_sd, state, PATH_RAY_EMISSION);
 		path_state_modify_bounce(state, false);
 
-		/* evaluate emissive closure */
+		/* Evaluate emissive closure. */
 		eval = shader_emissive_eval(kg, emission_sd);
 	}
 	
diff --git a/intern/cycles/kernel/kernel_path.h b/intern/cycles/kernel/kernel_path.h
index dbbb80ca37f..aef350b0658 100644
--- a/intern/cycles/kernel/kernel_path.h
+++ b/intern/cycles/kernel/kernel_path.h
@@ -400,6 +400,13 @@ ccl_device void kernel_path_indirect(KernelGlobals *kg,
                                      PathState *state,
                                      PathRadiance *L)
 {
+#ifdef __SUBSURFACE__
+	SubsurfaceIndirectRays ss_indirect;
+	kernel_path_subsurface_init_indirect(&ss_indirect);
+
+	for(;;) {
+#endif  /* __SUBSURFACE__ */
+
 	/* path iteration */
 	for(;;) {
 		/* Find intersection with objects in scene. */
@@ -439,11 +446,8 @@ ccl_device void kernel_path_indirect(KernelGlobals *kg,
 		}
 
 		/* Setup and evaluate shader. */
-		shader_setup_from_ray(kg,
-		                      sd,
-		                      &isect,
-		                      ray);
-		shader_eval_surface(kg, sd, state, state->flag, kernel_data.integrator.max_closures);
+		shader_setup_from_ray(kg, sd, &isect, ray);
+		shader_eval_surface(kg, sd, state, state->flag);
 		shader_prepare_closures(sd, state);
 
 		/* Apply shadow catcher, holdout, emission. */
@@ -485,29 +489,21 @@ ccl_device void kernel_path_indirect(KernelGlobals *kg,
 		}
 #endif  /* __AO__ */
 
+
 #ifdef __SUBSURFACE__
 		/* bssrdf scatter to a different location on the same object, replacing
 		 * the closures with a diffuse BSDF */
 		if(sd->flag & SD_BSSRDF) {
-			float bssrdf_u, bssrdf_v;
-			path_state_rng_2D(kg,
-			                  state,
-			                  PRNG_BSDF_U,
-			                  &bssrdf_u, &bssrdf_v);
-
-			const ShaderClosure *sc = shader_bssrdf_pick(sd, &throughput, &bssrdf_u);
-
-			/* do bssrdf scatter step if we picked a bssrdf closure */
-			if(sc) {
-				uint lcg_state = lcg_state_init(state, 0x68bc21eb);
-
-				subsurface_scatter_step(kg,
-				                        sd,
-				                        state,
-				                        sc,
-				                        &lcg_state,
-				                        bssrdf_u, bssrdf_v,
-				                        false);
+			if(kernel_path_subsurface_scatter(kg,
+			                                  sd,
+			                                  emission_sd,
+			                                  L,
+			                                  state,
+			                                  ray,
+			                                  &throughput,
+			                                  &ss_indirect))
+			{
+				break;
 			}
 		}
 #endif  /* __SUBSURFACE__ */
@@ -530,6 +526,24 @@ ccl_device void kernel_path_indirect(KernelGlobals *kg,
 		if(!kernel_path_surface_bounce(kg, sd, &throughput, state, &L->state, ray))
 			break;
 	}
+
+#ifdef __SUBSURFACE__
+		/* Trace indirect subsurface rays by restarting the loop. this uses less
+		 * stack memory than invoking kernel_path_indirect.
+		 */
+		if(ss_indirect.num_rays) {
+			kernel_path_subsurface_setup_indirect(kg,
+			                                      &ss_indirect,
+			                                      state,
+			                                      ray,
+			                                      L,
+			                                      &throughput);
+		}
+		else {
+			break;
+		}
+	}
+#endif  /* __SUBSURFACE__ */
 }
 
 #endif /* defined(__BRANCHED_PATH__) || defined(__BAKING__) */
@@ -593,7 +607,7 @@ ccl_device_forceinline void kernel_path_integrate(
 
 		/* Setup and evaluate shader. */
 		shader_setup_from_ray(kg, &sd, &isect, ray);
-		shader_eval_surface(kg, &sd, state, state->flag, kernel_data.integrator.max_closures);
+		shader_eval_surface(kg, &sd, state, state->flag);
 		shader_prepare_closures(&sd, state);
 
 		/* Apply shadow catcher, holdout, emission. */
diff --git a/intern/cycles/kernel/kernel_path_branched.h b/intern/cycles/kernel/kernel_path_branched.h
index 6fb55bda08d..441a06eeba3 100644
--- a/intern/cycles/kernel/kernel_path_branched.h
+++ b/intern/cycles/kernel/kernel_path_branched.h
@@ -480,7 +480,7 @@ ccl_device void kernel_branched_path_integrate(KernelGlobals *kg,
 
 		/* Setup and evaluate shader. */
 		shader_setup_from_ray(kg, &sd, &isect, &ray);
-		shader_eval_surface(kg, &sd, &state, state.flag, kernel_data.integrator.max_closures);
+		shader_eval_surface(kg, &sd, &state, state.flag);
 		shader_merge_closures(&sd);
 
 		/* Apply shadow catcher, holdout, emission. */
diff --git a/intern/cycles/kernel/kernel_path_state.h b/intern/cycles/kernel/kernel_path_state.h
index a16c20cbee6..15d81fcddf4 100644
--- a/intern/cycles/kernel/kernel_path_state.h
+++ b/intern/cycles/kernel/kernel_path_state.h
@@ -75,6 +75,9 @@ ccl_device_inline void path_state_next(KernelGlobals *kg, ccl_addr_space PathSta
 	if(label & LABEL_TRANSPARENT) {
 		state->flag |= PATH_RAY_TRANSPARENT;
 		state->transparent_bounce++;
+		if(state->transparent_bounce >= kernel_data.integrator.transparent_max_bounce) {
+			state->flag |= PATH_RAY_TERMINATE_IMMEDIATE;
+		}
 
 		if(!kernel_data.integrator.transparent_shadows)
 			state->flag |= PATH_RAY_MIS_SKIP;
@@ -86,6 +89,10 @@ ccl_device_inline void path_state_next(KernelGlobals *kg, ccl_addr_space PathSta
 	}
 
 	state->bounce++;
+	if(state->bounce >= kernel_data.integrator.max_bounce) {
+		state->flag |= PATH_RAY_TERMINATE_AFTER_TRANSPARENT;
+	}
+
 	state->flag &= ~(PATH_RAY_ALL_VISIBILITY|PATH_RAY_MIS_SKIP);
 
 #ifdef __VOLUME__
@@ -95,6 +102,9 @@ ccl_device_inline void path_state_next(KernelGlobals *kg, ccl_addr_space PathSta
 		state->flag &= ~PATH_RAY_TRANSPARENT_BACKGROUND;
 
 		state->volume_bounce++;
+		if(state->volume_bounce >= kernel_data.integrator.max_volume_bounce) {
+			state->flag |= PATH_RAY_TERMINATE_AFTER_TRANSPARENT;
+		}
 	}
 	else
 #endif
@@ -104,10 +114,18 @@ ccl_device_inline void path_state_next(KernelGlobals *kg, ccl_addr_space PathSta
 			state->flag |= PATH_RAY_REFLECT;
 			state->flag &= ~PATH_RAY_TRANSPARENT_BACKGROUND;
 
-			if(label & LABEL_DIFFUSE)
+			if(label & LABEL_DIFFUSE) {
 				state->diffuse_bounce++;
-			else
+				if(state->diffuse_bounce >= kernel_data.integrator.max_diffuse_bounce) {
+					state->flag |= PATH_RAY_TERMINATE_AFTER_TRANSPARENT;
+				}
+			}
+			else {
 				state->glossy_bounce++;
+				if(state->glossy_bounce >= kernel_data.integrator.max_glossy_bounce) {
+					state->flag |= PATH_RAY_TERMINATE_AFTER_TRANSPARENT;
+				}
+			}
 		}
 		else {
 			kernel_assert(label & LABEL_TRANSMIT);
@@ -119,6 +137,9 @@ ccl_device_inline void path_state_next(KernelGlobals *kg, ccl_addr_space PathSta
 			}
 
 			state->transmission_bounce++;
+			if(state->transmission_bounce >= kernel_data.integrator.max_transmission_bounce) {
+				state->flag |= PATH_RAY_TERMINATE_AFTER_TRANSPARENT;
+			}
 		}
 
 		/* diffuse/glossy/singular */
@@ -162,13 +183,13 @@ ccl_device_inline float path_state_continuation_probability(KernelGlobals *kg,
                                                             ccl_addr_space PathState *state,
                                                             const float3 throughput)
 {
-	if(state->flag & PATH_RAY_TRANSPARENT) {
-		/* Transparent rays are treated separately with own max bounces. */
-		if(state->transparent_bounce >= kernel_data.integrator.transparent_max_bounce) {
-			return 0.0f;
-		}
+	if(state->flag & PATH_RAY_TERMINATE_IMMEDIATE) {
+		/* Ray is to be terminated immediately. */
+		return 0.0f;
+	}
+	else if(state->flag & PATH_RAY_TRANSPARENT) {
 		/* Do at least one bounce without RR. */
-		else if(state->transparent_bounce <= 1) {
+		if(state->transparent_bounce <= 1) {
 			return 1.0f;
 		}
 #ifdef __SHADOW_TRICKS__
@@ -179,19 +200,8 @@ ccl_device_inline float path_state_continuation_probability(KernelGlobals *kg,
 #endif
 	}
 	else {
-		/* Test max bounces for various ray types. */
-		if((state->bounce >= kernel_data.integrator.max_bounce) ||
-		   (state->diffuse_bounce >= kernel_data.integrator.max_diffuse_bounce) ||
-		   (state->glossy_bounce >= kernel_data.integrator.max_glossy_bounce) ||
-#ifdef __VOLUME__
-		   (state->volume_bounce >= kernel_data.integrator.max_volume_bounce) ||
-#endif
-		   (state->transmission_bounce >= kernel_data.integrator.max_transmission_bounce))
-		{
-			return 0.0f;
-		}
 		/* Do at least one bounce without RR. */
-		else if(state->bounce <= 1) {
+		if(state->bounce <= 1) {
 			return 1.0f;
 		}
 #ifdef __SHADOW_TRICKS__
diff --git a/intern/cycles/kernel/kernel_path_volume.h b/intern/cycles/kernel/kernel_path_volume.h
index b6a856baf24..6275d0d6562 100644
--- a/intern/cycles/kernel/kernel_path_volume.h
+++ b/intern/cycles/kernel/kernel_path_volume.h
@@ -99,6 +99,23 @@ bool kernel_path_volume_bounce(
 	/* update path state */
 	path_state_next(kg, state, label);
 
+	/* Russian roulette termination of volume ray scattering. */
+	float probability = path_state_continuation_probability(kg, state, *throughput);
+
+	if(probability == 0.0f) {
+		return false;
+	}
+	else if(probability != 1.0f) {
+		/* Use dimension from the previous bounce, has not been used yet. */
+		float terminate = path_state_rng_1D(kg, state, PRNG_TERMINATE - PRNG_BOUNCE_NUM);
+
+		if(terminate >= probability) {
+			return false;
+		}
+
+		*throughput /= probability;
+	}
+
 	/* setup ray */
 	ray->P = sd->P;
 	ray->D = phase_omega_in;
diff --git a/intern/cycles/kernel/kernel_shader.h b/intern/cycles/kernel/kernel_shader.h
index 5f2f00c5ceb..8cfd33b808e 100644
--- a/intern/cycles/kernel/kernel_shader.h
+++ b/intern/cycles/kernel/kernel_shader.h
@@ -966,10 +966,21 @@ ccl_device float3 shader_holdout_eval(KernelGlobals *kg, ShaderData *sd)
 /* Surface Evaluation */
 
 ccl_device void shader_eval_surface(KernelGlobals *kg, ShaderData *sd,
-	ccl_addr_space PathState *state, int path_flag, int max_closure)
+	ccl_addr_space PathState *state, int path_flag)
 {
+	/* If path is being terminated, we are tracing a shadow ray or evaluating
+	 * emission, then we don't need to store closures. The emission and shadow
+	 * shader data also do not have a closure array to save GPU memory. */
+	int max_closures;
+	if(path_flag & (PATH_RAY_TERMINATE|PATH_RAY_SHADOW|PATH_RAY_EMISSION)) {
+		max_closures = 0;
+	}
+	else {
+		max_closures = kernel_data.integrator.max_closures;
+	}
+
 	sd->num_closure = 0;
-	sd->num_closure_left = max_closure;
+	sd->num_closure_left = max_closures;
 
 #ifdef __OSL__
 	if(kg->osl)
@@ -1140,13 +1151,23 @@ ccl_device_inline void shader_eval_volume(KernelGlobals *kg,
                                           ShaderData *sd,
                                           ccl_addr_space PathState *state,
                                           ccl_addr_space VolumeStack *stack,
-                                          int path_flag,
-                                          int max_closure)
+                                          int path_flag)
 {
+	/* If path is being terminated, we are tracing a shadow ray or evaluating
+	 * emission, then we don't need to store closures. The emission and shadow
+	 * shader data also do not have a closure array to save GPU memory. */
+	int max_closures;
+	if(path_flag & (PATH_RAY_TERMINATE|PATH_RAY_SHADOW|PATH_RAY_EMISSION)) {
+		max_closures = 0;
+	}
+	else {
+		max_closures = kernel_data.integrator.max_closures;
+	}
+
 	/* reset closures once at the start, we will be accumulating the closures
 	 * for all volumes in the stack into a single array of closures */
 	sd->num_closure = 0;
-	sd->num_closure_left = max_closure;
+	sd->num_closure_left = max_closures;
 	sd->flag = 0;
 	sd->object_flag = 0;
 
diff --git a/intern/cycles/kernel/kernel_shadow.h b/intern/cycles/kernel/kernel_shadow.h
index ab364d3037a..8a0da6c3b13 100644
--- a/intern/cycles/kernel/kernel_shadow.h
+++ b/intern/cycles/kernel/kernel_shadow.h
@@ -86,8 +86,7 @@ ccl_device_forceinline bool shadow_handle_transparent_isect(
 		shader_eval_surface(kg,
 		                    shadow_sd,
 		                    state,
-		                    PATH_RAY_SHADOW,
-		                    0);
+		                    PATH_RAY_SHADOW);
 		path_state_modify_bounce(state, false);
 		*throughput *= shader_bsdf_transparency(kg, shadow_sd);
 	}
diff --git a/intern/cycles/kernel/kernel_subsurface.h b/intern/cycles/kernel/kernel_subsurface.h
index 80dda31c61e..e8553d84547 100644
--- a/intern/cycles/kernel/kernel_subsurface.h
+++ b/intern/cycles/kernel/kernel_subsurface.h
@@ -69,44 +69,42 @@ ccl_device_inline float3 subsurface_scatter_eval(ShaderData *sd,
 }
 
 /* replace closures with a single diffuse bsdf closure after scatter step */
-ccl_device void subsurface_scatter_setup_diffuse_bsdf(KernelGlobals *kg, ShaderData *sd, const ShaderClosure *sc, float3 weight, bool hit, float3 N)
+ccl_device void subsurface_scatter_setup_diffuse_bsdf(KernelGlobals *kg, ShaderData *sd, const ShaderClosure *sc, float3 weight, float3 N)
 {
 	sd->flag &= ~SD_CLOSURE_FLAGS;
 	sd->num_closure = 0;
 	sd->num_closure_left = kernel_data.integrator.max_closures;
 
-	if(hit) {
-		Bssrdf *bssrdf = (Bssrdf *)sc;
+	Bssrdf *bssrdf = (Bssrdf *)sc;
 #ifdef __PRINCIPLED__
-		if(bssrdf->type == CLOSURE_BSSRDF_PRINCIPLED_ID ||
-		   bssrdf->type == CLOSURE_BSSRDF_PRINCIPLED_RANDOM_WALK_ID)
-		{
-			PrincipledDiffuseBsdf *bsdf = (PrincipledDiffuseBsdf*)bsdf_alloc(sd, sizeof(PrincipledDiffuseBsdf), weight);
-
-			if(bsdf) {
-				bsdf->N = N;
-				bsdf->roughness = bssrdf->roughness;
-				sd->flag |= bsdf_principled_diffuse_setup(bsdf);
-
-				/* replace CLOSURE_BSDF_PRINCIPLED_DIFFUSE_ID with this special ID so render passes
-				 * can recognize it as not being a regular Disney principled diffuse closure */
-				bsdf->type = CLOSURE_BSDF_BSSRDF_PRINCIPLED_ID;
-			}
+	if(bssrdf->type == CLOSURE_BSSRDF_PRINCIPLED_ID ||
+	   bssrdf->type == CLOSURE_BSSRDF_PRINCIPLED_RANDOM_WALK_ID)
+	{
+		PrincipledDiffuseBsdf *bsdf = (PrincipledDiffuseBsdf*)bsdf_alloc(sd, sizeof(PrincipledDiffuseBsdf), weight);
+
+		if(bsdf) {
+			bsdf->N = N;
+			bsdf->roughness = bssrdf->roughness;
+			sd->flag |= bsdf_principled_diffuse_setup(bsdf);
+
+			/* replace CLOSURE_BSDF_PRINCIPLED_DIFFUSE_ID with this special ID so render passes
+			 * can recognize it as not being a regular Disney principled diffuse closure */
+			bsdf->type = CLOSURE_BSDF_BSSRDF_PRINCIPLED_ID;
 		}
-		else if(CLOSURE_IS_BSDF_BSSRDF(bssrdf->type) ||
-		        CLOSURE_IS_BSSRDF(bssrdf->type))
+	}
+	else if(CLOSURE_IS_BSDF_BSSRDF(bssrdf->type) ||
+			CLOSURE_IS_BSSRDF(bssrdf->type))
 #endif  /* __PRINCIPLED__ */
-		{
-			DiffuseBsdf *bsdf = (DiffuseBsdf*)bsdf_alloc(sd, sizeof(DiffuseBsdf), weight);
+	{
+		DiffuseBsdf *bsdf = (DiffuseBsdf*)bsdf_alloc(sd, sizeof(DiffuseBsdf), weight);
 
-			if(bsdf) {
-				bsdf->N = N;
-				sd->flag |= bsdf_diffuse_setup(bsdf);
+		if(bsdf) {
+			bsdf->N = N;
+			sd->flag |= bsdf_diffuse_setup(bsdf);
 
-				/* replace CLOSURE_BSDF_DIFFUSE_ID with this special ID so render passes
-				 * can recognize it as not being a regular diffuse closure */
-				bsdf->type = CLOSURE_BSDF_BSSRDF_ID;
-			}
+			/* replace CLOSURE_BSDF_DIFFUSE_ID with this special ID so render passes
+			 * can recognize it as not being a regular diffuse closure */
+			bsdf->type = CLOSURE_BSDF_BSSRDF_ID;
 		}
 	}
 }
@@ -148,7 +146,7 @@ ccl_device void subsurface_color_bump_blur(KernelGlobals *kg,
 
 	if(bump || texture_blur > 0.0f) {
 		/* average color and normal at incoming point */
-		shader_eval_surface(kg, sd, state, state->flag, kernel_data.integrator.max_closures);
+		shader_eval_surface(kg, sd, state, state->flag);
 		float3 in_color = shader_bssrdf_sum(sd, (bump)? N: NULL, NULL);
 
 		/* we simply divide out the average color and multiply with the average
@@ -334,104 +332,7 @@ ccl_device_noinline void subsurface_scatter_multi_setup(
 	subsurface_color_bump_blur(kg, sd, state, &weight, &N);
 
 	/* Setup diffuse BSDF. */
-	subsurface_scatter_setup_diffuse_bsdf(kg, sd, sc, weight, true, N);
-}
-
-/* subsurface scattering step, from a point on the surface to another nearby point on the same object */
-ccl_device void subsurface_scatter_step(KernelGlobals *kg, ShaderData *sd, ccl_addr_space PathState *state,
-	const ShaderClosure *sc, uint *lcg_state, float disk_u, float disk_v, bool all)
-{
-	float3 eval = make_float3(0.0f, 0.0f, 0.0f);
-
-	/* pick random axis in local frame and point on disk */
-	float3 disk_N, disk_T, disk_B;
-	float pick_pdf_N, pick_pdf_T, pick_pdf_B;
-
-	disk_N = sd->Ng;
-	make_orthonormals(disk_N, &disk_T, &disk_B);
-
-	if(disk_v < 0.5f) {
-		pick_pdf_N = 0.5f;
-		pick_pdf_T = 0.25f;
-		pick_pdf_B = 0.25f;
-		disk_v *= 2.0f;
-	}
-	else if(disk_v < 0.75f) {
-		float3 tmp = disk_N;
-		disk_N = disk_T;
-		disk_T = tmp;
-		pick_pdf_N = 0.25f;
-		pick_pdf_T = 0.5f;
-		pick_pdf_B = 0.25f;
-		disk_v = (disk_v - 0.5f)*4.0f;
-	}
-	else {
-		float3 tmp = disk_N;
-		disk_N = disk_B;
-		disk_B = tmp;
-		pick_pdf_N = 0.25f;
-		pick_pdf_T = 0.25f;
-		pick_pdf_B = 0.5f;
-		disk_v = (disk_v - 0.75f)*4.0f;
-	}
-
-	/* sample point on disk */
-	float phi = M_2PI_F * disk_v;
-	float disk_height, disk_r;
-
-	bssrdf_sample(sc, disk_u, &disk_r, &disk_height);
-
-	float3 disk_P = (disk_r*cosf(phi)) * disk_T + (disk_r*sinf(phi)) * disk_B;
-
-	/* create ray */
-	Ray ray;
-	ray.P = sd->P + disk_N*disk_height + disk_P;
-	ray.D = -disk_N;
-	ray.t = 2.0f*disk_height;
-	ray.dP = sd->dP;
-	ray.dD = differential3_zero();
-	ray.time = sd->time;
-
-	/* intersect with the same object. if multiple intersections are
-	 * found it will randomly pick one of them */
-	LocalIntersection ss_isect;
-	scene_intersect_local(kg, ray, &ss_isect, sd->object, lcg_state, 1);
-
-	/* evaluate bssrdf */
-	if(ss_isect.num_hits > 0) {
-		float3 origP = sd->P;
-
-		/* Workaround for AMD GPU OpenCL compiler. Most probably cache bypass issue. */
-#if defined(__SPLIT_KERNEL__) && defined(__KERNEL_OPENCL_AMD__) && defined(__KERNEL_GPU__)
-		kernel_split_params.dummy_sd_flag = sd->flag;
-#endif
-		/* setup new shading point */
-		shader_setup_from_subsurface(kg, sd, &ss_isect.hits[0], &ray);
-
-		/* Probability densities for local frame axes. */
-		float pdf_N = pick_pdf_N * fabsf(dot(disk_N, sd->Ng));
-		float pdf_T = pick_pdf_T * fabsf(dot(disk_T, sd->Ng));
-		float pdf_B = pick_pdf_B * fabsf(dot(disk_B, sd->Ng));
-
-		/* Multiple importance sample between 3 axes, power heuristic
-		 * found to be slightly better than balance heuristic. pdf_N
-		 * in the MIS weight and denominator cancelled out. */
-		float w = pdf_N / (sqr(pdf_N) + sqr(pdf_T) + sqr(pdf_B));
-		w *= ss_isect.num_hits;
-
-		/* Real distance to sampled point. */
-		float r = len(sd->P - origP);
-
-		/* Evaluate profiles. */
-		eval = subsurface_scatter_eval(sd, sc, disk_r, r, all) * w;
-	}
-
-	/* optionally blur colors and bump mapping */
-	float3 N = sd->N;
-	subsurface_color_bump_blur(kg, sd, state, &eval, &N);
-
-	/* setup diffuse bsdf */
-	subsurface_scatter_setup_diffuse_bsdf(kg, sd, sc, eval, (ss_isect.num_hits > 0), N);
+	subsurface_scatter_setup_diffuse_bsdf(kg, sd, sc, weight, N);
 }
 
 /* Random walk subsurface scattering.
diff --git a/intern/cycles/kernel/kernel_types.h b/intern/cycles/kernel/kernel_types.h
index aeb63b4a65e..44e7fd46adc 100644
--- a/intern/cycles/kernel/kernel_types.h
+++ b/intern/cycles/kernel/kernel_types.h
@@ -347,12 +347,31 @@ enum PathRayFlag {
 
 	PATH_RAY_ALL_VISIBILITY = ((1 << 14)-1),
 
-	PATH_RAY_MIS_SKIP               = (1 << 15),
-	PATH_RAY_DIFFUSE_ANCESTOR       = (1 << 16),
-	PATH_RAY_SINGLE_PASS_DONE       = (1 << 17),
-	PATH_RAY_SHADOW_CATCHER         = (1 << 18),
-	PATH_RAY_STORE_SHADOW_INFO      = (1 << 19),
-	PATH_RAY_TRANSPARENT_BACKGROUND = (1 << 20),
+	/* Don't apply multiple importance sampling weights to emission from
+	 * lamp or surface hits, because they were not direct light sampled. */
+	PATH_RAY_MIS_SKIP                    = (1 << 14),
+	/* Diffuse bounce earlier in the path, skip SSS to improve performance
+	 * and avoid branching twice with disk sampling SSS. */
+	PATH_RAY_DIFFUSE_ANCESTOR            = (1 << 15),
+	/* Single pass has been written. */
+	PATH_RAY_SINGLE_PASS_DONE            = (1 << 16),
+	/* Ray is behind a shadow catcher .*/
+	PATH_RAY_SHADOW_CATCHER              = (1 << 17),
+	/* Store shadow data for shadow catcher or denoising. */
+	PATH_RAY_STORE_SHADOW_INFO           = (1 << 18),
+	/* Zero background alpha, for camera or transparent glass rays. */
+	PATH_RAY_TRANSPARENT_BACKGROUND      = (1 << 19),
+	/* Terminate ray immediately at next bounce. */
+	PATH_RAY_TERMINATE_IMMEDIATE         = (1 << 20),
+	/* Ray is to be terminated, but continue with transparent bounces and
+	 * emission as long as we encounter them. This is required to make the
+	 * MIS between direct and indirect light rays match, as shadow rays go
+	 * through transparent surfaces to reach emisison too. */
+	PATH_RAY_TERMINATE_AFTER_TRANSPARENT = (1 << 21),
+	/* Ray is to be terminated. */
+	PATH_RAY_TERMINATE                   = (PATH_RAY_TERMINATE_IMMEDIATE|PATH_RAY_TERMINATE_AFTER_TRANSPARENT),
+	/* Path and shader is being evaluated for direct lighting emission. */
+	PATH_RAY_EMISSION                    = (1 << 22)
 };
 
 /* Closure Label */
diff --git a/intern/cycles/kernel/kernel_volume.h b/intern/cycles/kernel/kernel_volume.h
index 7b67a37adc5..3274e05f98e 100644
--- a/intern/cycles/kernel/kernel_volume.h
+++ b/intern/cycles/kernel/kernel_volume.h
@@ -45,7 +45,7 @@ ccl_device_inline bool volume_shader_extinction_sample(KernelGlobals *kg,
                                                        float3 *extinction)
 {
 	sd->P = P;
-	shader_eval_volume(kg, sd, state, state->volume_stack, PATH_RAY_SHADOW, 0);
+	shader_eval_volume(kg, sd, state, state->volume_stack, PATH_RAY_SHADOW);
 
 	if(sd->flag & SD_EXTINCTION) {
 		*extinction = sd->closure_transparent_extinction;
@@ -64,7 +64,7 @@ ccl_device_inline bool volume_shader_sample(KernelGlobals *kg,
                                             VolumeShaderCoefficients *coeff)
 {
 	sd->P = P;
-	shader_eval_volume(kg, sd, state, state->volume_stack, state->flag, kernel_data.integrator.max_closures);
+	shader_eval_volume(kg, sd, state, state->volume_stack, state->flag);
 
 	if(!(sd->flag & (SD_EXTINCTION|SD_SCATTER|SD_EMISSION)))
 		return false;
@@ -76,18 +76,11 @@ ccl_device_inline bool volume_shader_sample(KernelGlobals *kg,
 	                                            make_float3(0.0f, 0.0f, 0.0f);
 
 	if(sd->flag & SD_SCATTER) {
-		if(state->bounce < kernel_data.integrator.max_bounce &&
-		   state->volume_bounce < kernel_data.integrator.max_volume_bounce) {
-			for(int i = 0; i < sd->num_closure; i++) {
-				const ShaderClosure *sc = &sd->closure[i];
+		for(int i = 0; i < sd->num_closure; i++) {
+			const ShaderClosure *sc = &sd->closure[i];
 
-				if(CLOSURE_IS_VOLUME(sc->type))
-					coeff->sigma_s += sc->weight;
-			}
-		}
-		else {
-			/* When at the max number of bounces, clear scattering. */
-			sd->flag &= ~SD_SCATTER;
+			if(CLOSURE_IS_VOLUME(sc->type))
+				coeff->sigma_s += sc->weight;
 		}
 	}
 
diff --git a/intern/cycles/kernel/osl/osl_closures.cpp b/intern/cycles/kernel/osl/osl_closures.cpp
index d0c357580fd..ee16ddaf0fd 100644
--- a/intern/cycles/kernel/osl/osl_closures.cpp
+++ b/intern/cycles/kernel/osl/osl_closures.cpp
@@ -705,7 +705,7 @@ public:
 
 	void setup(ShaderData *sd, int path_flag, float3 weight)
 	{
-		bsdf_transparent_setup(sd, weight);
+		bsdf_transparent_setup(sd, weight, path_flag);
 	}
 };
 
diff --git a/intern/cycles/kernel/shaders/node_bevel.osl b/intern/cycles/kernel/shaders/node_bevel.osl
index a5b185b6b4c..9c4ca15be17 100644
--- a/intern/cycles/kernel/shaders/node_bevel.osl
+++ b/intern/cycles/kernel/shaders/node_bevel.osl
@@ -23,9 +23,9 @@ shader node_bevel(
 	output normal NormalOut = N)
 {
 	/* Abuse texture call with special @bevel token. */
-	NormalOut = (normal)(color)texture("@bevel", samples, Radius);
+	vector bevel_N = (normal)(color)texture("@bevel", samples, Radius);
 
 	/* Preserve input normal. */
-	NormalOut = normalize(N + (NormalOut - NormalIn));
+	NormalOut = normalize(NormalIn + (bevel_N - N));
 }
 
diff --git a/intern/cycles/kernel/split/kernel_indirect_subsurface.h b/intern/cycles/kernel/split/kernel_indirect_subsurface.h
index e9fe5552e8c..b65f3d1a940 100644
--- a/intern/cycles/kernel/split/kernel_indirect_subsurface.h
+++ b/intern/cycles/kernel/split/kernel_indirect_subsurface.h
@@ -49,28 +49,22 @@ ccl_device void kernel_indirect_subsurface(KernelGlobals *kg)
 	ccl_global Ray *ray = &kernel_split_state.ray[ray_index];
 	ccl_global float3 *throughput = &kernel_split_state.throughput[ray_index];
 
-#ifdef __BRANCHED_PATH__
-	if(!kernel_data.integrator.branched) {
-#endif
-		if(IS_STATE(ray_state, ray_index, RAY_UPDATE_BUFFER)) {
-			ccl_addr_space SubsurfaceIndirectRays *ss_indirect = &kernel_split_state.ss_rays[ray_index];
+	if(IS_STATE(ray_state, ray_index, RAY_UPDATE_BUFFER)) {
+		ccl_addr_space SubsurfaceIndirectRays *ss_indirect = &kernel_split_state.ss_rays[ray_index];
 
-			/* Trace indirect subsurface rays by restarting the loop. this uses less
-			 * stack memory than invoking kernel_path_indirect.
-			 */
-			if(ss_indirect->num_rays) {
-				kernel_path_subsurface_setup_indirect(kg,
-					                                  ss_indirect,
-					                                  state,
-					                                  ray,
-					                                  L,
-					                                  throughput);
-				ASSIGN_RAY_STATE(ray_state, ray_index, RAY_REGENERATED);
-			}
+		/* Trace indirect subsurface rays by restarting the loop. this uses less
+		 * stack memory than invoking kernel_path_indirect.
+		 */
+		if(ss_indirect->num_rays) {
+			kernel_path_subsurface_setup_indirect(kg,
+												  ss_indirect,
+												  state,
+												  ray,
+												  L,
+												  throughput);
+			ASSIGN_RAY_STATE(ray_state, ray_index, RAY_REGENERATED);
 		}
-#ifdef __BRANCHED_PATH__
 	}
-#endif
 
 #endif  /* __SUBSURFACE__ */
 
diff --git a/intern/cycles/kernel/split/kernel_shader_eval.h b/intern/cycles/kernel/split/kernel_shader_eval.h
index 2409d1ba28b..2bc2d300699 100644
--- a/intern/cycles/kernel/split/kernel_shader_eval.h
+++ b/intern/cycles/kernel/split/kernel_shader_eval.h
@@ -50,7 +50,7 @@ ccl_device void kernel_shader_eval(KernelGlobals *kg)
 	if(IS_STATE(ray_state, ray_index, RAY_ACTIVE)) {
 		ccl_global PathState *state = &kernel_split_state.path_state[ray_index];
 
-		shader_eval_surface(kg, kernel_split_sd(sd, ray_index), state, state->flag, kernel_data.integrator.max_closures);
+		shader_eval_surface(kg, kernel_split_sd(sd, ray_index), state, state->flag);
 #ifdef __BRANCHED_PATH__
 		if(kernel_data.integrator.branched) {
 			shader_merge_closures(kernel_split_sd(sd, ray_index));
diff --git a/intern/cycles/kernel/split/kernel_split_common.h b/intern/cycles/kernel/split/kernel_split_common.h
index 21886ee62ee..b52e7bddc82 100644
--- a/intern/cycles/kernel/split/kernel_split_common.h
+++ b/intern/cycles/kernel/split/kernel_split_common.h
@@ -59,7 +59,12 @@ ccl_device_inline void kernel_split_path_end(KernelGlobals *kg, int ray_index)
 	ccl_global char *ray_state = kernel_split_state.ray_state;
 
 #ifdef __BRANCHED_PATH__
-	if(IS_FLAG(ray_state, ray_index, RAY_BRANCHED_INDIRECT_SHARED)) {
+	ccl_addr_space SubsurfaceIndirectRays *ss_indirect = &kernel_split_state.ss_rays[ray_index];
+
+	if(ss_indirect->num_rays) {
+		ASSIGN_RAY_STATE(ray_state, ray_index, RAY_UPDATE_BUFFER);
+	}
+	else if(IS_FLAG(ray_state, ray_index, RAY_BRANCHED_INDIRECT_SHARED)) {
 		int orig_ray = kernel_split_state.branched_state[ray_index].original_ray;
 
 		PathRadiance *L = &kernel_split_state.path_radiance[ray_index];
diff --git a/intern/cycles/kernel/split/kernel_subsurface_scatter.h b/intern/cycles/kernel/split/kernel_subsurface_scatter.h
index e50d63ea3bc..af0303d8608 100644
--- a/intern/cycles/kernel/split/kernel_subsurface_scatter.h
+++ b/intern/cycles/kernel/split/kernel_subsurface_scatter.h
@@ -228,7 +228,9 @@ ccl_device void kernel_subsurface_scatter(KernelGlobals *kg)
 		if(sd->flag & SD_BSSRDF) {
 
 #ifdef __BRANCHED_PATH__
-			if(!kernel_data.integrator.branched) {
+			if(!kernel_data.integrator.branched ||
+			   IS_FLAG(ray_state, ray_index, RAY_BRANCHED_INDIRECT))
+			{
 #endif
 				if(kernel_path_subsurface_scatter(kg,
 				                                  sd,
@@ -243,27 +245,6 @@ ccl_device void kernel_subsurface_scatter(KernelGlobals *kg)
 				}
 #ifdef __BRANCHED_PATH__
 			}
-			else if(IS_FLAG(ray_state, ray_index, RAY_BRANCHED_INDIRECT)) {
-				float bssrdf_u, bssrdf_v;
-				path_state_rng_2D(kg,
-				                  state,
-				                  PRNG_BSDF_U,
-				                  &bssrdf_u, &bssrdf_v);
-
-				const ShaderClosure *sc = shader_bssrdf_pick(sd, throughput, &bssrdf_u);
-
-				/* do bssrdf scatter step if we picked a bssrdf closure */
-				if(sc) {
-					uint lcg_state = lcg_state_init_addrspace(state, 0x68bc21eb);
-					subsurface_scatter_step(kg,
-					                        sd,
-					                        state,
-					                        sc,
-					                        &lcg_state,
-					                        bssrdf_u, bssrdf_v,
-					                        false);
-				}
-			}
 			else {
 				kernel_split_branched_path_subsurface_indirect_light_init(kg, ray_index);
 
diff --git a/intern/cycles/kernel/svm/svm_bevel.h b/intern/cycles/kernel/svm/svm_bevel.h
index dcfe4ad71b8..6d5a10db98f 100644
--- a/intern/cycles/kernel/svm/svm_bevel.h
+++ b/intern/cycles/kernel/svm/svm_bevel.h
@@ -216,7 +216,7 @@ ccl_device void svm_node_bevel(
 	if(stack_valid(normal_offset)) {
 		/* Preserve input normal. */
 		float3 ref_N = stack_load_float3(stack, normal_offset);
-		bevel_N = normalize(sd->N + (bevel_N - ref_N));
+		bevel_N = normalize(ref_N + (bevel_N - sd->N));;
 	}
 
 	stack_store_float3(stack, out_offset, bevel_N);
diff --git a/intern/cycles/kernel/svm/svm_closure.h b/intern/cycles/kernel/svm/svm_closure.h
index 5398f36c267..24452c81fe0 100644
--- a/intern/cycles/kernel/svm/svm_closure.h
+++ b/intern/cycles/kernel/svm/svm_closure.h
@@ -449,7 +449,7 @@ ccl_device void svm_node_closure_bsdf(KernelGlobals *kg, ShaderData *sd, float *
 		}
 		case CLOSURE_BSDF_TRANSPARENT_ID: {
 			float3 weight = sd->svm_closure_weight * mix_weight;
-			bsdf_transparent_setup(sd, weight);
+			bsdf_transparent_setup(sd, weight, path_flag);
 			break;
 		}
 		case CLOSURE_BSDF_REFLECTION_ID:
@@ -728,7 +728,7 @@ ccl_device void svm_node_closure_bsdf(KernelGlobals *kg, ShaderData *sd, float *
 				 * the throughput can blow up after multiple bounces. we
 				 * better figure out a way to skip backfaces from rays
 				 * spawned by transmission from the front */
-				bsdf_transparent_setup(sd, make_float3(1.0f, 1.0f, 1.0f));
+				bsdf_transparent_setup(sd, make_float3(1.0f, 1.0f, 1.0f), path_flag);
 			}
 			else {
 				HairBsdf *bsdf = (HairBsdf*)bsdf_alloc(sd, sizeof(HairBsdf), weight);
diff --git a/intern/cycles/render/nodes.cpp b/intern/cycles/render/nodes.cpp
index 48613a9324c..56c9e669a5c 100644
--- a/intern/cycles/render/nodes.cpp
+++ b/intern/cycles/render/nodes.cpp
@@ -3463,7 +3463,7 @@ NODE_DEFINE(ParticleInfoNode)
 {
 	NodeType* type = NodeType::add("particle_info", create, NodeType::SHADER);
 
-	SOCKET_OUT_FLOAT(random, "Index");
+	SOCKET_OUT_FLOAT(index, "Index");
 	SOCKET_OUT_FLOAT(random, "Random");
 	SOCKET_OUT_FLOAT(age, "Age");
 	SOCKET_OUT_FLOAT(lifetime, "Lifetime");
@@ -3576,7 +3576,7 @@ NODE_DEFINE(HairInfoNode)
 	SOCKET_OUT_FLOAT(is_strand, "Is Strand");
 	SOCKET_OUT_FLOAT(intercept, "Intercept");
 	SOCKET_OUT_FLOAT(thickness, "Thickness");
-	SOCKET_OUT_NORMAL(tangent Normal, "Tangent Normal");
+	SOCKET_OUT_NORMAL(tangent_normal, "Tangent Normal");
 #if 0 /*output for minimum hair width transparency - deactivated */
 	SOCKET_OUT_FLOAT(fade, "Fade");
 #endif
diff --git a/intern/cycles/render/osl.cpp b/intern/cycles/render/osl.cpp
index 5c5ac6e2be9..4d066c89b76 100644
--- a/intern/cycles/render/osl.cpp
+++ b/intern/cycles/render/osl.cpp
@@ -233,18 +233,25 @@ void OSLShaderManager::shading_system_init()
 			"glossy",			/* PATH_RAY_GLOSSY */
 			"singular",			/* PATH_RAY_SINGULAR */
 			"transparent",		/* PATH_RAY_TRANSPARENT */
+
 			"shadow",			/* PATH_RAY_SHADOW_OPAQUE_NON_CATCHER */
 			"shadow",			/* PATH_RAY_SHADOW_OPAQUE_CATCHER */
 			"shadow",			/* PATH_RAY_SHADOW_TRANSPARENT_NON_CATCHER */
 			"shadow",			/* PATH_RAY_SHADOW_TRANSPARENT_CATCHER */
 
 			"__unused__",
+			"volume_scatter",	/* PATH_RAY_VOLUME_SCATTER */
+			"__unused__",
+
 			"__unused__",
 			"diffuse_ancestor",	/* PATH_RAY_DIFFUSE_ANCESTOR */
 			"__unused__",
 			"__unused__",
-			"__unused__",		/* PATH_RAY_SINGLE_PASS_DONE */
-			"volume_scatter",	/* PATH_RAY_VOLUME_SCATTER */
+			"__unused__",
+			"__unused__",
+			"__unused__",
+			"__unused__",
+			"__unused__",
 		};
 
 		const int nraytypes = sizeof(raytypes)/sizeof(raytypes[0]);