[Bf-blender-cvs] [1e0c4ac] soc-2016-cycles_denoising: Cycles: Separate the render result for selective denoising

Lukas Stockner noreply at git.blender.org
Sat Jun 4 22:03:17 CEST 2016


Commit: 1e0c4acb29d3e3f78bbe93a413f73762cec3188f
Author: Lukas Stockner
Date:   Sat Jun 4 21:54:19 2016 +0200
Branches: soc-2016-cycles_denoising
https://developer.blender.org/rB1e0c4acb29d3e3f78bbe93a413f73762cec3188f

Cycles: Separate the render result for selective denoising

This commit finally implements the selective denoising pass writing.
With this commit, the denoising feature passes and therefore the changes to the
regular Cycles kernels should be finished.

===================================================================

M	intern/cycles/blender/blender_session.cpp
M	intern/cycles/kernel/kernel_accumulate.h
M	intern/cycles/kernel/kernel_passes.h
M	intern/cycles/kernel/kernel_types.h
M	intern/cycles/render/film.cpp
M	intern/cycles/render/film.h

===================================================================

diff --git a/intern/cycles/blender/blender_session.cpp b/intern/cycles/blender/blender_session.cpp
index c3c0b6a..27920e1 100644
--- a/intern/cycles/blender/blender_session.cpp
+++ b/intern/cycles/blender/blender_session.cpp
@@ -502,15 +502,24 @@ void BlenderSession::render()
 
 		buffer_params.passes = passes;
 		buffer_params.denoising_passes = b_layer_iter->keep_denoise_data() || b_layer_iter->denoise_result();
-		buffer_params.selective_denoising = !(b_layer_iter->denoise_diffuse_direct() && b_layer_iter->denoise_glossy_direct() && b_layer_iter->denoise_transmission_direct() && b_layer_iter->denoise_subsurface_direct() &&
-		                                      b_layer_iter->denoise_diffuse_indirect() && b_layer_iter->denoise_glossy_indirect() && b_layer_iter->denoise_transmission_indirect() && b_layer_iter->denoise_subsurface_indirect());
+		session->tile_manager.denoise = b_layer_iter->denoise_result();
 		scene->film->denoising_passes = buffer_params.denoising_passes;
-		scene->film->selective_denoising = buffer_params.selective_denoising;
+		scene->film->denoise_flags = 0;
+		if(b_layer_iter->denoise_diffuse_direct()) scene->film->denoise_flags |= DENOISE_DIFFUSE_DIR;
+		if(b_layer_iter->denoise_diffuse_indirect()) scene->film->denoise_flags |= DENOISE_DIFFUSE_IND;
+		if(b_layer_iter->denoise_glossy_direct()) scene->film->denoise_flags |= DENOISE_GLOSSY_DIR;
+		if(b_layer_iter->denoise_glossy_indirect()) scene->film->denoise_flags |= DENOISE_GLOSSY_IND;
+		if(b_layer_iter->denoise_transmission_direct()) scene->film->denoise_flags |= DENOISE_TRANSMISSION_DIR;
+		if(b_layer_iter->denoise_transmission_indirect()) scene->film->denoise_flags |= DENOISE_TRANSMISSION_IND;
+		if(b_layer_iter->denoise_subsurface_direct()) scene->film->denoise_flags |= DENOISE_SUBSURFACE_DIR;
+		if(b_layer_iter->denoise_subsurface_indirect()) scene->film->denoise_flags |= DENOISE_SUBSURFACE_IND;
+		scene->film->selective_denoising = (scene->film->denoise_flags != DENOISE_ALL);
+		buffer_params.selective_denoising = scene->film->selective_denoising;
+
 		scene->film->pass_alpha_threshold = b_layer_iter->pass_alpha_threshold();
 		scene->film->tag_passes_update(scene, passes);
 		scene->film->tag_update(scene);
 		scene->integrator->tag_update(scene);
-		session->tile_manager.denoise = b_layer_iter->denoise_result();
 
 		if(b_layer_iter->keep_denoise_data()) {
 			add_pass(b_engine, SCE_PASS_DENOISE_NORMAL, 3, b_rlay_name.c_str(), NULL);
diff --git a/intern/cycles/kernel/kernel_accumulate.h b/intern/cycles/kernel/kernel_accumulate.h
index 5f5a360..d529ac1 100644
--- a/intern/cycles/kernel/kernel_accumulate.h
+++ b/intern/cycles/kernel/kernel_accumulate.h
@@ -454,6 +454,29 @@ ccl_device_inline float3 path_radiance_clamp_and_sum(KernelGlobals *kg, PathRadi
 	return L_sum;
 }
 
+ccl_device_inline void path_radiance_split_denoising(KernelGlobals *kg, PathRadiance *L, float3 *noisy, float3 *clean)
+{
+#ifdef __PASSES__
+	kernel_assert(L->use_light_pass);
+
+	*clean = L->emission + L->background;
+	*noisy = L->direct_scatter + L->indirect_scatter;
+
+	/* TODO Clean this up */
+	*((kernel_data.film.denoise_flag & DENOISE_DIFFUSE_DIR)? noisy: clean) += L->direct_diffuse;
+	*((kernel_data.film.denoise_flag & DENOISE_DIFFUSE_IND)? noisy: clean) += L->indirect_diffuse;
+	*((kernel_data.film.denoise_flag & DENOISE_GLOSSY_DIR)? noisy: clean) += L->direct_glossy;
+	*((kernel_data.film.denoise_flag & DENOISE_GLOSSY_IND)? noisy: clean) += L->indirect_glossy;
+	*((kernel_data.film.denoise_flag & DENOISE_TRANSMISSION_DIR)? noisy: clean) += L->direct_transmission;
+	*((kernel_data.film.denoise_flag & DENOISE_TRANSMISSION_IND)? noisy: clean) += L->indirect_transmission;
+	*((kernel_data.film.denoise_flag & DENOISE_SUBSURFACE_DIR)? noisy: clean) += L->direct_subsurface;
+	*((kernel_data.film.denoise_flag & DENOISE_SUBSURFACE_IND)? noisy: clean) += L->indirect_subsurface;
+#else
+	*noisy = *L;
+	*clean = make_float3(0.0f, 0.0f, 0.0f);
+#endif
+}
+
 ccl_device_inline void path_radiance_accum_sample(PathRadiance *L, PathRadiance *L_sample, int num_samples)
 {
 	float fac = 1.0f/num_samples;
diff --git a/intern/cycles/kernel/kernel_passes.h b/intern/cycles/kernel/kernel_passes.h
index 32f0d68..4ce59dc 100644
--- a/intern/cycles/kernel/kernel_passes.h
+++ b/intern/cycles/kernel/kernel_passes.h
@@ -56,6 +56,14 @@ ccl_device_inline void kernel_write_pass_float3(ccl_global float *buffer, int sa
 #endif // __SPLIT_KERNEL__ && __WORK_STEALING__
 }
 
+ccl_device_inline void kernel_write_pass_float3_nopad(ccl_global float *buffer, int sample, float3 value)
+{
+	/* TODO somehow avoid this duplicated function */
+	buffer[0] = (sample == 0)? value.x: buffer[0] + value.x;
+	buffer[1] = (sample == 0)? value.y: buffer[1] + value.y;
+	buffer[2] = (sample == 0)? value.z: buffer[2] + value.z;
+}
+
 ccl_device_inline void kernel_write_pass_float3_var(ccl_global float *buffer, int sample, float3 value)
 {
 	if(sample == 0) {
@@ -303,9 +311,28 @@ ccl_device_inline void kernel_write_result(KernelGlobals *kg, ccl_global float *
 		kernel_write_pass_float4(buffer, sample, make_float4(L_sum.x, L_sum.y, L_sum.z, alpha));
 
 		kernel_write_light_passes(kg, buffer, L, sample);
+
+		if(kernel_data.film.pass_denoising) {
+			if(kernel_data.film.pass_no_denoising) {
+				float3 noisy, clean;
+				path_radiance_split_denoising(kg, L, &noisy, &clean);
+				kernel_write_pass_float3_var(buffer + kernel_data.film.pass_denoising + 14, sample, noisy);
+				kernel_write_pass_float3_nopad(buffer + kernel_data.film.pass_no_denoising, sample, clean);
+			}
+			else {
+				kernel_write_pass_float3_var(buffer + kernel_data.film.pass_denoising + 14, sample, L_sum);
+			}
+		}
 	}
 	else {
 		kernel_write_pass_float4(buffer, sample, make_float4(0.0f, 0.0f, 0.0f, 0.0f));
+
+		if(kernel_data.film.pass_denoising) {
+			kernel_write_pass_float3_var(buffer + kernel_data.film.pass_denoising + 14, sample, make_float3(0.0f, 0.0f, 0.0f));
+		}
+		if(kernel_data.film.pass_no_denoising) {
+			kernel_write_pass_float3_nopad(buffer + kernel_data.film.pass_no_denoising, sample, make_float3(0.0f, 0.0f, 0.0f));
+		}
 	}
 }
 
diff --git a/intern/cycles/kernel/kernel_types.h b/intern/cycles/kernel/kernel_types.h
index e84b7a9..5e3039e 100644
--- a/intern/cycles/kernel/kernel_types.h
+++ b/intern/cycles/kernel/kernel_types.h
@@ -394,6 +394,27 @@ typedef enum BakePassFilterCombos {
 	BAKE_FILTER_SUBSURFACE_INDIRECT = (BAKE_FILTER_INDIRECT | BAKE_FILTER_SUBSURFACE),
 } BakePassFilterCombos;
 
+typedef enum DenoiseFlag {
+	DENOISE_DIFFUSE_DIR      = (1 << 0),
+	DENOISE_DIFFUSE_IND      = (1 << 1),
+	DENOISE_GLOSSY_DIR       = (1 << 2),
+	DENOISE_GLOSSY_IND       = (1 << 3),
+	DENOISE_TRANSMISSION_DIR = (1 << 4),
+	DENOISE_TRANSMISSION_IND = (1 << 5),
+	DENOISE_SUBSURFACE_DIR   = (1 << 6),
+	DENOISE_SUBSURFACE_IND   = (1 << 7),
+
+	DENOISE_ALL = (
+	    DENOISE_DIFFUSE_DIR |
+	    DENOISE_DIFFUSE_IND |
+	    DENOISE_GLOSSY_DIR |
+	    DENOISE_GLOSSY_IND |
+	    DENOISE_TRANSMISSION_DIR |
+	    DENOISE_TRANSMISSION_IND |
+	    DENOISE_SUBSURFACE_DIR |
+	    DENOISE_SUBSURFACE_IND),
+} DenoiseFlag;
+
 #ifdef __PASSES__
 
 typedef ccl_addr_space struct PathRadiance {
@@ -1029,7 +1050,7 @@ typedef struct KernelFilm {
 
 	int pass_denoising;
 	int pass_no_denoising;
-	int pass_pad4;
+	int denoise_flag;
 	int pass_pad5;
 
 #ifdef __KERNEL_DEBUG__
diff --git a/intern/cycles/render/film.cpp b/intern/cycles/render/film.cpp
index e8dc220..6edb5a8 100644
--- a/intern/cycles/render/film.cpp
+++ b/intern/cycles/render/film.cpp
@@ -428,9 +428,11 @@ void Film::device_update(Device *device, DeviceScene *dscene, Scene *scene)
 	if(denoising_passes) {
 		kfilm->pass_denoising = kfilm->pass_stride;
 		kfilm->pass_stride += 20;
+		kfilm->denoise_flag = denoise_flags;
 		if(selective_denoising) {
 			kfilm->pass_no_denoising = kfilm->pass_stride;
 			kfilm->pass_stride += 3;
+			kfilm->use_light_pass = 1;
 		}
 	}
 
diff --git a/intern/cycles/render/film.h b/intern/cycles/render/film.h
index 5871499..b4da696 100644
--- a/intern/cycles/render/film.h
+++ b/intern/cycles/render/film.h
@@ -55,6 +55,7 @@ public:
 	vector<Pass> passes;
 	bool denoising_passes;
 	bool selective_denoising;
+	int denoise_flags;
 	float pass_alpha_threshold;
 
 	FilterType filter_type;




More information about the Bf-blender-cvs mailing list