[Bf-blender-cvs] [d18a3b728b4] cycles-x: Cycles X: improve denoising features for volumes

[Brecht Van Lommel]

Commit: d18a3b728b439cb754e96ab69ee0de8417fb37cc
Author: Brecht Van Lommel
Date:   Fri Sep 3 17:45:10 2021 +0200
Branches: cycles-x
https://developer.blender.org/rBd18a3b728b439cb754e96ab69ee0de8417fb37cc

Cycles X: improve denoising features for volumes

* Write accumulated volume albedo along ray
* Write view direction as normal
* Fix incorrect write of surface albedo after volume scatter

Differential Revision: https://developer.blender.org/D12394

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

M	intern/cycles/kernel/integrator/integrator_shade_surface.h
M	intern/cycles/kernel/integrator/integrator_shade_volume.h
M	intern/cycles/kernel/kernel_passes.h

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

diff --git a/intern/cycles/kernel/integrator/integrator_shade_surface.h b/intern/cycles/kernel/integrator/integrator_shade_surface.h
index 31d76a44f7e..73b7cad32be 100644
--- a/intern/cycles/kernel/integrator/integrator_shade_surface.h
+++ b/intern/cycles/kernel/integrator/integrator_shade_surface.h
@@ -431,7 +431,7 @@ ccl_device bool integrate_surface(INTEGRATOR_STATE_ARGS,
     }
 
 #ifdef __DENOISING_FEATURES__
-    kernel_write_denoising_features(INTEGRATOR_STATE_PASS, &sd, render_buffer);
+    kernel_write_denoising_features_surface(INTEGRATOR_STATE_PASS, &sd, render_buffer);
 #endif
 
 #ifdef __SHADOW_CATCHER__
diff --git a/intern/cycles/kernel/integrator/integrator_shade_volume.h b/intern/cycles/kernel/integrator/integrator_shade_volume.h
index aea8e1f9b78..4a864b1e6ce 100644
--- a/intern/cycles/kernel/integrator/integrator_shade_volume.h
+++ b/intern/cycles/kernel/integrator/integrator_shade_volume.h
@@ -16,6 +16,13 @@
 
 #pragma once
 
+#include "kernel/kernel_accumulate.h"
+#include "kernel/kernel_emission.h"
+#include "kernel/kernel_light.h"
+#include "kernel/kernel_passes.h"
+#include "kernel/kernel_path_state.h"
+#include "kernel/kernel_shader.h"
+
 #include "kernel/integrator/integrator_intersect_closest.h"
 #include "kernel/integrator/integrator_volume_stack.h"
 
@@ -559,6 +566,13 @@ ccl_device_forceinline void volume_integrate_heterogeneous(
         ray, equiangular_light_P, vstate.rscatter, &vstate.equiangular_pdf);
   }
 
+#  ifdef __DENOISING_FEATURES__
+  const bool write_denoising_features = (INTEGRATOR_STATE(path, flag) &
+                                         PATH_RAY_DENOISING_FEATURES);
+  float3 accum_albedo = zero_float3();
+#  endif
+  float3 accum_emission = zero_float3();
+
   for (int i = 0; i < max_steps; i++) {
     /* Advance to new position */
     vstate.end_t = min(ray->t, (i + steps_offset) * step_size);
@@ -581,16 +595,22 @@ ccl_device_forceinline void volume_integrate_heterogeneous(
         /* Only write emission before indirect light scatter position, since we terminate
          * stepping at that point if we have already found a direct light scatter position. */
         if (!result.indirect_scatter) {
-          /* TODO: write only once to avoid overhead of atomics? */
           const float3 emission = volume_emission_integrate(
               &coeff, closure_flag, transmittance, dt);
-          kernel_accum_emission(
-              INTEGRATOR_STATE_PASS, result.indirect_throughput, emission, render_buffer);
+          accum_emission += emission;
         }
       }
 
       if (closure_flag & SD_EXTINCTION) {
         if ((closure_flag & SD_SCATTER) || !vstate.absorption_only) {
+#  ifdef __DENOISING_FEATURES__
+          /* Accumulate albedo for denoising features. */
+          if (write_denoising_features && (closure_flag & SD_SCATTER)) {
+            const float3 albedo = safe_divide_color(coeff.sigma_s, coeff.sigma_t);
+            accum_albedo += result.indirect_throughput * albedo * (one_float3() - transmittance);
+          }
+#  endif
+
           /* Scattering and absorption. */
           volume_integrate_step_scattering(
               sd, ray, equiangular_light_P, coeff, transmittance, vstate, result);
@@ -627,6 +647,20 @@ ccl_device_forceinline void volume_integrate_heterogeneous(
       break;
     }
   }
+
+  /* Write accumulated emisison. */
+  if (!is_zero(accum_emission)) {
+    kernel_accum_emission(
+        INTEGRATOR_STATE_PASS, result.indirect_throughput, accum_emission, render_buffer);
+  }
+
+#  ifdef __DENOISING_FEATURES__
+  /* Write denoising features. */
+  if (write_denoising_features) {
+    kernel_write_denoising_features_volume(
+        INTEGRATOR_STATE_PASS, accum_albedo, result.indirect_scatter, render_buffer);
+  }
+#  endif /* __DENOISING_FEATURES__ */
 }
 
 #  ifdef __EMISSION__
diff --git a/intern/cycles/kernel/kernel_passes.h b/intern/cycles/kernel/kernel_passes.h
index a67dc6f6391..67466b28170 100644
--- a/intern/cycles/kernel/kernel_passes.h
+++ b/intern/cycles/kernel/kernel_passes.h
@@ -35,7 +35,7 @@ ccl_device_forceinline ccl_global float *kernel_pass_pixel_render_buffer(
 
 #ifdef __DENOISING_FEATURES__
 
-ccl_device_forceinline void kernel_write_denoising_features(
+ccl_device_forceinline void kernel_write_denoising_features_surface(
     INTEGRATOR_STATE_ARGS, const ShaderData *sd, ccl_global float *ccl_restrict render_buffer)
 {
   if (!(INTEGRATOR_STATE(path, flag) & PATH_RAY_DENOISING_FEATURES)) {
@@ -120,6 +120,31 @@ ccl_device_forceinline void kernel_write_denoising_features(
     INTEGRATOR_STATE_WRITE(path, denoising_feature_throughput) *= specular_albedo;
   }
 }
+
+ccl_device_forceinline void kernel_write_denoising_features_volume(INTEGRATOR_STATE_ARGS,
+                                                                   const float3 albedo,
+                                                                   const bool scatter,
+                                                                   ccl_global float *ccl_restrict
+                                                                       render_buffer)
+{
+  ccl_global float *buffer = kernel_pass_pixel_render_buffer(INTEGRATOR_STATE_PASS, render_buffer);
+  const float3 denoising_feature_throughput = INTEGRATOR_STATE(path, denoising_feature_throughput);
+
+  if (scatter && kernel_data.film.pass_denoising_normal != PASS_UNUSED) {
+    /* Assume scatter is sufficiently diffuse to stop writing denoising features. */
+    INTEGRATOR_STATE_WRITE(path, flag) &= ~PATH_RAY_DENOISING_FEATURES;
+
+    /* Write view direction as normal. */
+    const float3 denoising_normal = make_float3(0.0f, 0.0f, -1.0f);
+    kernel_write_pass_float3(buffer + kernel_data.film.pass_denoising_normal, denoising_normal);
+  }
+
+  if (kernel_data.film.pass_denoising_albedo != PASS_UNUSED) {
+    /* Write albedo. */
+    const float3 denoising_albedo = ensure_finite3(denoising_feature_throughput * albedo);
+    kernel_write_pass_float3(buffer + kernel_data.film.pass_denoising_albedo, denoising_albedo);
+  }
+}
 #endif /* __DENOISING_FEATURES__ */
 
 #ifdef __SHADOW_CATCHER__