Commit: 1730a7261e9c2edd7b27721b49af787cbd71cb02
Author: Lukas Stockner
Date:   Sat Feb 11 04:38:00 2017 +0100
Branches: temp-cycles-denoising
https://developer.blender.org/rB1730a7261e9c2edd7b27721b49af787cbd71cb02

Cycles Denoising: Rename variables for consistency and move them out of 
KernelData

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

M       intern/cycles/blender/blender_session.cpp
M       intern/cycles/blender/blender_sync.cpp
M       intern/cycles/device/device_cpu.cpp
M       intern/cycles/device/device_cuda.cpp
M       intern/cycles/device/device_denoising.cpp
M       intern/cycles/device/device_denoising.h
M       intern/cycles/device/device_task.h
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/buffers.cpp
M       intern/cycles/render/buffers.h
M       intern/cycles/render/film.cpp
M       intern/cycles/render/film.h
M       intern/cycles/render/integrator.cpp
M       intern/cycles/render/integrator.h
M       intern/cycles/render/session.cpp
M       intern/cycles/render/session.h

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

diff --git a/intern/cycles/blender/blender_session.cpp 
b/intern/cycles/blender/blender_session.cpp
index b44c988966..eae4db438c 100644
--- a/intern/cycles/blender/blender_session.cpp
+++ b/intern/cycles/blender/blender_session.cpp
@@ -406,27 +406,28 @@ void BlenderSession::render()
                }
 
                buffer_params.passes = passes;
-               buffer_params.denoising_passes = 
b_layer_iter->keep_denoise_data() || b_layer_iter->denoise_result();
+               buffer_params.denoising_data_pass = 
b_layer_iter->keep_denoise_data() || b_layer_iter->denoise_result();
                session->tile_manager.schedule_denoising = 
(b_layer_iter->denoise_result() && is_cpu) && !getenv("CPU_OVERSCAN");
                session->params.denoise_result = b_layer_iter->denoise_result();
-               scene->film->denoising_passes = buffer_params.denoising_passes;
-               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);
-               scene->film->cross_denoising = b_layer_iter->filter_cross();
-               buffer_params.selective_denoising = 
scene->film->selective_denoising;
-               buffer_params.cross_denoising = scene->film->cross_denoising;
-               scene->integrator->half_window = b_layer_iter->half_window();
-               scene->integrator->filter_strength = 
(b_layer_iter->filter_strength() == 0.0f)? 1e-3f : copysignf(powf(10.0f, 
-fabsf(b_layer_iter->filter_strength())*2.0f), b_layer_iter->filter_strength());
-               scene->integrator->weighting_adjust = powf(2.0f, 
b_layer_iter->filter_weighting_adjust() - 1.0f);
-               scene->integrator->use_gradients = 
b_layer_iter->filter_gradients();
+               scene->film->denoising_data_pass = 
buffer_params.denoising_data_pass;
+               scene->film->denoising_flags = 0;
+               if(!b_layer_iter->denoise_diffuse_direct()) 
scene->film->denoising_flags |= DENOISING_CLEAN_DIFFUSE_DIR;
+               if(!b_layer_iter->denoise_diffuse_indirect()) 
scene->film->denoising_flags |= DENOISING_CLEAN_DIFFUSE_IND;
+               if(!b_layer_iter->denoise_glossy_direct()) 
scene->film->denoising_flags |= DENOISING_CLEAN_GLOSSY_DIR;
+               if(!b_layer_iter->denoise_glossy_indirect()) 
scene->film->denoising_flags |= DENOISING_CLEAN_GLOSSY_IND;
+               if(!b_layer_iter->denoise_transmission_direct()) 
scene->film->denoising_flags |= DENOISING_CLEAN_TRANSMISSION_DIR;
+               if(!b_layer_iter->denoise_transmission_indirect()) 
scene->film->denoising_flags |= DENOISING_CLEAN_TRANSMISSION_IND;
+               if(!b_layer_iter->denoise_subsurface_direct()) 
scene->film->denoising_flags |= DENOISING_CLEAN_SUBSURFACE_DIR;
+               if(!b_layer_iter->denoise_subsurface_indirect()) 
scene->film->denoising_flags |= DENOISING_CLEAN_SUBSURFACE_IND;
+               scene->film->denoising_clean_pass = 
(scene->film->denoising_flags & DENOISING_CLEAN_ALL_PASSES);
+               scene->film->denoising_split_pass = 
b_layer_iter->filter_cross();
+               buffer_params.denoising_clean_pass = 
scene->film->denoising_clean_pass;
+               buffer_params.denoising_split_pass = 
scene->film->denoising_split_pass;
+               session->params.denoising_half_window = 
b_layer_iter->half_window();
+               session->params.denoising_pca_threshold = 
(b_layer_iter->filter_strength() == 0.0f)? 1e-3f : copysignf(powf(10.0f, 
-fabsf(b_layer_iter->filter_strength())*2.0f), b_layer_iter->filter_strength());
+               session->params.denoising_weight_adjust = powf(2.0f, 
b_layer_iter->filter_weighting_adjust() - 1.0f);
+               session->params.denoising_use_gradients = 
b_layer_iter->filter_gradients();
+               session->params.denoising_use_cross = 
b_layer_iter->filter_cross();
 
                scene->film->pass_alpha_threshold = 
b_layer_iter->pass_alpha_threshold();
                scene->film->tag_passes_update(scene, passes);
diff --git a/intern/cycles/blender/blender_sync.cpp 
b/intern/cycles/blender/blender_sync.cpp
index 9985029635..13bd763300 100644
--- a/intern/cycles/blender/blender_sync.cpp
+++ b/intern/cycles/blender/blender_sync.cpp
@@ -900,16 +900,16 @@ RenderBuffers* BlenderSync::get_render_buffer(Device 
*device,
                if(denoising_type) {
                        denoising_passes |= denoising_type;
                        if(denoising_type == DENOISING_PASS_CLEAN)
-                               params.selective_denoising = true;
+                               params.denoising_clean_pass = true;
                        if(denoising_type == DENOISING_PASS_NOISY_B)
-                               params.cross_denoising = true;
+                               params.denoising_split_pass = true;
                }
        }
        if(~denoising_passes & DENOISING_PASS_REQUIRED) {
                return NULL;
        }
-       params.denoising_passes = true;
-       assert(!params.cross_denoising || (denoising_passes & 
DENOISING_PASS_NOISY_B_VAR));
+       params.denoising_data_pass = true;
+       assert(!params.denoising_split_pass || (denoising_passes & 
DENOISING_PASS_NOISY_B_VAR));
 
        RenderBuffers *buffer = new RenderBuffers(device);
        buffer->reset(device, params);
diff --git a/intern/cycles/device/device_cpu.cpp 
b/intern/cycles/device/device_cpu.cpp
index a968bb04f6..dc2fc49123 100644
--- a/intern/cycles/device/device_cpu.cpp
+++ b/intern/cycles/device/device_cpu.cpp
@@ -470,7 +470,7 @@ public:
                                                              (float*) 
buffer_variance_ptr,
                                                              &task->rect.x,
                                                              
task->render_buffer.pass_stride,
-                                                             
task->render_buffer.denoising_offset,
+                                                             
task->render_buffer.denoising_data_offset,
                                                              
task->use_gradients);
                        }
                }
@@ -494,7 +494,7 @@ public:
                                                            (float*) 
variance_ptr,
                                                            &task->rect.x,
                                                            
task->render_buffer.pass_stride,
-                                                           
task->render_buffer.denoising_offset,
+                                                           
task->render_buffer.denoising_data_offset,
                                                            
task->use_cross_denoising);
                        }
                }
@@ -551,7 +551,7 @@ public:
                                        denoising.render_buffer.samples = 
end_sample;
 
                                        denoising.tiles_from_single_tile(tile);
-                                       
denoising.init_from_kerneldata(&kg.__data);
+                                       denoising.init_from_devicetask(task);
 
                                        denoising.functions.construct_transform 
= function_bind(&CPUDevice::denoising_construct_transform, this, &denoising);
                                        denoising.functions.reconstruct = 
function_bind(&CPUDevice::denoising_reconstruct, this, _1, _2, _3, _4, _5, 
&denoising);
@@ -575,7 +575,7 @@ public:
                                task.get_neighbor_tiles(rtiles);
                                denoising.tiles_from_rendertiles(rtiles);
 
-                               denoising.init_from_kerneldata(&kg.__data);
+                               denoising.init_from_devicetask(task);
 
                                denoising.functions.construct_transform = 
function_bind(&CPUDevice::denoising_construct_transform, this, &denoising);
                                denoising.functions.reconstruct = 
function_bind(&CPUDevice::denoising_reconstruct, this, _1, _2, _3, _4, _5, 
&denoising);
diff --git a/intern/cycles/device/device_cuda.cpp 
b/intern/cycles/device/device_cuda.cpp
index 1bbe98113e..d9a66b7463 100644
--- a/intern/cycles/device/device_cuda.cpp
+++ b/intern/cycles/device/device_cuda.cpp
@@ -93,7 +93,6 @@ public:
        int cuDevId;
        int cuDevArchitecture;
        bool first_error;
-       KernelData kernel_globals;
 
        struct PixelMem {
                GLuint cuPBO;
@@ -557,9 +556,6 @@ public:
 
                cuda_push_context();
                cuda_assert(cuModuleGetGlobal(&mem, &bytes, cuModule, name));
-               if(strcmp(name, "__data") == 0) {
-                       kernel_globals = *(KernelData*) host;
-               }
                //assert(bytes == size);
                cuda_assert(cuMemcpyHtoD(mem, host, size));
                cuda_pop_context();
@@ -1127,7 +1123,7 @@ public:
                                &buffer_variance_ptr,
                                &task->rect,
                                &task->render_buffer.pass_stride,
-                               &task->render_buffer.denoising_offset,
+                               &task->render_buffer.denoising_data_offset,
                                &task->use_gradients};
                CUDA_LAUNCH_KERNEL(cuFilterDivideShadow, args);
                cuda_assert(cuCtxSynchronize());
@@ -1162,7 +1158,7 @@ public:
                                &variance_ptr,
                                &task->rect,
                                &task->render_buffer.pass_stride,
-                               &task->render_buffer.denoising_offset,
+                               &task->render_buffer.denoising_data_offset,
                                &task->use_cross_denoising};
                CUDA_LAUNCH_KERNEL(cuFilterGetFeature, args);
                cuda_assert(cuCtxSynchronize());
@@ -1171,7 +1167,7 @@ public:
                return !have_error();
        }
 
-       void denoise(RenderTile &rtile, int sample)
+       void denoise(RenderTile &rtile, const DeviceTask &task, int sample)
        {
                DenoisingTask denoising(this);
 
@@ -1180,7 +1176,7 @@ public:
                denoising.render_buffer.samples = sample;
 
                denoising.tiles_from_single_tile(rtile);
-               denoising.init_from_kerneldata(&kernel_globals);
+               denoising.init_from_devicetask(task);
 
                denoising.functions.construct_transform = 
function_bind(&CUDADevice::denoising_construct_transform, this, &denoising);
                denoising.functions.reconstruct = 
function_bind(&CUDADevice::denoising_reconstruct, this, _1, _2, _3, _4, _5, 
&denoising);
@@ -1644,12 +1640,12 @@ public:
                                        }
 
                                        if(tile.buffers->params.overscan && 
!task->get_cancel()) { /* TODO(lukas) Works, but seems hacky? */
-                                               denoise(tile, end_sample);
+                                               denoise(tile, *task, 
end_sample);
                                        }
                                }
                                else if(tile.task == RenderTile::DENOISE) {
                                        int sample = tile.start_sample + 
tile.num_samples;
-                                       denoise(tile, sample);
+                                       denoise(tile, *task, sample);
                                        tile.sample = sample;
                                }
 
diff --git a/intern/cycles/device/device_denoising.cpp 
b/intern/cycles/device/device_denoising.cpp
index 7ac5eaf1ea..4653a08eb1 100644
--- a/intern/cycles/device/device_denoising.cpp
+++ b/intern/cycles/device/device_denoising.cpp
@@ -20,17 +20,17 @@
 
 CCL_NAMESPACE_BEGIN

@@ Diff output truncated at 10240 characters. @@

_______________________________________________
Bf-blender-cvs mailing list
[email protected]
https://lists.blender.org/mailman/listinfo/bf-blender-cvs

Reply via email to