Merge branch 'master' into refactor-mesh-position-generic

1 files changed, 246 insertions, 2 deletions

diff --git a/source/blender/nodes/composite/nodes/node_composite_tonemap.cc b/source/blender/nodes/composite/nodes/node_composite_tonemap.cc
index 2e06ad99df1..d26a01bb3c9 100644
--- a/source/blender/nodes/composite/nodes/node_composite_tonemap.cc
+++ b/source/blender/nodes/composite/nodes/node_composite_tonemap.cc
@@ -5,20 +5,35 @@
  * \ingroup cmpnodes
  */
 
+#include <cmath>
+
+#include "BLI_assert.h"
+#include "BLI_math_base.hh"
+#include "BLI_math_vec_types.hh"
+#include "BLI_math_vector.hh"
+
 #include "RNA_access.h"
 
 #include "UI_interface.h"
 #include "UI_resources.h"
 
+#include "IMB_colormanagement.h"
+
+#include "COM_algorithm_parallel_reduction.hh"
 #include "COM_node_operation.hh"
+#include "COM_utilities.hh"
 
 #include "node_composite_util.hh"
 
 namespace blender::nodes::node_composite_tonemap_cc {
 
+NODE_STORAGE_FUNCS(NodeTonemap)
+
 static void cmp_node_tonemap_declare(NodeDeclarationBuilder &b)
 {
-  b.add_input<decl::Color>(N_("Image")).default_value({1.0f, 1.0f, 1.0f, 1.0f});
+  b.add_input<decl::Color>(N_("Image"))
+      .default_value({1.0f, 1.0f, 1.0f, 1.0f})
+      .compositor_domain_priority(0);
   b.add_output<decl::Color>(N_("Image"));
 }
 
@@ -68,7 +83,236 @@ class ToneMapOperation : public NodeOperation {
 
   void execute() override
   {
-    get_input("Image").pass_through(get_result("Image"));
+    Result &input_image = get_input("Image");
+    Result &output_image = get_result("Image");
+    if (input_image.is_single_value()) {
+      input_image.pass_through(output_image);
+      return;
+    }
+
+    switch (get_type()) {
+      case CMP_NODE_TONE_MAP_SIMPLE:
+        execute_simple();
+        return;
+      case CMP_NODE_TONE_MAP_PHOTORECEPTOR:
+        execute_photoreceptor();
+        return;
+      default:
+        BLI_assert_unreachable();
+        return;
+    }
+  }
+
+  /* Tone mapping based on equation (3) from Reinhard, Erik, et al. "Photographic tone reproduction
+   * for digital images." Proceedings of the 29th annual conference on Computer graphics and
+   * interactive techniques. 2002. */
+  void execute_simple()
+  {
+    const float luminance_scale = compute_luminance_scale();
+    const float luminance_scale_blend_factor = compute_luminance_scale_blend_factor();
+    const float gamma = node_storage(bnode()).gamma;
+    const float inverse_gamma = gamma != 0.0f ? 1.0f / gamma : 0.0f;
+
+    GPUShader *shader = shader_manager().get("compositor_tone_map_simple");
+    GPU_shader_bind(shader);
+
+    GPU_shader_uniform_1f(shader, "luminance_scale", luminance_scale);
+    GPU_shader_uniform_1f(shader, "luminance_scale_blend_factor", luminance_scale_blend_factor);
+    GPU_shader_uniform_1f(shader, "inverse_gamma", inverse_gamma);
+
+    const Result &input_image = get_input("Image");
+    input_image.bind_as_texture(shader, "input_tx");
+
+    const Domain domain = compute_domain();
+    Result &output_image = get_result("Image");
+    output_image.allocate_texture(domain);
+    output_image.bind_as_image(shader, "output_img");
+
+    compute_dispatch_threads_at_least(shader, domain.size);
+
+    GPU_shader_unbind();
+    output_image.unbind_as_image();
+    input_image.unbind_as_texture();
+  }
+
+  /* Computes the scaling factor in equation (2) from Reinhard's 2002 paper. */
+  float compute_luminance_scale()
+  {
+    const float geometric_mean = compute_geometric_mean_of_luminance();
+    return geometric_mean != 0.0 ? node_storage(bnode()).key / geometric_mean : 0.0f;
+  }
+
+  /* Computes equation (1) from Reinhard's 2002 paper. However, note that the equation in the paper
+   * is most likely wrong, and the intention is actually to compute the geometric mean through a
+   * logscale arithmetic mean, that is, the division should happen inside the exponential function,
+   * not outside of it. That's because the sum of the log luminance will be a very large negative
+   * number, whose exponential will almost always be zero, which is unexpected and useless. */
+  float compute_geometric_mean_of_luminance()
+  {
+    return std::exp(compute_average_log_luminance());
+  }
+
+  /* Equation (3) from Reinhard's 2002 paper blends between high luminance scaling for high
+   * luminance values and low luminance scaling for low luminance values. This is done by adding 1
+   * to the denominator, since for low luminance values, the denominator will be close to 1 and for
+   * high luminance values, the 1 in the denominator will be relatively insignificant. But the
+   * response of such function is not always ideal, so in this implementation, the 1 was exposed as
+   * a parameter to the user for more flexibility. */
+  float compute_luminance_scale_blend_factor()
+  {
+    return node_storage(bnode()).offset;
+  }
+
+  /* Tone mapping based on equation (1) and the trilinear interpolation between equations (6) and
+   * (7) from Reinhard, Erik, and Kate Devlin. "Dynamic range reduction inspired by photoreceptor
+   * physiology." IEEE transactions on visualization and computer graphics 11.1 (2005): 13-24. */
+  void execute_photoreceptor()
+  {
+    const float4 global_adaptation_level = compute_global_adaptation_level();
+    const float contrast = compute_contrast();
+    const float intensity = compute_intensity();
+    const float chromatic_adaptation = get_chromatic_adaptation();
+    const float light_adaptation = get_light_adaptation();
+
+    GPUShader *shader = shader_manager().get("compositor_tone_map_photoreceptor");
+    GPU_shader_bind(shader);
+
+    GPU_shader_uniform_4fv(shader, "global_adaptation_level", global_adaptation_level);
+    GPU_shader_uniform_1f(shader, "contrast", contrast);
+    GPU_shader_uniform_1f(shader, "intensity", intensity);
+    GPU_shader_uniform_1f(shader, "chromatic_adaptation", chromatic_adaptation);
+    GPU_shader_uniform_1f(shader, "light_adaptation", light_adaptation);
+
+    float luminance_coefficients[3];
+    IMB_colormanagement_get_luminance_coefficients(luminance_coefficients);
+    GPU_shader_uniform_3fv(shader, "luminance_coefficients", luminance_coefficients);
+
+    const Result &input_image = get_input("Image");
+    input_image.bind_as_texture(shader, "input_tx");
+
+    const Domain domain = compute_domain();
+    Result &output_image = get_result("Image");
+    output_image.allocate_texture(domain);
+    output_image.bind_as_image(shader, "output_img");
+
+    compute_dispatch_threads_at_least(shader, domain.size);
+
+    GPU_shader_unbind();
+    output_image.unbind_as_image();
+    input_image.unbind_as_texture();
+  }
+
+  /* Computes the global adaptation level from the trilinear interpolation equations constructed
+   * from equations (6) and (7) in Reinhard's 2005 paper. */
+  float4 compute_global_adaptation_level()
+  {
+    const float4 average_color = compute_average_color();
+    const float average_luminance = compute_average_luminance();
+    const float chromatic_adaptation = get_chromatic_adaptation();
+    return math::interpolate(float4(average_luminance), average_color, chromatic_adaptation);
+  }
+
+  float4 compute_average_color()
+  {
+    /* The average color will reduce to zero if chromatic adaptation is zero, so just return zero
+     * in this case to avoid needlessly computing the average. See the trilinear interpolation
+     * equations constructed from equations (6) and (7) in Reinhard's 2005 paper. */
+    if (get_chromatic_adaptation() == 0.0f) {
+      return float4(0.0f);
+    }
+
+    const Result &input = get_input("Image");
+    return sum_color(context(), input.texture()) / (input.domain().size.x * input.domain().size.y);
+  }
+
+  float compute_average_luminance()
+  {
+    /* The average luminance will reduce to zero if chromatic adaptation is one, so just return
+     * zero in this case to avoid needlessly computing the average. See the trilinear interpolation
+     * equations constructed from equations (6) and (7) in Reinhard's 2005 paper. */
+    if (get_chromatic_adaptation() == 1.0f) {
+      return 0.0f;
+    }
+
+    float luminance_coefficients[3];
+    IMB_colormanagement_get_luminance_coefficients(luminance_coefficients);
+    const Result &input = get_input("Image");
+    float sum = sum_luminance(context(), input.texture(), luminance_coefficients);
+    return sum / (input.domain().size.x * input.domain().size.y);
+  }
+
+  /* Computes equation (5) from Reinhard's 2005 paper. */
+  float compute_intensity()
+  {
+    return std::exp(-node_storage(bnode()).f);
+  }
+
+  /* If the contrast is not zero, return it, otherwise, a zero contrast denote automatic derivation
+   * of the contrast value based on equations (2) and (4) from Reinhard's 2005 paper. */
+  float compute_contrast()
+  {
+    if (node_storage(bnode()).m != 0.0f) {
+      return node_storage(bnode()).m;
+    }
+
+    const float log_maximum_luminance = compute_log_maximum_luminance();
+    const float log_minimum_luminance = compute_log_minimum_luminance();
+
+    /* This is merely to guard against zero division later. */
+    if (log_maximum_luminance == log_minimum_luminance) {
+      return 1.0f;
+    }
+
+    const float average_log_luminance = compute_average_log_luminance();
+    const float dynamic_range = log_maximum_luminance - log_minimum_luminance;
+    const float luminance_key = (log_maximum_luminance - average_log_luminance) / (dynamic_range);
+
+    return 0.3f + 0.7f * std::pow(luminance_key, 1.4f);
+  }
+
+  float compute_average_log_luminance()
+  {
+    const Result &input_image = get_input("Image");
+
+    float luminance_coefficients[3];
+    IMB_colormanagement_get_luminance_coefficients(luminance_coefficients);
+    const float sum_of_log_luminance = sum_log_luminance(
+        context(), input_image.texture(), luminance_coefficients);
+
+    return sum_of_log_luminance / (input_image.domain().size.x * input_image.domain().size.y);
+  }
+
+  float compute_log_maximum_luminance()
+  {
+    float luminance_coefficients[3];
+    IMB_colormanagement_get_luminance_coefficients(luminance_coefficients);
+    const float maximum = maximum_luminance(
+        context(), get_input("Image").texture(), luminance_coefficients);
+    return std::log(math::max(maximum, 1e-5f));
+  }
+
+  float compute_log_minimum_luminance()
+  {
+    float luminance_coefficients[3];
+    IMB_colormanagement_get_luminance_coefficients(luminance_coefficients);
+    const float minimum = minimum_luminance(
+        context(), get_input("Image").texture(), luminance_coefficients);
+    return std::log(math::max(minimum, 1e-5f));
+  }
+
+  float get_chromatic_adaptation()
+  {
+    return node_storage(bnode()).c;
+  }
+
+  float get_light_adaptation()
+  {
+    return node_storage(bnode()).a;
+  }
+
+  CMPNodeToneMapType get_type()
+  {
+    return static_cast<CMPNodeToneMapType>(node_storage(bnode()).type);
   }
 };