[Bf-blender-cvs] [606107f6c46] temp-cycles-denoising: Merge remote-tracking branch 'origin/master' into temp-cycles-denoising

Lukas Stockner noreply at git.blender.org
Thu May 4 14:20:47 CEST 2017


Commit: 606107f6c46ebb92ba77f0d462acb8aa3b8de9dd
Author: Lukas Stockner
Date:   Wed May 3 21:35:58 2017 +0200
Branches: temp-cycles-denoising
https://developer.blender.org/rB606107f6c46ebb92ba77f0d462acb8aa3b8de9dd

Merge remote-tracking branch 'origin/master' into temp-cycles-denoising

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



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

diff --cc intern/cycles/device/device_cpu.cpp
index 13a12a137e1,3c481bb2b39..a84d0db7ac3
--- a/intern/cycles/device/device_cpu.cpp
+++ b/intern/cycles/device/device_cpu.cpp
@@@ -231,24 -204,22 +231,26 @@@ public
  			VLOG(1) << "Will be using split kernel.";
  		}
  
 -		kernel_cpu_register_functions(register_kernel_function);
 -#ifdef WITH_CYCLES_OPTIMIZED_KERNEL_SSE2
 -		kernel_cpu_sse2_register_functions(register_kernel_function);
 -#endif
 -#ifdef WITH_CYCLES_OPTIMIZED_KERNEL_SSE3
 -		kernel_cpu_sse3_register_functions(register_kernel_function);
 -#endif
 -#ifdef WITH_CYCLES_OPTIMIZED_KERNEL_SSE41
 -		kernel_cpu_sse41_register_functions(register_kernel_function);
 -#endif
 -#ifdef WITH_CYCLES_OPTIMIZED_KERNEL_AVX
 -		kernel_cpu_avx_register_functions(register_kernel_function);
 -#endif
 -#ifdef WITH_CYCLES_OPTIMIZED_KERNEL_AVX2
 -		kernel_cpu_avx2_register_functions(register_kernel_function);
 -#endif
 +#define REGISTER_SPLIT_KERNEL(name) split_kernels[#name] = KernelFunctions<void(*)(KernelGlobals*, KernelData*)>(KERNEL_FUNCTIONS(name))
 +		REGISTER_SPLIT_KERNEL(path_init);
 +		REGISTER_SPLIT_KERNEL(scene_intersect);
 +		REGISTER_SPLIT_KERNEL(lamp_emission);
 +		REGISTER_SPLIT_KERNEL(do_volume);
 +		REGISTER_SPLIT_KERNEL(queue_enqueue);
 +		REGISTER_SPLIT_KERNEL(indirect_background);
++		REGISTER_SPLIT_KERNEL(shader_setup);
++		REGISTER_SPLIT_KERNEL(shader_sort);
 +		REGISTER_SPLIT_KERNEL(shader_eval);
 +		REGISTER_SPLIT_KERNEL(holdout_emission_blurring_pathtermination_ao);
 +		REGISTER_SPLIT_KERNEL(subsurface_scatter);
 +		REGISTER_SPLIT_KERNEL(direct_lighting);
 +		REGISTER_SPLIT_KERNEL(shadow_blocked_ao);
 +		REGISTER_SPLIT_KERNEL(shadow_blocked_dl);
 +		REGISTER_SPLIT_KERNEL(next_iteration_setup);
 +		REGISTER_SPLIT_KERNEL(indirect_subsurface);
 +		REGISTER_SPLIT_KERNEL(buffer_update);
 +#undef REGISTER_SPLIT_KERNEL
 +#undef KERNEL_FUNCTIONS
  	}
  
  	~CPUDevice()
diff --cc intern/cycles/device/device_cuda.cpp
index 77b6eb4c6eb,a971170318e..968ee5bc487
--- a/intern/cycles/device/device_cuda.cpp
+++ b/intern/cycles/device/device_cuda.cpp
@@@ -1702,59 -1313,51 +1707,58 @@@ public
  			/* Upload Bindless Mapping */
  			load_bindless_mapping();
  
 -			if(!use_split_kernel()) {
 -				/* keep rendering tiles until done */
 -				while(task->acquire_tile(this, tile)) {
 -					int start_sample = tile.start_sample;
 -					int end_sample = tile.start_sample + tile.num_samples;
 -
 -					for(int sample = start_sample; sample < end_sample; sample++) {
 -						if(task->get_cancel()) {
 -							if(task->need_finish_queue == false)
 -								break;
 -						}
 -
 -						path_trace(tile, sample, branched);
 -
 -						tile.sample = sample + 1;
 -
 -						task->update_progress(&tile, tile.w*tile.h);
 -					}
 -
 -					task->release_tile(tile);
 -				}
 -			}
 -			else {
 -				DeviceRequestedFeatures requested_features;
 +			DeviceRequestedFeatures requested_features;
- 			CUDASplitKernel *split_kernel = NULL;
 +			if(use_split_kernel()) {
  				if(!use_adaptive_compilation()) {
  					requested_features.max_closure = 64;
  				}
  
- 				split_kernel = new CUDASplitKernel(this);
- 				split_kernel->load_kernels(requested_features);
+ 				if(split_kernel == NULL) {
+ 					split_kernel = new CUDASplitKernel(this);
+ 					split_kernel->load_kernels(requested_features);
+ 				}
 +			}
 +
 +			/* keep rendering tiles until done */
 +			while(task->acquire_tile(this, tile)) {
 +				if(tile.task == RenderTile::PATH_TRACE) {
 +					if(use_split_kernel()) {
 +						device_memory void_buffer;
 +						split_kernel->path_trace(task, tile, void_buffer, void_buffer);
 +					}
 +					else {
 +						int start_sample = tile.start_sample;
 +						int end_sample = tile.start_sample + tile.num_samples;
 +
 +						for(int sample = start_sample; sample < end_sample; sample++) {
 +							if(task->get_cancel()) {
 +								if(task->need_finish_queue == false)
 +									break;
 +							}
  
 -				while(task->acquire_tile(this, tile)) {
 -					device_memory void_buffer;
 -					split_kernel->path_trace(task, tile, void_buffer, void_buffer);
 +							path_trace(tile, sample, branched);
  
 -					task->release_tile(tile);
 +							tile.sample = sample + 1;
  
 -					if(task->get_cancel()) {
 -						if(task->need_finish_queue == false)
 -							break;
 +							task->update_progress(&tile, tile.w*tile.h);
 +						}
  					}
  				}
 +				else if(tile.task == RenderTile::DENOISE) {
 +					tile.sample = tile.start_sample + tile.num_samples;
 +
 +					denoise(tile, *task);
 +
 +					task->update_progress(&tile, tile.w*tile.h);
 +				}
 +
 +				task->release_tile(tile);
 +
 +				if(task->get_cancel()) {
 +					if(task->need_finish_queue == false)
 +						break;
 +				}
  			}
- 
- 			delete split_kernel;
  		}
  		else if(task->type == DeviceTask::SHADER) {
  			/* Upload Bindless Mapping */
diff --cc intern/cycles/kernel/kernel_path_surface.h
index 1ee0d964658,bd4ba775b4d..e676ea0f3ae
--- a/intern/cycles/kernel/kernel_path_surface.h
+++ b/intern/cycles/kernel/kernel_path_surface.h
@@@ -155,8 -155,7 +155,8 @@@ ccl_device bool kernel_branched_path_su
          ccl_addr_space float3 *throughput,
          ccl_addr_space PathState *state,
          PathRadiance *L,
-         Ray *ray,
 -        ccl_addr_space Ray *ray)
++        ccl_addr_space Ray *ray,
 +        float sum_sample_weight)
  {
  	/* sample BSDF */
  	float bsdf_pdf;
diff --cc intern/cycles/kernel/kernels/cpu/kernel_cpu_impl.h
index 3c7d8c9c3f3,8c05dd1d9ef..b9d82781840
--- a/intern/cycles/kernel/kernels/cpu/kernel_cpu_impl.h
+++ b/intern/cycles/kernel/kernels/cpu/kernel_cpu_impl.h
@@@ -219,11 -194,42 +223,10 @@@ DEFINE_SPLIT_KERNEL_FUNCTION(shadow_blo
  DEFINE_SPLIT_KERNEL_FUNCTION_LOCALS(next_iteration_setup, uint)
  DEFINE_SPLIT_KERNEL_FUNCTION(indirect_subsurface)
  DEFINE_SPLIT_KERNEL_FUNCTION_LOCALS(buffer_update, uint)
 -
 -void KERNEL_FUNCTION_FULL_NAME(register_functions)(void(*reg)(const char* name, void* func))
 -{
 -#define REGISTER_NAME_STRING(name) #name
 -#define REGISTER_EVAL_NAME(name) REGISTER_NAME_STRING(name)
 -#define REGISTER(name) reg(REGISTER_EVAL_NAME(KERNEL_FUNCTION_FULL_NAME(name)), (void*)KERNEL_FUNCTION_FULL_NAME(name));
 -
 -	REGISTER(path_trace);
 -	REGISTER(convert_to_byte);
 -	REGISTER(convert_to_half_float);
 -	REGISTER(shader);
 -
 -	REGISTER(data_init);
 -	REGISTER(path_init);
 -	REGISTER(scene_intersect);
 -	REGISTER(lamp_emission);
 -	REGISTER(do_volume);
 -	REGISTER(queue_enqueue);
 -	REGISTER(indirect_background);
 -	REGISTER(shader_setup);
 -	REGISTER(shader_sort);
 -	REGISTER(shader_eval);
 -	REGISTER(holdout_emission_blurring_pathtermination_ao);
 -	REGISTER(subsurface_scatter);
 -	REGISTER(direct_lighting);
 -	REGISTER(shadow_blocked_ao);
 -	REGISTER(shadow_blocked_dl);
 -	REGISTER(next_iteration_setup);
 -	REGISTER(indirect_subsurface);
 -	REGISTER(buffer_update);
 -
 -#undef REGISTER
 -#undef REGISTER_EVAL_NAME
 -#undef REGISTER_NAME_STRING
 -}
--
  #endif  /* __SPLIT_KERNEL__ */
  
 +#undef KERNEL_STUB
 +#undef STUB_ASSERT
 +#undef KERNEL_ARCH
 +
  CCL_NAMESPACE_END
diff --cc intern/cycles/kernel/split/kernel_branched.h
index 00000000000,c7bc1b4df0a..dc74a2ada53
mode 000000,100644..100644
--- a/intern/cycles/kernel/split/kernel_branched.h
+++ b/intern/cycles/kernel/split/kernel_branched.h
@@@ -1,0 -1,150 +1,170 @@@
+ /*
+  * Copyright 2011-2017 Blender Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+  * you may not use this file except in compliance with the License.
+  * You may obtain a copy of the License at
+  *
+  * http://www.apache.org/licenses/LICENSE-2.0
+  *
+  * Unless required by applicable law or agreed to in writing, software
+  * distributed under the License is distributed on an "AS IS" BASIS,
+  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  * See the License for the specific language governing permissions and
+  * limitations under the License.
+  */
+ 
+ CCL_NAMESPACE_BEGIN
+ 
+ #ifdef __BRANCHED_PATH__
+ 
+ /* sets up the various state needed to do an indirect loop */
+ ccl_device_inline void kernel_split_branched_path_indirect_loop_init(KernelGlobals *kg, int ray_index)
+ {
+ 	SplitBranchedState *branched_state = &kernel_split_state.branched_state[ray_index];
+ 
+ 	/* save a copy of the state to restore later */
+ #define BRANCHED_STORE(name) \
+ 		branched_state->name = kernel_split_state.name[ray_index];
+ 
+ 	BRANCHED_STORE(path_state);
+ 	BRANCHED_STORE(throughput);
+ 	BRANCHED_STORE(ray);
+ 	BRANCHED_STORE(sd);
+ 	BRANCHED_STORE(isect);
+ 	BRANCHED_STORE(ray_state);
+ 
+ #undef BRANCHED_STORE
+ 
+ 	/* set loop counters to intial position */
+ 	branched_state->next_closure = 0;
+ 	branched_state->next_sample = 0;
+ }
+ 
+ /* ends an indirect loop and restores the previous state */
+ ccl_device_inline void kernel_split_branched_path_indirect_loop_end(KernelGlobals *kg, int ray_index)
+ {
+ 	SplitBranchedState *branched_state = &kernel_split_state.branched_state[ray_index];
+ 
+ 	/* restore state */
+ #define BRANCHED_RESTORE(name) \
+ 		kernel_split_state.name[ray_index] = branched_state->name;
+ 
+ 	BRANCHED_RESTORE(path_state);
+ 	BRANCHED_RESTORE(throughput);
+ 	BRANCHED_RESTORE(ray);
+ 	BRANCHED_RESTORE(sd);
+ 	BRANCHED_RESTORE(isect);
+ 	BRANCHED_RESTORE(ray_state);
+ 
+ #undef BRANCHED_RESTORE
+ 
+ 	/* leave indirect loop */
+ 	REMOVE_RAY_FLAG(kernel_split_state.ray_state, ray_index, RAY_BRANCHED_INDIRECT);
+ }
+ 
+ /* bounce off surface and integrate indirect light */
+ ccl_device_noinline bool kernel_split_branched_path_surface_indirect_light_iter(KernelGlobals *kg,
+                                                                                 int ray_index,
+                                                                                 float num_samples_adjust,
+                                                                                 ShaderData *saved_sd,
+                                                                                 bool reset_path_state)
+ {
+ 	SplitBranchedState *branched_state = &kernel_split_state.branched_state[ray_index];
+ 
+ 	ShaderData *sd = saved_sd;
+ 	RNG rng = kernel_split_state.rng[ray_index];
+ 	PathRadiance *L = &kernel_split_state

@@ Diff output truncated at 10240 characters. @@




More information about the Bf-blender-cvs mailing list