source/blender/draw/engines/eevee_next/eevee_shader_shared.hh

@@ -841,21 +841,23 @@ struct Surfel {
   int next;
   /** Surface albedo to apply to incoming radiance. */
   packed_float3 albedo_front;
-  int _pad0;
+  int _pad3;
   packed_float3 albedo_back;
   /** Distance along the ray direction for sorting. */
   float ray_distance;
-  /** Reflected radiance from previous bounce. */
+  /** Surface  radiance. */
   packed_float3 radiance_front;
-  int _pad1;
+  int _pad4;
   packed_float3 radiance_back;
+  int _pad0;
+  /** Radiance from previous bounce. This is what is being scattered during a bounce. */
+  packed_float3 outgoing_light_front;
+  int _pad1;
+  packed_float3 outgoing_light_back;
   int _pad2;
-  /**
-   * Accumulated reflected radiance for the current bounce.
-   * Weight is stored in the fourth component.
-   */
-  float4 radiance_bounce_front;
-  float4 radiance_bounce_back;
+  /** Accumulated radiance for the current bounce. Weight is stored in the fourth component. */
+  float4 incomming_light_front;
+  float4 incomming_light_back;
 };
 BLI_STATIC_ASSERT_ALIGN(Surfel, 16)
 

source/blender/draw/engines/eevee_next/shaders/eevee_surf_capture_frag.glsl

@@ -47,12 +47,13 @@ void main()
         surfel_buf[surfel_id].normal = gl_FrontFacing ? g_data.Ng : -g_data.Ng;
         surfel_buf[surfel_id].albedo_front = albedo;
         surfel_buf[surfel_id].radiance_front = g_emission;
+        surfel_buf[surfel_id].outgoing_light_front = g_emission;
+        surfel_buf[surfel_id].incomming_light_front = vec4(0.0);
         /* TODO(fclem): 2nd surface evaluation. */
         surfel_buf[surfel_id].albedo_back = albedo;
         surfel_buf[surfel_id].radiance_back = g_emission;
-
-        surfel_buf[surfel_id].radiance_bounce_front = vec4(0.0);
-        surfel_buf[surfel_id].radiance_bounce_back = vec4(0.0);
+        surfel_buf[surfel_id].outgoing_light_back = g_emission;
+        surfel_buf[surfel_id].incomming_light_back = vec4(0.0);
       }
     }
   }

source/blender/draw/engines/eevee_next/shaders/eevee_surfel_bounce_comp.glsl

@@ -15,7 +15,7 @@ vec3 finalize_integration(vec4 radiance)
   radiance.rgb *= safe_rcp(radiance.w);
   /* TODO: Find why this is needed. */
   radiance.rgb *= 2.0;
-  /* Multiply by hemisphere area. */
+  /* Multiply by hemisphere area since we are integrating over it. */
   return radiance.rgb * M_TAU;
 }
 
@@ -25,11 +25,16 @@ void main()
   if (surfel_index >= capture_info_buf.surfel_len) {
     return;
   }
-
-  vec4 radiance_bounce_front = surfel_buf[surfel_index].radiance_bounce_front;
-  vec4 radiance_bounce_back = surfel_buf[surfel_index].radiance_bounce_back;
-  surfel_buf[surfel_index].radiance_front += finalize_integration(radiance_bounce_front);
-  surfel_buf[surfel_index].radiance_back += finalize_integration(radiance_bounce_back);
-  surfel_buf[surfel_index].radiance_bounce_front = vec4(0.0);
-  surfel_buf[surfel_index].radiance_bounce_back = vec4(0.0);
+  Surfel surfel = surfel_buf[surfel_index];
+  vec3 radiance_front = finalize_integration(surfel.incomming_light_front);
+  vec3 radiance_back = finalize_integration(surfel.incomming_light_back);
+  /* Re-inject the bounced light for the next bounce event. */
+  surfel_buf[surfel_index].outgoing_light_front = radiance_front;
+  surfel_buf[surfel_index].outgoing_light_back = radiance_back;
+  /* Add to final radiance. */
+  surfel_buf[surfel_index].radiance_front += radiance_front;
+  surfel_buf[surfel_index].radiance_back += radiance_back;
+  /* Reset accumulator for next bounce. */
+  surfel_buf[surfel_index].incomming_light_front = vec4(0.0);
+  surfel_buf[surfel_index].incomming_light_back = vec4(0.0);
 }

source/blender/draw/engines/eevee_next/shaders/eevee_surfel_ray_comp.glsl

@@ -16,15 +16,15 @@
 void radiance_transfer(inout Surfel surfel, vec3 irradiance, vec3 L)
 {
   float NL = dot(surfel.normal, L);
-  /* Lambertian BSDF. */
-  vec3 bsdf = irradiance * M_1_PI;
+  /* Lambertian BSDF. Albedo applied later depending on which side of the surfel was hit. */
+  float bsdf = M_1_PI;
   /* Outgoing light. */
-  vec3 radiance = bsdf * abs(NL);
+  vec3 radiance = bsdf * irradiance * abs(NL);
   if (NL > 0.0) {
-    surfel.radiance_bounce_front += vec4(radiance, 1.0);
+    surfel.incomming_light_front += vec4(radiance * surfel.albedo_front, 1.0);
   }
   else {
-    surfel.radiance_bounce_back += vec4(radiance, 1.0);
+    surfel.incomming_light_back += vec4(radiance * surfel.albedo_back, 1.0);
   }
 }
 
@@ -32,7 +32,8 @@ void radiance_transfer(inout Surfel surfel, Surfel surfel_emitter)
 {
   vec3 L = safe_normalize(surfel_emitter.position - surfel.position);
   bool facing = dot(-L, surfel_emitter.normal) > 0.0;
-  vec3 irradiance = facing ? surfel_emitter.radiance_front : surfel_emitter.radiance_back;
+  vec3 irradiance = facing ? surfel_emitter.outgoing_light_front :
+                             surfel_emitter.outgoing_light_back;
 
   radiance_transfer(surfel, irradiance, L);
 }
@@ -64,6 +65,6 @@ void main()
     radiance_transfer(surfel, vec3(0.0), -sky_L);
   }
 
-  surfel_buf[surfel_index].radiance_bounce_front = surfel.radiance_bounce_front;
-  surfel_buf[surfel_index].radiance_bounce_back = surfel.radiance_bounce_back;
+  surfel_buf[surfel_index].incomming_light_front = surfel.incomming_light_front;
+  surfel_buf[surfel_index].incomming_light_back = surfel.incomming_light_back;
 }